src/os2/gauge.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/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"

#if wxUSE_GAUGE

#include "wx/gauge.h"

#ifndef WX_PRECOMP
    #include "wx/utils.h"
    #include "wx/scrolwin.h"
#endif

#include "wx/os2/private.h"

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

IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxGaugeBase)

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(wxT("LIGHT GREY")));
    m_foregroundColour.Set(wxString(wxT("NAVY")));

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

    if (vId == wxID_ANY)
        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
           );
    m_nWidth  = nWidth;     // Save for GetBestSize
    m_nHeight = 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

wxSize wxGauge::DoGetBestSize() const
{
    return wxSize(m_nWidth,m_nHeight);
}

#endif // wxUSE_GAUGE
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/os2/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	#if wxUSE_GAUGE
	15
	16	#include "wx/gauge.h"
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/utils.h"
	20	#include "wx/scrolwin.h"
	21	#endif
	22
	23	#include "wx/os2/private.h"
	24
	25	static WXFARPROC fnWndProcGauge = (WXFARPROC)NULL;
	26	extern void wxAssociateWinWithHandle( HWND hWnd
	27	,wxWindowOS2* pWin
	28	);
	29
	30	IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxGaugeBase)
	31
	32	MRESULT EXPENTRY wxGaugeWndProc( HWND hWnd,
	33	UINT uMessage,
	34	MPARAM wParam,
	35	MPARAM lParam )
	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( wxWindowOS2* pParent,
	134	wxWindowID vId,
	135	int nRange,
	136	const wxPoint& rPos,
	137	const wxSize& rSize,
	138	long lStyle,
	139	const wxValidator& rValidator,
	140	const wxString& rsName )
	141	{
	142	int nX = rPos.x;
	143	int nY = rPos.y;
	144	int nWidth = rSize.x;
	145	int nHeight = rSize.y;
	146	long lMsStyle = 0L;
	147	SWP vSwp;
	148
	149	SetName(rsName);
	150	#if wxUSE_VALIDATORS
	151	SetValidator(rValidator);
	152	#endif
	153	if (pParent)
	154	pParent->AddChild(this);
	155	m_backgroundColour.Set(wxString(wxT("LIGHT GREY")));
	156	m_foregroundColour.Set(wxString(wxT("NAVY")));
	157
	158	m_nRangeMax = nRange;
	159	m_nGaugePos = 0;
	160	m_windowStyle = lStyle;
	161
	162	if (vId == wxID_ANY)
	163	m_windowId = (int)NewControlId();
	164	else
	165	m_windowId = vId;
	166
	167	if (m_windowStyle & wxCLIP_SIBLINGS )
	168	lMsStyle \|= WS_CLIPSIBLINGS;
	169
	170	//
	171	// OS/2 will use an edit control for this, since there is not a native gauge
	172	// Other choices include using an armless slider but they are more difficult
	173	// to control and manipulate
	174	//
	175
	176	lMsStyle = WS_VISIBLE \| ES_MARGIN \| ES_LEFT \| ES_READONLY;
	177	if (m_windowStyle & wxCLIP_SIBLINGS)
	178	lMsStyle \|= WS_CLIPSIBLINGS;
	179
	180	m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
	181	,WC_ENTRYFIELD // Window class
	182	,(PSZ)NULL // Initial Text
	183	,(ULONG)lMsStyle // Style flags
	184	,0L, 0L, 0L, 0L // Origin -- 0 size
	185	,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
	186	,HWND_TOP // initial z position
	187	,(HMENU)m_windowId // Window identifier
	188	,NULL // Slider control data
	189	,NULL // no Presentation parameters
	190	);
	191
	192	wxAssociateWinWithHandle( m_hWnd
	193	,(wxWindowOS2*)this
	194	);
	195	::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
	196	fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc);
	197	::WinQueryWindowPos(m_hWnd, &vSwp);
	198	SetXComp(vSwp.x);
	199	SetYComp(vSwp.y);
	200	wxFont* pTextFont = new wxFont( 10
	201	,wxMODERN
	202	,wxNORMAL
	203	,wxNORMAL
	204	);
	205	SetFont(*pTextFont);
	206	if (nWidth == -1L)
	207	nWidth = 50L;
	208	if (nHeight == -1L)
	209	nHeight = 28L;
	210	SetSize( nX
	211	,nY
	212	,nWidth
	213	,nHeight
	214	);
	215	m_nWidth = nWidth; // Save for GetBestSize
	216	m_nHeight = nHeight;
	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( const wxColour& rColour )
	243	{
	244	if (!wxControl::SetBackgroundColour(rColour))
	245	return false;
	246
	247	LONG lColor = (LONG)rColour.GetPixel();
	248
	249	::WinSetPresParam( GetHwnd()
	250	,PP_BACKGROUNDCOLOR
	251	,sizeof(LONG)
	252	,(PVOID)&lColor
	253	);
	254	return true;
	255	} // end of wxGauge::SetBackgroundColour
	256
	257	void wxGauge::SetBezelFace( int WXUNUSED(nWidth) )
	258	{
	259	} // end of wxGauge::SetBezelFace
	260
	261	bool wxGauge::SetForegroundColour( const wxColour& rColour )
	262	{
	263	if (!wxControl::SetForegroundColour(rColour))
	264	return false;
	265
	266	LONG lColor = (LONG)rColour.GetPixel();
	267
	268	::WinSetPresParam( GetHwnd()
	269	,PP_FOREGROUNDCOLOR
	270	,sizeof(LONG)
	271	,(PVOID)&lColor
	272	);
	273
	274	return true;
	275	} // end of wxGauge::SetForegroundColour
	276
	277	void wxGauge::SetRange( int nRange )
	278	{
	279	m_nRangeMax = nRange;
	280	} // end of wxGauge::SetRange
	281
	282	void wxGauge::SetShadowWidth( int WXUNUSED(nWidth) )
	283	{
	284	} // end of wxGauge::SetShadowWidth
	285
	286	void wxGauge::SetValue( int nPos )
	287	{
	288	RECT vRect;
	289
	290	m_nGaugePos = nPos;
	291	::WinQueryWindowRect(GetHwnd(), &vRect);
	292	::WinInvalidateRect(GetHwnd(), &vRect, FALSE);
	293	} // end of wxGauge::SetValue
	294
	295	wxSize wxGauge::DoGetBestSize() const
	296	{
	297	return wxSize(m_nWidth,m_nHeight);
	298	}
	299
	300	#endif // wxUSE_GAUGE