[wxWidgets.git] / src / os2 / dcmemory.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dcmemory.cpp
// Purpose:     wxMemoryDC class
// Author:      David Webster
// Modified by:
// Created:     10/14/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

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

#include "wx/os2/private.h"

#include "wx/dcmemory.h"

IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)

/////////////////////////////////////////////////////////////////////////////
// Memory DC
/////////////////////////////////////////////////////////////////////////////

wxMemoryDC::wxMemoryDC(void)
{
    ERRORID                         vError;
    wxString                        sError;
    HDC                             hDC;
    HPS                             hPS;
    DEVOPENSTRUC                    vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
    SIZEL                           vSize = {0, 0};

    //
    // Create a memory device context
    //
    hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
    if (hDC != DEV_ERROR)
    {
        hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
        if (hPS != GPI_ERROR)
        {
            m_hPS = hPS;
            m_hDC = hDC;
            m_ok = TRUE;
            m_bOwnsDC = TRUE;
            SetBrush(*wxWHITE_BRUSH);
            SetPen(*wxBLACK_PEN);
            if (!::GpiCreateLogColorTable( m_hPS
                                          ,0L
                                          ,LCOLF_CONSECRGB
                                          ,0L
                                          ,(LONG)wxTheColourDatabase->m_nSize
                                          ,(PLONG)wxTheColourDatabase->m_palTable
                                         ))
            {
                vError = ::WinGetLastError(vHabmain);
                sError = wxPMErrorToStr(vError);
                wxLogError("Unable to set current color table. Error: %s\n", sError);
            }
            //
            // Set the color table to RGB mode
            //
            if (!::GpiCreateLogColorTable( m_hPS
                                          ,0L
                                          ,LCOLF_RGB
                                          ,0L
                                          ,0L
                                          ,NULL
                                         ))
            {
                vError = ::WinGetLastError(vHabmain);
                sError = wxPMErrorToStr(vError);
                wxLogError("Unable to set current color table. Error: %s\n", sError);
            }
        }
        else
        {
            m_hPS = NULLHANDLE;
            m_hDC = NULLHANDLE;
            m_ok  = FALSE;
            m_bOwnsDC = FALSE;
        }
    }
    else
    {
        m_hPS = NULLHANDLE;
        m_hDC = NULLHANDLE;
        m_ok  = FALSE;
        m_bOwnsDC = FALSE;
    }
} // end of wxMemoryDC::wxMemoryDC

wxMemoryDC::wxMemoryDC(
  wxDC*                             pOldDC
)
{
    HDC                             hDC;
    HPS                             hPS;
    DEVOPENSTRUC                    vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
    SIZEL                           vSize = {0, 0};

    pOldDC->BeginDrawing();

    //
    // Create a memory device context
    //
    hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, GetHdcOf(*pOldDC));
    if (hDC != DEV_ERROR)
    {
        hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
        if (hPS != GPI_ERROR)
        {
            m_hPS = hPS;
            m_hDC = hDC;
            m_ok = TRUE;
            m_bOwnsDC = TRUE;
            pOldDC->EndDrawing();
            SetBrush(*wxWHITE_BRUSH);
            SetPen(*wxBLACK_PEN);
        }
        else
        {
            pOldDC->EndDrawing();
            m_hPS = NULLHANDLE;
            m_hDC = NULLHANDLE;
            m_ok  = FALSE;
            m_bOwnsDC = FALSE;
        }
    }
    else
    {
        pOldDC->EndDrawing();
        m_hPS = NULLHANDLE;
        m_hDC = NULLHANDLE;
        m_ok  = FALSE;
        m_bOwnsDC = FALSE;
    }
} // end of wxMemoryDC::wxMemoryDC

wxMemoryDC::~wxMemoryDC()
{
    m_vSelectedBitmap.SetSelectedInto(NULL);
    if (m_hPS != NULLHANDLE)
        ::GpiDestroyPS(m_hPS);
    if (m_hDC != NULLHANDLE)
        ::DevCloseDC(m_hDC);
} // end of wxMemoryDC::~wxMemoryDC

void wxMemoryDC::SelectObject(
  const wxBitmap&                   rBitmap
)
{
    //
    // Select old bitmap out of the device context
    //
    if (m_hOldBitmap)
    {
        ::GpiSetBitmap(m_hPS, NULLHANDLE);
        if (m_vSelectedBitmap.Ok())
        {
            m_vSelectedBitmap.SetSelectedInto(NULL);
            m_vSelectedBitmap = wxNullBitmap;
        }
    }

    //
    // Check for whether the bitmap is already selected into a device context
    //
    wxCHECK_RET( !rBitmap.GetSelectedInto() ||
                 (rBitmap.GetSelectedInto() == this),
                 wxT("Bitmap is selected in another wxMemoryDC, delete the first wxMemoryDC or use SelectObject(NULL)") );

    m_vSelectedBitmap = rBitmap;

    WXHBITMAP                       hBmp = m_vSelectedBitmap.GetHBITMAP();

    if (!hBmp)
        return;

    m_vSelectedBitmap.SetSelectedInto(this);
    hBmp = (WXHBITMAP)::GpiSetBitmap(m_hPS, (HBITMAP)hBmp);

    if (hBmp == HBM_ERROR)
    {
        wxLogLastError(wxT("SelectObject(memDC, bitmap)"));
        wxFAIL_MSG(wxT("Couldn't select a bitmap into wxMemoryDC"));
    }
    else if (!m_hOldBitmap)
    {
        m_hOldBitmap = hBmp;
    }
} // end of wxMemoryDC::SelectObject

void wxMemoryDC::DoGetSize(
  int*                              pWidth
, int*                              pHeight
) const
{
    if (!m_vSelectedBitmap.Ok())
    {
        *pWidth  = 0;
        *pHeight = 0;
        return;
    }
    *pWidth = m_vSelectedBitmap.GetWidth();
    *pHeight = m_vSelectedBitmap.GetHeight();
} // end of wxMemoryDC::DoGetSize
Commit	Line	Data
0e320a79 DW	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dcmemory.cpp
	3	// Purpose: wxMemoryDC class
fb46a9a6	4	// Author: David Webster
0e320a79	5	// Modified by:
fb46a9a6	6	// Created: 10/14/99
0e320a79	7	// RCS-ID: $Id$
fb46a9a6 DW	8	// Copyright: (c) David Webster
fb46a9a6 DW	9	// Licence: wxWindows licence
0e320a79 DW	10	/////////////////////////////////////////////////////////////////////////////
0e320a79 DW	11
fb46a9a6 DW	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifndef WX_PRECOMP
	16	#include "wx/utils.h"
0e320a79 DW	17	#endif
0e320a79 DW	18
fb46a9a6 DW	19	#include "wx/os2/private.h"
fb46a9a6 DW	20
0e320a79 DW	21	#include "wx/dcmemory.h"
0e320a79 DW	22
fb46a9a6	23	IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
0e320a79	24
23122f8c DW	25	/////////////////////////////////////////////////////////////////////////////
	26	// Memory DC
	27	/////////////////////////////////////////////////////////////////////////////
0e320a79 DW	28
	29	wxMemoryDC::wxMemoryDC(void)
	30	{
5afb9458 DW	31	ERRORID vError;
5afb9458 DW	32	wxString sError;
23122f8c DW	33	HDC hDC;
	34	HPS hPS;
	35	DEVOPENSTRUC vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
	36	SIZEL vSize = {0, 0};
	37
	38	//
	39	// Create a memory device context
	40	//
	41	hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDOP, NULLHANDLE);
	42	if (hDC != DEV_ERROR)
	43	{
	44	hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS \| GPIT_MICRO \| GPIA_ASSOC);
	45	if (hPS != GPI_ERROR)
	46	{
	47	m_hPS = hPS;
	48	m_hDC = hDC;
	49	m_ok = TRUE;
	50	m_bOwnsDC = TRUE;
	51	SetBrush(*wxWHITE_BRUSH);
	52	SetPen(*wxBLACK_PEN);
5afb9458 DW	53	if (!::GpiCreateLogColorTable( m_hPS
	54	,0L
	55	,LCOLF_CONSECRGB
	56	,0L
	57	,(LONG)wxTheColourDatabase->m_nSize
	58	,(PLONG)wxTheColourDatabase->m_palTable
	59	))
	60	{
	61	vError = ::WinGetLastError(vHabmain);
	62	sError = wxPMErrorToStr(vError);
	63	wxLogError("Unable to set current color table. Error: %s\n", sError);
	64	}
	65	//
	66	// Set the color table to RGB mode
	67	//
	68	if (!::GpiCreateLogColorTable( m_hPS
	69	,0L
	70	,LCOLF_RGB
	71	,0L
	72	,0L
	73	,NULL
	74	))
	75	{
	76	vError = ::WinGetLastError(vHabmain);
	77	sError = wxPMErrorToStr(vError);
	78	wxLogError("Unable to set current color table. Error: %s\n", sError);
	79	}
23122f8c DW	80	}
	81	else
	82	{
	83	m_hPS = NULLHANDLE;
	84	m_hDC = NULLHANDLE;
	85	m_ok = FALSE;
	86	m_bOwnsDC = FALSE;
	87	}
	88	}
	89	else
	90	{
	91	m_hPS = NULLHANDLE;
	92	m_hDC = NULLHANDLE;
	93	m_ok = FALSE;
	94	m_bOwnsDC = FALSE;
	95	}
	96	} // end of wxMemoryDC::wxMemoryDC
	97
	98	wxMemoryDC::wxMemoryDC(
	99	wxDC* pOldDC
	100	)
0e320a79	101	{
23122f8c DW	102	HDC hDC;
	103	HPS hPS;
	104	DEVOPENSTRUC vDOP = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
	105	SIZEL vSize = {0, 0};
	106
	107	pOldDC->BeginDrawing();
	108
	109	//
	110	// Create a memory device context
	111	//
	112	hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "", 5L, (PDEVOPENDATA)&vDOP, GetHdcOf(pOldDC));
	113	if (hDC != DEV_ERROR)
	114	{
	115	hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS \| GPIT_MICRO \| GPIA_ASSOC);
	116	if (hPS != GPI_ERROR)
	117	{
	118	m_hPS = hPS;
	119	m_hDC = hDC;
	120	m_ok = TRUE;
	121	m_bOwnsDC = TRUE;
	122	pOldDC->EndDrawing();
	123	SetBrush(*wxWHITE_BRUSH);
	124	SetPen(*wxBLACK_PEN);
	125	}
	126	else
	127	{
	128	pOldDC->EndDrawing();
	129	m_hPS = NULLHANDLE;
	130	m_hDC = NULLHANDLE;
	131	m_ok = FALSE;
	132	m_bOwnsDC = FALSE;
	133	}
	134	}
	135	else
	136	{
	137	pOldDC->EndDrawing();
	138	m_hPS = NULLHANDLE;
	139	m_hDC = NULLHANDLE;
	140	m_ok = FALSE;
	141	m_bOwnsDC = FALSE;
	142	}
	143	} // end of wxMemoryDC::wxMemoryDC
	144
	145	wxMemoryDC::~wxMemoryDC()
0e320a79	146	{
1159a76f	147	m_vSelectedBitmap.SetSelectedInto(NULL);
23122f8c DW	148	if (m_hPS != NULLHANDLE)
	149	::GpiDestroyPS(m_hPS);
	150	if (m_hDC != NULLHANDLE)
	151	::DevCloseDC(m_hDC);
	152	} // end of wxMemoryDC::~wxMemoryDC
	153
	154	void wxMemoryDC::SelectObject(
	155	const wxBitmap& rBitmap
	156	)
0e320a79	157	{
23122f8c DW	158	//
	159	// Select old bitmap out of the device context
	160	//
	161	if (m_hOldBitmap)
	162	{
	163	::GpiSetBitmap(m_hPS, NULLHANDLE);
	164	if (m_vSelectedBitmap.Ok())
	165	{
	166	m_vSelectedBitmap.SetSelectedInto(NULL);
	167	m_vSelectedBitmap = wxNullBitmap;
	168	}
	169	}
	170
	171	//
	172	// Check for whether the bitmap is already selected into a device context
	173	//
	174	wxCHECK_RET( !rBitmap.GetSelectedInto() \|\|
	175	(rBitmap.GetSelectedInto() == this),
	176	wxT("Bitmap is selected in another wxMemoryDC, delete the first wxMemoryDC or use SelectObject(NULL)") );
	177
	178	m_vSelectedBitmap = rBitmap;
	179
	180	WXHBITMAP hBmp = m_vSelectedBitmap.GetHBITMAP();
	181
	182	if (!hBmp)
	183	return;
	184
	185	m_vSelectedBitmap.SetSelectedInto(this);
	186	hBmp = (WXHBITMAP)::GpiSetBitmap(m_hPS, (HBITMAP)hBmp);
	187
5afb9458	188	if (hBmp == HBM_ERROR)
23122f8c DW	189	{
	190	wxLogLastError(wxT("SelectObject(memDC, bitmap)"));
	191	wxFAIL_MSG(wxT("Couldn't select a bitmap into wxMemoryDC"));
	192	}
	193	else if (!m_hOldBitmap)
	194	{
	195	m_hOldBitmap = hBmp;
	196	}
	197	} // end of wxMemoryDC::SelectObject
	198
	199	void wxMemoryDC::DoGetSize(
	200	int* pWidth
	201	, int* pHeight
	202	) const
0e320a79	203	{
23122f8c DW	204	if (!m_vSelectedBitmap.Ok())
	205	{
	206	*pWidth = 0;
	207	*pHeight = 0;
	208	return;
	209	}
	210	*pWidth = m_vSelectedBitmap.GetWidth();
	211	*pHeight = m_vSelectedBitmap.GetHeight();
	212	} // end of wxMemoryDC::DoGetSize
0e320a79 DW	213
0e320a79 DW	214