Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
45016e1a6bfed375993470efa844b94a42a41c73
wxWidgets/src/os2/gauge.cpp
David Webster 45016e1a6b *** empty log message *** 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3898 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1999-10-09 04:19:01 +00:00

1147 lines
36 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// Name: gauge.cpp
// Purpose: wxGauge class
// Author: David Webster
// Modified by:
// Created: 10/06/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#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"
/* 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);
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif
bool wxGauge::Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
static bool wxGaugeOS2Initialised = FALSE;
if ( !wxGaugeOS2Initialised )
{
if (!gaugeInit((HINSTANCE) wxGetInstance()))
wxFatalError("Cannot initalize Gauge library");
wxGaugeOS2Initialised = TRUE;
}
SetName(name);
SetValidator(validator);
if (parent) parent->AddChild(this);
m_rangeMax = range;
m_gaugePos = 0;
m_windowStyle = style;
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
// TODO
/*
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
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 ::SendMessage(GetHwnd(), ZYZG_SETWIDTH3D, w, 0);
}
void wxGauge::SetBezelFace(int w)
{
// TODO optional ::SendMessage(GetHwnd(), ZYZG_SETBEZELFACE, w, 0);
}
void wxGauge::SetRange(int r)
{
m_rangeMax = r;
// TODO ::SendMessage(GetHwnd(), ZYZG_SETRANGE, r, 0);
}
void wxGauge::SetValue(int pos)
{
m_gaugePos = pos;
// TODO ::SendMessage(GetHwnd(), ZYZG_SETPOSITION, pos, 0);
}
int wxGauge::GetShadowWidth() const
{
// TODO return (int) ::SendMessage(GetHwnd(), ZYZG_GETWIDTH3D, 0, 0);
return 0;
}
int wxGauge::GetBezelFace() const
{
// 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 **/
Reference in New Issue View Git Blame Copy Permalink