src/os2/gauge.cpp

/////////////////////////////////////////////////////////////////////////////
// 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"
#include "wx/scrolwin.h"
#endif

#include "wx/os2/private.h"
#include "wx/gauge.h"

static WXFARPROC fnWndProcGauge = (WXFARPROC)NULL;
extern void  wxAssociateWinWithHandle( HWND         hWnd
                                      ,wxWindowOS2* pWin
                                     );

IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)

MRESULT EXPENTRY wxGaugeWndProc(
  HWND                              hWnd
, UINT                              uMessage
, MPARAM                            wParam
, MPARAM                            lParam
)
{
    wxGauge*                        pGauge = (wxGauge *)::WinQueryWindowULong( hWnd
                                                                              ,QWL_USER
                                                                             );
    HPS                             hPS;
    RECTL                           vRect;
    RECTL                           vRect2;
    RECTL                           vRect3;
    double                          dPixelToRange = 0.0;
    double                          dRange = 0.0;

    switch (uMessage )
    {
        case WM_PAINT:
            hPS = ::WinBeginPaint( hWnd
                                  ,NULLHANDLE
                                  ,&vRect
                                 );
            if(hPS)
            {
                ::WinQueryWindowRect(hWnd, &vRect);
                ::GpiCreateLogColorTable( hPS
                                         ,0L
                                         ,LCOLF_CONSECRGB
                                         ,0L
                                         ,(LONG)wxTheColourDatabase->m_nSize
                                         ,(PLONG)wxTheColourDatabase->m_palTable
                                        );
                ::GpiCreateLogColorTable( hPS
                                         ,0L
                                         ,LCOLF_RGB
                                         ,0L
                                         ,0L
                                         ,NULL
                                        );
                //
                // Draw the guage box
                //
                LONG                lColor = 0x00FFFFFF; // White
                POINTL              vPoint = {vRect.xLeft + 1, vRect.yBottom + 1};

                ::GpiSetColor(hPS, lColor);
                ::GpiMove(hPS, &vPoint);
                vPoint.x = vRect.xRight - 1;
                ::GpiLine(hPS, &vPoint);
                vPoint.y = vRect.yTop - 1;
                ::GpiLine(hPS, &vPoint);
                lColor = 0x000C0C0C; // Darkish Grey to give depth feel
                ::GpiSetColor(hPS, lColor);
                vPoint.x = vRect.xLeft + 1;
                ::GpiLine(hPS, &vPoint);
                vPoint.y = vRect.yBottom + 1;
                ::GpiLine(hPS, &vPoint);
                vRect3.xLeft   = vRect.xLeft + 2;
                vRect3.xRight  = vRect.xRight - 2;
                vRect3.yTop    = vRect.yTop - 2;
                vRect3.yBottom = vRect.yBottom + 2;

                if (pGauge->GetWindowStyleFlag() & wxGA_VERTICAL)
                {
                    dRange = (double)(vRect3.yTop - vRect3.yBottom);
                    dPixelToRange  = dRange/(double)pGauge->GetRange();
                    vRect2.yTop    = (int)(pGauge->GetValue() * dPixelToRange);
                    vRect2.yBottom = vRect3.yBottom;
                    vRect2.xLeft   = vRect3.xLeft;
                    vRect2.xRight  = vRect3.xRight;
                    vRect3.yBottom  = vRect2.yTop;
                    if (vRect3.yBottom <= 1)
                         vRect3.yBottom = 2;
                    ::WinFillRect(hPS, &vRect3,  pGauge->GetBackgroundColour().GetPixel());
                    ::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
                }
                else
                {
                    dRange = (double)(vRect3.xRight - vRect3.xLeft);
                    dPixelToRange  = dRange/(double)pGauge->GetRange();
                    vRect2.yTop    = vRect3.yTop;
                    vRect2.yBottom = vRect3.yBottom;
                    vRect2.xLeft   = vRect3.xLeft;
                    vRect2.xRight  = (int)(pGauge->GetValue() * dPixelToRange);
                    vRect3.xLeft = vRect2.xRight;
                    if (vRect3.xLeft <= 1)
                        vRect3.xLeft = 2;
                    ::WinFillRect(hPS, &vRect3,  pGauge->GetBackgroundColour().GetPixel());
                    ::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
                }
                ::WinEndPaint(hPS);
            }
    }
    return (fnWndProcGauge( hWnd
                           ,(ULONG)uMessage
                           ,(MPARAM)wParam
                           ,(MPARAM)lParam
                          )
           );
} // end of wxGaugeWndProc

bool wxGauge::Create(
  wxWindowOS2*                      pParent
, wxWindowID                        vId
, int                               nRange
, const wxPoint&                    rPos
, const wxSize&                     rSize
, long                              lStyle
, const wxValidator&                rValidator
, const wxString&                   rsName
)
{
    int                             nX       = rPos.x;
    int                             nY       = rPos.y;
    int                             nWidth   = rSize.x;
    int                             nHeight  = rSize.y;
    long                            lMsStyle = 0L;
    SWP                             vSwp;

    SetName(rsName);
#if wxUSE_VALIDATORS
    SetValidator(rValidator);
#endif
    if (pParent)
        pParent->AddChild(this);
    m_backgroundColour.Set(wxString("LIGHT GREY"));
    m_foregroundColour.Set(wxString("NAVY"));

    m_nRangeMax   = nRange;
    m_nGaugePos   = 0;
    m_windowStyle = lStyle;

    if (vId == -1)
        m_windowId = (int)NewControlId();
    else
        m_windowId = vId;

    if (m_windowStyle & wxCLIP_SIBLINGS )
        lMsStyle |= WS_CLIPSIBLINGS;

    //
    // OS/2 will use an edit control for this, since there is not a native gauge
    // Other choices include using an armless slider but they are more difficult
    // to control and manipulate
    //

    lMsStyle = WS_VISIBLE | ES_MARGIN | ES_LEFT | ES_READONLY;
    if (m_windowStyle & wxCLIP_SIBLINGS)
        lMsStyle |= WS_CLIPSIBLINGS;

    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
                                       ,WC_ENTRYFIELD            // Window class
                                       ,(PSZ)NULL                // Initial Text
                                       ,(ULONG)lMsStyle          // Style flags
                                       ,0L, 0L, 0L, 0L           // Origin -- 0 size
                                       ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
                                       ,HWND_TOP                 // initial z position
                                       ,(HMENU)m_windowId        // Window identifier
                                       ,NULL                     // Slider control data
                                       ,NULL                     // no Presentation parameters
                                      );

    wxAssociateWinWithHandle( m_hWnd
                             ,(wxWindowOS2*)this
                            );
    ::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
    fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc);
    ::WinQueryWindowPos(m_hWnd, &vSwp);
    SetXComp(vSwp.x);
    SetYComp(vSwp.y);
    wxFont*                          pTextFont = new wxFont( 10
                                                            ,wxMODERN
                                                            ,wxNORMAL
                                                            ,wxNORMAL
                                                           );
    SetFont(*pTextFont);
    if (nWidth == -1L)
        nWidth = 50L;
    if (nHeight == -1L)
        nHeight = 28L;
    SetSize( nX
            ,nY
            ,nWidth
            ,nHeight
           );
    ::WinShowWindow((HWND)GetHWND(), TRUE);
    delete pTextFont;
    return TRUE;
} // end of wxGauge::Create

int wxGauge::GetBezelFace() const
{
    return 0;
} // end of wxGauge::GetBezelFace

int wxGauge::GetRange() const
{
    return m_nRangeMax;
} // end of wxGauge::GetRange

int wxGauge::GetShadowWidth() const
{
    return 0;
} // end of wxGauge::GetShadowWidth

int wxGauge::GetValue() const
{
    return m_nGaugePos;
} // end of wxGauge::GetValue

bool wxGauge::SetBackgroundColour(
  const wxColour&                   rColour
)
{
    if (!wxControl::SetBackgroundColour(rColour))
        return FALSE;

    LONG                            lColor = (LONG)rColour.GetPixel();

    ::WinSetPresParam( GetHwnd()
                      ,PP_BACKGROUNDCOLOR
                      ,sizeof(LONG)
                      ,(PVOID)&lColor
                     );
    return TRUE;
} // end of wxGauge::SetBackgroundColour

void wxGauge::SetBezelFace(
  int                               WXUNUSED(nWidth)
)
{
} // end of wxGauge::SetBezelFace

bool wxGauge::SetForegroundColour(
  const wxColour&                   rColour
)
{
    if (!wxControl::SetForegroundColour(rColour))
        return FALSE;

    LONG                            lColor = (LONG)rColour.GetPixel();

    ::WinSetPresParam( GetHwnd()
                      ,PP_FOREGROUNDCOLOR
                      ,sizeof(LONG)
                      ,(PVOID)&lColor
                     );

    return TRUE;
} // end of wxGauge::SetForegroundColour

void wxGauge::SetRange(
  int                               nRange
)
{
    m_nRangeMax = nRange;
} // end of wxGauge::SetRange

void wxGauge::SetShadowWidth(
  int                               WXUNUSED(nWidth)
)
{
} // end of wxGauge::SetShadowWidth

void wxGauge::SetValue(
  int                               nPos
)
{
    RECT                            vRect;

    m_nGaugePos = nPos;
    ::WinQueryWindowRect(GetHwnd(), &vRect);
    ::WinInvalidateRect(GetHwnd(), &vRect, FALSE);
} // end of wxGauge::SetValue
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gauge.cpp
	3	// Purpose: wxGauge class
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 10/06/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) David Webster
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#include "wx/wxprec.h"
	13
	14	#ifndef WX_PRECOMP
	15	#include "wx/defs.h"
	16	#include "wx/utils.h"
	17	#include "wx/scrolwin.h"
	18	#endif
	19
	20	#include "wx/os2/private.h"
	21	#include "wx/gauge.h"
	22
	23	static WXFARPROC fnWndProcGauge = (WXFARPROC)NULL;
	24	extern void wxAssociateWinWithHandle( HWND hWnd
	25	,wxWindowOS2* pWin
	26	);
	27
	28	IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
	29
	30	MRESULT EXPENTRY wxGaugeWndProc(
	31	HWND hWnd
	32	, UINT uMessage
	33	, MPARAM wParam
	34	, MPARAM lParam
	35	)
	36	{
	37	wxGauge* pGauge = (wxGauge *)::WinQueryWindowULong( hWnd
	38	,QWL_USER
	39	);
	40	HPS hPS;
	41	RECTL vRect;
	42	RECTL vRect2;
	43	RECTL vRect3;
	44	double dPixelToRange = 0.0;
	45	double dRange = 0.0;
	46
	47	switch (uMessage )
	48	{
	49	case WM_PAINT:
	50	hPS = ::WinBeginPaint( hWnd
	51	,NULLHANDLE
	52	,&vRect
	53	);
	54	if(hPS)
	55	{
	56	::WinQueryWindowRect(hWnd, &vRect);
	57	::GpiCreateLogColorTable( hPS
	58	,0L
	59	,LCOLF_CONSECRGB
	60	,0L
	61	,(LONG)wxTheColourDatabase->m_nSize
	62	,(PLONG)wxTheColourDatabase->m_palTable
	63	);
	64	::GpiCreateLogColorTable( hPS
	65	,0L
	66	,LCOLF_RGB
	67	,0L
	68	,0L
	69	,NULL
	70	);
	71	//
	72	// Draw the guage box
	73	//
	74	LONG lColor = 0x00FFFFFF; // White
	75	POINTL vPoint = {vRect.xLeft + 1, vRect.yBottom + 1};
	76
	77	::GpiSetColor(hPS, lColor);
	78	::GpiMove(hPS, &vPoint);
	79	vPoint.x = vRect.xRight - 1;
	80	::GpiLine(hPS, &vPoint);
	81	vPoint.y = vRect.yTop - 1;
	82	::GpiLine(hPS, &vPoint);
	83	lColor = 0x000C0C0C; // Darkish Grey to give depth feel
	84	::GpiSetColor(hPS, lColor);
	85	vPoint.x = vRect.xLeft + 1;
	86	::GpiLine(hPS, &vPoint);
	87	vPoint.y = vRect.yBottom + 1;
	88	::GpiLine(hPS, &vPoint);
	89	vRect3.xLeft = vRect.xLeft + 2;
	90	vRect3.xRight = vRect.xRight - 2;
	91	vRect3.yTop = vRect.yTop - 2;
	92	vRect3.yBottom = vRect.yBottom + 2;
	93
	94	if (pGauge->GetWindowStyleFlag() & wxGA_VERTICAL)
	95	{
	96	dRange = (double)(vRect3.yTop - vRect3.yBottom);
	97	dPixelToRange = dRange/(double)pGauge->GetRange();
	98	vRect2.yTop = (int)(pGauge->GetValue() * dPixelToRange);
	99	vRect2.yBottom = vRect3.yBottom;
	100	vRect2.xLeft = vRect3.xLeft;
	101	vRect2.xRight = vRect3.xRight;
	102	vRect3.yBottom = vRect2.yTop;
	103	if (vRect3.yBottom <= 1)
	104	vRect3.yBottom = 2;
	105	::WinFillRect(hPS, &vRect3, pGauge->GetBackgroundColour().GetPixel());
	106	::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
	107	}
	108	else
	109	{
	110	dRange = (double)(vRect3.xRight - vRect3.xLeft);
	111	dPixelToRange = dRange/(double)pGauge->GetRange();
	112	vRect2.yTop = vRect3.yTop;
	113	vRect2.yBottom = vRect3.yBottom;
	114	vRect2.xLeft = vRect3.xLeft;
	115	vRect2.xRight = (int)(pGauge->GetValue() * dPixelToRange);
	116	vRect3.xLeft = vRect2.xRight;
	117	if (vRect3.xLeft <= 1)
	118	vRect3.xLeft = 2;
	119	::WinFillRect(hPS, &vRect3, pGauge->GetBackgroundColour().GetPixel());
	120	::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
	121	}
	122	::WinEndPaint(hPS);
	123	}
	124	}
	125	return (fnWndProcGauge( hWnd
	126	,(ULONG)uMessage
	127	,(MPARAM)wParam
	128	,(MPARAM)lParam
	129	)
	130	);
	131	} // end of wxGaugeWndProc
	132
	133	bool wxGauge::Create(
	134	wxWindowOS2* pParent
	135	, wxWindowID vId
	136	, int nRange
	137	, const wxPoint& rPos
	138	, const wxSize& rSize
	139	, long lStyle
	140	, const wxValidator& rValidator
	141	, const wxString& rsName
	142	)
	143	{
	144	int nX = rPos.x;
	145	int nY = rPos.y;
	146	int nWidth = rSize.x;
	147	int nHeight = rSize.y;
	148	long lMsStyle = 0L;
	149	SWP vSwp;
	150
	151	SetName(rsName);
	152	#if wxUSE_VALIDATORS
	153	SetValidator(rValidator);
	154	#endif
	155	if (pParent)
	156	pParent->AddChild(this);
	157	m_backgroundColour.Set(wxString("LIGHT GREY"));
	158	m_foregroundColour.Set(wxString("NAVY"));
	159
	160	m_nRangeMax = nRange;
	161	m_nGaugePos = 0;
	162	m_windowStyle = lStyle;
	163
	164	if (vId == -1)
	165	m_windowId = (int)NewControlId();
	166	else
	167	m_windowId = vId;
	168
	169	if (m_windowStyle & wxCLIP_SIBLINGS )
	170	lMsStyle \|= WS_CLIPSIBLINGS;
	171
	172	//
	173	// OS/2 will use an edit control for this, since there is not a native gauge
	174	// Other choices include using an armless slider but they are more difficult
	175	// to control and manipulate
	176	//
	177
	178	lMsStyle = WS_VISIBLE \| ES_MARGIN \| ES_LEFT \| ES_READONLY;
	179	if (m_windowStyle & wxCLIP_SIBLINGS)
	180	lMsStyle \|= WS_CLIPSIBLINGS;
	181
	182	m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
	183	,WC_ENTRYFIELD // Window class
	184	,(PSZ)NULL // Initial Text
	185	,(ULONG)lMsStyle // Style flags
	186	,0L, 0L, 0L, 0L // Origin -- 0 size
	187	,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
	188	,HWND_TOP // initial z position
	189	,(HMENU)m_windowId // Window identifier
	190	,NULL // Slider control data
	191	,NULL // no Presentation parameters
	192	);
	193
	194	wxAssociateWinWithHandle( m_hWnd
	195	,(wxWindowOS2*)this
	196	);
	197	::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
	198	fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc);
	199	::WinQueryWindowPos(m_hWnd, &vSwp);
	200	SetXComp(vSwp.x);
	201	SetYComp(vSwp.y);
	202	wxFont* pTextFont = new wxFont( 10
	203	,wxMODERN
	204	,wxNORMAL
	205	,wxNORMAL
	206	);
	207	SetFont(*pTextFont);
	208	if (nWidth == -1L)
	209	nWidth = 50L;
	210	if (nHeight == -1L)
	211	nHeight = 28L;
	212	SetSize( nX
	213	,nY
	214	,nWidth
	215	,nHeight
	216	);
	217	::WinShowWindow((HWND)GetHWND(), TRUE);
	218	delete pTextFont;
	219	return TRUE;
	220	} // end of wxGauge::Create
	221
	222	int wxGauge::GetBezelFace() const
	223	{
	224	return 0;
	225	} // end of wxGauge::GetBezelFace
	226
	227	int wxGauge::GetRange() const
	228	{
	229	return m_nRangeMax;
	230	} // end of wxGauge::GetRange
	231
	232	int wxGauge::GetShadowWidth() const
	233	{
	234	return 0;
	235	} // end of wxGauge::GetShadowWidth
	236
	237	int wxGauge::GetValue() const
	238	{
	239	return m_nGaugePos;
	240	} // end of wxGauge::GetValue
	241
	242	bool wxGauge::SetBackgroundColour(
	243	const wxColour& rColour
	244	)
	245	{
	246	if (!wxControl::SetBackgroundColour(rColour))
	247	return FALSE;
	248
	249	LONG lColor = (LONG)rColour.GetPixel();
	250
	251	::WinSetPresParam( GetHwnd()
	252	,PP_BACKGROUNDCOLOR
	253	,sizeof(LONG)
	254	,(PVOID)&lColor
	255	);
	256	return TRUE;
	257	} // end of wxGauge::SetBackgroundColour
	258
	259	void wxGauge::SetBezelFace(
	260	int WXUNUSED(nWidth)
	261	)
	262	{
	263	} // end of wxGauge::SetBezelFace
	264
	265	bool wxGauge::SetForegroundColour(
	266	const wxColour& rColour
	267	)
	268	{
	269	if (!wxControl::SetForegroundColour(rColour))
	270	return FALSE;
	271
	272	LONG lColor = (LONG)rColour.GetPixel();
	273
	274	::WinSetPresParam( GetHwnd()
	275	,PP_FOREGROUNDCOLOR
	276	,sizeof(LONG)
	277	,(PVOID)&lColor
	278	);
	279
	280	return TRUE;
	281	} // end of wxGauge::SetForegroundColour
	282
	283	void wxGauge::SetRange(
	284	int nRange
	285	)
	286	{
	287	m_nRangeMax = nRange;
	288	} // end of wxGauge::SetRange
	289
	290	void wxGauge::SetShadowWidth(
	291	int WXUNUSED(nWidth)
	292	)
	293	{
	294	} // end of wxGauge::SetShadowWidth
	295
	296	void wxGauge::SetValue(
	297	int nPos
	298	)
	299	{
	300	RECT vRect;
	301
	302	m_nGaugePos = nPos;
	303	::WinQueryWindowRect(GetHwnd(), &vRect);
	304	::WinInvalidateRect(GetHwnd(), &vRect, FALSE);
	305	} // end of wxGauge::SetValue
	306
	307