+ wxCHECK_MSG( source, false, wxT("invalid source dc") );
+
+ if (!m_gdkwindow) return false;
+
+ // transform the source DC coords to the device ones
+ xsrc = source->LogicalToDeviceX(xsrc);
+ ysrc = source->LogicalToDeviceY(ysrc);
+
+ wxBitmap selected;
+ wxMemoryDC *memDC = wxDynamicCast(source, wxMemoryDC);
+ if ( memDC )
+ {
+ selected = memDC->GetSelectedBitmap();
+ if ( !selected.IsOk() )
+ return false;
+ }
+
+ bool use_bitmap_method = false;
+ bool is_mono = false;
+
+ if (xsrcMask == -1 && ysrcMask == -1)
+ {
+ xsrcMask = xsrc;
+ ysrcMask = ysrc;
+ }
+
+ if (selected.IsOk())
+ {
+ is_mono = (selected.GetDepth() == 1);
+
+ // we use the "XCopyArea" way to copy a memory dc into
+ // a different window if the memory dc BOTH
+ // a) doesn't have any mask or its mask isn't used
+ // b) it is clipped
+ // c) is not 1-bit
+
+ if (useMask && (selected.GetMask()))
+ {
+ // 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;
+ }
+ else if (is_mono)
+ {
+ // we HAVE TO use the direct way for memory dcs
+ // that are bitmaps because XCopyArea doesn't cope
+ // with different bit depths
+ use_bitmap_method = true;
+ }
+ else if ((xsrc == 0) && (ysrc == 0) &&
+ (width == selected.GetWidth()) &&
+ (height == selected.GetHeight()))
+ {
+ // we SHOULD use the direct way if all of the bitmap
+ // 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;
+ }
+ }
+
+ CalcBoundingBox( xdest, ydest );
+ CalcBoundingBox( xdest + width, ydest + height );
+
+ // 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
+ if (IsOutsideOfClippingRegion( xx,yy,ww,hh ))
+ return true;
+
+ int old_logical_func = m_logicalFunction;
+ SetLogicalFunction( logical_func );
+
+ if (use_bitmap_method)
+ {
+ // scale/translate bitmap size
+ wxCoord bm_width = selected.GetWidth();
+ wxCoord bm_height = selected.GetHeight();
+
+ // Get clip coords for the bitmap. If we don't
+ // use wxBitmap::Rescale(), which can clip the
+ // bitmap, these are the same as the original
+ // coordinates
+ wxCoord cx = xx;
+ wxCoord cy = yy;
+ wxCoord cw = ww;
+ wxCoord ch = hh;
+
+ // interpret userscale of src too
+ double xsc,ysc;
+ memDC->GetUserScale(&xsc,&ysc);
+ bm_width = (int) (bm_width / xsc);
+ bm_height = (int) (bm_height / ysc);
+
+ wxCoord bm_ww = XLOG2DEVREL( bm_width );
+ wxCoord bm_hh = YLOG2DEVREL( bm_height );
+
+ // Scale bitmap if required
+ wxBitmap use_bitmap = selected;
+ if ((selected.GetWidth()!= bm_ww) || ( selected.GetHeight()!= bm_hh))
+ {
+ // This indicates that the blitting code below will get
+ // a clipped bitmap and therefore needs to move the origin
+ // accordingly
+ wxRegion tmp( xx,yy,ww,hh );
+ if (!m_currentClippingRegion.IsNull())
+ tmp.Intersect( m_currentClippingRegion );
+ tmp.GetBox(cx,cy,cw,ch);
+
+ // Scale and clipped bitmap
+ use_bitmap = selected.Rescale(cx-xx,cy-yy,cw,ch,bm_ww,bm_hh);
+ }
+
+ // apply mask if any
+ GdkBitmap *mask = (GdkBitmap *) NULL;
+ if (useMask && use_bitmap.GetMask())
+ mask = use_bitmap.GetMask()->GetBitmap();
+
+ GdkGC* use_gc = is_mono ? m_textGC : m_penGC;
+
+ bool mask_owned = false;
+
+ if (mask != NULL)
+ {
+ if (!m_currentClippingRegion.IsNull())
+ {
+ mask = GetClippedMask(mask, bm_ww, bm_hh, cx, cy,
+ xsrcMask, ysrcMask);
+ mask_owned = true;
+ }
+
+ gdk_gc_set_clip_mask(use_gc, mask);
+ if (mask_owned)
+ gdk_gc_set_clip_origin(use_gc, cx, cy);
+ else
+ gdk_gc_set_clip_origin(use_gc, cx - xsrcMask, cy - ysrcMask);
+ }
+
+ // Draw XPixmap or XBitmap, depending on what the wxBitmap contains.
+ if (is_mono)
+ {
+ DoDrawMonoBitmap(use_bitmap, bm_ww, bm_hh,
+ xsrc, ysrc, cx, cy, cw, ch);
+ }
+ else
+ {
+ // was: gdk_draw_drawable( m_gdkwindow, m_penGC, use_bitmap.GetPixmap(), xsrc, ysrc, xx, yy, ww, hh );
+ gdk_draw_drawable(m_gdkwindow, use_gc, use_bitmap.GetPixmap(), xsrc, ysrc, cx, cy, cw, ch);
+ }
+
+ // remove mask again if any
+ if (mask != NULL)
+ {
+ RemoveClipMask(use_gc);
+ if (mask_owned)
+ g_object_unref (mask);
+ }
+ }
+ else // use_bitmap_method
+ {
+ if (selected.IsOk() && ((width != ww) || (height != hh)))
+ {
+ wxBitmap bitmap = selected.Rescale( xsrc, ysrc, width, height, ww, hh );
+ // draw scaled bitmap
+ gdk_draw_drawable( m_gdkwindow, m_penGC, bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
+ }
+ else
+ {
+ // No scaling and not a memory dc with a mask either
+ GdkWindow* window = NULL;
+ wxDCImpl *impl = source->GetImpl();
+ wxWindowDCImpl *gtk_impl = wxDynamicCast(impl, wxWindowDCImpl);
+ if (gtk_impl)
+ window = gtk_impl->GetGDKWindow();
+ if ( !window )
+ {
+ SetLogicalFunction( old_logical_func );
+ return false;
+ }
+
+ // copy including child window contents
+ gdk_gc_set_subwindow( m_penGC, GDK_INCLUDE_INFERIORS );
+ gdk_draw_drawable( m_gdkwindow, m_penGC,
+ window,
+ xsrc, ysrc, xx, yy,
+ width, height );
+ gdk_gc_set_subwindow( m_penGC, GDK_CLIP_BY_CHILDREN );
+ }
+ }
+
+ SetLogicalFunction( old_logical_func );
+
+ return true;
+}
+
+void wxWindowDCImpl::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (!m_gdkwindow) return;
+
+ if (text.empty()) return;
+
+ x = XLOG2DEV(x);
+ y = YLOG2DEV(y);
+
+ wxCHECK_RET( m_context, wxT("no Pango context") );
+ wxCHECK_RET( m_layout, wxT("no Pango layout") );
+ wxCHECK_RET( m_fontdesc, wxT("no Pango font description") );
+
+ gdk_pango_context_set_colormap( m_context, m_cmap ); // not needed in gtk+ >= 2.6
+
+ bool underlined = m_font.IsOk() && m_font.GetUnderlined();
+
+ wxCharBuffer data = wxGTK_CONV(text);
+ if ( !data )
+ return;
+ size_t datalen = strlen(data);
+
+ // in Pango >= 1.16 the "underline of leading/trailing spaces" bug
+ // has been fixed and thus the hack implemented below should never be used
+ static bool pangoOk = !wx_pango_version_check(1, 16, 0);
+
+ bool needshack = underlined && !pangoOk;
+
+ if (needshack)
+ {
+ // a PangoLayout which has leading/trailing spaces with underlined font
+ // is not correctly drawn by this pango version: Pango won't underline the spaces.
+ // This can be a problem; e.g. wxHTML rendering of underlined text relies on
+ // this behaviour. To workaround this problem, we use a special hack here
+ // suggested by pango maintainer Behdad Esfahbod: we prepend and append two
+ // empty space characters and give them a dummy colour attribute.
+ // This will force Pango to underline the leading/trailing spaces, too.
+
+ wxCharBuffer data_tmp(datalen + 6);
+ // copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
+ memcpy(data_tmp.data(), "\342\200\214", 3);
+ // copy the user string
+ memcpy(data_tmp.data() + 3, data, datalen);
+ // copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
+ memcpy(data_tmp.data() + 3 + datalen, "\342\200\214", 3);
+
+ data = data_tmp;
+ datalen += 6;
+ }
+
+ pango_layout_set_text(m_layout, data, datalen);
+
+ if (underlined)
+ {
+ PangoAttrList *attrs = pango_attr_list_new();
+ PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+ a->start_index = 0;
+ a->end_index = datalen;
+ pango_attr_list_insert(attrs, a);
+
+ if (needshack)
+ {
+ // dummy colour for the leading space
+ a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
+ a->start_index = 0;
+ a->end_index = 1;
+ pango_attr_list_insert(attrs, a);
+
+ // dummy colour for the trailing space
+ a = pango_attr_foreground_new (0x0057, 0x52A9, 0xD614);
+ a->start_index = datalen - 1;
+ a->end_index = datalen;
+ pango_attr_list_insert(attrs, a);
+ }
+
+ pango_layout_set_attributes(m_layout, attrs);
+ pango_attr_list_unref(attrs);
+ }
+
+ int oldSize = 0;
+ const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
+ if (isScaled)
+ {
+ // If there is a user or actually any scale applied to
+ // the device context, scale the font.
+
+ // scale font description
+ oldSize = pango_font_description_get_size(m_fontdesc);
+ pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
+
+ // actually apply scaled font
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+ }
+
+ int w, h;
+ pango_layout_get_pixel_size(m_layout, &w, &h);
+
+ // Draw layout.
+ int x_rtl = x;
+ if (m_window && m_window->GetLayoutDirection() == wxLayout_RightToLeft)
+ x_rtl -= w;
+
+ const GdkColor* bg_col = NULL;
+ if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
+ bg_col = m_textBackgroundColour.GetColor();
+
+ gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x_rtl, y, m_layout, NULL, bg_col);
+
+ if (isScaled)
+ {
+ // reset unscaled size
+ pango_font_description_set_size( m_fontdesc, oldSize );
+
+ // actually apply unscaled font
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+ }
+ if (underlined)
+ {
+ // undo underline attributes setting:
+ pango_layout_set_attributes(m_layout, NULL);
+ }
+
+ CalcBoundingBox(x + int(w / m_scaleX), y + int(h / m_scaleY));
+ CalcBoundingBox(x, y);
+}
+
+// TODO: When GTK2.6 is required, merge DoDrawText and DoDrawRotatedText to
+// avoid code duplication
+void wxWindowDCImpl::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
+{
+ if (!m_gdkwindow || text.empty())
+ return;
+
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+#if __WXGTK26__
+ if (!gtk_check_version(2,6,0))
+ {
+ x = XLOG2DEV(x);
+ y = YLOG2DEV(y);
+
+ pango_layout_set_text(m_layout, wxGTK_CONV(text), -1);
+
+ if (m_font.GetUnderlined())
+ {
+ PangoAttrList *attrs = pango_attr_list_new();
+ PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+ pango_attr_list_insert(attrs, a);
+ pango_layout_set_attributes(m_layout, attrs);
+ pango_attr_list_unref(attrs);
+ }
+
+ int oldSize = 0;
+ const bool isScaled = fabs(m_scaleY - 1.0) > 0.00001;
+ if (isScaled)
+ {
+ //TODO: when Pango >= 1.6 is required, use pango_matrix_scale()
+ // If there is a user or actually any scale applied to
+ // the device context, scale the font.
+
+ // scale font description
+ oldSize = pango_font_description_get_size(m_fontdesc);
+ pango_font_description_set_size(m_fontdesc, int(oldSize * m_scaleY));
+
+ // actually apply scaled font
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+ }
+
+ int w, h;
+ pango_layout_get_pixel_size(m_layout, &w, &h);
+
+ const GdkColor* bg_col = NULL;
+ if (m_backgroundMode == wxBRUSHSTYLE_SOLID)
+ bg_col = m_textBackgroundColour.GetColor();
+
+ // rotate the text
+ PangoMatrix matrix = PANGO_MATRIX_INIT;
+ pango_matrix_rotate (&matrix, angle);
+ pango_context_set_matrix (m_context, &matrix);
+ pango_layout_context_changed (m_layout);
+
+ // To be compatible with MSW, the rotation axis must be in the old
+ // top-left corner.
+ // Calculate the vertices of the rotated rectangle containing the text,
+ // relative to the old top-left vertex.
+ // We could use the matrix for this, but it's simpler with trignonometry.
+ double rad = DegToRad(angle);
+ // the rectangle vertices are counted clockwise with the first one
+ // being at (0, 0)
+ double x2 = w * cos(rad);
+ double y2 = -w * sin(rad); // y axis points to the bottom, hence minus
+ double x4 = h * sin(rad);
+ double y4 = h * cos(rad);
+ double x3 = x4 + x2;
+ double y3 = y4 + y2;
+ // Then we calculate max and min of the rotated rectangle.
+ wxCoord maxX = (wxCoord)(dmax(dmax(0, x2), dmax(x3, x4)) + 0.5),
+ maxY = (wxCoord)(dmax(dmax(0, y2), dmax(y3, y4)) + 0.5),
+ minX = (wxCoord)(dmin(dmin(0, x2), dmin(x3, x4)) - 0.5),
+ minY = (wxCoord)(dmin(dmin(0, y2), dmin(y3, y4)) - 0.5);
+
+ gdk_draw_layout_with_colors(m_gdkwindow, m_textGC, x+minX, y+minY,
+ m_layout, NULL, bg_col);
+
+ if (m_font.GetUnderlined())
+ pango_layout_set_attributes(m_layout, NULL);
+
+ // clean up the transformation matrix
+ pango_context_set_matrix(m_context, NULL);
+
+ if (isScaled)
+ {
+ // reset unscaled size
+ pango_font_description_set_size( m_fontdesc, oldSize );
+
+ // actually apply unscaled font
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+ }
+
+ CalcBoundingBox(x+minX, y+minY);
+ CalcBoundingBox(x+maxX, y+maxY);
+ }
+ else
+#endif //__WXGTK26__
+ {
+#if wxUSE_IMAGE
+ if ( wxIsNullDouble(angle) )
+ {
+ DoDrawText(text, x, y);
+ return;
+ }
+
+ wxCoord w;
+ wxCoord h;
+
+ // TODO: implement later without GdkFont for GTK 2.0
+ DoGetTextExtent(text, &w, &h, NULL,NULL, &m_font);
+
+ // draw the string normally
+ wxBitmap src(w, h);
+ wxMemoryDC dc;
+ dc.SelectObject(src);
+ dc.SetFont(GetFont());
+ dc.SetBackground(*wxBLACK_BRUSH);
+ dc.SetBrush(*wxBLACK_BRUSH);
+ dc.Clear();
+ dc.SetTextForeground( *wxWHITE );
+ dc.DrawText(text, 0, 0);
+ dc.SelectObject(wxNullBitmap);
+
+ // Calculate the size of the rotated bounding box.
+ double rad = DegToRad(angle);
+ double dx = cos(rad),
+ dy = sin(rad);
+
+ // the rectngle vertices are counted clockwise with the first one being at
+ // (0, 0) (or, rather, at (x, y))
+ double x2 = w*dx,
+ y2 = -w*dy; // y axis points to the bottom, hence minus
+ double x4 = h*dy,
+ y4 = h*dx;
+ double x3 = x4 + x2,
+ y3 = y4 + y2;
+
+ // calc max and min
+ wxCoord maxX = (wxCoord)(dmax(x2, dmax(x3, x4)) + 0.5),
+ maxY = (wxCoord)(dmax(y2, dmax(y3, y4)) + 0.5),
+ minX = (wxCoord)(dmin(x2, dmin(x3, x4)) - 0.5),
+ minY = (wxCoord)(dmin(y2, dmin(y3, y4)) - 0.5);
+
+
+ wxImage image = src.ConvertToImage();
+
+ image.ConvertColourToAlpha( m_textForegroundColour.Red(),
+ m_textForegroundColour.Green(),
+ m_textForegroundColour.Blue() );
+ image = image.Rotate( rad, wxPoint(0,0) );
+
+ int i_angle = (int) angle;
+ i_angle = i_angle % 360;
+ if (i_angle < 0)
+ i_angle += 360;
+ int xoffset = 0;
+ if ((i_angle >= 90.0) && (i_angle < 270.0))
+ xoffset = image.GetWidth();
+ int yoffset = 0;
+ if ((i_angle >= 0.0) && (i_angle < 180.0))
+ yoffset = image.GetHeight();
+
+ if ((i_angle >= 0) && (i_angle < 90))
+ yoffset -= (int)( cos(rad)*h );
+ if ((i_angle >= 90) && (i_angle < 180))
+ xoffset -= (int)( sin(rad)*h );
+ if ((i_angle >= 180) && (i_angle < 270))
+ yoffset -= (int)( cos(rad)*h );
+ if ((i_angle >= 270) && (i_angle < 360))
+ xoffset -= (int)( sin(rad)*h );
+
+ int i_x = x - xoffset;
+ int i_y = y - yoffset;
+
+ src = image;
+ DoDrawBitmap( src, i_x, i_y, true );
+
+
+ // it would be better to draw with non underlined font and draw the line
+ // manually here (it would be more straight...)
+#if 0
+ if ( m_font.GetUnderlined() )
+ {
+ gdk_draw_line( m_gdkwindow, m_textGC,
+ XLOG2DEV(x + x4), YLOG2DEV(y + y4 + font->descent),
+ XLOG2DEV(x + x3), YLOG2DEV(y + y3 + font->descent));
+ }
+#endif // 0
+
+ // update the bounding box
+ CalcBoundingBox(x + minX, y + minY);
+ CalcBoundingBox(x + maxX, y + maxY);
+#else // !wxUSE_IMAGE
+ wxUnusedVar(text);
+ wxUnusedVar(x);
+ wxUnusedVar(y);
+ wxUnusedVar(angle);
+#endif // wxUSE_IMAGE/!wxUSE_IMAGE
+ }
+}
+
+void wxWindowDCImpl::DoGetTextExtent(const wxString &string,
+ wxCoord *width, wxCoord *height,
+ wxCoord *descent, wxCoord *externalLeading,
+ const wxFont *theFont) const
+{
+ if ( width )
+ *width = 0;
+ if ( height )
+ *height = 0;
+ if ( descent )
+ *descent = 0;
+ if ( externalLeading )
+ *externalLeading = 0;
+
+ if (string.empty())
+ return;
+
+ // ensure that theFont is always non-NULL
+ if ( !theFont || !theFont->IsOk() )
+ theFont = &m_font;
+
+ // and use it if it's valid
+ if ( theFont->IsOk() )
+ {
+ pango_layout_set_font_description
+ (
+ m_layout,
+ theFont->GetNativeFontInfo()->description
+ );
+ }
+
+ // Set layout's text
+ const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(string, *theFont);
+ if ( !dataUTF8 )
+ {
+ // hardly ideal, but what else can we do if conversion failed?
+ return;
+ }
+
+ pango_layout_set_text(m_layout, dataUTF8, -1);
+
+ int h;
+ pango_layout_get_pixel_size(m_layout, width, &h);
+ if (descent)
+ {
+ PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
+ int baseline = pango_layout_iter_get_baseline(iter);
+ pango_layout_iter_free(iter);
+ *descent = h - PANGO_PIXELS(baseline);
+ }
+ if (height)
+ *height = h;
+
+ // Reset old font description
+ if (theFont->IsOk())
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+}
+
+
+bool wxWindowDCImpl::DoGetPartialTextExtents(const wxString& text,
+ wxArrayInt& widths) const
+{
+ const size_t len = text.length();
+ widths.Empty();
+ widths.Add(0, len);
+
+ if (text.empty())
+ return true;
+
+ // Set layout's text
+ const wxCharBuffer dataUTF8 = wxGTK_CONV_FONT(text, m_font);
+ if ( !dataUTF8 )
+ {
+ // hardly ideal, but what else can we do if conversion failed?
+ wxLogLastError(wxT("DoGetPartialTextExtents"));
+ return false;
+ }
+
+ pango_layout_set_text(m_layout, dataUTF8, -1);
+
+ // Calculate the position of each character based on the widths of
+ // the previous characters
+
+ // Code borrowed from Scintilla's PlatGTK
+ PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
+ PangoRectangle pos;
+ pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
+ size_t i = 0;
+ while (pango_layout_iter_next_cluster(iter))
+ {
+ pango_layout_iter_get_cluster_extents(iter, NULL, &pos);
+ int position = PANGO_PIXELS(pos.x);
+ widths[i++] = position;
+ }
+ while (i < len)
+ widths[i++] = PANGO_PIXELS(pos.x + pos.width);
+ pango_layout_iter_free(iter);
+
+ return true;
+}
+
+
+wxCoord wxWindowDCImpl::GetCharWidth() const
+{
+ pango_layout_set_text( m_layout, "H", 1 );
+ int w;
+ pango_layout_get_pixel_size( m_layout, &w, NULL );
+ return w;
+}
+
+wxCoord wxWindowDCImpl::GetCharHeight() const
+{
+ PangoFontMetrics *metrics = pango_context_get_metrics (m_context, m_fontdesc, pango_context_get_language(m_context));
+ wxCHECK_MSG( metrics, -1, _T("failed to get pango font metrics") );
+
+ wxCoord h = PANGO_PIXELS (pango_font_metrics_get_descent (metrics) +
+ pango_font_metrics_get_ascent (metrics));
+ pango_font_metrics_unref (metrics);
+ return h;
+}
+
+void wxWindowDCImpl::Clear()
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (!m_gdkwindow) return;
+
+ int width,height;
+ DoGetSize( &width, &height );
+ gdk_draw_rectangle( m_gdkwindow, m_bgGC, TRUE, 0, 0, width, height );
+}
+
+void wxWindowDCImpl::SetFont( const wxFont &font )
+{
+ m_font = font;
+
+ if (m_font.IsOk())
+ {
+ if (m_fontdesc)
+ pango_font_description_free( m_fontdesc );
+
+ m_fontdesc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
+
+
+ if (m_window)
+ {
+ PangoContext *oldContext = m_context;
+
+ m_context = m_window->GtkGetPangoDefaultContext();
+
+ // If we switch back/forth between different contexts
+ // we also have to create a new layout. I think so,
+ // at least, and it doesn't hurt to do it.
+ if (oldContext != m_context)
+ {
+ if (m_layout)
+ g_object_unref (m_layout);
+
+ m_layout = pango_layout_new( m_context );
+ }
+ }
+
+ pango_layout_set_font_description( m_layout, m_fontdesc );
+ }
+}
+
+void wxWindowDCImpl::SetPen( const wxPen &pen )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (m_pen == pen) return;
+
+ m_pen = pen;
+
+ if (!m_pen.IsOk()) return;
+
+ if (!m_gdkwindow) return;
+
+ gint width = m_pen.GetWidth();
+ if (width <= 0)
+ {
+ // CMB: if width is non-zero scale it with the dc
+ width = 1;
+ }
+ else
+ {
+ // X doesn't allow different width in x and y and so we take
+ // the average
+ double w = 0.5 +
+ ( fabs((double) XLOG2DEVREL(width)) +
+ fabs((double) YLOG2DEVREL(width)) ) / 2.0;
+ width = (int)w;
+ if ( !width )
+ {
+ // width can't be 0 or an internal GTK error occurs inside
+ // gdk_gc_set_dashes() below
+ width = 1;
+ }
+ }
+
+ static const wxGTKDash dotted[] = {1, 1};
+ static const wxGTKDash short_dashed[] = {2, 2};
+ static const wxGTKDash wxCoord_dashed[] = {2, 4};
+ static const wxGTKDash dotted_dashed[] = {3, 3, 1, 3};
+
+ // We express dash pattern in pen width unit, so we are
+ // independent of zoom factor and so on...
+ int req_nb_dash;
+ const wxGTKDash *req_dash;
+
+ GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
+ switch (m_pen.GetStyle())
+ {
+ case wxPENSTYLE_USER_DASH:
+ req_nb_dash = m_pen.GetDashCount();
+ req_dash = (wxGTKDash*)m_pen.GetDash();
+ break;
+ case wxPENSTYLE_DOT:
+ req_nb_dash = 2;
+ req_dash = dotted;
+ break;
+ case wxPENSTYLE_LONG_DASH:
+ req_nb_dash = 2;
+ req_dash = wxCoord_dashed;
+ break;
+ case wxPENSTYLE_SHORT_DASH:
+ req_nb_dash = 2;
+ req_dash = short_dashed;
+ break;
+ case wxPENSTYLE_DOT_DASH:
+ req_nb_dash = 4;
+ req_dash = dotted_dashed;
+ break;
+
+ case wxPENSTYLE_TRANSPARENT:
+ case wxPENSTYLE_STIPPLE_MASK_OPAQUE:
+ case wxPENSTYLE_STIPPLE:
+ case wxPENSTYLE_SOLID:
+ default:
+ lineStyle = GDK_LINE_SOLID;
+ req_dash = (wxGTKDash*)NULL;
+ req_nb_dash = 0;
+ break;
+ }
+
+ if (req_dash && req_nb_dash)
+ {
+ wxGTKDash *real_req_dash = new wxGTKDash[req_nb_dash];
+ if (real_req_dash)
+ {
+ for (int i = 0; i < req_nb_dash; i++)
+ real_req_dash[i] = req_dash[i] * width;
+ gdk_gc_set_dashes( m_penGC, 0, real_req_dash, req_nb_dash );
+ delete[] real_req_dash;
+ }
+ else
+ {
+ // No Memory. We use non-scaled dash pattern...
+ gdk_gc_set_dashes( m_penGC, 0, (wxGTKDash*)req_dash, req_nb_dash );
+ }
+ }
+
+ GdkCapStyle capStyle = GDK_CAP_ROUND;
+ switch (m_pen.GetCap())
+ {
+ case wxCAP_PROJECTING: { capStyle = GDK_CAP_PROJECTING; break; }
+ case wxCAP_BUTT: { capStyle = GDK_CAP_BUTT; break; }
+ case wxCAP_ROUND:
+ default:
+ if (width <= 1)
+ {
+ width = 0;
+ capStyle = GDK_CAP_NOT_LAST;
+ }
+ break;
+ }
+
+ GdkJoinStyle joinStyle = GDK_JOIN_ROUND;
+ switch (m_pen.GetJoin())
+ {
+ case wxJOIN_BEVEL: { joinStyle = GDK_JOIN_BEVEL; break; }
+ case wxJOIN_MITER: { joinStyle = GDK_JOIN_MITER; break; }
+ case wxJOIN_ROUND:
+ default: { joinStyle = GDK_JOIN_ROUND; break; }
+ }
+
+ gdk_gc_set_line_attributes( m_penGC, width, lineStyle, capStyle, joinStyle );
+
+ m_pen.GetColour().CalcPixel( m_cmap );
+ gdk_gc_set_foreground( m_penGC, m_pen.GetColour().GetColor() );
+}
+
+void wxWindowDCImpl::SetBrush( const wxBrush &brush )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (m_brush == brush) return;
+
+ m_brush = brush;
+
+ if (!m_brush.IsOk()) return;
+
+ if (!m_gdkwindow) return;
+
+ m_brush.GetColour().CalcPixel( m_cmap );
+ gdk_gc_set_foreground( m_brushGC, m_brush.GetColour().GetColor() );
+
+ gdk_gc_set_fill( m_brushGC, GDK_SOLID );
+
+ if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE) && (m_brush.GetStipple()->IsOk()))
+ {
+ if (m_brush.GetStipple()->GetDepth() != 1)
+ {
+ gdk_gc_set_fill( m_brushGC, GDK_TILED );
+ gdk_gc_set_tile( m_brushGC, m_brush.GetStipple()->GetPixmap() );
+ }
+ else
+ {
+ gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
+ gdk_gc_set_stipple( m_brushGC, m_brush.GetStipple()->GetPixmap() );
+ }
+ }
+
+ if ((m_brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
+ {
+ gdk_gc_set_fill( m_textGC, GDK_OPAQUE_STIPPLED);
+ gdk_gc_set_stipple( m_textGC, m_brush.GetStipple()->GetMask()->GetBitmap() );
+ }
+
+ if (m_brush.IsHatch())
+ {
+ gdk_gc_set_fill( m_brushGC, GDK_STIPPLED );
+ gdk_gc_set_stipple(m_brushGC, GetHatch(m_brush.GetStyle()));
+ }
+}
+
+void wxWindowDCImpl::SetBackground( const wxBrush &brush )
+{
+ /* CMB 21/7/98: Added SetBackground. Sets background brush
+ * for Clear() and bg colour for shapes filled with cross-hatch brush */
+
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (m_backgroundBrush == brush) return;
+
+ m_backgroundBrush = brush;
+
+ if (!m_backgroundBrush.IsOk()) return;
+
+ if (!m_gdkwindow) return;
+
+ wxColor color = m_backgroundBrush.GetColour();
+ color.CalcPixel(m_cmap);
+ const GdkColor* gdkColor = color.GetColor();
+ gdk_gc_set_background(m_brushGC, gdkColor);
+ gdk_gc_set_background(m_penGC, gdkColor);
+ gdk_gc_set_background(m_bgGC, gdkColor);
+ gdk_gc_set_foreground(m_bgGC, gdkColor);
+
+
+ gdk_gc_set_fill( m_bgGC, GDK_SOLID );
+
+ if (m_backgroundBrush.GetStyle() == wxBRUSHSTYLE_STIPPLE)
+ {
+ const wxBitmap* stipple = m_backgroundBrush.GetStipple();
+ if (stipple->IsOk())
+ {
+ if (stipple->GetDepth() != 1)
+ {
+ gdk_gc_set_fill(m_bgGC, GDK_TILED);
+ gdk_gc_set_tile(m_bgGC, stipple->GetPixmap());
+ }
+ else
+ {
+ gdk_gc_set_fill(m_bgGC, GDK_STIPPLED);
+ gdk_gc_set_stipple(m_bgGC, stipple->GetPixmap());
+ }
+ }
+ }
+ else if (m_backgroundBrush.IsHatch())
+ {
+ gdk_gc_set_fill( m_bgGC, GDK_STIPPLED );
+ gdk_gc_set_stipple(m_bgGC, GetHatch(m_backgroundBrush.GetStyle()));
+ }
+}
+
+void wxWindowDCImpl::SetLogicalFunction( int function )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (m_logicalFunction == function)
+ return;
+
+ // VZ: shouldn't this be a CHECK?
+ if (!m_gdkwindow)
+ return;
+
+ GdkFunction mode;
+ switch (function)
+ {
+ case wxXOR: mode = GDK_XOR; break;
+ case wxINVERT: mode = GDK_INVERT; break;
+ case wxOR_REVERSE: mode = GDK_OR_REVERSE; break;
+ case wxAND_REVERSE: mode = GDK_AND_REVERSE; break;
+ case wxCLEAR: mode = GDK_CLEAR; break;
+ case wxSET: mode = GDK_SET; break;
+ case wxOR_INVERT: mode = GDK_OR_INVERT; break;
+ case wxAND: mode = GDK_AND; break;
+ case wxOR: mode = GDK_OR; break;
+ case wxEQUIV: mode = GDK_EQUIV; break;
+ case wxNAND: mode = GDK_NAND; break;
+ case wxAND_INVERT: mode = GDK_AND_INVERT; break;
+ case wxCOPY: mode = GDK_COPY; break;
+ case wxNO_OP: mode = GDK_NOOP; break;
+ case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
+ case wxNOR: mode = GDK_NOR; break;
+ default:
+ wxFAIL_MSG( wxT("unsupported logical function") );
+ mode = GDK_COPY;
+ }
+
+ m_logicalFunction = function;
+
+ gdk_gc_set_function( m_penGC, mode );
+ gdk_gc_set_function( m_brushGC, mode );
+
+ // to stay compatible with wxMSW, we don't apply ROPs to the text
+ // operations (i.e. DrawText/DrawRotatedText).
+ // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
+ gdk_gc_set_function( m_textGC, mode );
+}
+
+void wxWindowDCImpl::SetTextForeground( const wxColour &col )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ // don't set m_textForegroundColour to an invalid colour as we'd crash
+ // later then (we use m_textForegroundColour.GetColor() without checking
+ // in a few places)
+ if ( !col.IsOk() || (m_textForegroundColour == col) )
+ return;
+
+ m_textForegroundColour = col;
+
+ if ( m_gdkwindow )
+ {
+ m_textForegroundColour.CalcPixel( m_cmap );
+ gdk_gc_set_foreground( m_textGC, m_textForegroundColour.GetColor() );
+ }
+}
+
+void wxWindowDCImpl::SetTextBackground( const wxColour &col )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ // same as above
+ if ( !col.IsOk() || (m_textBackgroundColour == col) )
+ return;
+
+ m_textBackgroundColour = col;
+
+ if ( m_gdkwindow )
+ {
+ m_textBackgroundColour.CalcPixel( m_cmap );
+ gdk_gc_set_background( m_textGC, m_textBackgroundColour.GetColor() );
+ }
+}
+
+void wxWindowDCImpl::SetBackgroundMode( int mode )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ m_backgroundMode = mode;
+}
+
+void wxWindowDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
+{
+ wxFAIL_MSG( wxT("wxWindowDCImpl::SetPalette not implemented") );
+}
+
+void wxWindowDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (!m_gdkwindow) return;
+
+ wxRect rect;
+ rect.x = XLOG2DEV(x);
+ rect.y = YLOG2DEV(y);
+ rect.width = XLOG2DEVREL(width);
+ rect.height = YLOG2DEVREL(height);
+
+ if (m_window && m_window->m_wxwindow &&
+ (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
+ {
+ rect.x -= rect.width;
+ }
+
+ DoSetDeviceClippingRegion(wxRegion(rect));
+}
+
+void wxWindowDCImpl::DoSetDeviceClippingRegion( const wxRegion ®ion )
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ if (region.Empty())
+ {
+ DestroyClippingRegion();
+ return;
+ }
+
+ if (!m_gdkwindow) return;
+
+ if (!m_currentClippingRegion.IsNull())
+ m_currentClippingRegion.Intersect( region );
+ else
+ m_currentClippingRegion.Union( region );
+
+#if USE_PAINT_REGION
+ if (!m_paintClippingRegion.IsNull())
+ m_currentClippingRegion.Intersect( m_paintClippingRegion );
+#endif
+
+ wxCoord xx, yy, ww, hh;
+ m_currentClippingRegion.GetBox( xx, yy, ww, hh );
+ wxGTKDCImpl::DoSetClippingRegion( xx, yy, ww, hh );
+
+ GdkRegion* gdkRegion = m_currentClippingRegion.GetRegion();
+ gdk_gc_set_clip_region(m_penGC, gdkRegion);
+ gdk_gc_set_clip_region(m_brushGC, gdkRegion);
+ gdk_gc_set_clip_region(m_textGC, gdkRegion);
+ gdk_gc_set_clip_region(m_bgGC, gdkRegion);
+}
+
+void wxWindowDCImpl::DestroyClippingRegion()
+{
+ wxCHECK_RET( IsOk(), wxT("invalid window dc") );
+
+ wxDCImpl::DestroyClippingRegion();
+
+ m_currentClippingRegion.Clear();
+
+#if USE_PAINT_REGION
+ if (!m_paintClippingRegion.IsEmpty())
+ m_currentClippingRegion.Union( m_paintClippingRegion );
+#endif
+
+ if (!m_gdkwindow) return;
+
+ GdkRegion* gdkRegion = NULL;
+ if (!m_currentClippingRegion.IsEmpty())
+ gdkRegion = m_currentClippingRegion.GetRegion();
+
+ gdk_gc_set_clip_region(m_penGC, gdkRegion);
+ gdk_gc_set_clip_region(m_brushGC, gdkRegion);
+ gdk_gc_set_clip_region(m_textGC, gdkRegion);
+ gdk_gc_set_clip_region(m_bgGC, gdkRegion);
+}
+
+void wxWindowDCImpl::Destroy()
+{
+ if (m_penGC) wxFreePoolGC( m_penGC );
+ m_penGC = (GdkGC*) NULL;
+ if (m_brushGC) wxFreePoolGC( m_brushGC );
+ m_brushGC = (GdkGC*) NULL;
+ if (m_textGC) wxFreePoolGC( m_textGC );
+ m_textGC = (GdkGC*) NULL;
+ if (m_bgGC) wxFreePoolGC( m_bgGC );
+ m_bgGC = (GdkGC*) NULL;
+}
+
+void wxWindowDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
+{
+ m_deviceOriginX = x;
+ m_deviceOriginY = y;
+
+ ComputeScaleAndOrigin();
+}
+
+void wxWindowDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+{
+ m_signX = (xLeftRight ? 1 : -1);
+ m_signY = (yBottomUp ? -1 : 1);
+
+ if (m_window && m_window->m_wxwindow &&
+ (m_window->GetLayoutDirection() == wxLayout_RightToLeft))
+ m_signX = -m_signX;
+
+ ComputeScaleAndOrigin();
+}
+
+void wxWindowDCImpl::ComputeScaleAndOrigin()
+{
+ const wxRealPoint origScale(m_scaleX, m_scaleY);
+
+ wxDCImpl::ComputeScaleAndOrigin();
+
+ // if scale has changed call SetPen to recalulate the line width
+ if ( wxRealPoint(m_scaleX, m_scaleY) != origScale && m_pen.IsOk() )
+ {
+ // this is a bit artificial, but we need to force wxDC to think the pen
+ // has changed
+ wxPen pen = m_pen;
+ m_pen = wxNullPen;
+ SetPen( pen );
+ }
+}
+
+// Resolution in pixels per logical inch
+wxSize wxWindowDCImpl::GetPPI() const
+{
+ return wxSize( (int) (m_mm_to_pix_x * 25.4 + 0.5), (int) (m_mm_to_pix_y * 25.4 + 0.5));
+}
+
+int wxWindowDCImpl::GetDepth() const
+{
+ return gdk_drawable_get_depth(m_gdkwindow);
+}
+
+
+//-----------------------------------------------------------------------------
+// wxClientDCImpl
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
+
+wxClientDCImpl::wxClientDCImpl( wxDC *owner )
+ : wxWindowDCImpl( owner )
+{
+}
+
+wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *win )
+ : wxWindowDCImpl( owner, win )
+{
+ wxCHECK_RET( win, _T("NULL window in wxClientDCImpl::wxClientDC") );
+
+#ifdef __WXUNIVERSAL__
+ wxPoint ptOrigin = win->GetClientAreaOrigin();
+ SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
+ wxSize size = win->GetClientSize();
+ DoSetClippingRegion(0, 0, size.x, size.y);
+#endif
+ // __WXUNIVERSAL__
+}
+
+void wxClientDCImpl::DoGetSize(int *width, int *height) const
+{
+ wxCHECK_RET( m_window, _T("GetSize() doesn't work without window") );
+
+ m_window->GetClientSize( width, height );
+}
+
+//-----------------------------------------------------------------------------
+// wxPaintDCImpl
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)
+
+// Limit the paint region to the window size. Sometimes
+// the paint region is too big, and this risks X11 errors
+static void wxLimitRegionToSize(wxRegion& region, const wxSize& sz)
+{
+ wxRect originalRect = region.GetBox();
+ wxRect rect(originalRect);
+ if (rect.width + rect.x > sz.x)
+ rect.width = sz.x - rect.x;
+ if (rect.height + rect.y > sz.y)
+ rect.height = sz.y - rect.y;
+ if (rect != originalRect)
+ {
+ region = wxRegion(rect);
+ wxLogTrace(wxT("painting"), wxT("Limiting region from %d, %d, %d, %d to %d, %d, %d, %d\n"),
+ originalRect.x, originalRect.y, originalRect.width, originalRect.height,
+ rect.x, rect.y, rect.width, rect.height);
+ }
+}
+
+wxPaintDCImpl::wxPaintDCImpl( wxDC *owner )
+ : wxClientDCImpl( owner )
+{
+}
+
+wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *win )
+ : wxClientDCImpl( owner, win )
+{
+#if USE_PAINT_REGION
+ if (!win->m_clipPaintRegion)
+ return;
+
+ wxSize sz = win->GetSize();
+ m_paintClippingRegion = win->m_nativeUpdateRegion;
+ wxLimitRegionToSize(m_paintClippingRegion, sz);
+
+ GdkRegion *region = m_paintClippingRegion.GetRegion();
+ if ( region )
+ {
+ m_currentClippingRegion.Union( m_paintClippingRegion );
+ wxLimitRegionToSize(m_currentClippingRegion, sz);
+
+ if (sz.x <= 0 || sz.y <= 0)
+ return ;
+
+ gdk_gc_set_clip_region( m_penGC, region );
+ gdk_gc_set_clip_region( m_brushGC, region );
+ gdk_gc_set_clip_region( m_textGC, region );
+ gdk_gc_set_clip_region( m_bgGC, region );
+ }
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// wxDCModule
+// ----------------------------------------------------------------------------
+
+class wxDCModule : public wxModule
+{
+public:
+ bool OnInit();
+ void OnExit();
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxDCModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
+
+bool wxDCModule::OnInit()
+{
+ wxInitGCPool();
+ return true;
+}
+
+void wxDCModule::OnExit()
+{
+ wxCleanUpGCPool();
+
+ for (int i = wxBRUSHSTYLE_LAST_HATCH - wxBRUSHSTYLE_FIRST_HATCH; i--; )
+ {
+ if (hatches[i])
+ g_object_unref(hatches[i]);
+ }
+}
projects / wxWidgets.git / blobdiff