/*

device context data types

Created July 1994, Mark Hammond (MHammond@cmutual.com.au)

These are implemented using CDC's, and hDC's in the map

Note that this source file contains embedded documentation.

This documentation consists of marked up text inside the

C comments, and is prefixed with an '@' symbol. The source

files are processed by a tool called "autoduck" which

generates Windows .hlp files.

@doc

*/

#define PY_SSIZE_T_CLEAN // this module is Py_ssize_t clean!

#include "stdafx.h"

#include <winspool.h>

#include "win32dc.h"

#include "win32gdi.h"

#include "win32brush.h"

#include "win32font.h"

#include "win32pen.h"

#include "win32bitmap.h"

#include "win32rgn.h"

// LOGPALETTE support.

BOOL PyObject_AsLOGPALETTE(PyObject *obLogPal, LOGPALETTE **ppLogPal)

{

BOOL ok = FALSE;

if (!PySequence_Check(obLogPal)) {

PyErr_SetString(PyExc_TypeError, "LOGPALETTE must be a sequence");

return FALSE;

}

Py_ssize_t n = PySequence_Length(obLogPal);

*ppLogPal = (LOGPALETTE *)malloc(sizeof(LOGPALETTE) + n * sizeof(PALETTEENTRY));

LOGPALETTE *pPal = *ppLogPal;

if (pPal==NULL) {

PyErr_SetString(PyExc_MemoryError, "Allocating LOGPALETTE");

return FALSE;

}

pPal->palVersion = 0x300;

pPal->palNumEntries = PyWin_SAFE_DOWNCAST(n, Py_ssize_t, WORD);

for (Py_ssize_t i=0;i<n;i++) {

PyObject *subOb = PySequence_GetItem(obLogPal, i);

if (subOb==NULL)

goto done;

if (!PyArg_ParseTuple(subOb, "bbbb",

&pPal->palPalEntry[i].peRed, &pPal->palPalEntry[i].peGreen, &pPal->palPalEntry[i].peBlue, &pPal->palPalEntry[i].peFlags)) {

Py_XDECREF(subOb);

goto done;

}

Py_XDECREF(subOb);

}

ok = TRUE;

done:

if (!ok) {

free(pPal);

}

return ok;

}

void PyObject_FreeLOGPALETTE(LOGPALETTE *pLogPal)

{

if (pLogPal) free(pLogPal);

}

PyObject *PyObject_FromLOGPALETTE( LOGPALETTE *pLP)

{

PyObject *entries = PyTuple_New(pLP->palNumEntries);

for (int i=0;i<pLP->palNumEntries;i++) {

PyTuple_SET_ITEM(entries, i, Py_BuildValue("bbbb",

pLP->palPalEntry[i].peRed,

pLP->palPalEntry[i].peGreen,

pLP->palPalEntry[i].peBlue,

pLP->palPalEntry[i].peFlags));

}

PyObject *rc = Py_BuildValue("lO", pLP->palVersion, entries);

Py_DECREF(entries);

return rc;

}

// @pymethod int|win32ui|CreatePalette|Creates a HPALETTE

PyObject *win32uiCreatePalette(PyObject *self, PyObject *args)

{

// @pyparm <o LOGPALETTE>|lp||The entries for the palette.

PyObject *obLP;

if (!PyArg_ParseTuple(args, "O", &obLP))

return NULL;

LOGPALETTE *pLP;

if (!PyObject_AsLOGPALETTE(obLP, &pLP))

return NULL;

HPALETTE hp = CreatePalette(pLP);

PyObject_FreeLOGPALETTE(pLP);

if (hp==NULL)

RETURN_API_ERR("CreatePalette");

return PyWinLong_FromHANDLE(hp);

}

// this returns a pointer that should not be stored.

CDC *ui_dc_object::GetDC(PyObject *self)

{

return (CDC *)GetGoodCppObject( self, &type);

}

void ui_dc_object::SetAssocInvalid()

{

return; // do nothing. Dont call base as dont want my handle wiped.

}

ui_dc_object::~ui_dc_object()

{

if (m_deleteDC) {

CDC *pDC = GetDC(this);

if (pDC)

::DeleteDC (pDC->m_hDC);

}

}

// @pymethod |win32ui|CreateDC|Creates an uninitialised device context.

PyObject *ui_dc_object::create_dc( PyObject *self, PyObject *args )

{

CHECK_NO_ARGS2(args, CreateDC);

// create Python device context

CDC *pDC = new CDC;

ui_dc_object *dc =

(ui_dc_object *) ui_assoc_object::make (ui_dc_object::type, pDC, true)->GetGoodRet();

if (dc)

dc->bManualDelete= true;

return dc;

}

// @pymethod |win32ui|CreateDCFromHandle|Creates a DC object from an integer handle.

PyObject *ui_create_dc_from_handle (PyObject *self, PyObject *args)

{

HDC hDC;

if (!PyArg_ParseTuple(args,"O&:CreateDCFromHandle",

PyWinObject_AsHANDLE, &hDC))

return NULL;

CDC* pDC = CDC::FromHandle(hDC);

if (pDC==NULL)

RETURN_ERR ("Could not create DC.");

// create Python device context

ui_dc_object *dc =

(ui_dc_object *) ui_assoc_object::make (ui_dc_object::type, pDC)->GetGoodRet();

return dc;

}

// @pymethod |PyCDC|BitBlt|Copies a bitmap from the source device context to this device context.

static PyObject *

ui_dc_bitblt (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x, y, width, height, xsrc, ysrc;

DWORD rop;

PyObject *dc_ob;

if (!PyArg_ParseTuple (args, "(ii)(ii)O(ii)i",

&x, &y, // @pyparm (x,y)-ints|destPos||The logical x,y coordinates of the upper-left corner of the destination rectangle.

&width, &height, // @pyparm (width, height)-ints|size||Specifies the width and height (in logical units) of the destination rectangle and source bitmap.

&dc_ob, // @pyparm <o PyCDC>|dc||Specifies the PyCDC object from which the bitmap will be copied. It must be None if rop specifies a raster operation that does not include a source.

&xsrc, &ysrc, // @pyparm (xSrc, ySrc)-ints|srcPos||Specifies the logical x,y coordinates of the upper-left corner of the source bitmap.

&rop)) // @pyparm int|rop||Specifies the raster operation to be performed. See the win32 api documentation for details.

return NULL;

if (!ui_base_class::is_uiobject (dc_ob, &ui_dc_object::type))

RETURN_TYPE_ERR("The 'O' param must be a PyCDC object");

CDC *pSrcDC = NULL;

if (dc_ob!=Py_None) {

pSrcDC = ui_dc_object::GetDC(dc_ob);

if (!pSrcDC)

RETURN_ERR("The source DC is invalid");

}

GUI_BGN_SAVE;

BOOL ok = pDC->BitBlt(x, y, width, height, pSrcDC, xsrc, ysrc, rop);

GUI_END_SAVE;

if (!ok) // @pyseemfc CDC|BitBlt

RETURN_ERR("BitBlt failed");

RETURN_NONE;

}

// @pymethod |PyCDC|PatBlt|Creates a bit pattern on the device.

static PyObject *

ui_dc_patblt (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x, y, width, height;

DWORD rop;

if (!PyArg_ParseTuple (args, "(ii)(ii)i",

&x, &y, // @pyparm (x,y)-ints|destPos||The logical x,y coordinates of the upper-left corner of the destination rectangle.

&width, &height, // @pyparm (width, height)-ints|size||Specifies the width and height (in logical units) of the destination rectangle and source bitmap.

&rop)) // @pyparm int|rop||Specifies the raster operation to be performed. See the win32 api documentation for details.

return NULL;

GUI_BGN_SAVE;

BOOL ok = pDC->PatBlt(x, y, width, height, rop);

GUI_END_SAVE;

if (!ok) // @pyseemfc CDC|BitBlt

RETURN_ERR("PatBlt failed");

RETURN_NONE;

}

// @pymethod |PyCDC|SetPixel|Sets a pixel in a device context

static PyObject *

ui_dc_setpixel (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x, y;

long color, rcolor;

if (!PyArg_ParseTuple (args, "iil",

&x, // @pyparm int|x||Horizontal coordinate.

&y, // @pyparm int|y||Vertical coordinate.

&color)) { // @pyparm int|color||The brush color.

return NULL;

}

GUI_BGN_SAVE;

rcolor = pDC->SetPixel (x, y, color);

GUI_END_SAVE;

if (rcolor < 0)

RETURN_ERR ("SetPixel failed");

return Py_BuildValue ("l", rcolor);

}

// @pymethod int|PyCDC|GetSafeHdc|Returns the HDC of this DC object.

static PyObject *

ui_dc_get_safe_hdc(PyObject *self, PyObject *args)

{

CHECK_NO_ARGS(args);

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

// @pyseemfc CDC|GetSafeHdc

HDC hdc = pDC->GetSafeHdc();

return PyWinLong_FromHANDLE(hdc);

}

// @pymethod |PyCDC|GetPixel|Gets a pixel at a local in a device context

static PyObject *

ui_dc_get_pixel (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x, y;

long rcolor;

if (!PyArg_ParseTuple (args, "ii",

&x, // @pyparm int|x||Horizontal coordinate.

&y)) { // @pyparm int|y||Vertical coordinate.

return NULL;

}

GUI_BGN_SAVE;

rcolor = pDC->GetPixel (x, y);

GUI_END_SAVE;

if (rcolor < 0)

RETURN_ERR ("GetPixel failed");

return Py_BuildValue ("l", rcolor);

}

// @pymethod (x, y)|PyCDC|GetCurrentPosition|Retrieves the current position (in logical coordinates).

static PyObject *

ui_dc_get_current_position (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CHECK_NO_ARGS(args);

CPoint pt;

pt = pDC->GetCurrentPosition ();

return Py_BuildValue ("(ii)", pt.x, pt.y);

}

// @pymethod |PyCDC|Pie|Draws a pie slice in a device context

static PyObject *

ui_dc_pie (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x1, y1, x2, y2, x3, y3, x4, y4;

if (!PyArg_ParseTuple (args, "iiiiiiii",

&x1, // @pyparm int|x1||X coordinate of upper left corner

&y1, // @pyparm int|y1||Y coordinate of upper left corner

&x2, // @pyparm int|x2||X coordinate of lower right corner

&y2, // @pyparm int|y2||Y coordinate of lower right corner

&x3, // @pyparm int|x3||X coordinate of starting point of arc

&y3, // @pyparm int|y3||Y coordinate of starting point of arc

&x4, // @pyparm int|x4||X coordinate of ending point of arc

&y4)) { // @pyparm int|y4||Y coordinate of ending point of arc

return NULL;

}

GUI_BGN_SAVE;

int rc = pDC->Pie (x1, y1, x2, y2, x3, y3, x4, y4);

GUI_END_SAVE;

return Py_BuildValue ("i", rc);

}

// @pymethod |PyCDC|CreateCompatibleDC|Creates a memory device context that is compatible with this DC.

PyObject *ui_dc_object::create_compatible_dc( PyObject *self, PyObject *args )

{

// @comm Note that unlike the MFC version, this function

// calls the global CreateCompatibleDC function and returns

// a new <o PyCDC> object.

PyObject *obDCFrom = Py_None;

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

if (!PyArg_ParseTuple(args, "|O:CreateCompatibleDC", &obDCFrom ))

return NULL; // @pyparm <o PyCDC>|dcFrom|None|The source DC, or None to make a screen compatible DC.

CDC *dcFrom = NULL;

if (obDCFrom!=Py_None)

dcFrom = GetDC(obDCFrom);

HDC hDC = NULL;

if (dcFrom) {

hDC = dcFrom->GetSafeHdc();

}

GUI_BGN_SAVE;

HDC hcDC = ::CreateCompatibleDC(hDC);

GUI_END_SAVE;

if (!hcDC) // @pyseemfc CDC|CreateCompatibleDC

RETURN_ERR("CreateCompatibleDC failed");

// create Python device context

CDC *pcDC = pDC->FromHandle(hcDC);

ui_dc_object *dc =

(ui_dc_object *) ui_assoc_object::make (ui_dc_object::type, pcDC)->GetGoodRet();

return dc;

}

// @pymethod |PyCDC|CreatePrinterDC|Creates a device context for a specific printer

PyObject *ui_dc_object::create_printer_dc( PyObject *self, PyObject *args )

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

TCHAR *printerName = NULL;

PyObject *obprinterName=Py_None;

if (!PyArg_ParseTuple(args, "|O:CreatePrinterDC", &obprinterName ))

return NULL; // @pyparm string|printerName|None|The printer name, or None for the default printer

if (!PyWinObject_AsTCHAR(obprinterName, &printerName, TRUE))

return NULL;

BOOL result;

if (printerName == NULL)

{

// Attempt to open the default printer

CPrintInfo info;

if (!AfxGetApp()->GetPrinterDeviceDefaults(&(info.m_pPD->m_pd)))

{

RETURN_ERR("No default printer found");

return NULL;

}

if (info.m_pPD->m_pd.hDC == NULL && !info.m_pPD->CreatePrinterDC())

{

result = FALSE;

}

else

{

result = pDC->Attach(info.m_pPD->m_pd.hDC);

info.m_pPD->m_pd.hDC = NULL; // Prevent this DC from being deleted

}

}

else

{

// Attempt to open a specific printer

HANDLE hPrinter;

if (!::OpenPrinter(printerName, &hPrinter, NULL))

{

PyWinObject_FreeTCHAR(printerName);

RETURN_ERR("Unable to open printer");

return NULL;

}

PyWinObject_FreeTCHAR(printerName);

DWORD len;

unsigned char buf;

::GetPrinter(hPrinter, 2, &buf, 1, &len);

unsigned char *buffer = new unsigned char[len];

result = ::GetPrinter(hPrinter, 2, buffer, len, &len);

::ClosePrinter(hPrinter);

if (!result)

{

RETURN_ERR("Unable to get printer info");

delete [] buffer;

return NULL;

}

PRINTER_INFO_2 *pinfo = (PRINTER_INFO_2*)buffer;

GUI_BGN_SAVE;

result = pDC->CreateDC(pinfo->pDriverName, pinfo->pPrinterName, NULL, NULL); // @pyseemfc CDC|CreateDC

GUI_END_SAVE;

delete [] buffer;

}

if (!result)

RETURN_ERR("CreateDC failed");

RETURN_NONE;

}

// @pymethod |PyCDC|DeleteDC|Deletes all resources associated with a device context.

static PyObject *

ui_dc_delete_dc (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CHECK_NO_ARGS2(args, DeleteDC);

GUI_BGN_SAVE;

BOOL ok = pDC->DeleteDC();

GUI_END_SAVE;

if (!ok)

RETURN_ERR("DeleteDC failed");

RETURN_NONE;

// @comm In general, do not call this function; the destructor will do it for you.

// <nl>An application should not call DeleteDC if objects have been selected into the device context. Objects must first be selected out of the device context before it it is deleted.

// <nl>An application must not delete a device context whose handle was obtained by calling CWnd::GetDC. Instead, it must call CWnd::ReleaseDC to free the device context.

// <nl>The DeleteDC function is generally used to delete device contexts created with CreateDC, CreateIC, or CreateCompatibleDC.

}

// @pymethod |PyCDC|DrawIcon|Draws an icon on the DC.

static PyObject *

ui_dc_draw_icon (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int x, y;

HICON hIcon;

if (!PyArg_ParseTuple (args, "(ii)O&:DrawIcon",

&x, &y, // @pyparm (x,y)|point||The point coordinate to draw to.

PyWinObject_AsHANDLE, &hIcon)) // @pyparm <o PyHANDLE>|hIcon||The handle of the icon to draw.

return NULL;

GUI_BGN_SAVE;

BOOL ok = pDC->DrawIcon (x,y, hIcon);

GUI_END_SAVE;

if (!ok) // @pyseemfc CDC|DrawIcon

RETURN_ERR ("DrawIcon failed");

else

RETURN_NONE;

}

// @pymethod |PyCDC|DrawFocusRect|Draws a rectangle in the style used to

// indicate the rectangle has focus

static PyObject *

ui_dc_draw_focus_rect (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

CRect rect;

if (!pDC) {

return NULL;

// @pyparm (left, top, right, bottom)|rect||The coordinates of the

// rectangle

} else if (!PyArg_ParseTuple (args,

"(iiii)",

&rect.left, &rect.top,

&rect.right, &rect.bottom)) {

return NULL;

} else {

// it's a void function

GUI_BGN_SAVE;

pDC->DrawFocusRect (rect); // @pyseemfc CDC|DrawFocusRect

GUI_END_SAVE;

RETURN_NONE;

}

}

//@pymethod |PyCDC|ExtTextOut|Writes text to the DC.

static PyObject *ui_dc_ext_text_out (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

TCHAR *text;

DWORD strLen;

int x, y;

UINT options;

PyObject *obtext, *rectObject, *widthObject = NULL;

RECT rect, *rectPtr;

int *widths = NULL;

if (!PyArg_ParseTuple (args, "iiiOO|O:ExtTextOut",

&x, // @pyparm x|int||The x coordinate to write the text to.

&y, // @pyparm y|int||The y coordinate to write the text to.

&options, // @pyparm nOptions|int||Specifies the rectangle type. This parameter can be one, both, or neither of ETO_CLIPPED and ETO_OPAQUE

&rectObject,// @pyparm (left, top, right, bottom)|rect||Specifies the text's bounding rectangle. (Can be None.)

&obtext, // @pyparm text|string||The text to write.

&widthObject)) // @pyparm (width1, width2, ...)|tuple||Optional array of values that indicate distance between origins of character cells.

{

return NULL;

}

// Parse out rectangle object

if (rectObject != Py_None) {

if (!PyArg_ParseTuple(rectObject, "iiii", &rect.left,

&rect.top, &rect.right, &rect.bottom))

return NULL;

rectPtr = &rect;

}

else

rectPtr = NULL;

if (!PyWinObject_AsTCHAR(obtext, &text, FALSE, &strLen))

return NULL;

// Parse out widths

if (widthObject) {

BOOL error = !PyTuple_Check(widthObject);

if (!error) {

Py_ssize_t len = PyTuple_Size(widthObject);

if (len == (strLen - 1)) {

widths = new int[len + 1];

for (Py_ssize_t i = 0; i < len; i++) {

PyObject *item = PyTuple_GetItem(widthObject, i);

if (!PyInt_Check(item))

error = TRUE;

else

widths[i] = PyInt_AsLong(item);

}

}

}

if (error) {

delete [] widths;

PyWinObject_FreeTCHAR(text);

RETURN_TYPE_ERR("The width param must be a tuple of integers with a length one less than that of the string");

}

}

GUI_BGN_SAVE;

BOOL ret = pDC->ExtTextOut(x, y, options, rectPtr, text, strLen, widths);

// @pyseemfc CDC|ExtTextOut

GUI_END_SAVE;

PyWinObject_FreeTCHAR(text);

delete [] widths;

if (!ret) {

RETURN_API_ERR("CDC::TextOut");

}

RETURN_NONE;

// @rdesc Always none. If the function fails, an exception is raised.

}

// @pymethod int|PyCDC|RectVisible|Determines whether any part of the given rectangle lies within the clipping region of the display context.

static PyObject *ui_dc_rect_visible( PyObject *self, PyObject *args )

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CRect rect;

// @pyparm (left, top, right, bottom)|rect||The coordinates of the reactangle to be checked.

if (!PyArg_ParseTuple(args,"(iiii):RectVisible", &rect.left, &rect.top, &rect.right, &rect.bottom))

return NULL;

GUI_BGN_SAVE;

int rc = pDC->RectVisible(&rect);

GUI_END_SAVE;

return Py_BuildValue("i",rc); // @pyseemfc CDC|RectVisible

// @rdesc Non zero if any part of the rectangle lies within the clipping region, else zero.

}

// @pymethod |PyCDC|Arc|Draws an eliptical arc.

static PyObject *ui_dc_arc (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CRect rect;

POINT pts, pte;

if (!PyArg_ParseTuple(args,"(iiii)(ii)(ii):Arc",

// @pyparm (left, top, right, bottom)|rect||Specifies the ellipse's bounding rectangle

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (x,y)|pointStart||Specifies the x- and y-coordinates

// of the point that defines the arc's starting point (in logical units).

// This point does not have to lie exactly on the arc.

&pts.x, &pts.y,

// @pyparm (x,y)|pointEnd||Specifies the x- and y-coordinates

// of the point that defines the arc's ending point (in logical units).

// This point does not have to lie exactly on the arc.

&pte.x, &pte.y ))

return NULL;

GUI_BGN_SAVE;

BOOL ret = pDC->Arc(&rect, pts, pte); // @pyseemfc CDC|Arc

GUI_END_SAVE;

if (!ret)

RETURN_API_ERR("CDC::Arc");

RETURN_NONE;

// @rdesc Always none. If the function fails, an exception is raised.

// @comm The arc drawn by using the function is a segment of the ellipse defined by the specified bounding rectangle.

// The actual starting point of the arc is the point at which a ray drawn

// from the center of the bounding rectangle through the specified starting

// point intersects the ellipse. The actual ending point of the arc is the

// point at which a ray drawn from the center of the bounding rectangle through

// the specified ending point intersects the ellipse. The arc is drawn in a

// counterclockwise direction. Since an arc is not a closed figure, it is

// not filled. Both the width and height of the rectangle must be greater

// than 2 units and less than 32,767 units.

}

// @pymethod |PyCDC|Chord|Draws a chord.

static PyObject *ui_dc_chord (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CRect rect;

POINT pts, pte;

if (!PyArg_ParseTuple(args,"(iiii)(ii)(ii):Chord",

// @pyparm (left, top, right, bottom)|rect||Specifies the ellipse's bounding rectangle

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (x,y)|pointStart||Specifies the x- and y-coordinates

// of the point that defines the arc's starting point (in logical units).

// This point does not have to lie exactly on the arc.

&pts.x, &pts.y,

// @pyparm (x,y)|pointEnd||Specifies the x- and y-coordinates

// of the point that defines the arc's ending point (in logical units).

// This point does not have to lie exactly on the arc.

&pte.x, &pte.y ))

return NULL;

GUI_BGN_SAVE;

BOOL ret = pDC->Chord(&rect,pts,pte); // @pyseemfc CDC|Chord

GUI_END_SAVE;

if (!ret)

RETURN_API_ERR("CDC::Chord");

RETURN_NONE;

// @rdesc Always none. If the function fails, an exception is raised.

// @comm Draws a chord (a closed figure bounded by the intersection

// of an ellipse and a line segment). The rect parameter specify the

// upper-left and lower-right corners, respectively, of a rectangle

// bounding the ellipse that is part of the chord.

// The pointStart and pointEnd parameters specify

// the endpoints of a line that intersects the ellipse.

// The chord is drawn by using the selected pen and filled

// by using the selected brush.

}

// @pymethod |PyCDC|Ellipse|Draws an Ellipse.

static PyObject *ui_dc_ellipse (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

CRect rect;

// @pyparm (left, top, right, bottom)|rect||Specifies the ellipse's bounding rectangle

if (!PyArg_ParseTuple(args,"(iiii):Ellipse", &rect.left, &rect.top, &rect.right, &rect.bottom))

return NULL;

GUI_BGN_SAVE;

BOOL ret = pDC->Ellipse(rect); // @pyseemfc CDC|Ellipse

GUI_END_SAVE;

if (!ret)

RETURN_API_ERR("CDC::Ellipse");

RETURN_NONE;

// @rdesc Always none. If the function fails, an exception is raised.

// @comm The center of the ellipse is the center of the bounding rectangle

// specified by rect. The ellipse is drawn with the current pen, and its

// interior is filled with the current brush.

}

// @pymethod |PyCDC|Polygon|Draws an Polygon.

static PyObject *ui_dc_polygon (PyObject *self, PyObject *args)

{

PyObject * point_list;

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

if (!PyArg_ParseTuple(args,

"O:Polygon",

&point_list)) {

return NULL;

} else if (!PyList_Check(point_list)) {

return NULL;

} else {

// Convert the list of point tuples into an array of POINT structs

Py_ssize_t num = PyList_Size (point_list);

POINT * point_array = new POINT[num];

for (Py_ssize_t i=0; i < num; i++) {

PyObject * point_tuple = PyList_GetItem (point_list, i);

if (!PyTuple_Check (point_tuple) || PyTuple_Size (point_tuple) != 2) {

PyErr_SetString (PyExc_ValueError,

"point list must be a list of (x,y) tuples");

delete[] point_array;

return NULL;

} else {

long x, y;

PyObject *px, *py;

px = PyTuple_GetItem (point_tuple, 0);

py = PyTuple_GetItem (point_tuple, 1);

if ((!PyInt_Check(px)) || (!PyInt_Check(py))) {

PyErr_SetString (PyExc_ValueError,

"point list must be a list of (x,y) tuples");

delete[] point_array;

return NULL;

} else {

x = PyInt_AsLong (px);

y = PyInt_AsLong (py);

point_array[i].x = x;

point_array[i].y = y;

}

}

}

// we have an array of POINT structs, now we

// can finally draw the polygon.

GUI_BGN_SAVE;

BOOL ret = pDC->Polygon (point_array, PyWin_SAFE_DOWNCAST(num, Py_ssize_t, int));

GUI_END_SAVE;

delete[] point_array;

if (!ret) {

RETURN_API_ERR("CDC::Polygon");

} else {

RETURN_NONE;

}

}

}

// @pymethod |PyCDC|PolyBezier|Draws one or more Bezier splines.

static PyObject *ui_dc_poly_bezier (PyObject *self, PyObject *args)

{

PyObject * triple_list;

int do_to=0;

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

if (!PyArg_ParseTuple(args,

"O|i:PolyBezier[To]",

&triple_list,

&do_to)) {

return NULL;

} else if (!PyList_Check(triple_list)) {

return NULL;

} else {

int index = 0;

Py_ssize_t num = PyList_Size (triple_list);

#define HURL \

do { \

PyErr_SetString (PyExc_ValueError, \

"arg must be a list of 3-tuples of (x,y) tuples"); \

delete[] point_array; \

return NULL; \

} \

while (0)

POINT * point_array = new POINT[num*3];

for (Py_ssize_t i=0; i < num; i++) {

PyObject * triplet = PyList_GetItem (triple_list, i);

if (!PyTuple_Check (triplet) || PyTuple_Size (triplet) != 3) {

HURL;

} else {

for (int j=0; j < 3; j++) {

PyObject *point = PyTuple_GetItem (triplet, j);

if (!PyTuple_Check (point) || PyTuple_Size (point) != 2) {

HURL;

} else {

PyObject *px, *py;

px = PyTuple_GetItem (point, 0);

py = PyTuple_GetItem (point, 1);

if (!PyInt_Check(px) || !PyInt_Check(py)) {

HURL;

} else {

point_array[index].x = PyInt_AsLong (px);

point_array[index].y = PyInt_AsLong (py);

index++;

}

}

}

}

}

// we have an array of POINT structs, now we

// can finally draw the splines..

BOOL result;

if (do_to) {

result = pDC->PolyBezierTo (point_array, index);

} else {

result = pDC->PolyBezier (point_array, index);

}

delete[] point_array;

if (!result) {

RETURN_API_ERR("CDC::PolyBezier[To]");

} else {

RETURN_NONE;

}

}

}

// @pymethod |PyCDC|FillRect|Fills a given rectangle with the specified brush

static PyObject *

ui_dc_fillrect (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

RECT rect;

PyObject *obBrush;

if (!PyArg_ParseTuple (args, "(iiii)O:FillRect",

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (left, top, right, bottom|rect||Specifies the bounding rectangle, in logical units.

&obBrush)) // @pyparm <o PyCBrush>|brush||Specifies the brush to use.

return NULL;

if (!ui_base_class::is_uiobject (obBrush, &PyCBrush::type))

RETURN_TYPE_ERR("The 'O' param must be a PyCBrush object");

CBrush *pBrush = PyCBrush::GetBrush(obBrush);

if (!pBrush)

return NULL;

GUI_BGN_SAVE;

pDC->FillRect( &rect, pBrush );

GUI_END_SAVE;

// @pyseemfc CDC|FillRect

RETURN_NONE;

}

// @pymethod |PyCDC|FillSolidRect|Fills the given rectangle with the specified solid color.

static PyObject *

ui_dc_fillsolidrect (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

RECT rect;

int col;

if (!PyArg_ParseTuple (args, "(iiii)i:FillSolidRect",

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (left, top, right, bottom|rect||Specifies the bounding rectangle, in logical units.

&col)) // @pyparm int|color||Specifies the color to use.

return NULL;

GUI_BGN_SAVE;

pDC->FillSolidRect( &rect, (COLORREF)col );

GUI_END_SAVE;

// @pyseemfc CDC|FillSolidRect

RETURN_NONE;

}

// @pymethod |PyCDC|FrameRect|Draws a border around the rectangle specified by rect

static PyObject *

ui_dc_framerect (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

RECT rect;

PyObject *obBrush;

if (!PyArg_ParseTuple (args, "(iiii)O:FrameRect",

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (left, top, right, bottom|rect||Specifies the bounding rectangle, in logical units.

&obBrush)) // @pyparm <o PyCBrush>|brush||Specifies the brush to use.

return NULL;

if (!ui_base_class::is_uiobject (obBrush, &PyCBrush::type))

RETURN_TYPE_ERR("The 'O' param must be a PyCBrush object");

CBrush *pBrush = PyCBrush::GetBrush(obBrush);

if (!pBrush)

RETURN_ERR("The PyCBrush parameter is invalid.");

GUI_BGN_SAVE;

pDC->FrameRect( &rect, pBrush );

GUI_END_SAVE;

// @pyseemfc CDC|FrameRect

RETURN_NONE;

}

// @pymethod |PyCDC|Draw3dRect|Draws a three-dimensional rectangle.

static PyObject *

ui_dc_draw3drect(PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

RECT rect;

int ctl, cbr;

if (!PyArg_ParseTuple (args, "(iiii)ii:Draw3dRect",

&rect.left, &rect.top, &rect.right, &rect.bottom,

// @pyparm (left, top, right, bottom|rect||Specifies the bounding rectangle, in logical units.

&ctl, // @pyparm int|colorTopLeft||Specifies the color of the top and left sides of the three-dimensional rectangle.

&cbr)) // @pyparm int|colorBotRight||Specifies the color of the bottom and right sides of the three-dimensional rectangle.

return NULL;

GUI_BGN_SAVE;

pDC->Draw3dRect( &rect, ctl, cbr);

GUI_END_SAVE;

// @pyseemfc CDC|Draw3dRect

RETURN_NONE;

}

// @pymethod int|PyCDC|GetNearestColor|Returns the closest color a device can map.

static PyObject *ui_dc_get_nearest_color (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int col;

// @pyparm int|color||Specifies the color to be matched.

if (!PyArg_ParseTuple (args, "i:GetNearestColor", &col))

return NULL;

GUI_BGN_SAVE;

int rc = pDC->GetNearestColor(col);

GUI_END_SAVE;

return Py_BuildValue ("i", rc);

}

// @pymethod (x,y)|PyCDC|GetTextExtentPoint|An alias for <om PyCDC.GetTextExtent>.

// GetTextExtentPoint is the preferred win32api name, but GetTextExtent is the MFC name.<nl>

// Calculates the width and height of a line of text using the current font to determine the dimensions.

// @pyparm string|text||The text to calculate for.

// @rdesc A tuple of integers with the size of the string, in logical units.

// @pymethod (x,y)|PyCDC|GetTextExtent|Calculates the width and height of a line of text using the current font to determine the dimensions.

static PyObject *ui_dc_get_text_extent (PyObject *self, PyObject *args)

{

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

TCHAR *text;

PyObject *obtext;

DWORD strLen;

// @pyparm string|text||The text to calculate for.

if (!PyArg_ParseTuple (args, "O:GetTextExtent", &obtext))

return NULL;

if (!PyWinObject_AsTCHAR(obtext, &text, FALSE, &strLen))

return NULL;

GUI_BGN_SAVE;

CSize sz = pDC->GetTextExtent(text, strLen);

// @pyseemfc CFC|GetTextExtent

GUI_END_SAVE;

PyWinObject_FreeTCHAR(text);

return Py_BuildValue ("(ii)", sz.cx, sz.cy);

// @rdesc A tuple of integers with the size of the string, in logical units.

}

// @pymethod int|PyCDC|SetTextColor|Sets the text color to the specified color.

static PyObject *

ui_dc_set_text_color (PyObject *self, PyObject *args)

{

// @comm This text color is used when writing text to this device context and also when converting bitmaps between color and monochrome device contexts.

// If the device cannot represent the specified color, the system sets the text color to the nearest physical color.

// The background color for a character is specified by the SetBkColor and SetBkMode member functions.

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int new_color;

// @pyparm int|color||A windows color specification. See the win32api documentation for details.

if (!PyArg_ParseTuple (args, "i", &new_color))

return NULL;

GUI_BGN_SAVE;

int old_color = pDC->SetTextColor (new_color); // @pyseemfc CDC|SetTextColor

GUI_END_SAVE;

return Py_BuildValue ("i", old_color);

// @rdesc The return value is the previous text color.

}

// @pymethod int|PyCDC|SetBkColor|Sets the current background color to the specified color.

static PyObject *

ui_dc_set_bk_color (PyObject *self, PyObject *args)

{

// @comm If the background mode is OPAQUE, the system uses the background color

// to fill the gaps in styled lines, the gaps between hatched lines in brushes, and

// the background in character cells.

// The system also uses the background color when converting bitmaps between color and

// monochrome device contexts.

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int new_color;

if (!PyArg_ParseTuple (args, "i", &new_color)) // @pyparm int|color||A windows color specification. See the win32api documentation for details.

return NULL;

GUI_BGN_SAVE;

int old_color = pDC->SetBkColor (new_color); // @pyseemfc CDC|SetBkColor

GUI_END_SAVE;

return Py_BuildValue ("i", old_color);

// @rdesc The return value is the previous background color.

}

// @pymethod int|PyCDC|SetBkMode|Sets the current background mode to the specified mode.

static PyObject *

ui_dc_set_bk_mode (PyObject *self, PyObject *args)

{

// @comm Specifies the mode to be set. This parameter can be either OPAQUE or TRANSPARENT

CDC *pDC = ui_dc_object::GetDC(self);

if (!pDC)

return NULL;

int new_mode;

if (!PyArg_ParseTuple (args, "i", &new_mode)) // @pyparm int|mode||A background mode. May be either TRANSPARENT or OPAQUE.

return NULL;

GUI_BGN_SAVE;

int old_mode = pDC->SetBkMode(new_mode); // @pyseemfc CDC|SetBkMode

GUI_END_SAVE;