src/msw/gaugemsw.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gaugemsw.cpp
   3 // Purpose:     wxGaugeMSW class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "gauge.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/defs.h"
  25 #endif
  26
  27 #if wxUSE_GAUGE
  28
  29 #include "wx/msw/gaugemsw.h"
  30 #include "wx/msw/private.h"
  31
  32 /* gas gauge graph control messages--class "zYzGauge" */
  33 #define ZYZG_SETRANGE       (WM_USER + 0)
  34 #define ZYZG_GETRANGE       (WM_USER + 1)
  35 #define ZYZG_SETPOSITION    (WM_USER + 2)
  36 #define ZYZG_GETPOSITION    (WM_USER + 3)
  37 #define ZYZG_SETORIENTATION (WM_USER + 4)
  38 #define ZYZG_GETORIENTATION (WM_USER + 5)
  39 #define ZYZG_SETFGCOLOR     (WM_USER + 6)
  40 #define ZYZG_GETFGCOLOR     (WM_USER + 7)
  41 #define ZYZG_SETBKCOLOR     (WM_USER + 8)
  42 #define ZYZG_GETBKCOLOR     (WM_USER + 9)
  43 #define ZYZG_SETWIDTH3D     (WM_USER + 10)
  44 #define ZYZG_GETWIDTH3D     (WM_USER + 11)
  45 #define ZYZG_SETBEZELFACE   (WM_USER + 12)
  46 #define ZYZG_GETBEZELFACE   (WM_USER + 13)
  47 #define ZYZG_SETDELTAPOS    (WM_USER + 14)
  48
  49
  50 /* orientations for ZYZG_WW_ORIENTATION */
  51 #define ZYZG_ORIENT_LEFTTORIGHT     0
  52 #define ZYZG_ORIENT_RIGHTTOLEFT     1
  53 #define ZYZG_ORIENT_BOTTOMTOTOP     2
  54 #define ZYZG_ORIENT_TOPTOBOTTOM     3
  55
  56 /* gauge styles */
  57 #define ZYZGS_3D        0x8000L     /* control will be 3D       */
  58
  59 /* public function prototypes */
  60 BOOL FAR PASCAL gaugeInit(HINSTANCE hInstance);
  61
  62 #if !USE_SHARED_LIBRARY
  63 IMPLEMENT_DYNAMIC_CLASS(wxGaugeMSW, wxControl)
  64 #endif
  65
  66 bool wxGaugeMSW::Create(wxWindow *parent, wxWindowID id,
  67            int range,
  68            const wxPoint& pos,
  69            const wxSize& size,
  70            long style,
  71            const wxValidator& validator,
  72            const wxString& name)
  73 {
  74   static bool wxGaugeMSWInitialised = FALSE;
  75
  76   if ( !wxGaugeMSWInitialised )
  77   {
  78     if (!gaugeInit((HINSTANCE) wxGetInstance()))
  79         wxFatalError("Cannot initalize Gauge library");
  80         wxGaugeMSWInitialised = TRUE;
  81   }
  82
  83   SetName(name);
  84   SetValidator(validator);
  85
  86   if (parent) parent->AddChild(this);
  87   m_rangeMax = range;
  88   m_gaugePos = 0;
  89
  90   SetBackgroundColour(parent->GetBackgroundColour()) ;
  91   SetForegroundColour(parent->GetForegroundColour()) ;
  92
  93   m_windowStyle = style;
  94
  95   if ( id == -1 )
  96         m_windowId = (int)NewControlId();
  97   else
  98         m_windowId = id;
  99
 100   int x = pos.x;
 101   int y = pos.y;
 102   int width = size.x;
 103   int height = size.y;
 104
 105   long msFlags = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
 106   msFlags |= ZYZGS_3D;
 107
 108   HWND wx_button =
 109       CreateWindowEx(MakeExtendedStyle(m_windowStyle), "zYzGauge", NULL, msFlags,
 110                     0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
 111                     wxGetInstance(), NULL);
 112
 113   m_hWnd = (WXHWND)wx_button;
 114
 115   // Subclass again for purposes of dialog editing mode
 116   SubclassWin((WXHWND)wx_button);
 117
 118   int wOrient = 0;
 119
 120   if (m_windowStyle & wxGA_HORIZONTAL)
 121     wOrient = ZYZG_ORIENT_LEFTTORIGHT;
 122   else
 123     wOrient = ZYZG_ORIENT_BOTTOMTOTOP;
 124
 125   SendMessage(wx_button, ZYZG_SETORIENTATION, wOrient, 0);
 126   SendMessage(wx_button, ZYZG_SETRANGE, range, 0);
 127
 128   SendMessage((HWND) GetHWND(), ZYZG_SETFGCOLOR, 0, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
 129   SendMessage((HWND) GetHWND(), ZYZG_SETBKCOLOR, 0, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
 130
 131   SetFont(parent->GetFont());
 132
 133   if (width == -1)
 134     width = 50;
 135   if (height == -1)
 136     height = 50;
 137   SetSize(x, y, width, height);
 138
 139   ShowWindow((HWND) GetHWND(), SW_SHOW);
 140
 141   return TRUE;
 142 }
 143
 144 void wxGaugeMSW::SetSize(int x, int y, int width, int height, int sizeFlags)
 145 {
 146   int currentX, currentY;
 147   GetPosition(&currentX, &currentY);
 148   int x1 = x;
 149   int y1 = y;
 150   int w1 = width;
 151   int h1 = height;
 152
 153   if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 154     x1 = currentX;
 155   if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 156     y1 = currentY;
 157
 158   AdjustForParentClientOrigin(x1, y1, sizeFlags);
 159
 160   // If we're prepared to use the existing size, then...
 161   if (width == -1 && height == -1 && ((sizeFlags & wxSIZE_AUTO) != wxSIZE_AUTO))
 162   {
 163     GetSize(&w1, &h1);
 164   }
 165
 166   // Deal with default size (using -1 values)
 167   if (w1<=0)
 168     w1 = DEFAULT_ITEM_WIDTH;
 169
 170   if (h1<=0)
 171     h1 = DEFAULT_ITEM_HEIGHT;
 172
 173   MoveWindow((HWND) GetHWND(), x1, y1, w1, h1, TRUE);
 174 }
 175
 176 void wxGaugeMSW::SetShadowWidth(int w)
 177 {
 178   SendMessage((HWND) GetHWND(), ZYZG_SETWIDTH3D, w, 0);
 179 }
 180
 181 void wxGaugeMSW::SetBezelFace(int w)
 182 {
 183   SendMessage((HWND) GetHWND(), ZYZG_SETBEZELFACE, w, 0);
 184 }
 185
 186 void wxGaugeMSW::SetRange(int r)
 187 {
 188   m_rangeMax = r;
 189
 190   SendMessage((HWND) GetHWND(), ZYZG_SETRANGE, r, 0);
 191 }
 192
 193 void wxGaugeMSW::SetValue(int pos)
 194 {
 195   m_gaugePos = pos;
 196
 197   SendMessage((HWND) GetHWND(), ZYZG_SETPOSITION, pos, 0);
 198 }
 199
 200 int wxGaugeMSW::GetShadowWidth(void) const
 201 {
 202   return (int) SendMessage((HWND) GetHWND(), ZYZG_GETWIDTH3D, 0, 0);
 203 }
 204
 205 int wxGaugeMSW::GetBezelFace(void) const
 206 {
 207   return (int) SendMessage((HWND) GetHWND(), ZYZG_GETBEZELFACE, 0, 0);
 208 }
 209
 210 int wxGaugeMSW::GetRange(void) const
 211 {
 212   return (int) SendMessage((HWND) GetHWND(), ZYZG_GETRANGE, 0, 0);
 213 }
 214
 215 int wxGaugeMSW::GetValue(void) const
 216 {
 217   return (int) SendMessage((HWND) GetHWND(), ZYZG_GETPOSITION, 0, 0);
 218 }
 219
 220 void wxGaugeMSW::SetForegroundColour(const wxColour& col)
 221 {
 222   m_foregroundColour = col ;
 223   SendMessage((HWND) GetHWND(), ZYZG_SETFGCOLOR, 0, RGB(col.Red(), col.Green(), col.Blue()));
 224 }
 225
 226 void wxGaugeMSW::SetBackgroundColour(const wxColour& col)
 227 {
 228   m_backgroundColour = col ;
 229   SendMessage((HWND) GetHWND(), ZYZG_SETBKCOLOR, 0, RGB(col.Red(), col.Green(), col.Blue()));
 230 }
 231
 232
 233 /** zyz3d.c
 234  *
 235  *  DESCRIPTION:
 236  *      This module contains functions for creating nifty 3D borders
 237  *      around controls like zYzGauge.
 238  *
 239  *  HISTORY:
 240  *      3/14/91     cjp     put in this comment
 241  *      6/19/92     cjp     touched it a bit
 242  *
 243  ** cjp */
 244 // COPYRIGHT:
 245 //
 246 //   (C) Copyright Microsoft Corp. 1992.  All rights reserved.
 247 //
 248 //   You have a royalty-free right to use, modify, reproduce and
 249 //   distribute the Sample Files (and/or any modified version) in
 250 //   any way you find useful, provided that you agree that
 251 //   Microsoft has no warranty obligations or liability for any
 252 //   Sample Application Files which are modified.
 253 //
 254
 255
 256 /* get the includes we need */
 257 #include <windows.h>
 258
 259 /* misc. control flag defines */
 260 #define DRAW3D_IN           0x0001
 261 #define DRAW3D_OUT          0x0002
 262
 263 #define DRAW3D_TOPLINE      0x0004
 264 #define DRAW3D_BOTTOMLINE   0x0008
 265 #define DRAW3D_LEFTLINE     0x0010
 266 #define DRAW3D_RIGHTLINE    0x0020
 267
 268
 269 /* public function prototypes */
 270 void FAR PASCAL Draw3DFaceFrame(HDC, LPRECT, WORD);
 271 void FAR PASCAL Draw3DRect(HDC, LPRECT, WORD, WORD);
 272 void FAR PASCAL Draw3DLine(HDC, WORD, WORD, WORD, WORD, WORD);
 273
 274
 275 /** void FAR PASCAL Draw3DFaceFrame(HDC hdc, LPRECT rc, WORD wWidth)
 276  *
 277  *  DESCRIPTION:
 278  *      This function draws a flat frame with the current button-face
 279  *      color.
 280  *
 281  *  ARGUMENTS:
 282  *      HDC hdc     :   The DC to draw into.
 283  *
 284  *      LPRECT rc   :   The containing rect for the new frame.
 285  *
 286  *      WORD wWidth :   The width of the frame to draw.
 287  *
 288  *  RETURN (void FAR PASCAL):
 289  *      The frame will have been drawn into the DC.
 290  *
 291  *  NOTES:
 292  *
 293  ** cjp */
 294
 295 void FAR PASCAL Draw3DFaceFrame(HDC hdc, LPRECT rc, WORD wWidth)
 296 {
 297     RECT    rc1;
 298     DWORD   rgbOld;
 299
 300     /* don't go through a bunch of work if we don't have to */
 301     if (!wWidth)
 302         return;
 303
 304     /* set up color to be button-face color--so it may not be gray */
 305     rgbOld = SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
 306
 307     /* perform CopyRect w/o bloody windows style overhead */
 308     rc1 = *rc;
 309
 310     /* top */
 311     rc1.top = rc->top;
 312     rc1.left = rc->left;
 313     rc1.bottom = rc->top + wWidth;
 314     rc1.right = rc->right;
 315
 316     /* blast it out */
 317     ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
 318
 319     /* right */
 320     rc1.left = rc->right - wWidth;
 321     rc1.bottom = rc->bottom;
 322
 323     /* blast this part now */
 324     ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
 325
 326     /* left */
 327     rc1.left = rc->left;
 328     rc1.right = rc->left + wWidth;
 329
 330     /* and another part */
 331     ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
 332
 333     /* bottom */
 334     rc1.right = rc->right;
 335     rc1.top = rc->bottom - wWidth;
 336
 337     /* finish it off */
 338     ExtTextOut(hdc, rc1.left, rc1.top, ETO_OPAQUE, &rc1, NULL, 0, NULL);
 339
 340     /* restore the old bk color */
 341     SetBkColor(hdc, rgbOld);
 342 } /* Draw3DFaceFrame() */
 343
 344
 345 /** void FAR PASCAL Draw3DRect(HDC, LPRECT, WORD, WORD)
 346  *
 347  *  DESCRIPTION:
 348  *      Draws a 3D rectangle that is shaded.  wFlags can be used to
 349  *      control how the rectangle looks.
 350  *
 351  *  ARGUMENTS:
 352  *      HDC hdc             :   Handle to the device context that will be
 353  *                              used to display the rectangle.
 354  *
 355  *      RECT rect           :   A rectangle describing the dimensions of
 356  *                              the rectangle in device coordinates.
 357  *
 358  *      WORD wShadowWidth   :   Width of the shadow in device coordinates.
 359  *
 360  *      WORD wFlags         :   The following flags may be passed to describe
 361  *                              the style of the rectangle:
 362  *
 363  *                              DRAW3D_IN   :   The shadow is drawn such that
 364  *                              the box appears to be sunk in to the screen.
 365  *                              This is default if 0 is passed.
 366  *
 367  *                              DRAW3D_OUT  :   The shadow is drawn such that
 368  *                              the box appears to be sticking out of the
 369  *                              screen.
 370  *
 371  *  RETURN (void FAR PASCAL):
 372  *      The 3D looking rectangle will have been drawn into the DC.
 373  *
 374  *  NOTES:
 375  *
 376  ** cjp */
 377
 378 void FAR PASCAL Draw3DRect(HDC hdc, LPRECT lpRect,
 379                                WORD wShadowWidth, WORD wFlags)
 380 {
 381     /* sanity check--don't work if you don't have to! */
 382     if (!wShadowWidth || !RectVisible(hdc, lpRect))
 383         return;
 384
 385     /* draw the top line */
 386     Draw3DLine(hdc, lpRect->left, lpRect->top,
 387                     lpRect->right - lpRect->left,
 388                     wShadowWidth, DRAW3D_TOPLINE | wFlags);
 389
 390     /* right line */
 391     Draw3DLine(hdc, lpRect->right, lpRect->top,
 392                     lpRect->bottom - lpRect->top,
 393                     wShadowWidth, DRAW3D_RIGHTLINE | wFlags);
 394
 395     /* bottom line */
 396     Draw3DLine(hdc, lpRect->left, lpRect->bottom,
 397                     lpRect->right - lpRect->left,
 398                     wShadowWidth, DRAW3D_BOTTOMLINE | wFlags);
 399
 400     /* left line */
 401     Draw3DLine(hdc, lpRect->left, lpRect->top,
 402                     lpRect->bottom - lpRect->top,
 403                     wShadowWidth, DRAW3D_LEFTLINE | wFlags);
 404 } /* Draw3DRect() */
 405
 406
 407 /** void FAR PASCAL Draw3DLine(HDC hdc, WORD x, WORD y, WORD nLen,
 408  *
 409  *  DESCRIPTION:
 410  *      Draws a 3D line that can be used to make a 3D box.
 411  *
 412  *  ARGUMENTS:
 413  *      HDC hdc             :   Handle to the device context that will be
 414  *                              used to display the 3D line.
 415  *
 416  *      WORD x, y           :   Coordinates of the beginning of the line.
 417  *                              These coordinates are in device units and
 418  *                              represent the _outside_ most point. Horiz-
 419  *                              ontal lines are drawn from left to right and
 420  *                              vertical lines are drawn from top to bottom.
 421  *
 422  *      WORD wShadowWidth   :   Width of the shadow in device coordinates.
 423  *
 424  *      WORD  wFlags        :   The following flags may be passed to
 425  *                              describe the style of the 3D line:
 426  *
 427  *                              DRAW3D_IN   :   The shadow is drawn such that
 428  *                              the box appears to be sunk in to the screen.
 429  *                              This is default if 0 is passed.
 430  *
 431  *                              DRAW3D_OUT  :   The shadow is drawn such that
 432  *                              the box appears to be sticking out of the
 433  *                              screen.
 434  *
 435  *                              DRAW3D_TOPLINE, _BOTTOMLINE, _LEFTLINE, and
 436  *                              _RIGHTLINE  :   Specifies that a "top",
 437  *                              "Bottom", "Left", or"Right" line is to be
 438  *                              drawn.
 439  *
 440  *  RETURN (void FAR PASCAL):
 441  *      The line will have been drawn into the DC.
 442  *
 443  *  NOTES:
 444  *
 445  ** cjp */
 446
 447 void FAR PASCAL Draw3DLine(HDC hdc, WORD x, WORD y, WORD nLen,
 448                                WORD wShadowWidth, WORD wFlags)
 449 {
 450     HBRUSH  hOldBrush;
 451     HPEN    hOldPen;
 452     BOOL    fDark;
 453     POINT   Point[ 4 ];         /* define a polgon with 4 points    */
 454
 455     /* if width is zero, don't do nothin'! */
 456     if (!wShadowWidth)
 457         return;
 458
 459     /* define shape of polygon--origin is always the same */
 460     Point[0].x = x;
 461     Point[0].y = y;
 462
 463     /*  To do this we'll simply draw a polygon with four sides, using
 464      *  the appropriate brush.  I dare you to ask me why this isn't a
 465      *  switch/case!
 466      */
 467     if (wFlags & DRAW3D_TOPLINE)
 468     {
 469         /* across to right */
 470         Point[1].x = x + nLen - (wShadowWidth == 1 ? 1 : 0);
 471         Point[1].y = y;
 472
 473         /* down/left */
 474         Point[2].x = x + nLen - wShadowWidth;
 475         Point[2].y = y + wShadowWidth;
 476
 477         /* accross to left */
 478         Point[3].x = x + wShadowWidth;
 479         Point[3].y = y + wShadowWidth;
 480
 481         /* select 'dark' brush if 'in'--'light' for 'out' */
 482         fDark = (wFlags & DRAW3D_IN) ? TRUE : FALSE;
 483     }
 484
 485     /* possibly the bottom? */
 486     else if (wFlags & DRAW3D_BOTTOMLINE)
 487     {
 488         /* across to right */
 489         Point[1].x = x + nLen;
 490         Point[1].y = y;
 491
 492         /* up/left */
 493         Point[2].x = x + nLen - wShadowWidth;
 494         Point[2].y = y - wShadowWidth;
 495
 496         /* accross to left */
 497         Point[3].x = x + wShadowWidth;
 498         Point[3].y = y - wShadowWidth;
 499
 500         /* select 'light' brush if 'in' */
 501         fDark = (wFlags & DRAW3D_IN) ? FALSE : TRUE;
 502     }
 503
 504     /* ok, it's gotta be left? */
 505     else if (wFlags & DRAW3D_LEFTLINE)
 506     {
 507         /* down */
 508         Point[1].x = x;
 509         Point[1].y = y + nLen - (wShadowWidth == 1 ? 1 : 0);
 510
 511         /* up/right */
 512         Point[2].x = x + wShadowWidth;
 513         Point[2].y = y + nLen - wShadowWidth;
 514
 515         /* down */
 516         Point[3].x = x + wShadowWidth;
 517         Point[3].y = y + wShadowWidth;
 518
 519         /* select 'dark' brush if 'in'--'light' for 'out' */
 520         fDark = (wFlags & DRAW3D_IN) ? TRUE : FALSE;
 521     }
 522
 523     /* well maybe it's for the right side? */
 524     else if (wFlags & DRAW3D_RIGHTLINE)
 525     {
 526         /* down */
 527         Point[1].x = x;
 528         Point[1].y = y + nLen;
 529
 530         /* up/left */
 531         Point[2].x = x - wShadowWidth;
 532         Point[2].y = y + nLen - wShadowWidth;
 533
 534         /* up */
 535         Point[3].x = x - wShadowWidth;
 536         Point[3].y = y + wShadowWidth;
 537
 538         /* select 'light' brush if 'in' */
 539         fDark = (wFlags & DRAW3D_IN) ? FALSE : TRUE;
 540     }
 541
 542     /* bad drugs? */
 543     else return;
 544
 545     /* select NULL_PEN for no borders */
 546     hOldPen = (HPEN) SelectObject(hdc, GetStockObject(NULL_PEN));
 547
 548     /* select the appropriate color for the fill */
 549     if (fDark)
 550         hOldBrush = (HBRUSH) SelectObject(hdc, GetStockObject(GRAY_BRUSH));
 551     else
 552         hOldBrush = (HBRUSH) SelectObject(hdc, GetStockObject(WHITE_BRUSH));
 553
 554     /* finally, draw the dern thing */
 555     Polygon(hdc, (LPPOINT)&Point, 4);
 556
 557     /* restore what we killed */
 558     SelectObject(hdc, hOldBrush);
 559     SelectObject(hdc, hOldPen);
 560 } /* Draw3DLine() */
 561
 562 /** EOF: zyz3d.c **/
 563
 564 /** zyzgauge.c
 565  *
 566  *  DESCRIPTION:
 567  *      Yet another 'Gas Gauge Custom Control.'  This control gives you
 568  *      a 'progress bar' class (named zYzGauge) for use in your applications.
 569  *      You can set the range, position, font, color, orientation, and 3d
 570  *      effect of the gauge by sending messages to the control.
 571  *
 572  *      Before you can use this control, you MUST first export the window
 573  *      procedure for the control (or define it with the _export keyword):
 574  *
 575  *          EXPORTS     gaugeWndProc
 576  *
 577  *      You then need initialize the class before you use it:
 578  *
 579  *          if (!gaugeInit(hInstance))
 580  *              die a horrible death
 581  *          else
 582  *              you are good to go
 583  *
 584  *      The colors used by the control default to black and white if you
 585  *      are running on a mono-display.  They default to blue and white
 586  *      if you are on a color display.  You enable the 3D effect by setting
 587  *      the ZYZGS_3D style flag in the styles field of the control (like
 588  *      any other control).
 589  *
 590  *      To select your own colors, you can send the ZYZG_SETFGCOLOR and
 591  *      ZYZG_SETBKCOLOR messages to set the foreground (percent done) and
 592  *      background (percent not done) colors.  The lParam is the RGB()
 593  *      value--wParam is ignored.
 594  *
 595  *      In all of the following ZYZG_??? messages, the arguments are
 596  *      WORDS.  If you are setting parameters, the value is sent as
 597  *      the wParam (lParam is ignored).  If you are getting parameters,
 598  *      the value is returned as a LONG and should be cast to a *signed*
 599  *      integer.
 600  *
 601  *      To set the depth of the 3D effect (if enabled), you can send the
 602  *      ZYZG_SETBEZELFACE and ZYZG_SETWIDTH3D messages.  The bezel face
 603  *      is the flat top on the 3D border--its color will be that of the
 604  *      button-face.  The 3D width is the width of the bezel itself; inside
 605  *      and outside.  The light color is white, the dark color is gray.
 606  *      Both widths *can* be zero--both default to 2 which looks to me.
 607  *
 608  *      The range of the control can be set by sending the ZYZG_SETRANGE
 609  *      message to the control.  It can be any integer from 1 to 32767.
 610  *      What this specifies is the number of pieces that create a whole.
 611  *      The default is 100.  You can get the current range setting by
 612  *      sending the ZYZG_GETRANGE message to the control.
 613  *
 614  *      The position (number of pieces out of the whole have been used) is
 615  *      set with the ZYZG_SETPOSITION message.  It can be any integer from
 616  *      0 to the current range setting of the control--it will be clipped
 617  *      if the position is out of bounds.  The default position is 0.  You
 618  *      can get the current position at any time with the ZYZG_GETPOSITION
 619  *      message.
 620  *
 621  *      You can also set the range using a delta from the current range.
 622  *      This is done by sending the ZYZG_SETDELTAPOS message with wParam
 623  *      set to a _signed_ integer value within the range of the control.
 624  *
 625  *      The font used for the percentage text can be set using the standard
 626  *      WM_SETFONT message.  You can get the current font at any time with
 627  *      the WM_GETFONT message.
 628  *
 629  *      The orientation can be left to right, right to left, bottom to top,
 630  *      or top to bottom.  Whatever suits your needs.  You set this by
 631  *      sending the ZYZG_ORIENTATION message to the control with one of
 632  *      the following values (default is ZYZG_ORIENT_LEFTTORIGHT):
 633  *
 634  *          ZYZG_ORIENT_LEFTTORIGHT (0)
 635  *          ZYZG_ORIENT_RIGHTTOLEFT (1)
 636  *          ZYZG_ORIENT_BOTTOMTOTOP (2)
 637  *          ZYZG_ORIENT_TOPTOBOTTOM (3)
 638  *
 639  *  HISTORY:
 640  *      3/12/91     cjp     put in this comment
 641  *      6/19/92     cjp     touched it a bit
 642  *
 643  ** cjp */
 644 // COPYRIGHT:
 645 //
 646 //   (C) Copyright Microsoft Corp. 1992.  All rights reserved.
 647 //
 648 //   You have a royalty-free right to use, modify, reproduce and
 649 //   distribute the Sample Files (and/or any modified version) in
 650 //   any way you find useful, provided that you agree that
 651 //   Microsoft has no warranty obligations or liability for any
 652 //   Sample Application Files which are modified.
 653 //
 654
 655
 656 /* get the includes we need */
 657 #ifndef __GNUWIN32__
 658 #include <malloc.h>
 659 #endif
 660 #include <stdio.h>
 661 #include <string.h>
 662 #include <stdlib.h>
 663 // #include "zyz3d.h"
 664 // #include "zyzgauge.h"
 665
 666
 667 /* static global variables */
 668 static char gszzYzGaugeClass[] = "zYzGauge";
 669
 670
 671 /* window word position definitions */
 672 #define ZYZG_WW_PZYZGAUGE   0
 673 /* #define ZYZG_WW_EXTRABYTES  2 */
 674 #define ZYZG_WW_EXTRABYTES  4
 675
 676
 677 /* control block structure typedef */
 678 typedef struct tZYZGAUGE
 679 {
 680     WORD    wRange;
 681     WORD    wPosition;
 682     WORD    wOrientation;
 683     WORD    wWidth3D;
 684     WORD    wWidthBezelFace;
 685     HFONT   hFont;
 686     DWORD   rgbTextColor;
 687     DWORD   rgbBkColor;
 688
 689 } ZYZGAUGE, *PZYZGAUGE, FAR *LPZYZGAUGE;
 690
 691
 692 /* some default values for the control */
 693 #define ZYZG_DEF_RANGE          100
 694 #define ZYZG_DEF_POSITION       0
 695 #define ZYZG_DEF_ORIENTATION    ZYZG_ORIENT_LEFTTORIGHT
 696 #define ZYZG_DEF_WIDTH3D        2
 697 #define ZYZG_DEF_BEZELFACE      2
 698
 699
 700
 701 /* the default settings for drawing colors--display dependent */
 702 static DWORD    rgbDefTextColor;
 703 static DWORD    rgbDefBkColor;
 704 static BOOL     fSupport3D;
 705
 706 #if !defined(APIENTRY)  // NT defines APIENTRY, 3.x not
 707 #define APIENTRY FAR PASCAL
 708 #endif
 709
 710 #ifdef __WIN32__
 711 #define _EXPORT /**/
 712 #else
 713 #define _EXPORT _export
 714 typedef signed short int SHORT ;
 715 #endif
 716
 717 /* internal function prototypes */
 718 static void PASCAL gaugePaint(HWND, HDC);
 719 /* LRESULT FAR PASCAL */
 720 LRESULT APIENTRY _EXPORT gaugeWndProc(HWND, UINT, WPARAM, LPARAM);
 721
 722
 723
 724 /** BOOL FAR PASCAL gaugeInit(HINSTANCE hInstance)
 725  *
 726  *  DESCRIPTION:
 727  *      Registers the window class for the zYzGauge control.  Performs
 728  *      other initialization for the zYzGauge text control.  This must
 729  *      be done before the zYzGauge control is used--or it will fail
 730  *      and your dialog box will not open!
 731  *
 732  *  ARGUMENTS:
 733  *      HINSTANCE hInstance :   Instance handle to register class with.
 734  *
 735  *  RETURN (BOOL FAR):
 736  *      The return value is TRUE if the zYzGauge class was successfully
 737  *      registered.  It is FALSE if the initialization fails.
 738  *
 739  *  NOTES:
 740  *
 741  ** cjp */
 742
 743 //#pragma alloc_text(init, gaugeInit)
 744
 745 BOOL FAR PASCAL gaugeInit(HINSTANCE hInstance)
 746 {
 747     static BOOL fRegistered = FALSE;
 748     WNDCLASS    wc;
 749     HDC         hdc;
 750
 751     /* assume already registered if not first instance */
 752     if (fRegistered)
 753         return (TRUE);
 754
 755     /* fill in the class structure for the zyzgauge control */
 756     wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
 757     wc.hIcon            = NULL;
 758     wc.lpszMenuName     = NULL;
 759     wc.lpszClassName    = gszzYzGaugeClass;
 760     wc.hbrBackground    = (HBRUSH)(COLOR_WINDOW + 1);
 761     wc.hInstance        = hInstance;
 762
 763 #ifdef ZYZGAUGE_DLL
 764     wc.style            = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
 765 #else
 766     wc.style            = CS_HREDRAW | CS_VREDRAW;
 767 #endif
 768
 769     wc.lpfnWndProc      = gaugeWndProc;
 770     wc.cbClsExtra       = 0;
 771     wc.cbWndExtra       = ZYZG_WW_EXTRABYTES;
 772
 773     /* attempt to register it--return FALSE if fail */
 774     if (!RegisterClass(&wc))
 775         return (FALSE);
 776
 777     /*  Get a DC to determine whether device is mono or not, and set
 778      *  default foreground/background colors as appropriate.
 779      */
 780     if ((hdc = CreateIC("DISPLAY", NULL, NULL, 0L)))
 781     {
 782         /* check for mono-display */
 783         if ((GetDeviceCaps(hdc, BITSPIXEL) == 1) &&
 784              (GetDeviceCaps(hdc, PLANES) == 1))
 785         {
 786             /* using a mono DC--white foreground, black background */
 787             rgbDefTextColor = RGB(255, 255, 255);
 788             rgbDefBkColor = RGB(0, 0, 0);
 789         }
 790
 791         /* good! we have color: blue foreground, white background */
 792         else
 793         {
 794             rgbDefTextColor = RGB(0, 0, 255);
 795             rgbDefBkColor = RGB(255, 255, 255);
 796         }
 797
 798         /* need at _least_ 8 for two shades of gray (>=VGA) */
 799         fSupport3D = (GetDeviceCaps(hdc, NUMCOLORS) >= 8) ? TRUE : FALSE;
 800
 801         /* get rid of the DC (IC) */
 802         DeleteDC(hdc);
 803     }
 804
 805     /* uh-oh... can't get DC (IC)... fail */
 806     else
 807     {
 808         /* unregister the class */
 809         UnregisterClass(gszzYzGaugeClass, hInstance);
 810         return (FALSE);
 811     }
 812
 813     /* return success */
 814     return (fRegistered = TRUE);
 815 } /* gaugeInit() */
 816
 817
 818 /** static void PASCAL gaugePaint(HWND hwnd, HDC hdc)
 819  *
 820  *  DESCRIPTION:
 821  *      This function is responsible for painting the zYzGauge control.
 822  *
 823  *  ARGUMENTS:
 824  *      HWND hwnd   :   The window handle for the gauge.
 825  *
 826  *      HDC hdc     :   The DC for the gauge's window.
 827  *
 828  *  RETURN (void):
 829  *      The control will have been painted.
 830  *
 831  *  NOTES:
 832  *
 833  ** cjp */
 834
 835 static void PASCAL gaugePaint(HWND hwnd, HDC hdc)
 836 {
 837     PZYZGAUGE   pgauge;
 838     WORD        iRange, iPos;
 839     WORD        Offset = 1;
 840     DWORD       dwExtent;
 841     RECT        rc1, rc2;
 842     HFONT       hFont;
 843     char        ach[ 6 ];
 844     WORD        dx, dy, wGomerX, wGomerY;
 845 /* Win32s has no GetTextExtent(); let's try GetTextExtentPoint() instead,
 846  * which needs a SIZE* parameter */
 847 #if defined(__WIN32__)
 848     SIZE size;
 849 #endif
 850
 851     /* get pointer to the control's control block */
 852 //    pgauge = (PZYZGAUGE)GetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE);
 853     pgauge = (PZYZGAUGE)GetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE);
 854
 855     /* set the colors into for the gauge into the control */
 856     SetTextColor(hdc, pgauge->rgbTextColor);
 857     SetBkColor(hdc, pgauge->rgbBkColor);
 858
 859     /* draw black rectangle for gauge */
 860     GetClientRect(hwnd, &rc1);
 861
 862     /* draw a black border on the _outside_ */
 863     FrameRect(hdc, &rc1, (HBRUSH) GetStockObject(BLACK_BRUSH));
 864
 865     /* we want to draw _just inside_ the black border */
 866     InflateRect(&rc1, -1, -1);
 867
 868     /* one line thick so far... */
 869 //    Offset = (WORD) 1;
 870
 871     /* for 3D stuff, we need to have at least two shades of gray */
 872     if ((GetWindowLong(hwnd, GWL_STYLE) & ZYZGS_3D) && fSupport3D)
 873     {
 874         Draw3DRect(hdc, &rc1, pgauge->wWidth3D, DRAW3D_OUT);
 875         InflateRect(&rc1, ~(pgauge->wWidth3D), ~(pgauge->wWidth3D));
 876
 877         Draw3DFaceFrame(hdc, &rc1, pgauge->wWidthBezelFace);
 878         InflateRect(&rc1, ~(pgauge->wWidthBezelFace), ~(pgauge->wWidthBezelFace));
 879
 880         Draw3DRect(hdc, &rc1, pgauge->wWidth3D, DRAW3D_IN);
 881         InflateRect(&rc1, ~(pgauge->wWidth3D), ~(pgauge->wWidth3D));
 882
 883         /* draw a black border on the _inside_ */
 884         FrameRect(hdc, &rc1, (HBRUSH) GetStockObject(BLACK_BRUSH));
 885
 886         /* we want to draw _just inside_ the black border */
 887         InflateRect(&rc1, -1, -1);
 888
 889         /* add all the other pixels into the border width */
 890         Offset += (2 * pgauge->wWidth3D) + pgauge->wWidthBezelFace + 1;
 891     }
 892
 893     /* dup--one rc for 'how much filled', one rc for 'how much empty' */
 894     rc2 = rc1;
 895
 896     /* get the range--make sure it's a valid range */
 897     if ((iRange = pgauge->wRange) <= 0)
 898         iRange = 1;
 899
 900     /* get the position--greater than 100% would be bad */
 901     if ((iPos = pgauge->wPosition) > iRange)
 902         iPos = iRange;
 903
 904     /* compute the actual size of the gauge */
 905     dx = rc1.right - rc1.left;
 906     dy = rc1.bottom - rc1.top;
 907     wGomerX = (WORD)((DWORD)iPos * dx / iRange);
 908     wGomerY = (WORD)((DWORD)iPos * dy / iRange);
 909
 910     /* get the orientation and munge rects accordingly */
 911     switch (pgauge->wOrientation)
 912     {
 913         case ZYZG_ORIENT_RIGHTTOLEFT:
 914             rc1.left = rc2.right = rc1.right - wGomerX;
 915             break;
 916
 917         case ZYZG_ORIENT_BOTTOMTOTOP:
 918             rc1.top = rc2.bottom = rc1.bottom - wGomerY;
 919             break;
 920
 921         case ZYZG_ORIENT_TOPTOBOTTOM:
 922             rc1.bottom = rc2.top += wGomerY;
 923             break;
 924
 925         default:
 926             rc1.right = rc2.left += wGomerX;
 927             break;
 928     } /* switch () */
 929
 930     /* select the correct font */
 931     hFont = (HFONT) SelectObject(hdc, pgauge->hFont);
 932
 933     /* build up a string to blit out--ie the meaning of life: "42%" */
 934     wsprintf(ach, "%3d%%", (WORD)((DWORD)iPos * 100 / iRange));
 935 /* Win32s has no GetTextExtent(); let's try GetTextExtentPoint() instead */
 936 #if defined(__WIN32__)
 937     GetTextExtentPoint(hdc, ach, wGomerX = lstrlen(ach), &size);
 938     dwExtent = size.cx;
 939 #else
 940     dwExtent = GetTextExtent(hdc, ach, wGomerX = lstrlen(ach));
 941 #endif
 942
 943
 944     /*  Draw the finished (ie the percent done) side of box.  If
 945      *  ZYZG_WW_POSITION is 42, (in range of 0 to 100) this ExtTextOut
 946      *  draws the meaning of life (42%) bar.
 947      */
 948     ExtTextOut(hdc, (dx - LOWORD(dwExtent)) / 2 + Offset,
 949                     (dy - HIWORD(dwExtent)) / 2 + Offset,
 950                     ETO_OPAQUE | ETO_CLIPPED, &rc2, ach, wGomerX, NULL);
 951
 952     /*  Reverse fore and back colors for drawing the undone (ie the non-
 953      *  finished) side of the box.
 954      */
 955     SetBkColor(hdc, pgauge->rgbTextColor);
 956     SetTextColor(hdc, pgauge->rgbBkColor);
 957
 958     ExtTextOut(hdc, (dx - LOWORD(dwExtent)) / 2 + Offset,
 959                     (dy - HIWORD(dwExtent)) / 2 + Offset,
 960                     ETO_OPAQUE | ETO_CLIPPED, &rc1, ach, wGomerX, NULL);
 961
 962     /* unselect the font */
 963     SelectObject(hdc, hFont);
 964 } /* gaugePaint() */
 965
 966
 967 /** LRESULT FAR PASCAL gaugeWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 968  *
 969  *  DESCRIPTION:
 970  *      This is the control's window procedure.  Its purpose is to handle
 971  *      special messages for this custom control.
 972  *
 973  *      The special control messages for the gauge control are:
 974  *
 975  *          ZYZG_SETRANGE       :   Sets the range of the gauge.  In other
 976  *                                  words, the number of parts that make a
 977  *                                  whole.
 978  *
 979  *          ZYZG_GETRANGE       :   Returns the current range of the gauge.
 980  *
 981  *          ZYZG_SETORIENTATION :   Sets the orientation of the gauge.  This
 982  *                                  can be one of the ZYZG_ORIENT_?? msgs.
 983  *
 984  *          ZYZG_GETORIENTATION :   Gets the current orientation of the
 985  *                                  gauge.
 986  *
 987  *          ZYZG_SETPOSITION    :   Sets the current position of the gauge.
 988  *                                  In other words, how many pieces of the
 989  *                                  whole have been used.
 990  *
 991  *          ZYZG_GETPOSITION    :   Gets the current position of the gauge.
 992  *
 993  *          ZYZG_SETDELTAPOS    :   Sets the position of the gauge +/- the
 994  *                                  specified amount.
 995  *
 996  *          ZYZG_SETFGCOLOR     :   Sets the foreground (percent done) color.
 997  *
 998  *          ZYZG_GETFGCOLOR     :   Gets the foreground (percent done) color.
 999  *
1000  *          ZYZG_SETBKCOLOR     :   Sets the background (percent not done)
1001  *                                  color.
1002  *
1003  *          ZYZG_GETBKCOLOR     :   Gets the background (percent not done)
1004  *                                  color.
1005  *
1006  *          WM_SETFONT          :   Sets the font to use for the percentage
1007  *                                  text of the gauge.
1008  *
1009  *          WM_GETFONT          :   Gets the current font in use by the
1010  *                                  gauge.
1011  *
1012  *  NOTES:
1013  *
1014  ** cjp */
1015
1016 /* LRESULT FAR PASCAL */
1017
1018 LRESULT APIENTRY _EXPORT gaugeWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1019 {
1020     HFONT       hFont;
1021     PAINTSTRUCT ps;
1022     PZYZGAUGE   pgauge;
1023     RECT        rc;
1024
1025 //    pgauge = (PZYZGAUGE)GetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE);
1026     pgauge = (PZYZGAUGE)GetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE);
1027
1028     /* break to get DefWindowProc() */
1029     switch (uMsg)
1030     {
1031         case WM_CREATE:
1032             /* need to allocate a control block */
1033 //            pgauge = (PZYZGAUGE)LocalAlloc(LPTR, sizeof(ZYZGAUGE));
1034             pgauge = (PZYZGAUGE)malloc(sizeof(ZYZGAUGE));
1035             if (!pgauge)
1036                 return (0L);
1037
1038             /* hang on to this control block */
1039 //            SetWindowWord(hwnd, ZYZG_WW_PZYZGAUGE, (WORD)pgauge);
1040             SetWindowLong(hwnd, ZYZG_WW_PZYZGAUGE, (LONG)pgauge);
1041
1042             /* fill control block with defaults */
1043             pgauge->wRange           = ZYZG_DEF_RANGE;
1044             pgauge->wPosition        = ZYZG_DEF_POSITION;
1045             pgauge->wOrientation     = ZYZG_DEF_ORIENTATION;
1046             pgauge->wWidth3D         = ZYZG_DEF_WIDTH3D;
1047             pgauge->wWidthBezelFace  = ZYZG_DEF_BEZELFACE;
1048             pgauge->rgbTextColor     = rgbDefTextColor;
1049             pgauge->rgbBkColor       = rgbDefBkColor;
1050
1051             /* use system font */
1052             SendMessage(hwnd, WM_SETFONT, (WPARAM)NULL, 0L);
1053
1054             /* go to DefWindowProc() to finish the job */
1055             break;
1056
1057         case WM_DESTROY:
1058             /* get rid of the control's memory */
1059             if (pgauge)
1060 //                LocalFree((HANDLE)pgauge);
1061                 free(pgauge);
1062             break;
1063
1064         case ZYZG_GETPOSITION:
1065             return (pgauge->wPosition);
1066
1067         case ZYZG_GETRANGE:
1068             return (pgauge->wRange);
1069
1070         case ZYZG_GETORIENTATION:
1071             return (pgauge->wOrientation);
1072
1073         case ZYZG_GETWIDTH3D:
1074             return (pgauge->wWidth3D);
1075
1076         case ZYZG_GETBEZELFACE:
1077             return (pgauge->wWidthBezelFace);
1078
1079         case ZYZG_GETBKCOLOR:
1080             return (pgauge->rgbTextColor);
1081
1082         case ZYZG_GETFGCOLOR:
1083             return (pgauge->rgbBkColor);
1084
1085         case ZYZG_SETBKCOLOR:
1086             pgauge->rgbBkColor = lParam;
1087             return (0L);
1088
1089         case ZYZG_SETFGCOLOR:
1090             pgauge->rgbTextColor = lParam;
1091             return (0L);
1092
1093
1094         case ZYZG_SETPOSITION:
1095             pgauge->wPosition = wParam;
1096
1097 zyzgForceRepaint:
1098             GetClientRect(hwnd, &rc);
1099             if ((GetWindowLong(hwnd, GWL_STYLE) & ZYZGS_3D) && fSupport3D)
1100             {
1101                 wParam = (2 * pgauge->wWidth3D) +
1102                             pgauge->wWidthBezelFace + 2;
1103             }
1104
1105             else
1106                 wParam = 1;
1107
1108             InflateRect(&rc, ~(wParam), ~(wParam));
1109             InvalidateRect(hwnd, &rc, FALSE);
1110             UpdateWindow(hwnd);
1111             return (0L);
1112
1113         case ZYZG_SETRANGE:
1114             pgauge->wRange = wParam;
1115             goto zyzgForceRepaint;
1116
1117         case ZYZG_SETORIENTATION:
1118             pgauge->wOrientation = wParam;
1119             goto zyzgForceRepaint;
1120
1121         case ZYZG_SETWIDTH3D:
1122             pgauge->wWidth3D = wParam;
1123
1124 zyzgForceRepaint3D:
1125             InvalidateRect(hwnd, NULL, FALSE);
1126             UpdateWindow(hwnd);
1127             return (0L);
1128
1129         case ZYZG_SETBEZELFACE:
1130             pgauge->wWidthBezelFace = wParam;
1131             goto zyzgForceRepaint3D;
1132
1133         case ZYZG_SETDELTAPOS:
1134 /* Watcom doesn't like the following line so removing typecasts */
1135 /*            (int)pgauge->wPosition += (int)wParam; */
1136             pgauge->wPosition += wParam;
1137             goto zyzgForceRepaint;
1138
1139         case WM_PAINT:
1140             BeginPaint(hwnd, &ps);
1141             gaugePaint(hwnd, ps.hdc);
1142             EndPaint(hwnd, &ps);
1143             return (0L);
1144
1145         case WM_GETFONT:
1146             hFont = pgauge->hFont;
1147
1148             /* if system font, then return NULL handle */
1149             return (long)((hFont == GetStockObject(SYSTEM_FONT)) ? NULL : hFont);
1150
1151         case WM_SETFONT:
1152             /* if NULL hFont, use system font */
1153             if (!(hFont = (HFONT)wParam))
1154                 hFont = (HFONT) GetStockObject(SYSTEM_FONT);
1155
1156             pgauge->hFont = hFont;
1157
1158             /* redraw if indicated in message */
1159             if ((BOOL)lParam)
1160             {
1161                 InvalidateRect(hwnd, NULL, TRUE);
1162                 UpdateWindow(hwnd);
1163             }
1164             return (0L);
1165     } /* switch () */
1166
1167     /* let the dialog mangler take care of this message */
1168     return (DefWindowProc(hwnd, uMsg, wParam, lParam));
1169 } /* gaugeWndProc() */
1170
1171
1172 /** EOF: zyzgauge.c **/
1173
1174 #endif // wxUSE_GAUGE