gauge.c
上传用户:xmgzy123
上传日期:2007-01-07
资源大小:373k
文件大小:8k
源码类别:

SCSI/ASPI

开发平台:

WINDOWS

  1. /*
  2.  * gauge.c - Copyright (C) 1999,2000 Jay A. Key
  3.  *
  4.  * Implementation of 3D-look gauge control
  5.  *
  6.  **********************************************************************
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21.  *
  22.  */
  23. #include <windows.h>
  24. #include <stdio.h>
  25. #include "gauge.h"
  26. /*******************************************************************/
  27. /* Typedefs                                                        */
  28. /*******************************************************************/
  29. typedef struct
  30. {
  31.   UINT     uRange;
  32.   UINT     uPosition;
  33.   COLORREF rgbTextColor;
  34.   COLORREF rgbBkColor;
  35.   HPEN     hDarkGrayPen;
  36.   HPEN     hLiteGrayPen;
  37.   HBRUSH   hFgBrush;
  38.   HBRUSH   hStockWhiteBrush;
  39.   BOOL     bDispPct;
  40.   HDC      hDC;
  41.   HBITMAP  hBmp;
  42. } GAUGESTRUCT, FAR *LPGAUGESTRUCT;
  43. /*******************************************************************/
  44. /* Local Variables                                                 */
  45. /*******************************************************************/
  46. char szGaugeClassName[] = "AKProgMeter";
  47. /*******************************************************************/
  48. /* Prototypes                                                      */
  49. /*******************************************************************/
  50. LRESULT CALLBACK GaugeWndProc( HWND, UINT, WPARAM, LPARAM );
  51. void PaintGauge( HWND hWnd );
  52. void InitGaugeWnd( HWND hWnd );
  53. UINT percent( UINT a, UINT b );
  54. #define INVRECT FALSE
  55. BOOL InitGauge( HINSTANCE hInst )
  56. {
  57.   static BOOL bRegistered = FALSE;
  58.   WNDCLASSEX wc;
  59.   if ( bRegistered )
  60.     return TRUE;
  61.   ZeroMemory( &wc, sizeof(wc) );
  62.   wc.cbSize        = sizeof(wc);
  63.   wc.style         = CS_HREDRAW | CS_VREDRAW | CS_PARENTDC;
  64.   wc.lpfnWndProc   = (WNDPROC)GaugeWndProc;
  65.   wc.hInstance     = hInst;
  66.   wc.hCursor       = LoadCursor( NULL, IDC_ARROW );
  67.   wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  68.   wc.lpszClassName = szGaugeClassName;
  69.   if ( !RegisterClassEx( &wc ) )
  70.     return FALSE;
  71.   bRegistered = TRUE;
  72.   return TRUE;
  73. }
  74. void InitGaugeWnd( HWND hWnd )
  75. {
  76.   LPGAUGESTRUCT lpg;
  77.   LOGBRUSH lb;
  78.   HDC hDC;
  79.   RECT rc;
  80.   int x, y;
  81.   lpg = GlobalAlloc( GPTR, sizeof(GAUGESTRUCT) );
  82.   hDC = GetDC( hWnd );
  83.   GetClientRect( hWnd, &rc );
  84.   x = rc.right - rc.left + 2;
  85.   y = rc.bottom - rc.top + 2;
  86.   lpg->hBmp = CreateCompatibleBitmap( hDC, x, y );
  87.   lpg->hDC = CreateCompatibleDC( hDC );
  88.   SelectObject( lpg->hDC, lpg->hBmp );
  89.   ReleaseDC( hWnd, hDC );
  90.   lpg->uRange        = 100;
  91.   lpg->uPosition     = 0;
  92.   lpg->rgbTextColor  = RGB( 0, 255, 0 );
  93.   lpg->rgbBkColor    = RGB( 255, 255, 255 );
  94.   lpg->bDispPct      = TRUE;
  95.   lpg->hDarkGrayPen  = CreatePen( PS_SOLID, 1, RGB(128, 128, 128) );
  96.   lpg->hLiteGrayPen  = CreatePen( PS_SOLID, 1, RGB(192, 192, 192) );
  97.   lb.lbStyle         = PS_SOLID;
  98.   lb.lbColor         = RGB( 0, 255, 0 );
  99.   lpg->hFgBrush      = CreateBrushIndirect( &lb );
  100.   lpg->hStockWhiteBrush = (HBRUSH)GetStockObject( WHITE_BRUSH );
  101.   
  102.   SetWindowLong( hWnd, GWL_USERDATA, (LONG)lpg );
  103. }
  104. LRESULT CALLBACK GaugeWndProc( HWND hWnd, UINT uMsg, WPARAM wParam,
  105.        LPARAM lParam )
  106. {
  107.   LPGAUGESTRUCT lpg;
  108.   UINT uNewPos;
  109.   BOOL bRepaint;
  110.   lpg = (LPGAUGESTRUCT)GetWindowLong( hWnd, GWL_USERDATA );
  111.   switch( uMsg )
  112.     {
  113.     case WM_CREATE:
  114.       InitGaugeWnd( hWnd );
  115.       break;
  116.     case WM_DESTROY:
  117.       DeleteObject( lpg->hDarkGrayPen );
  118.       DeleteObject( lpg->hLiteGrayPen );
  119.       DeleteObject( lpg->hFgBrush );
  120.       DeleteDC( lpg->hDC );
  121.       DeleteObject( lpg->hBmp );
  122.       GlobalFree( lpg );
  123.       return DefWindowProc( hWnd, uMsg, wParam, lParam );
  124.     case WM_PAINT:
  125.       PaintGauge( hWnd );
  126.       break;
  127.     case GM_SETRANGE:
  128.       lpg->uRange = (UINT)wParam;
  129.       if ( lpg->uPosition > lpg->uRange )
  130. lpg->uPosition = lpg->uRange;
  131.       InvalidateRect( hWnd, NULL, INVRECT );
  132.       UpdateWindow( hWnd );
  133.       break;
  134.     case GM_GETRANGE:
  135.       return (LRESULT)lpg->uRange;
  136.     case GM_SETPOS:
  137.       bRepaint = ( percent( lpg->uPosition, lpg->uRange ) !=
  138.    percent( (UINT)wParam, lpg->uRange ) );
  139.       lpg->uPosition = (UINT)wParam;
  140.       if ( bRepaint )
  141. {
  142.   InvalidateRect( hWnd, NULL, INVRECT );
  143.   UpdateWindow( hWnd );
  144. }
  145.       break;
  146.     case GM_GETPOS:
  147.       return (LRESULT)lpg->uPosition;
  148.     case GM_SETDELTAPOS:
  149.       uNewPos = (UINT)((int)lpg->uPosition + (int)wParam);
  150.       bRepaint = ( percent( lpg->uPosition, lpg->uRange ) !=
  151.    percent( uNewPos, lpg->uRange ) );
  152.       lpg->uPosition = uNewPos;
  153.       if ( lpg->uPosition > lpg->uRange )
  154. lpg->uPosition = lpg->uRange;
  155.       if ( bRepaint )
  156. {
  157.   InvalidateRect( hWnd, NULL, INVRECT );
  158.   UpdateWindow( hWnd );
  159. }
  160.       break;
  161.     case GM_DISPPCT:
  162.       lpg->bDispPct = (BOOL)wParam;
  163.       InvalidateRect( hWnd, NULL, INVRECT );
  164.       UpdateWindow( hWnd );
  165.       break;
  166.     default:
  167.       return DefWindowProc( hWnd, uMsg, wParam, lParam );
  168.     }
  169.   return 0L;
  170. }
  171. void PaintGauge( HWND hWnd )
  172. {
  173.   RECT rc, rc1;
  174.   HDC hDC;
  175.   PAINTSTRUCT ps;
  176.   HPEN hOldPen;
  177.   LPGAUGESTRUCT lpg;
  178.   int x;
  179.   float f;
  180.   char buf[81];
  181.   SIZE textSize;
  182.   BOOL bRetVal;
  183.   //DWORD dwError;
  184.   //RECT rcUpdate;
  185.   lpg = (LPGAUGESTRUCT)GetWindowLong( hWnd, GWL_USERDATA );
  186.   if ( !lpg )
  187.     return;
  188.   hDC = BeginPaint( hWnd, &ps );
  189.   // draw the 3-d indent
  190.   GetClientRect( hWnd, &rc );
  191.   FillRect( lpg->hDC, &rc, lpg->hStockWhiteBrush );
  192.   //FillRect( lpg->hDC, &rc, (HBRUSH)GetStockObject( WHITE_BRUSH ) );
  193.   hOldPen = SelectObject( lpg->hDC, GetStockObject( BLACK_PEN ) );
  194.   MoveToEx( lpg->hDC, rc.left+1, rc.bottom-3, NULL );
  195.   LineTo( lpg->hDC, rc.left+1, rc.top+1 );
  196.   LineTo( lpg->hDC, rc.right-2, rc.top+1 );
  197.   SelectObject( lpg->hDC, lpg->hDarkGrayPen );
  198.   MoveToEx( lpg->hDC, rc.left, rc.bottom-2, NULL );
  199.   LineTo( lpg->hDC, rc.left, rc.top );
  200.   LineTo( lpg->hDC, rc.right-1, rc.top );
  201.   SelectObject( lpg->hDC, lpg->hLiteGrayPen );
  202.   MoveToEx( lpg->hDC, rc.left+1, rc.bottom-2, NULL );
  203.   LineTo( lpg->hDC, rc.right-2, rc.bottom-2 );
  204.   LineTo( lpg->hDC, rc.right-2, rc.top );
  205.   // draw the percentage
  206.   f = 100.0 * (float)lpg->uPosition / (float)lpg->uRange;
  207.   if ( lpg->bDispPct )
  208.     {
  209.       sprintf( buf, "%1.1f", f );
  210.       lstrcat( buf, "%" );
  211.     }
  212.   else
  213.     lstrcpy( buf, "" );
  214.   InflateRect( &rc, -2, -2 );
  215.   rc1 = rc;
  216.   x = rc.right - rc.left + 1;
  217.   rc1.right = rc.left + (int)((float)x * f / 100.0);
  218.   SetBkColor( lpg->hDC, lpg->rgbTextColor );
  219.   SetTextColor( lpg->hDC, RGB(0,0,0) );
  220.   GetTextExtentPoint32( lpg->hDC, buf, lstrlen( buf ), &textSize );
  221.   ExtTextOut( lpg->hDC, (rc.right-rc.left+1-textSize.cx)/2,
  222.       (rc.bottom-rc.top+1-textSize.cy)/2 + 1,
  223.       ETO_OPAQUE | ETO_CLIPPED, &rc1, buf, lstrlen( buf ), NULL );
  224.   SetBkColor( lpg->hDC, lpg->rgbBkColor );
  225.   SetTextColor( lpg->hDC, RGB(0,0,0) );
  226.   rc1.left = rc1.right;
  227.   rc1.right = rc.right;
  228.   ExtTextOut( lpg->hDC, (rc.right-rc.left+1-textSize.cx)/2,
  229.       (rc.bottom-rc.top+1-textSize.cy)/2 + 1,
  230.       ETO_OPAQUE | ETO_CLIPPED, &rc1, buf, lstrlen( buf ), NULL );
  231.   SelectObject( lpg->hDC, hOldPen );
  232.   GetClientRect( hWnd, &rc );
  233.   bRetVal = BitBlt( hDC, 0, 0, rc.right, rc.bottom, 
  234.     lpg->hDC, 0, 0, SRCCOPY );
  235.   //if ( !bRetVal )
  236.   //  dwError = GetLastError();
  237.   EndPaint( hWnd, &ps );
  238. }
  239. UINT percent( UINT a, UINT b )
  240. {
  241.   return ( a * 1000 ) / b;
  242. }