/////////////////////////////////////////////////////////////////////////////
// Name: gauge.cpp
// Purpose: wxGauge class
-// Author: AUTHOR
+// Author: David Webster
// Modified by:
-// Created: ??/??/98
+// Created: 10/06/99
// RCS-ID: $Id$
-// Copyright: (c) AUTHOR
-// Licence: wxWindows licence
+// Copyright: (c) David Webster
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "gauge.h"
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+#include "wx/defs.h"
+#include "wx/utils.h"
#endif
+#include "wx/os2/private.h"
#include "wx/gauge.h"
-#if !USE_SHARED_LIBRARY
+/* gas gauge graph control messages--class "zYzGauge" */
+#define ZYZG_SETRANGE (WM_USER + 0)
+#define ZYZG_GETRANGE (WM_USER + 1)
+#define ZYZG_SETPOSITION (WM_USER + 2)
+#define ZYZG_GETPOSITION (WM_USER + 3)
+#define ZYZG_SETORIENTATION (WM_USER + 4)
+#define ZYZG_GETORIENTATION (WM_USER + 5)
+#define ZYZG_SETFGCOLOR (WM_USER + 6)
+#define ZYZG_GETFGCOLOR (WM_USER + 7)
+#define ZYZG_SETBKCOLOR (WM_USER + 8)
+#define ZYZG_GETBKCOLOR (WM_USER + 9)
+#define ZYZG_SETWIDTH3D (WM_USER + 10)
+#define ZYZG_GETWIDTH3D (WM_USER + 11)
+#define ZYZG_SETBEZELFACE (WM_USER + 12)
+#define ZYZG_GETBEZELFACE (WM_USER + 13)
+#define ZYZG_SETDELTAPOS (WM_USER + 14)
+
+/* orientations for ZYZG_WW_ORIENTATION */
+#define ZYZG_ORIENT_LEFTTORIGHT 0
+#define ZYZG_ORIENT_RIGHTTOLEFT 1
+#define ZYZG_ORIENT_BOTTOMTOTOP 2
+#define ZYZG_ORIENT_TOPTOBOTTOM 3
+
+/* gauge styles */
+#define ZYZGS_3D 0x8000L /* control will be 3D */
+
+/* public function prototypes */
+// BOOL _Optlink gaugeInit(HINSTANCE hInstance);
+
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
-#endif
bool wxGauge::Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
+#if wxUSE_VALIDATORS
const wxValidator& validator,
+#endif
const wxString& name)
{
+ static bool wxGaugeOS2Initialised = FALSE;
+
+ if ( !wxGaugeOS2Initialised )
+ {
+//TODO:
+/*
+ if (!gaugeInit((HINSTANCE) wxGetInstance()))
+ wxFatalError("Cannot initalize Gauge library");
+*/
+ wxGaugeOS2Initialised = TRUE;
+ }
+
SetName(name);
+#if wxUSE_VALIDATORS
SetValidator(validator);
+#endif
+ if (parent) parent->AddChild(this);
m_rangeMax = range;
- m_windowStyle = style;
+ m_gaugePos = 0;
- if (parent) parent->AddChild(this);
+ m_windowStyle = style;
if ( id == -1 )
- m_windowId = (int)NewControlId();
+ m_windowId = (int)NewControlId();
else
- m_windowId = id;
+ m_windowId = id;
+ int x = pos.x;
+ int y = pos.y;
+ int width = size.x;
+ int height = size.y;
// TODO
- return FALSE;
-}
+/*
+ int x = pos.x;
+ int y = pos.y;
+ int width = size.x;
+ int height = size.y;
-void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
-{
- // TODO
+ long msFlags = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
+ msFlags |= ZYZGS_3D;
+
+ HWND wx_button =
+ CreateWindowEx(MakeExtendedStyle(m_windowStyle), wxT("zYzGauge"), NULL, msFlags,
+ 0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
+ wxGetInstance(), NULL);
+
+ m_hWnd = (WXHWND)wx_button;
+
+ // Subclass again for purposes of dialog editing mode
+ SubclassWin((WXHWND)wx_button);
+
+ int wOrient = 0;
+
+ if (m_windowStyle & wxGA_HORIZONTAL)
+ wOrient = ZYZG_ORIENT_LEFTTORIGHT;
+ else
+ wOrient = ZYZG_ORIENT_BOTTOMTOTOP;
+
+ SendMessage(wx_button, ZYZG_SETORIENTATION, wOrient, 0);
+ SendMessage(wx_button, ZYZG_SETRANGE, range, 0);
+
+ SendMessage(GetHwnd(), ZYZG_SETFGCOLOR, 0, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
+ SendMessage(GetHwnd(), ZYZG_SETBKCOLOR, 0, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
+
+ SetFont(parent->GetFont());
+
+ if (width == -1)
+ width = 50;
+ if (height == -1)
+ height = 50;
+ SetSize(x, y, width, height);
+
+ ShowWindow(GetHwnd(), SW_SHOW);
+*/
+ return TRUE;
}
void wxGauge::SetShadowWidth(int w)
{
- // TODO optional
+ // TODO optional ::SendMessage(GetHwnd(), ZYZG_SETWIDTH3D, w, 0);
}
void wxGauge::SetBezelFace(int w)
{
- // TODO optional
+ // TODO optional ::SendMessage(GetHwnd(), ZYZG_SETBEZELFACE, w, 0);
}
void wxGauge::SetRange(int r)
{
m_rangeMax = r;
- // TODO
+ // TODO ::SendMessage(GetHwnd(), ZYZG_SETRANGE, r, 0);
}
void wxGauge::SetValue(int pos)
{
m_gaugePos = pos;
- // TODO
+ // TODO ::SendMessage(GetHwnd(), ZYZG_SETPOSITION, pos, 0);
}
int wxGauge::GetShadowWidth() const
{
- // TODO optional
+ // TODO return (int) ::SendMessage(GetHwnd(), ZYZG_GETWIDTH3D, 0, 0);
return 0;
}
int wxGauge::GetBezelFace() const
{
- // TODO optional
+ // TODO return (int) ::SendMessage(GetHwnd(), ZYZG_GETBEZELFACE, 0, 0);
return 0;
}
int wxGauge::GetRange() const
{
+ // TODO return (int) ::SendMessage(GetHwnd(), ZYZG_GETRANGE, 0, 0);
return m_rangeMax;
}
int wxGauge::GetValue() const
{
+ // TODO return (int) ::SendMessage(GetHwnd(), ZYZG_GETPOSITION, 0, 0);
return m_gaugePos;
}
+bool wxGauge::SetForegroundColour(const wxColour& col)
+{
+ if ( !wxControl::SetForegroundColour(col) )
+ return FALSE;
+
+ // TODO ::SendMessage(GetHwnd(), ZYZG_SETFGCOLOR, 0, RGB(col.Red(), col.Green(), col.Blue()));
+
+ return TRUE;
+}
+
+bool wxGauge::SetBackgroundColour(const wxColour& col)
+{
+ if ( !wxControl::SetBackgroundColour(col) )
+ return FALSE;
+
+ // TODO ::SendMessage(GetHwnd(), ZYZG_SETBKCOLOR, 0, RGB(col.Red(), col.Green(), col.Blue()));
+
+ return TRUE;
+}
+
+///** zyz3d.c
+// *
+// * DESCRIPTION:
+// * This module contains functions for creating nifty 3D borders
+// * around controls like zYzGauge.
+// *
+// * HISTORY:
+// * 3/14/91 cjp put in this comment
+// * 6/19/92 cjp touched it a bit
+// *
+// ** cjp */
+// COPYRIGHT:
+//
+// (C) Copyright Microsoft Corp. 1992. All rights reserved.
+//
+// You have a royalty-free right to use, modify, reproduce and
+// distribute the Sample Files (and/or any modified version) in
+// any way you find useful, provided that you agree that
+// Microsoft has no warranty obligations or liability for any
+// Sample Application Files which are modified.
+//
+
+
+///* get the includes we need */
+//#define INCL_PM
+//#include <os2.h>
+
+///* misc. control flag defines */
+//#define DRAW3D_IN 0x0001
+//#define DRAW3D_OUT 0x0002
+
+//#define DRAW3D_TOPLINE 0x0004
+//#define DRAW3D_BOTTOMLINE 0x0008
+//#define DRAW3D_LEFTLINE 0x0010
+//#define DRAW3D_RIGHTLINE 0x0020
+
+
+///* public function prototypes */
+//void _Optlink Draw3DFaceFrame(HDC, LPRECT, WORD);
+//void _Optlink Draw3DRect(HDC, LPRECT, WORD, WORD);
+//void _Optlink Draw3DLine(HDC, WORD, WORD, WORD, WORD, WORD);
+
+
+///** void _Optlink Draw3DFaceFrame(HDC hdc, LPRECT rc, WORD wWidth)
+// *
+// * DESCRIPTION:
+// * This function draws a flat frame with the current button-face
+// * color.
+// *
+// * ARGUMENTS:
+// * HDC hdc : The DC to draw into.
+// *
+// * LPRECT rc : The containing rect for the new frame.
+// *
+// * WORD wWidth : The width of the frame to draw.
+// *
+// * RETURN (void _Optlink):
+// * The frame will have been drawn into the DC.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+//void _Optlink Draw3DFaceFrame(HDC hdc, RECTL* rc, WORD wWidth)
+//{
+// RECTL rc1;
+// DWORD rgbOld;
+
+// /* don't go through a bunch of work if we don't have to */
+// if (!wWidth)
+// return;
+
+// /* set up color to be button-face color--so it may not be gray */
+// rgbOld = SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
+
+// /* perform CopyRect w/o bloody windows style overhead */
+// rc1 = *rc;
+
+ /* top */
+// rc1.top = rc->top;
+// rc1.left = rc->left;
+// rc1.bottom = rc->top + wWidth;
+// rc1.right = rc->right;
+
+ /* blast it out */
+// ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
+
+ /* right */
+// rc1.left = rc->right - wWidth;
+// rc1.bottom = rc->bottom;
+
+ /* blast this part now */
+// ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
+
+ /* left */
+// rc1.left = rc->left;
+// rc1.right = rc->left + wWidth;
+
+ /* and another part */
+// ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
+
+ /* bottom */
+// rc1.right = rc->right;
+// rc1.top = rc->bottom - wWidth;
+
+ /* finish it off */
+// ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
+
+ /* restore the old bk color */
+// SetBkColor(hdc, rgbOld);
+//} /* Draw3DFaceFrame() */
+
+
+///** void _Optlink Draw3DRect(HDC, LPRECT, WORD, WORD)
+// *
+// * DESCRIPTION:
+// * Draws a 3D rectangle that is shaded. wFlags can be used to
+// * control how the rectangle looks.
+// *
+// * ARGUMENTS:
+// * HDC hdc : Handle to the device context that will be
+// * used to display the rectangle.
+// *
+// * RECT rect : A rectangle describing the dimensions of
+// * the rectangle in device coordinates.
+// *
+// * WORD wShadowWidth : Width of the shadow in device coordinates.
+// *
+// * WORD wFlags : The following flags may be passed to describe
+// * the style of the rectangle:
+// *
+// * DRAW3D_IN : The shadow is drawn such that
+// * the box appears to be sunk in to the screen.
+// * This is default if 0 is passed.
+// *
+// * DRAW3D_OUT : The shadow is drawn such that
+// * the box appears to be sticking out of the
+// * screen.
+// *
+// * RETURN (void _Optlink):
+// * The 3D looking rectangle will have been drawn into the DC.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+//void _Optlink Draw3DRect(HDC hdc, LPRECT lpRect,
+// WORD wShadowWidth, WORD wFlags)
+//{
+// /* sanity check--don't work if you don't have to! */
+// if (!wShadowWidth || !RectVisible(hdc, lpRect))
+// return;
+
+ /* draw the top line */
+// Draw3DLine(hdc, lpRect->left, lpRect->top,
+// lpRect->right - lpRect->left,
+// wShadowWidth, DRAW3D_TOPLINE | wFlags);
+
+ /* right line */
+// Draw3DLine(hdc, lpRect->right, lpRect->top,
+// lpRect->bottom - lpRect->top,
+// wShadowWidth, DRAW3D_RIGHTLINE | wFlags);
+
+ /* bottom line */
+// Draw3DLine(hdc, lpRect->left, lpRect->bottom,
+// lpRect->right - lpRect->left,
+// wShadowWidth, DRAW3D_BOTTOMLINE | wFlags);
+
+ /* left line */
+// Draw3DLine(hdc, lpRect->left, lpRect->top,
+// lpRect->bottom - lpRect->top,
+// wShadowWidth, DRAW3D_LEFTLINE | wFlags);
+//} /* Draw3DRect() */
+
+
+///** void _Optlink Draw3DLine(HDC hdc, WORD x, WORD y, WORD nLen,
+// *
+// * DESCRIPTION:
+// * Draws a 3D line that can be used to make a 3D box.
+// *
+// * ARGUMENTS:
+// * HDC hdc : Handle to the device context that will be
+// * used to display the 3D line.
+// *
+// * WORD x, y : Coordinates of the beginning of the line.
+// * These coordinates are in device units and
+// * represent the _outside_ most point. Horiz-
+// * ontal lines are drawn from left to right and
+// * vertical lines are drawn from top to bottom.
+// *
+// * WORD wShadowWidth : Width of the shadow in device coordinates.
+// *
+// * WORD wFlags : The following flags may be passed to
+// * describe the style of the 3D line:
+// *
+// * DRAW3D_IN : The shadow is drawn such that
+// * the box appears to be sunk in to the screen.
+// * This is default if 0 is passed.
+// *
+// * DRAW3D_OUT : The shadow is drawn such that
+// * the box appears to be sticking out of the
+// * screen.
+// *
+// * DRAW3D_TOPLINE, _BOTTOMLINE, _LEFTLINE, and
+// * _RIGHTLINE : Specifies that a "top",
+// * "Bottom", "Left", or"Right" line is to be
+// * drawn.
+// *
+// * RETURN (void _Optlink):
+// * The line will have been drawn into the DC.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+//void _Optlink Draw3DLine(HDC hdc, WORD x, WORD y, WORD nLen,
+// WORD wShadowWidth, WORD wFlags)
+//{
+// HBRUSH hOldBrush;
+// HPEN hOldPen;
+// BOOL fDark;
+// POINT Point[ 4 ]; /* define a polgon with 4 points */
+
+// /* if width is zero, don't do nothin'! */
+// if (!wShadowWidth)
+// return;
+
+ /* define shape of polygon--origin is always the same */
+// Point[0].x = x;
+// Point[0].y = y;
+
+// /* To do this we'll simply draw a polygon with four sides, using
+// * the appropriate brush. I dare you to ask me why this isn't a
+// * switch/case!
+// */
+// if (wFlags & DRAW3D_TOPLINE)
+// {
+// /* across to right */
+// Point[1].x = x + nLen - (wShadowWidth == 1 ? 1 : 0);
+// Point[1].y = y;
+
+ /* down/left */
+// Point[2].x = x + nLen - wShadowWidth;
+// Point[2].y = y + wShadowWidth;
+
+ /* accross to left */
+// Point[3].x = x + wShadowWidth;
+// Point[3].y = y + wShadowWidth;
+
+ /* select 'dark' brush if 'in'--'light' for 'out' */
+// fDark = (wFlags & DRAW3D_IN) ? TRUE : FALSE;
+// }
+
+ /* possibly the bottom? */
+// else if (wFlags & DRAW3D_BOTTOMLINE)
+// {
+ /* across to right */
+// Point[1].x = x + nLen;
+// Point[1].y = y;
+
+ /* up/left */
+// Point[2].x = x + nLen - wShadowWidth;
+// Point[2].y = y - wShadowWidth;
+
+ /* accross to left */
+// Point[3].x = x + wShadowWidth;
+// Point[3].y = y - wShadowWidth;
+
+ /* select 'light' brush if 'in' */
+// fDark = (wFlags & DRAW3D_IN) ? FALSE : TRUE;
+// }
+
+ /* ok, it's gotta be left? */
+// else if (wFlags & DRAW3D_LEFTLINE)
+// {
+ /* down */
+// Point[1].x = x;
+// Point[1].y = y + nLen - (wShadowWidth == 1 ? 1 : 0);
+
+ /* up/right */
+// Point[2].x = x + wShadowWidth;
+// Point[2].y = y + nLen - wShadowWidth;
+
+ /* down */
+// Point[3].x = x + wShadowWidth;
+// Point[3].y = y + wShadowWidth;
+
+ /* select 'dark' brush if 'in'--'light' for 'out' */
+// fDark = (wFlags & DRAW3D_IN) ? TRUE : FALSE;
+// }
+
+ /* well maybe it's for the right side? */
+// else if (wFlags & DRAW3D_RIGHTLINE)
+// {
+ /* down */
+// Point[1].x = x;
+// Point[1].y = y + nLen;
+
+ /* up/left */
+// Point[2].x = x - wShadowWidth;
+// Point[2].y = y + nLen - wShadowWidth;
+
+ /* up */
+// Point[3].x = x - wShadowWidth;
+// Point[3].y = y + wShadowWidth;
+
+ /* select 'light' brush if 'in' */
+// fDark = (wFlags & DRAW3D_IN) ? FALSE : TRUE;
+// }
+
+ /* bad drugs? */
+// else return;
+
+ /* select NULL_PEN for no borders */
+// hOldPen = (HPEN) SelectObject(hdc, GetStockObject(NULL_PEN));
+
+ /* select the appropriate color for the fill */
+// if (fDark)
+// hOldBrush = (HBRUSH) SelectObject(hdc, GetStockObject(GRAY_BRUSH));
+// else
+// hOldBrush = (HBRUSH) SelectObject(hdc, GetStockObject(WHITE_BRUSH));
+
+ /* finally, draw the dern thing */
+// Polygon(hdc, (LPPOINT)&Point, 4);
+
+ /* restore what we killed */
+// SelectObject(hdc, hOldBrush);
+// SelectObject(hdc, hOldPen);
+//} /* Draw3DLine() */
+
+/** EOF: zyz3d.c **/
+
+///** zyzgauge.c
+// *
+// * DESCRIPTION:
+// * Yet another 'Gas Gauge Custom Control.' This control gives you
+// * a 'progress bar' class (named zYzGauge) for use in your applications.
+// * You can set the range, position, font, color, orientation, and 3d
+// * effect of the gauge by sending messages to the control.
+// *
+// * Before you can use this control, you MUST first export the window
+// * procedure for the control (or define it with the _export keyword):
+// *
+// * EXPORTS gaugeWndProc
+// *
+// * You then need initialize the class before you use it:
+// *
+// * if (!gaugeInit(hInstance))
+// * die a horrible death
+// * else
+// * you are good to go
+// *
+// * The colors used by the control default to black and white if you
+// * are running on a mono-display. They default to blue and white
+// * if you are on a color display. You enable the 3D effect by setting
+// * the ZYZGS_3D style flag in the styles field of the control (like
+// * any other control).
+// *
+// * To select your own colors, you can send the ZYZG_SETFGCOLOR and
+// * ZYZG_SETBKCOLOR messages to set the foreground (percent done) and
+// * background (percent not done) colors. The lParam is the RGB()
+// * value--wParam is ignored.
+// *
+// * In all of the following ZYZG_??? messages, the arguments are
+// * WORDS. If you are setting parameters, the value is sent as
+// * the wParam (lParam is ignored). If you are getting parameters,
+// * the value is returned as a LONG and should be cast to a *signed*
+// * integer.
+// *
+// * To set the depth of the 3D effect (if enabled), you can send the
+// * ZYZG_SETBEZELFACE and ZYZG_SETWIDTH3D messages. The bezel face
+// * is the flat top on the 3D border--its color will be that of the
+// * button-face. The 3D width is the width of the bezel itself; inside
+// * and outside. The light color is white, the dark color is gray.
+// * Both widths *can* be zero--both default to 2 which looks to me.
+// *
+// * The range of the control can be set by sending the ZYZG_SETRANGE
+// * message to the control. It can be any integer from 1 to 32767.
+// * What this specifies is the number of pieces that create a whole.
+// * The default is 100. You can get the current range setting by
+// * sending the ZYZG_GETRANGE message to the control.
+// *
+// * The position (number of pieces out of the whole have been used) is
+// * set with the ZYZG_SETPOSITION message. It can be any integer from
+// * 0 to the current range setting of the control--it will be clipped
+// * if the position is out of bounds. The default position is 0. You
+// * can get the current position at any time with the ZYZG_GETPOSITION
+// * message.
+// *
+// * You can also set the range using a delta from the current range.
+// * This is done by sending the ZYZG_SETDELTAPOS message with wParam
+// * set to a _signed_ integer value within the range of the control.
+// *
+// * The font used for the percentage text can be set using the standard
+// * WM_SETFONT message. You can get the current font at any time with
+// * the WM_GETFONT message.
+// *
+// * The orientation can be left to right, right to left, bottom to top,
+// * or top to bottom. Whatever suits your needs. You set this by
+// * sending the ZYZG_ORIENTATION message to the control with one of
+// * the following values (default is ZYZG_ORIENT_LEFTTORIGHT):
+// *
+// * ZYZG_ORIENT_LEFTTORIGHT (0)
+// * ZYZG_ORIENT_RIGHTTOLEFT (1)
+// * ZYZG_ORIENT_BOTTOMTOTOP (2)
+// * ZYZG_ORIENT_TOPTOBOTTOM (3)
+// *
+// * HISTORY:
+// * 3/12/91 cjp put in this comment
+// * 6/19/92 cjp touched it a bit
+// *
+// ** cjp */
+// COPYRIGHT:
+//
+// (C) Copyright Microsoft Corp. 1992. All rights reserved.
+//
+// You have a royalty-free right to use, modify, reproduce and
+// distribute the Sample Files (and/or any modified version) in
+// any way you find useful, provided that you agree that
+// Microsoft has no warranty obligations or liability for any
+// Sample Application Files which are modified.
+//
+
+
+/* get the includes we need */
+//#if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
+//#include <malloc.h>
+//#endif
+//#include <stdio.h>
+//#include <string.h>
+//#include <stdlib.h>
+// #include "zyz3d.h"
+// #include "zyzgauge.h"
+
+
+/* static global variables */
+//static wxChar gszzYzGaugeClass[] = wxT("zYzGauge");
+
+
+/* window word position definitions */
+//#define ZYZG_WW_PZYZGAUGE 0
+/* #define ZYZG_WW_EXTRABYTES 2 */
+//#define ZYZG_WW_EXTRABYTES 4
+
+
+/* control block structure typedef */
+//typedef struct tZYZGAUGE
+//{
+// WORD wRange;
+// WORD wPosition;
+// WORD wOrientation;
+// WORD wWidth3D;
+// WORD wWidthBezelFace;
+// HFONT hFont;
+// DWORD rgbTextColor;
+// DWORD rgbBkColor;
+
+//} ZYZGAUGE, *PZYZGAUGE, FAR *LPZYZGAUGE;
+
+
+/* some default values for the control */
+//#define ZYZG_DEF_RANGE 100
+//#define ZYZG_DEF_POSITION 0
+//#define ZYZG_DEF_ORIENTATION ZYZG_ORIENT_LEFTTORIGHT
+//#define ZYZG_DEF_WIDTH3D 2
+//#define ZYZG_DEF_BEZELFACE 2
+
+
+
+/* the default settings for drawing colors--display dependent */
+//static DWORD rgbDefTextColor;
+//static DWORD rgbDefBkColor;
+//static BOOL fSupport3D;
+
+//#if !defined(APIENTRY) // NT defines APIENTRY, 3.x not
+//#define APIENTRY _Optlink
+//#endif
+
+//#ifdef __WIN32__
+//#define _EXPORT /**/
+//#else
+//#define _EXPORT _export
+//typedef signed short int SHORT ;
+//#endif
+
+/* internal function prototypes */
+//static void PASCAL gaugePaint(HWND, HDC);
+/* LRESULT _Optlink */
+//LRESULT APIENTRY _EXPORT gaugeWndProc(HWND, UINT, WPARAM, LPARAM);
+
+
+
+///** BOOL _Optlink gaugeInit(HINSTANCE hInstance)
+// *
+// * DESCRIPTION:
+// * Registers the window class for the zYzGauge control. Performs
+// * other initialization for the zYzGauge text control. This must
+// * be done before the zYzGauge control is used--or it will fail
+// * and your dialog box will not open!
+// *
+// * ARGUMENTS:
+// * HINSTANCE hInstance : Instance handle to register class with.
+// *
+// * RETURN (BOOL FAR):
+// * The return value is TRUE if the zYzGauge class was successfully
+// * registered. It is FALSE if the initialization fails.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+//#pragma alloc_text(init, gaugeInit)
+
+//BOOL _Optlink gaugeInit(HINSTANCE hInstance)
+//{
+// static BOOL fRegistered = FALSE;
+// WNDCLASS wc;
+// HDC hdc;
+
+ /* assume already registered if not first instance */
+// if (fRegistered)
+// return (TRUE);
+
+ /* fill in the class structure for the zyzgauge control */
+// wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+// wc.hIcon = NULL;
+// wc.lpszMenuName = NULL;
+// wc.lpszClassName = gszzYzGaugeClass;
+// wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+// wc.hInstance = hInstance;
+
+//#ifdef ZYZGAUGE_DLL
+// wc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
+//#else
+// wc.style = CS_HREDRAW | CS_VREDRAW;
+//#endif
+
+// wc.lpfnWndProc = gaugeWndProc;
+// wc.cbClsExtra = 0;
+// wc.cbWndExtra = ZYZG_WW_EXTRABYTES;
+
+ /* attempt to register it--return FALSE if fail */
+// if (!RegisterClass(&wc))
+// return (FALSE);
+
+ /* Get a DC to determine whether device is mono or not, and set
+ * default foreground/background colors as appropriate.
+ */
+// hdc = CreateIC(wxT("DISPLAY"), NULL, NULL, 0L) ;
+// if (hdc)
+// {
+ /* check for mono-display */
+// if ((GetDeviceCaps(hdc, BITSPIXEL) == 1) &&
+// (GetDeviceCaps(hdc, PLANES) == 1))
+// {
+ /* using a mono DC--white foreground, black background */
+// rgbDefTextColor = RGB(255, 255, 255);
+// rgbDefBkColor = RGB(0, 0, 0);
+// }
+
+ /* good! we have color: blue foreground, white background */
+// else
+// {
+// rgbDefTextColor = RGB(0, 0, 255);
+// rgbDefBkColor = RGB(255, 255, 255);
+// }
+
+ /* need at _least_ 8 for two shades of gray (>=VGA) */
+// fSupport3D = (GetDeviceCaps(hdc, NUMCOLORS) >= 8) ? TRUE : FALSE;
+
+ /* get rid of the DC (IC) */
+// DeleteDC(hdc);
+// }
+
+ /* uh-oh... can't get DC (IC)... fail */
+// else
+// {
+ /* unregister the class */
+// UnregisterClass(gszzYzGaugeClass, hInstance);
+// return (FALSE);
+// }
+
+ /* return success */
+// return (fRegistered = TRUE);
+//} /* gaugeInit() */
+
+
+/** static void PASCAL gaugePaint(HWND hwnd, HDC hdc)
+// *
+// * DESCRIPTION:
+// * This function is responsible for painting the zYzGauge control.
+// *
+// * ARGUMENTS:
+// * HWND hwnd : The window handle for the gauge.
+// *
+// * HDC hdc : The DC for the gauge's window.
+// *
+// * RETURN (void):
+// * The control will have been painted.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+//static void PASCAL gaugePaint(HWND hwnd, HDC hdc)
+//{
+// PZYZGAUGE pgauge;
+// WORD iRange, iPos;
+// WORD Offset = 1;
+// DWORD dwExtent;
+// RECT rc1, rc2;
+// HFONT hFont;
+// wxChar ach[ 6 ];
+// WORD dx, dy, wGomerX, wGomerY;
+///* Win32s has no GetTextExtent(); let's try GetTextExtentPoint() instead,
+// * which needs a SIZE* parameter */
+//#if defined(__WIN32__)
+// SIZE size;
+//#endif
+
+// /* get pointer to the control's control block */
+// pgauge = (PZYZGAUGE)GetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE);
+// pgauge = (PZYZGAUGE)GetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE);
+
+ /* set the colors into for the gauge into the control */
+// SetTextColor(hdc, pgauge->rgbTextColor);
+// SetBkColor(hdc, pgauge->rgbBkColor);
+
+ /* draw black rectangle for gauge */
+// GetClientRect(hwnd, &rc1);
+
+ /* draw a black border on the _outside_ */
+// FrameRect(hdc, &rc1, (HBRUSH) GetStockObject(BLACK_BRUSH));
+
+ /* we want to draw _just inside_ the black border */
+// InflateRect(&rc1, -1, -1);
+
+ /* one line thick so far... */
+// Offset = (WORD) 1;
+
+ /* for 3D stuff, we need to have at least two shades of gray */
+// if ((GetWindowLong(hwnd, GWL_STYLE) & ZYZGS_3D) && fSupport3D)
+// {
+// Draw3DRect(hdc, &rc1, pgauge->wWidth3D, DRAW3D_OUT);
+// InflateRect(&rc1, ~(pgauge->wWidth3D), ~(pgauge->wWidth3D));
+
+// Draw3DFaceFrame(hdc, &rc1, pgauge->wWidthBezelFace);
+// InflateRect(&rc1, ~(pgauge->wWidthBezelFace), ~(pgauge->wWidthBezelFace));
+
+// Draw3DRect(hdc, &rc1, pgauge->wWidth3D, DRAW3D_IN);
+// InflateRect(&rc1, ~(pgauge->wWidth3D), ~(pgauge->wWidth3D));
+
+ /* draw a black border on the _inside_ */
+// FrameRect(hdc, &rc1, (HBRUSH) GetStockObject(BLACK_BRUSH));
+
+ /* we want to draw _just inside_ the black border */
+// InflateRect(&rc1, -1, -1);
+
+ /* add all the other pixels into the border width */
+// Offset += (2 * pgauge->wWidth3D) + pgauge->wWidthBezelFace + 1;
+// }
+
+ /* dup--one rc for 'how much filled', one rc for 'how much empty' */
+// rc2 = rc1;
+
+ /* get the range--make sure it's a valid range */
+// if ((iRange = pgauge->wRange) <= 0)
+// iRange = 1;
+
+ /* get the position--greater than 100% would be bad */
+// if ((iPos = pgauge->wPosition) > iRange)
+// iPos = iRange;
+
+ /* compute the actual size of the gauge */
+// dx = rc1.right - rc1.left;
+// dy = rc1.bottom - rc1.top;
+// wGomerX = (WORD)((DWORD)iPos * dx / iRange);
+// wGomerY = (WORD)((DWORD)iPos * dy / iRange);
+
+ /* get the orientation and munge rects accordingly */
+// switch (pgauge->wOrientation)
+// {
+// case ZYZG_ORIENT_RIGHTTOLEFT:
+// rc1.left = rc2.right = rc1.right - wGomerX;
+// break;
+
+// case ZYZG_ORIENT_BOTTOMTOTOP:
+// rc1.top = rc2.bottom = rc1.bottom - wGomerY;
+// break;
+
+// case ZYZG_ORIENT_TOPTOBOTTOM:
+// rc1.bottom = rc2.top += wGomerY;
+// break;
+
+// default:
+// rc1.right = rc2.left += wGomerX;
+// break;
+// } /* switch () */
+
+ /* select the correct font */
+// hFont = (HFONT) SelectObject(hdc, pgauge->hFont);
+
+ /* build up a string to blit out--ie the meaning of life: "42%" */
+// wsprintf(ach, wxT("%3d%%"), (WORD)((DWORD)iPos * 100 / iRange));
+/* Win32s has no GetTextExtent(); let's try GetTextExtentPoint() instead */
+//#if defined(__WIN32__)
+// GetTextExtentPoint(hdc, ach, wGomerX = lstrlen(ach), &size);
+// dwExtent = size.cx;
+//#else
+// dwExtent = GetTextExtent(hdc, ach, wGomerX = lstrlen(ach));
+//#endif
+
+
+ /* Draw the finished (ie the percent done) side of box. If
+ * ZYZG_WW_POSITION is 42, (in range of 0 to 100) this ExtTextOut
+ * draws the meaning of life (42%) bar.
+ */
+// ExtTextOut(hdc, (dx - LOWORD(dwExtent)) / 2 + Offset,
+// (dy - HIWORD(dwExtent)) / 2 + Offset,
+// ETO_OPAQUE | ETO_CLIPPED, &rc2, ach, wGomerX, NULL);
+
+ /* Reverse fore and back colors for drawing the undone (ie the non-
+ * finished) side of the box.
+ */
+// SetBkColor(hdc, pgauge->rgbTextColor);
+// SetTextColor(hdc, pgauge->rgbBkColor);
+
+// ExtTextOut(hdc, (dx - LOWORD(dwExtent)) / 2 + Offset,
+// (dy - HIWORD(dwExtent)) / 2 + Offset,
+// ETO_OPAQUE | ETO_CLIPPED, &rc1, ach, wGomerX, NULL);
+
+ /* unselect the font */
+// SelectObject(hdc, hFont);
+//} /* gaugePaint() */
+
+
+/** LRESULT _Optlink gaugeWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+// *
+// * DESCRIPTION:
+// * This is the control's window procedure. Its purpose is to handle
+// * special messages for this custom control.
+// *
+// * The special control messages for the gauge control are:
+// *
+// * ZYZG_SETRANGE : Sets the range of the gauge. In other
+// * words, the number of parts that make a
+// * whole.
+// *
+// * ZYZG_GETRANGE : Returns the current range of the gauge.
+// *
+// * ZYZG_SETORIENTATION : Sets the orientation of the gauge. This
+// * can be one of the ZYZG_ORIENT_?? msgs.
+// *
+// * ZYZG_GETORIENTATION : Gets the current orientation of the
+// * gauge.
+// *
+// * ZYZG_SETPOSITION : Sets the current position of the gauge.
+// * In other words, how many pieces of the
+// * whole have been used.
+// *
+// * ZYZG_GETPOSITION : Gets the current position of the gauge.
+// *
+// * ZYZG_SETDELTAPOS : Sets the position of the gauge +/- the
+// * specified amount.
+// *
+// * ZYZG_SETFGCOLOR : Sets the foreground (percent done) color.
+// *
+// * ZYZG_GETFGCOLOR : Gets the foreground (percent done) color.
+// *
+// * ZYZG_SETBKCOLOR : Sets the background (percent not done)
+// * color.
+// *
+// * ZYZG_GETBKCOLOR : Gets the background (percent not done)
+// * color.
+// *
+// * WM_SETFONT : Sets the font to use for the percentage
+// * text of the gauge.
+// *
+// * WM_GETFONT : Gets the current font in use by the
+// * gauge.
+// *
+// * NOTES:
+// *
+// ** cjp */
+
+/* LRESULT _Optlink */
+
+//LRESULT APIENTRY _EXPORT gaugeWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+//{
+// HFONT hFont;
+// PAINTSTRUCT ps;
+// PZYZGAUGE pgauge;
+// RECT rc;
+
+// pgauge = (PZYZGAUGE)GetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE);
+// pgauge = (PZYZGAUGE)GetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE);
+
+ /* break to get DefWindowProc() */
+// switch (uMsg)
+// {
+// case WM_CREATE:
+ /* need to allocate a control block */
+// pgauge = (PZYZGAUGE)LocalAlloc(LPTR, sizeof(ZYZGAUGE));
+// pgauge = (PZYZGAUGE)malloc(sizeof(ZYZGAUGE));
+// if (!pgauge)
+// return (0L);
+
+ /* hang on to this control block */
+// SetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE, (WORD)pgauge);
+// SetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE, (LONG)pgauge);
+
+ /* fill control block with defaults */
+// pgauge->wRange = ZYZG_DEF_RANGE;
+// pgauge->wPosition = ZYZG_DEF_POSITION;
+// pgauge->wOrientation = ZYZG_DEF_ORIENTATION;
+// pgauge->wWidth3D = ZYZG_DEF_WIDTH3D;
+// pgauge->wWidthBezelFace = ZYZG_DEF_BEZELFACE;
+// pgauge->rgbTextColor = rgbDefTextColor;
+// pgauge->rgbBkColor = rgbDefBkColor;
+
+ /* use system font */
+// SendMessage(hwnd, WM_SETFONT, (WPARAM)NULL, 0L);
+
+ /* go to DefWindowProc() to finish the job */
+// break;
+
+// case WM_DESTROY:
+ /* get rid of the control's memory */
+// if (pgauge)
+// LocalFree((HANDLE)pgauge);
+// free(pgauge);
+// break;
+
+// case ZYZG_GETPOSITION:
+// return (pgauge->wPosition);
+
+// case ZYZG_GETRANGE:
+// return (pgauge->wRange);
+
+// case ZYZG_GETORIENTATION:
+// return (pgauge->wOrientation);
+
+// case ZYZG_GETWIDTH3D:
+// return (pgauge->wWidth3D);
+
+// case ZYZG_GETBEZELFACE:
+// return (pgauge->wWidthBezelFace);
+
+// case ZYZG_GETBKCOLOR:
+// return (pgauge->rgbTextColor);
+
+// case ZYZG_GETFGCOLOR:
+// return (pgauge->rgbBkColor);
+
+// case ZYZG_SETBKCOLOR:
+// pgauge->rgbBkColor = lParam;
+// return (0L);
+
+// case ZYZG_SETFGCOLOR:
+// pgauge->rgbTextColor = lParam;
+// return (0L);
+
+
+// case ZYZG_SETPOSITION:
+// pgauge->wPosition = wParam;
+
+//zyzgForceRepaint:
+// GetClientRect(hwnd, &rc);
+// if ((GetWindowLong(hwnd, GWL_STYLE) & ZYZGS_3D) && fSupport3D)
+// {
+// wParam = (2 * pgauge->wWidth3D) +
+// pgauge->wWidthBezelFace + 2;
+// }
+
+// else
+// wParam = 1;
+
+// InflateRect(&rc, ~(wParam), ~(wParam));
+// InvalidateRect(hwnd, &rc, FALSE);
+// UpdateWindow(hwnd);
+// return (0L);
+
+// case ZYZG_SETRANGE:
+// pgauge->wRange = wParam;
+// goto zyzgForceRepaint;
+
+// case ZYZG_SETORIENTATION:
+// pgauge->wOrientation = wParam;
+// goto zyzgForceRepaint;
+
+// case ZYZG_SETWIDTH3D:
+// pgauge->wWidth3D = wParam;
+
+//zyzgForceRepaint3D:
+// InvalidateRect(hwnd, NULL, FALSE);
+// UpdateWindow(hwnd);
+// return (0L);
+
+// case ZYZG_SETBEZELFACE:
+// pgauge->wWidthBezelFace = wParam;
+// goto zyzgForceRepaint3D;
+
+// case ZYZG_SETDELTAPOS:
+///* Watcom doesn't like the following line so removing typecasts */
+///* (int)pgauge->wPosition += (int)wParam; */
+// pgauge->wPosition += wParam;
+// goto zyzgForceRepaint;
+
+// case WM_PAINT:
+// BeginPaint(hwnd, &ps);
+// gaugePaint(hwnd, ps.hdc);
+// EndPaint(hwnd, &ps);
+// return (0L);
+
+// case WM_GETFONT:
+// hFont = pgauge->hFont;
+
+// /* if system font, then return NULL handle */
+// return (long)((hFont == GetStockObject(SYSTEM_FONT)) ? NULL : hFont);
+
+// case WM_SETFONT:
+ /* if NULL hFont, use system font */
+// hFont = (HFONT)wParam ;
+// if (!hFont)
+// hFont = (HFONT) GetStockObject(SYSTEM_FONT);
+
+// pgauge->hFont = hFont;
+
+ /* redraw if indicated in message */
+// if ((BOOL)lParam)
+// {
+// InvalidateRect(hwnd, NULL, TRUE);
+// UpdateWindow(hwnd);
+// }
+// return (0L);
+// } /* switch () */
+
+ /* let the dialog mangler take care of this message */
+// return (DefWindowProc(hwnd, uMsg, wParam, lParam));
+//} /* gaugeWndProc() */
+
+
+/** EOF: zyzgauge.c **/
+
+
projects / wxWidgets.git / blobdiff