// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "dcclient.h"
#endif
#include "wx/window.h"
#include "wx/app.h"
#include "wx/image.h"
+#include "wx/module.h"
+#include "wx/fontutil.h"
#include "wx/x11/private.h"
-#include <math.h>
+#include "wx/math.h"
+
+#if wxUSE_UNICODE
+#include "glib.h"
+#include "pango/pangox.h"
+#ifdef HAVE_PANGO_XFT
+ #include "pango/pangoxft.h"
+#endif
+
+#include "pango_x.cpp"
+#endif
//-----------------------------------------------------------------------------
// local defines
wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
wxGCPool[i].m_type = type;
- wxGCPool[i].m_used = FALSE;
+ wxGCPool[i].m_used = false;
}
if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
{
- wxGCPool[i].m_used = TRUE;
+ wxGCPool[i].m_used = true;
return wxGCPool[i].m_gc;
}
}
{
if (wxGCPool[i].m_gc == gc)
{
- wxGCPool[i].m_used = FALSE;
+ wxGCPool[i].m_used = false;
return;
}
}
m_textGC = (WXGC *) NULL;
m_bgGC = (WXGC *) NULL;
m_cmap = (WXColormap *) NULL;
- m_isMemDC = FALSE;
- m_isScreenDC = FALSE;
+ m_isMemDC = false;
+ m_isScreenDC = false;
m_owner = (wxWindow *)NULL;
+
+#if wxUSE_UNICODE
+ m_context = (PangoContext *)NULL;
+ m_fontdesc = (PangoFontDescription *)NULL;
+#endif
}
wxWindowDC::wxWindowDC( wxWindow *window )
m_bgGC = (WXGC *) NULL;
m_cmap = (WXColormap *) NULL;
m_owner = (wxWindow *)NULL;
- m_isMemDC = FALSE;
- m_isScreenDC = FALSE;
+ m_isMemDC = false;
+ m_isScreenDC = false;
m_font = window->GetFont();
m_window = (WXWindow*) window->GetMainWindow();
if (!m_window)
{
// don't report problems
- m_ok = TRUE;
+ m_ok = true;
return;
}
m_display = (WXDisplay *) wxGlobalDisplay();
-
+
+#if wxUSE_UNICODE
+ m_context = wxTheApp->GetPangoContext();
+ m_fontdesc = window->GetFont().GetNativeFontInfo()->description;
+#endif
+
int screen = DefaultScreen( (Display*) m_display );
m_cmap = (WXColormap) DefaultColormap( (Display*) m_display, screen );
void wxWindowDC::SetUpDC()
{
- m_ok = TRUE;
+ m_ok = true;
wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
m_backgroundBrush.GetColour().CalcPixel( m_cmap );
unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
+ m_textForegroundColour = *wxBLACK;
+ m_textBackgroundColour = *wxWHITE;
+
/* m_textGC */
m_textForegroundColour.CalcPixel( m_cmap );
XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
/* m_bgGC */
XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
-
+
XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
/* ROPs */
{
int xscreen = DefaultScreen( (Display*) m_display );
Window xroot = RootWindow( (Display*) m_display, xscreen );
-
+
hatch_bitmap = hatches;
hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
m_owner->GetSize(width, height);
}
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
- const wxColour& WXUNUSED(col), int WXUNUSED(style) )
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+ const wxColour & col, int style);
+
+bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
+ const wxColour& col, int style)
{
- wxFAIL_MSG("not implemented");
+ return wxDoFloodFill(this, x, y, col, style);
}
bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
memdc.SelectObject(bitmap);
memdc.Blit(0, 0, 1, 1, (wxDC*) this, x1, y1);
memdc.SelectObject(wxNullBitmap);
- wxImage image(bitmap);
+ wxImage image(bitmap.ConvertToImage());
col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
- return TRUE;
+ return true;
}
void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
if (m_pen.GetStyle() != wxTRANSPARENT)
{
if (m_window)
- XDrawLine( (Display*) m_display, (Window) m_window,
- (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
+ {
+ // This hack is for the iPaq: XDrawLine draws
+ // nothing, whereas XDrawLines works...
+ wxPoint points[2];
+ points[0].x = x1;
+ points[0].y = y1;
+ points[1].x = x2;
+ points[1].y = y2;
+ DrawLines( 2, points, 0, 0 );
+
+ // XDrawLine( (Display*) m_display, (Window) m_window,
+ // (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
+ }
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
} else
if (IS_15_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 15, m_deviceOriginY % 15 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (IS_16_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 16, m_deviceOriginY % 16 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (m_brush.GetStyle() == wxSTIPPLE)
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
}
else
{
XDrawArc( (Display*) m_display, (Window) m_window,
(GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
-
+
XDrawLine( (Display*) m_display, (Window) m_window,
(GC) m_penGC, xx1, yy1, xxc, yyc );
-
+
XDrawLine( (Display*) m_display, (Window) m_window,
(GC) m_penGC, xxc, yyc, xx2, yy2 );
}
XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_textGC, xx, yy, ww, hh, start, end );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
} else
if (IS_15_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 15, m_deviceOriginY % 15 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, start, end );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (IS_16_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 16, m_deviceOriginY % 16 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, start, end );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (m_brush.GetStyle() == wxSTIPPLE)
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, start, end );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
}
else
{
xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
-
+
CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
}
XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
{
xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
-
+
CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
}
{
if (m_brush.GetStyle() != wxTRANSPARENT)
{
-
+
if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillPolygon( (Display*) m_display, (Window) m_window,
(GC) m_textGC, xpoints, n, Complex, 0);
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
} else
if (IS_15_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 15, m_deviceOriginY % 15 );
-
+
XFillPolygon( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xpoints, n, Complex, 0);
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (IS_16_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 16, m_deviceOriginY % 16 );
-
+
XFillPolygon( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xpoints, n, Complex, 0);
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (m_brush.GetStyle() == wxSTIPPLE)
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillPolygon( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xpoints, n, Complex, 0);
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
}
else
// CMB: handle -ve width and/or height
if (ww < 0) { ww = -ww; xx = xx - ww; }
if (hh < 0) { hh = -hh; yy = yy - hh; }
-
+
if (m_window)
{
if (m_brush.GetStyle() != wxTRANSPARENT)
XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillRectangle( (Display*) m_display, (Window) m_window,
(GC) m_textGC, xx, yy, ww, hh );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
} else
if (IS_15_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 15, m_deviceOriginY % 15 );
-
+
XFillRectangle( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (IS_16_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 16, m_deviceOriginY % 16 );
-
+
XFillRectangle( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (m_brush.GetStyle() == wxSTIPPLE)
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillRectangle( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
}
else
void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
{
- // later
+ wxCHECK_RET( Ok(), wxT("invalid window dc") );
+
+ if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
+
+ wxCoord xx = XLOG2DEV(x);
+ wxCoord yy = YLOG2DEV(y);
+ wxCoord ww = m_signX * XLOG2DEVREL(width);
+ wxCoord hh = m_signY * YLOG2DEVREL(height);
+ wxCoord rr = XLOG2DEVREL((wxCoord)radius);
+
+ // CMB: handle -ve width and/or height
+ if (ww < 0) { ww = -ww; xx = xx - ww; }
+ if (hh < 0) { hh = -hh; yy = yy - hh; }
+
+ // CMB: if radius is zero use DrawRectangle() instead to avoid
+ // X drawing errors with small radii
+ if (rr == 0)
+ {
+ XDrawRectangle( (Display*) m_display, (Window) m_window,
+ (GC) m_penGC, x, y, width, height);
+ return;
+ }
+
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0) return;
+
+ // CMB: adjust size if outline is drawn otherwise the result is
+ // 1 pixel too wide and high
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ ww--;
+ hh--;
+ }
+
+ if (m_window)
+ {
+ // CMB: ensure dd is not larger than rectangle otherwise we
+ // get an hour glass shape
+ wxCoord dd = 2 * rr;
+ if (dd > ww) dd = ww;
+ if (dd > hh) dd = hh;
+ rr = dd / 2;
+
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
+ {
+ XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
+ m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
+ m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+rr, yy, ww-dd+1, hh );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+rr, ww, hh-dd+1 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0);
+ } else
+ if (IS_15_PIX_HATCH(m_brush.GetStyle()))
+ {
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 15, m_deviceOriginY % 15 );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
+ } else
+ if (IS_16_PIX_HATCH(m_brush.GetStyle()))
+ {
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, m_deviceOriginX % 16, m_deviceOriginY % 16 );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
+ } else
+ if (m_brush.GetStyle() == wxSTIPPLE)
+ {
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
+ m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
+ m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0);
+ }
+ else
+ {
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
+ XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+rr, ww, hh-dd+1 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XFillArc( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ }
+ }
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+rr+1, yy, xx+ww-rr, yy );
+ XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+rr+1, yy+hh, xx+ww-rr, yy+hh );
+ XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+rr+1, xx, yy+hh-rr );
+ XDrawLine( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww, yy+rr+1, xx+ww, yy+hh-rr );
+ XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy, dd, dd, 90*64, 90*64 );
+ XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww-dd, yy, dd, dd, 0, 90*64 );
+ XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx+ww-dd, yy+hh-dd, dd, dd, 270*64, 90*64 );
+ XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
+ }
+ }
+
+ // this ignores the radius
+ CalcBoundingBox( x, y );
+ CalcBoundingBox( x + width, y + height );
}
void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
} else
if (IS_15_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 15, m_deviceOriginY % 15 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (IS_16_PIX_HATCH(m_brush.GetStyle()))
{
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % 16, m_deviceOriginY % 16 );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
} else
if (m_brush.GetStyle() == wxSTIPPLE)
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
-
+
XFillArc( (Display*) m_display, (Window) m_window,
(GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
-
+
XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
}
else
void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
{
+ DoDrawBitmap(icon, x, y, true);
}
#if wxUSE_NANOX
wxCHECK_RET( Ok(), wxT("invalid window dc") );
wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
-
+
bool is_mono = (bitmap.GetBitmap() != NULL);
/* scale/translate size and position */
wxBitmap use_bitmap;
if ((w != ww) || (h != hh))
{
- wxImage image( bitmap );
+ wxImage image( bitmap.ConvertToImage() );
image.Rescale( ww, hh );
#if 0
if (is_mono)
use_bitmap = image.ConvertToMonoBitmap(255,255,255);
else
#endif
- use_bitmap = image.ConvertToBitmap();
+ use_bitmap = image;
}
else
{
GrCopyArea(bufPixmap, gc, 0, 0, w, h, (Window) m_window,
0, 0, GR_MODE_COPY);
#endif
-
+
// Copy src to buffer using selected raster op (none selected
// in DrawBitmap, so just use Gxcopy)
GrCopyArea(bufPixmap, gc, 0, 0, w, h, pixmap,
GrSetGCForeground(gc, BLACK);
GrCopyArea(bufPixmap, gc, 0, 0, w, h, maskPixmap,
0, 0, GR_MODE_AND);
-
+
// set unmasked area in dest to BLACK
GrSetGCBackground(gc, BLACK);
GrSetGCForeground(gc, WHITE);
wxCHECK_RET( Ok(), wxT("invalid window dc") );
wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
-
+
bool is_mono = (bitmap.GetBitmap() != NULL);
- /* scale/translate size and position */
+ // scale/translate size and position
int xx = XLOG2DEV(x);
int yy = YLOG2DEV(y);
int ww = XLOG2DEVREL(w);
int hh = YLOG2DEVREL(h);
- /* compare to current clipping region */
+ // compare to current clipping region
if (!m_currentClippingRegion.IsNull())
{
wxRegion tmp( xx,yy,ww,hh );
return;
}
- /* scale bitmap if required */
+ // scale bitmap if required
wxBitmap use_bitmap;
if ((w != ww) || (h != hh))
{
- wxImage image( bitmap );
+ wxImage image( bitmap.ConvertToImage() );
image.Rescale( ww, hh );
#if 0
if (is_mono)
use_bitmap = image.ConvertToMonoBitmap(255,255,255);
else
#endif
- use_bitmap = image.ConvertToBitmap();
+ use_bitmap = image;
}
else
{
use_bitmap = bitmap;
}
- /* apply mask if any */
+ // apply mask if any
WXPixmap mask = NULL;
if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
- {
+
if (useMask && mask)
{
WXPixmap new_mask = NULL;
XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
}
-
+
if (new_mask)
XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
}
- }
- /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
- drawing a mono-bitmap (XBitmap) we use the current text GC */
+ // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
+ // drawing a mono-bitmap (XBitmap) we use the current text GC
if (is_mono)
XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
(GC) m_textGC, 0, 0, w, h, xx, yy, 1 );
XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
(GC) m_penGC, 0, 0, w, h, xx, yy );
- /* remove mask again if any */
+ // remove mask again if any
if (useMask && mask)
{
if (is_mono)
// wxUSE_NANOX/!wxUSE_NANOX
bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
- wxDC *source, wxCoord xsrc, wxCoord ysrc, int rop, bool useMask,
+ wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask )
{
/* this is the nth try to get this utterly useless function to
of the source dc, but scales correctly on the target dc and
knows about possible mask information in a memory dc. */
- wxCHECK_MSG( Ok(), FALSE, wxT("invalid window dc") );
+ wxCHECK_MSG( Ok(), false, wxT("invalid window dc") );
- wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
+ wxCHECK_MSG( source, false, wxT("invalid source dc") );
- if (!m_window) return FALSE;
+ if (!m_window) return false;
// transform the source DC coords to the device ones
xsrc = source->XLOG2DEV(xsrc);
wxClientDC *srcDC = (wxClientDC*)source;
wxMemoryDC *memDC = (wxMemoryDC*)source;
- bool use_bitmap_method = FALSE;
- bool is_mono = FALSE;
+ bool use_bitmap_method = false;
+ bool is_mono = false;
- /* TODO: use the mask origin when drawing transparently */
+ // TODO: use the mask origin when drawing transparently
if (xsrcMask == -1 && ysrcMask == -1)
{
- xsrcMask = xsrc; ysrcMask = ysrc;
+ xsrcMask = xsrc;
+ ysrcMask = ysrc;
}
-
-#if 0
+
if (srcDC->m_isMemDC)
{
- if (!memDC->m_selected.Ok()) return FALSE;
+ if (!memDC->m_selected.Ok()) return false;
/* we use the "XCopyArea" way to copy a memory dc into
y different window if the memory dc BOTH
/* we HAVE TO use the direct way for memory dcs
that have mask since the XCopyArea doesn't know
about masks */
- use_bitmap_method = TRUE;
+ use_bitmap_method = true;
}
else if (memDC->m_selected.GetDepth() == 1)
{
/* we HAVE TO use the direct way for memory dcs
that are bitmaps because XCopyArea doesn't cope
with different bit depths */
- is_mono = TRUE;
- use_bitmap_method = TRUE;
+ is_mono = true;
+ use_bitmap_method = true;
}
else if ((xsrc == 0) && (ysrc == 0) &&
(width == memDC->m_selected.GetWidth()) &&
in the memory dc is copied in which case XCopyArea
wouldn't be able able to boost performace by reducing
the area to be scaled */
- use_bitmap_method = TRUE;
+ use_bitmap_method = true;
}
else
{
- use_bitmap_method = FALSE;
+ use_bitmap_method = false;
}
}
CalcBoundingBox( xdest, ydest );
CalcBoundingBox( xdest + width, ydest + height );
- /* scale/translate size and position */
+ // scale/translate size and position
wxCoord xx = XLOG2DEV(xdest);
wxCoord yy = YLOG2DEV(ydest);
wxCoord ww = XLOG2DEVREL(width);
wxCoord hh = YLOG2DEVREL(height);
- /* compare to current clipping region */
+ // compare to current clipping region
if (!m_currentClippingRegion.IsNull())
{
wxRegion tmp( xx,yy,ww,hh );
tmp.Intersect( m_currentClippingRegion );
if (tmp.IsEmpty())
- return TRUE;
+ return true;
}
int old_logical_func = m_logicalFunction;
if (use_bitmap_method)
{
- /* scale/translate bitmap size */
+ // scale/translate bitmap size
wxCoord bm_width = memDC->m_selected.GetWidth();
wxCoord bm_height = memDC->m_selected.GetHeight();
wxCoord bm_ww = XLOG2DEVREL( bm_width );
wxCoord bm_hh = YLOG2DEVREL( bm_height );
- /* scale bitmap if required */
+ // scale bitmap if required
wxBitmap use_bitmap;
if ((bm_width != bm_ww) || (bm_height != bm_hh))
{
- wxImage image( memDC->m_selected );
+ wxImage image( memDC->m_selected.ConvertToImage() );
image = image.Scale( bm_ww, bm_hh );
+#if 0
if (is_mono)
use_bitmap = image.ConvertToMonoBitmap(255,255,255);
else
- use_bitmap = image.ConvertToBitmap();
+#endif
+ use_bitmap = image;
}
else
{
use_bitmap = memDC->m_selected;
}
- /* apply mask if any */
- GdkBitmap *mask = (GdkBitmap *) NULL;
+ // apply mask if any
+ WXPixmap mask = NULL;
if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
if (useMask && mask)
{
- GdkBitmap *new_mask = (GdkBitmap*) NULL;
+ WXPixmap new_mask = NULL;
+#if 0
if (!m_currentClippingRegion.IsNull())
{
GdkColor col;
gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, bm_ww, bm_hh );
gdk_gc_unref( gc );
}
-
+#endif
if (is_mono)
{
if (new_mask)
- gdk_gc_set_clip_mask( m_textGC, new_mask );
+ XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) new_mask );
else
- gdk_gc_set_clip_mask( m_textGC, mask );
- gdk_gc_set_clip_origin( m_textGC, xx, yy );
+ XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
+ XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
}
else
{
if (new_mask)
- gdk_gc_set_clip_mask( m_penGC, new_mask );
+ XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask );
else
- gdk_gc_set_clip_mask( m_penGC, mask );
- gdk_gc_set_clip_origin( m_penGC, xx, yy );
+ XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
+ XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
}
+
if (new_mask)
- gdk_bitmap_unref( new_mask );
+ XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
}
- /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
- drawing a mono-bitmap (XBitmap) we use the current text GC */
+ // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
+ // drawing a mono-bitmap (XBitmap) we use the current text GC
if (is_mono)
- gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), xsrc, ysrc, xx, yy, ww, hh );
+ XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
+ (GC) m_textGC, xsrc, ysrc, width, height, xx, yy, 1 );
else
- gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
+ XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
+ (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
- /* remove mask again if any */
+ // remove mask again if any
if (useMask && mask)
{
if (is_mono)
{
- gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
- gdk_gc_set_clip_origin( m_textGC, 0, 0 );
+ XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
+ XSetClipOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
if (!m_currentClippingRegion.IsNull())
- gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
+ XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );
}
else
{
- gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
- gdk_gc_set_clip_origin( m_penGC, 0, 0 );
+ XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
+ XSetClipOrigin( (Display*) m_display, (GC) m_penGC, 0, 0 );
if (!m_currentClippingRegion.IsNull())
- gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
+ XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );
}
}
}
- else /* use_bitmap_method */
+ else // use_bitmap_method
{
if ((width != ww) || (height != hh))
{
- /* draw source window into a bitmap as we cannot scale
+ /* Draw source window into a bitmap as we cannot scale
a window in contrast to a bitmap. this would actually
work with memory dcs as well, but we'd lose the mask
information and waste one step in this process since
wxBitmap bitmap( width, height );
- /* copy including child window contents */
- gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
- gdk_window_copy_area( bitmap.GetPixmap(), m_penGC, 0, 0,
- srcDC->GetWindow(),
- xsrc, ysrc, width, height );
- gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
+ // copy including child window contents
+ XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
+ XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) bitmap.GetPixmap(),
+ (GC) m_penGC, xsrc, ysrc, width, height, 0, 0 );
+ XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
- /* scale image */
- wxImage image( bitmap );
+ // scale image
+ wxImage image( bitmap.ConvertToImage() );
image = image.Scale( ww, hh );
- /* convert to bitmap */
- bitmap = image.ConvertToBitmap();
-
- /* draw scaled bitmap */
- gdk_draw_pixmap( m_window, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
+ // convert to bitmap
+ bitmap = image;
+ // draw scaled bitmap
+ XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_window,
+ (GC) m_penGC, 0, 0, width, height, xx, yy );
}
else
{
- /* No scaling and not a memory dc with a mask either */
-
- /* copy including child window contents */
- gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
- gdk_window_copy_area( m_window, m_penGC, xx, yy,
- srcDC->GetWindow(),
- xsrc, ysrc, width, height );
- gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
+ // No scaling and not a memory dc with a mask either
+
+ // copy including child window contents
+ XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
+ XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) m_window,
+ (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
+ XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
}
}
SetLogicalFunction( old_logical_func );
- return TRUE;
-#endif
- return FALSE;
+ return true;
}
void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
if (!m_window) return;
- XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
-
- wxCHECK_RET( xfont, wxT("invalid font") );
-
x = XLOG2DEV(x);
y = YLOG2DEV(y);
-#if 0
- wxCoord width = gdk_string_width( font, text.mbc_str() );
- wxCoord height = font->ascent + font->descent;
+#if wxUSE_UNICODE
+ PangoLayout *layout = pango_layout_new(m_context);
+ pango_layout_set_font_description(layout, m_fontdesc);
+
+ const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
+ pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
+
+ // Measure layout.
+ int w,h;
+ pango_layout_get_pixel_size(layout, &w, &h);
+ wxCoord width = w;
+ wxCoord height = h;
- if ( m_backgroundMode == wxSOLID )
+ // Draw layout.
+ x11_draw_layout( (Drawable) m_window, (GC) m_textGC, x, y, layout, m_textForegroundColour );
+
+ g_object_unref( G_OBJECT( layout ) );
+
+ CalcBoundingBox (x + width, y + height);
+ CalcBoundingBox (x, y);
+#else
+ XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
+
+ wxCHECK_RET( xfont, wxT("invalid font") );
+
+ // First draw a rectangle representing the text background, if a text
+ // background is specified
+ if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
{
- gdk_gc_set_foreground( m_textGC, m_textBackgroundColour.GetColor() );
- gdk_draw_rectangle( m_window, m_textGC, TRUE, x, y, width, height );
- gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
+ // Since X draws from the baseline of the text, must add the text height
+ int cx = 0;
+ int cy = 0;
+ int ascent = 0;
+ int slen;
+ int direction, descent;
+
+ slen = strlen(text);
+ XCharStruct overall_return;
+
+ (void)XTextExtents(xfont, (char*) text.c_str(), slen, &direction,
+ &ascent, &descent, &overall_return);
+
+ cx = overall_return.width;
+ cy = ascent + descent;
+ m_textBackgroundColour.CalcPixel(m_cmap);
+ m_textForegroundColour.CalcPixel(m_cmap);
+ XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());
+ XFillRectangle( (Display*) m_display, (Window) m_window,
+ (GC) m_textGC, x, y, cx, cy );
+ XSetForeground ((Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel());
+
}
-#endif
XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
#if !wxUSE_NANOX
if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
#endif
{
- XDrawString( (Display*) m_display, (Window) m_window,
+ XDrawString( (Display*) m_display, (Window) m_window,
(GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.Len() );
}
width = wxCoord(width / m_scaleX);
height = wxCoord(height / m_scaleY);
-
+
CalcBoundingBox (x + width, y + height);
CalcBoundingBox (x, y);
#endif
+#endif
}
void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
wxCoord *descent, wxCoord *externalLeading,
wxFont *font ) const
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( Ok(), wxT("invalid dc") );
+
+ if (string.empty())
+ {
+ if (width) (*width) = 0;
+ if (height) (*height) = 0;
+ return;
+ }
+
+#if wxUSE_UNICODE
+ PangoLayout *layout = pango_layout_new( m_context );
+
+ if (font)
+ pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
+ else
+ pango_layout_set_font_description(layout, m_fontdesc);
+
+ const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
+ pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
+
+ // Measure text.
+ int w,h;
+ pango_layout_get_pixel_size(layout, &w, &h);
+
+ if (width) (*width) = (wxCoord) w;
+ if (height) (*height) = (wxCoord) h;
+ if (descent)
+ {
+ // Do something about metrics here. TODO.
+ (*descent) = 0;
+ }
+ if (externalLeading) (*externalLeading) = 0; // ??
+ g_object_unref( G_OBJECT( layout ) );
+#else
wxFont fontToUse = m_font;
if (font) fontToUse = *font;
- wxCHECK_RET( fontToUse.Ok(), "invalid font" );
+ wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
wxCHECK_RET( xfont, wxT("invalid font") );
-
+
int direction, ascent, descent2;
XCharStruct overall;
*descent = (wxCoord)(descent2 / m_scaleY );
if (externalLeading)
*externalLeading = 0; // ??
+#endif
}
wxCoord wxWindowDC::GetCharWidth() const
{
- wxCHECK_MSG( Ok(), 0, "invalid dc" );
-
- wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
+
+#if wxUSE_UNICODE
+ PangoLayout *layout = pango_layout_new( m_context );
+
+ if (m_fontdesc)
+ pango_layout_set_font_description(layout, m_fontdesc);
+ else
+ pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+
+ pango_layout_set_text(layout, "H", 1 );
+ int w,h;
+ pango_layout_get_pixel_size(layout, &w, &h);
+ g_object_unref( G_OBJECT( layout ) );
+
+ return w;
+#else
+ wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
int direction, ascent, descent;
XCharStruct overall;
-
+
XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
-
+
return (wxCoord)(overall.width / m_scaleX);
+#endif
}
wxCoord wxWindowDC::GetCharHeight() const
{
- wxCHECK_MSG( Ok(), 0, "invalid dc" );
-
- wxCHECK_MSG( m_font.Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
+
+#if wxUSE_UNICODE
+ PangoLayout *layout = pango_layout_new( m_context );
+
+ if (m_fontdesc)
+ pango_layout_set_font_description(layout, m_fontdesc);
+ else
+ pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+
+ pango_layout_set_text(layout, "H", 1 );
+ int w,h;
+ pango_layout_get_pixel_size(layout, &w, &h);
+ g_object_unref( G_OBJECT( layout ) );
+
+ return h;
+#else
+ wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
int direction, ascent, descent;
XCharStruct overall;
-
+
XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
-
+
return (wxCoord)((ascent+descent) / m_scaleY);
+#endif
}
void wxWindowDC::Clear()
void wxWindowDC::SetFont( const wxFont &font )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( Ok(), wxT("invalid dc") );
m_font = font;
+
+ return;
+
+#if wxUSE_UNICODE
+ m_fontdesc = font.GetNativeFontInfo()->description;
+#endif
}
void wxWindowDC::SetPen( const wxPen &pen )
m_brush.GetColour().CalcPixel( m_cmap );
XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
-
+
XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
}
- if (IS_HATCH(m_brush.GetStyle()))
+ if (m_brush.IsHatch())
{
XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
}
}
- if (IS_HATCH(m_backgroundBrush.GetStyle()))
+ if (m_backgroundBrush.IsHatch())
{
XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
void wxWindowDC::SetLogicalFunction( int function )
{
- wxCHECK_RET( Ok(), "invalid dc" );
+ wxCHECK_RET( Ok(), wxT("invalid dc") );
int x_function;
// VZ: shouldn't this be a CHECK?
if (!m_window)
return;
-
+
switch (function)
{
case wxCLEAR:
// operations (i.e. DrawText/DrawRotatedText).
// True, but mono-bitmaps use the m_textGC and they use ROPs as well.
XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
-
+
m_logicalFunction = function;
}
return -1;
}
+//-----------------------------------------------------------------------------
+// wxClientDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+
+wxClientDC::wxClientDC( wxWindow *window )
+ : wxWindowDC( window )
+{
+ wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );
+
+ m_window = (WXWindow*) window->GetClientAreaWindow();
+
+ // Adjust the client area when the wxWindow is not using 2 X11 windows.
+ if (m_window == (WXWindow*) window->GetMainWindow())
+ {
+ wxPoint ptOrigin = window->GetClientAreaOrigin();
+ SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
+ wxSize size = window->GetClientSize();
+ SetClippingRegion(wxPoint(0, 0), size);
+ }
+}
+
+void wxClientDC::DoGetSize(int *width, int *height) const
+{
+ wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
+
+ m_owner->GetClientSize( width, height );
+}
+
// ----------------------------------------------------------------------------
// wxPaintDC
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
-wxPaintDC::wxPaintDC(wxWindow* win)
- : wxClientDC(win)
+wxPaintDC::wxPaintDC(wxWindow* window)
+ : wxClientDC(window)
{
#if USE_PAINT_REGION
- if (!win->GetClipPaintRegion())
+ if (!window->GetClipPaintRegion())
return;
- m_paintClippingRegion = win->GetUpdateRegion();
+ m_paintClippingRegion = window->GetUpdateRegion();
Region region = (Region) m_paintClippingRegion.GetX11Region();
if (region)
{
- m_paintClippingRegion = win->GetUpdateRegion();
- Region region2 = (Region) m_paintClippingRegion.GetX11Region();
- if (region2)
- {
m_currentClippingRegion.Union( m_paintClippingRegion );
- XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
- XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
- XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
- XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
- }
+ XSetRegion( (Display*) m_display, (GC) m_penGC, region );
+ XSetRegion( (Display*) m_display, (GC) m_brushGC, region );
+ XSetRegion( (Display*) m_display, (GC) m_textGC, region );
+ XSetRegion( (Display*) m_display, (GC) m_bgGC, region );
}
#endif // USE_PAINT_REGION
}
-//-----------------------------------------------------------------------------
-// wxClientDC
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-
-wxClientDC::wxClientDC( wxWindow *win )
- : wxWindowDC( win )
-{
- wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
-
-#ifdef __WXUNIVERSAL__
- wxPoint ptOrigin = win->GetClientAreaOrigin();
- SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
- wxSize size = win->GetClientSize();
- SetClippingRegion(wxPoint(0, 0), size);
-#endif // __WXUNIVERSAL__
-}
-
-void wxClientDC::DoGetSize(int *width, int *height) const
-{
- wxCHECK_RET( m_owner, _T("GetSize() doesn't work without window") );
-
- m_owner->GetClientSize( width, height );
-}
-
// ----------------------------------------------------------------------------
// wxDCModule
// ----------------------------------------------------------------------------
bool wxDCModule::OnInit()
{
wxInitGCPool();
- return TRUE;
+ return true;
}
void wxDCModule::OnExit()
projects / wxWidgets.git / blobdiff