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