[wxWidgets.git] / 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
#if wxUSE_VALIDATORS
, const wxValidator&                rValidator
#endif
, 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
0e320a79 DW	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gauge.cpp
	3	// Purpose: wxGauge class
0371a691	4	// Author: David Webster
0e320a79	5	// Modified by:
0371a691	6	// Created: 10/06/99
0e320a79	7	// RCS-ID: $Id$
0371a691 DW	8	// Copyright: (c) David Webster
0371a691 DW	9	// Licence: wxWindows licence
0e320a79 DW	10	/////////////////////////////////////////////////////////////////////////////
0e320a79 DW	11
0371a691 DW	12	#include "wx/wxprec.h"
	13
	14	#ifndef WX_PRECOMP
	15	#include "wx/defs.h"
	16	#include "wx/utils.h"
a4a16252	17	#include "wx/scrolwin.h"
0e320a79 DW	18	#endif
0e320a79 DW	19
0371a691	20	#include "wx/os2/private.h"
0e320a79 DW	21	#include "wx/gauge.h"
0e320a79 DW	22
3c299c3a DW	23	static WXFARPROC fnWndProcGauge = (WXFARPROC)NULL;
	24	extern void wxAssociateWinWithHandle( HWND hWnd
	25	,wxWindowOS2* pWin
	26	);
0371a691	27
0e320a79	28	IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
0e320a79	29
3c299c3a DW	30	MRESULT EXPENTRY wxGaugeWndProc(
	31	HWND hWnd
	32	, UINT uMessage
	33	, MPARAM wParam
	34	, MPARAM lParam
	35	)
0e320a79	36	{
3c299c3a DW	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;
b720b24d	46	RECTL vRect3;
3c299c3a DW	47	double dPixelToRange = 0.0;
	48	double dRange = 0.0;
	49
	50	switch (uMessage )
0371a691	51	{
3c299c3a DW	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	);
b720b24d DW	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
3c299c3a DW	97	if (pGauge->GetWindowStyleFlag() & wxGA_VERTICAL)
3c299c3a DW	98	{
b720b24d	99	dRange = (double)(vRect3.yTop - vRect3.yBottom);
3c299c3a DW	100	dPixelToRange = dRange/(double)pGauge->GetRange();
3c299c3a DW	101	vRect2.yTop = (int)(pGauge->GetValue() * dPixelToRange);
b720b24d DW	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());
3c299c3a DW	109	::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
	110	}
	111	else
	112	{
b720b24d	113	dRange = (double)(vRect3.xRight - vRect3.xLeft);
3c299c3a	114	dPixelToRange = dRange/(double)pGauge->GetRange();
b720b24d DW	115	vRect2.yTop = vRect3.yTop;
	116	vRect2.yBottom = vRect3.yBottom;
	117	vRect2.xLeft = vRect3.xLeft;
3c299c3a	118	vRect2.xRight = (int)(pGauge->GetValue() * dPixelToRange);
b720b24d DW	119	vRect3.xLeft = vRect2.xRight;
	120	if (vRect3.xLeft <= 1)
	121	vRect3.xLeft = 2;
	122	::WinFillRect(hPS, &vRect3, pGauge->GetBackgroundColour().GetPixel());
3c299c3a DW	123	::WinFillRect(hPS, &vRect2, pGauge->GetForegroundColour().GetPixel());
	124	}
	125	::WinEndPaint(hPS);
	126	}
0371a691	127	}
3c299c3a DW	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	#if wxUSE_VALIDATORS
	144	, const wxValidator& rValidator
	145	#endif
	146	, const wxString& rsName
	147	)
	148	{
	149	int nX = rPos.x;
	150	int nY = rPos.y;
	151	int nWidth = rSize.x;
	152	int nHeight = rSize.y;
	153	long lMsStyle = 0L;
d8a3f66c	154	SWP vSwp;
0371a691	155
3c299c3a	156	SetName(rsName);
5d4b632b	157	#if wxUSE_VALIDATORS
3c299c3a	158	SetValidator(rValidator);
5d4b632b	159	#endif
3c299c3a DW	160	if (pParent)
3c299c3a DW	161	pParent->AddChild(this);
b720b24d DW	162	m_backgroundColour.Set(wxString("LIGHT GREY"));
b720b24d DW	163	m_foregroundColour.Set(wxString("NAVY"));
0e320a79	164
3c299c3a DW	165	m_nRangeMax = nRange;
	166	m_nGaugePos = 0;
	167	m_windowStyle = lStyle;
0e320a79	168
3c299c3a DW	169	if (vId == -1)
3c299c3a DW	170	m_windowId = (int)NewControlId();
0e320a79	171	else
3c299c3a DW	172	m_windowId = vId;
	173
	174	if (m_windowStyle & wxCLIP_SIBLINGS )
	175	lMsStyle \|= WS_CLIPSIBLINGS;
	176
	177	//
	178	// OS/2 will use an edit control for this, since there is not a native gauge
	179	// Other choices include using an armless slider but they are more difficult
	180	// to control and manipulate
	181	//
	182
	183	lMsStyle = WS_VISIBLE \| ES_MARGIN \| ES_LEFT \| ES_READONLY;
	184	if (m_windowStyle & wxCLIP_SIBLINGS)
	185	lMsStyle \|= WS_CLIPSIBLINGS;
	186
3c299c3a DW	187	m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
	188	,WC_ENTRYFIELD // Window class
	189	,(PSZ)NULL // Initial Text
	190	,(ULONG)lMsStyle // Style flags
	191	,0L, 0L, 0L, 0L // Origin -- 0 size
	192	,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
	193	,HWND_TOP // initial z position
	194	,(HMENU)m_windowId // Window identifier
	195	,NULL // Slider control data
	196	,NULL // no Presentation parameters
	197	);
	198
	199	wxAssociateWinWithHandle( m_hWnd
	200	,(wxWindowOS2*)this
	201	);
	202	::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
	203	fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc);
d8a3f66c DW	204	::WinQueryWindowPos(m_hWnd, &vSwp);
	205	SetXComp(vSwp.x);
	206	SetYComp(vSwp.y);
b3260bce DW	207	wxFont* pTextFont = new wxFont( 10
	208	,wxMODERN
	209	,wxNORMAL
	210	,wxNORMAL
	211	);
	212	SetFont(*pTextFont);
3c299c3a DW	213	if (nWidth == -1L)
	214	nWidth = 50L;
	215	if (nHeight == -1L)
	216	nHeight = 28L;
	217	SetSize( nX
	218	,nY
	219	,nWidth
	220	,nHeight
	221	);
	222	::WinShowWindow((HWND)GetHWND(), TRUE);
b3260bce	223	delete pTextFont;
3c299c3a DW	224	return TRUE;
3c299c3a DW	225	} // end of wxGauge::Create
0e320a79	226
3c299c3a	227	int wxGauge::GetBezelFace() const
0e320a79	228	{
3c299c3a DW	229	return 0;
3c299c3a DW	230	} // end of wxGauge::GetBezelFace
0e320a79	231
3c299c3a	232	int wxGauge::GetRange() const
0e320a79	233	{
3c299c3a DW	234	return m_nRangeMax;
3c299c3a DW	235	} // end of wxGauge::GetRange
0e320a79 DW	236
	237	int wxGauge::GetShadowWidth() const
	238	{
0e320a79	239	return 0;
3c299c3a	240	} // end of wxGauge::GetShadowWidth
0e320a79 DW	241
	242	int wxGauge::GetValue() const
	243	{
3c299c3a DW	244	return m_nGaugePos;
3c299c3a DW	245	} // end of wxGauge::GetValue
0e320a79	246
3c299c3a DW	247	bool wxGauge::SetBackgroundColour(
	248	const wxColour& rColour
	249	)
0371a691	250	{
3c299c3a	251	if (!wxControl::SetBackgroundColour(rColour))
0371a691 DW	252	return FALSE;
0371a691 DW	253
3c299c3a	254	LONG lColor = (LONG)rColour.GetPixel();
0371a691	255
3c299c3a DW	256	::WinSetPresParam( GetHwnd()
	257	,PP_BACKGROUNDCOLOR
	258	,sizeof(LONG)
	259	,(PVOID)&lColor
	260	);
0371a691	261	return TRUE;
3c299c3a	262	} // end of wxGauge::SetBackgroundColour
0371a691	263
3c299c3a DW	264	void wxGauge::SetBezelFace(
	265	int WXUNUSED(nWidth)
	266	)
0371a691	267	{
3c299c3a	268	} // end of wxGauge::SetBezelFace
0371a691	269
3c299c3a DW	270	bool wxGauge::SetForegroundColour(
	271	const wxColour& rColour
	272	)
	273	{
	274	if (!wxControl::SetForegroundColour(rColour))
	275	return FALSE;
0371a691	276
3c299c3a	277	LONG lColor = (LONG)rColour.GetPixel();
0371a691	278
3c299c3a DW	279	::WinSetPresParam( GetHwnd()
	280	,PP_FOREGROUNDCOLOR
	281	,sizeof(LONG)
	282	,(PVOID)&lColor
	283	);
0371a691	284
3c299c3a DW	285	return TRUE;
3c299c3a DW	286	} // end of wxGauge::SetForegroundColour
0371a691	287
3c299c3a DW	288	void wxGauge::SetRange(
	289	int nRange
	290	)
	291	{
	292	m_nRangeMax = nRange;
	293	} // end of wxGauge::SetRange
0371a691	294
3c299c3a DW	295	void wxGauge::SetShadowWidth(
	296	int WXUNUSED(nWidth)
	297	)
	298	{
	299	} // end of wxGauge::SetShadowWidth
0371a691	300
3c299c3a DW	301	void wxGauge::SetValue(
	302	int nPos
	303	)
	304	{
	305	RECT vRect;
0371a691	306
3c299c3a DW	307	m_nGaugePos = nPos;
	308	::WinQueryWindowRect(GetHwnd(), &vRect);
	309	::WinInvalidateRect(GetHwnd(), &vRect, FALSE);
	310	} // end of wxGauge::SetValue
0371a691 DW	311
0371a691 DW	312