void content_draw (GtkWidget *widget, cairo_t *cr) { PangoContext *context; PangoLayout *title_layout; PangoLayout *sub_layout; PangoFontDescription *desc; int width, height; int sub_width; width = gdk_window_get_width (gtk_widget_get_window (widget)); height = gdk_window_get_height (gtk_widget_get_window (widget)); cairo_translate (cr, width / 2, height / 2); context = gdk_pango_context_get_for_screen (gtk_widget_get_screen (widget)); title_layout = pango_layout_new (context); pango_layout_set_text (title_layout, _("This session is locked"), -1); desc = pango_font_description_from_string (TITLE_FONT); pango_layout_set_font_description (title_layout, desc); pango_font_description_free (desc); cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 1.0); pango_cairo_update_layout (cr, title_layout); pango_layout_get_size (title_layout, &width, &height); cairo_save (cr); /* Adjust the translation to the middle left of the icon */ cairo_translate (cr, - width / PANGO_SCALE / 2 - height / PANGO_SCALE, - height / PANGO_SCALE / 2); draw_lock_icon (cr, height / PANGO_SCALE); cairo_restore (cr); cairo_move_to (cr, - width / PANGO_SCALE / 2 + height / PANGO_SCALE, - height / PANGO_SCALE); pango_cairo_show_layout (cr, title_layout); g_object_unref (title_layout); sub_layout = pango_layout_new (context); pango_layout_set_text (sub_layout, _("You'll be redirected to the unlock dialog automatically in a few seconds"), -1); pango_layout_set_wrap (sub_layout, PANGO_WRAP_WORD_CHAR); pango_layout_set_width (sub_layout, width + 2 * height); desc = pango_font_description_from_string (MESSAGE_FONT); pango_layout_set_font_description (sub_layout, desc); pango_font_description_free (desc); cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 1.0); pango_cairo_update_layout (cr, sub_layout); pango_layout_get_size (sub_layout, &sub_width, NULL); cairo_move_to (cr, - (width + 2 * height) / PANGO_SCALE / 2, height / PANGO_SCALE); cairo_scale (cr, (width + 2 * height) / (gdouble)sub_width, (width + 2 * height) / (gdouble)sub_width); pango_cairo_show_layout (cr, sub_layout); g_object_unref (sub_layout); g_object_unref (context); }
static void workrave_timebar_init_ui(WorkraveTimebar *self) { WorkraveTimebarPrivate *priv = WORKRAVE_TIMEBAR_GET_PRIVATE(self); priv->style_context = gtk_style_context_new(); GtkWidgetPath *path = gtk_widget_path_new(); gtk_widget_path_append_type(path, GTK_TYPE_BUTTON); gtk_style_context_set_path(priv->style_context, path); gtk_style_context_add_class(priv->style_context, GTK_STYLE_CLASS_TROUGH); GdkScreen *screen = gdk_screen_get_default(); priv->pango_context = gdk_pango_context_get_for_screen(screen); const PangoFontDescription *font_desc = gtk_style_context_get_font(priv->style_context, GTK_STATE_FLAG_ACTIVE); pango_context_set_language(priv->pango_context, gtk_get_default_language()); pango_context_set_font_description(priv->pango_context, font_desc); priv->pango_layout = pango_layout_new(priv->pango_context); pango_layout_set_text(priv->pango_layout, "-9:59:59", -1); pango_layout_get_pixel_size(priv->pango_layout, &priv->width, &priv->height); priv->width = MAX(priv->width + 2 * MARGINX, MIN_HORIZONTAL_BAR_WIDTH); priv->height = MAX(priv->height + 2 * MARGINY, MIN_HORIZONTAL_BAR_HEIGHT); gtk_widget_path_free(path); }
static gboolean expose_cb (GtkWidget *widget, GdkEventExpose *event, ccss_style_t const *style) { cairo_t *cr; char *font_family; cr = gdk_cairo_create (widget->window); font_family = NULL; ccss_style_get_string (style, "font-family", &font_family); if (font_family) { PangoContext *context; PangoLayout *layout; context = gtk_widget_get_pango_context (widget); layout = pango_layout_new (context); pango_layout_set_text (layout, font_family, strlen (font_family)); pango_cairo_show_layout (cr, layout); g_object_unref (G_OBJECT (layout)), layout = NULL; } cairo_destroy (cr); return FALSE; }
ttext::ttext() : #if PANGO_VERSION_CHECK(1,22,0) context_(pango_font_map_create_context(pango_cairo_font_map_get_default())), #else context_(pango_cairo_font_map_create_context(( reinterpret_cast<PangoCairoFontMap*>(pango_cairo_font_map_get_default())))), #endif layout_(pango_layout_new(context_)), rect_(), surface_(), #ifdef SDL_GPU texture_(), #endif text_(), markedup_text_(false), link_aware_(false), link_color_(), font_class_(font::FONT_SANS_SERIF), font_size_(14), font_style_(STYLE_NORMAL), foreground_color_(0xFFFFFFFF), // solid white maximum_width_(-1), characters_per_line_(0), maximum_height_(-1), ellipse_mode_(PANGO_ELLIPSIZE_END), alignment_(PANGO_ALIGN_LEFT), maximum_length_(std::string::npos), calculation_dirty_(true), length_(0), surface_dirty_(true), surface_buffer_(nullptr) { // With 72 dpi the sizes are the same as with SDL_TTF so hardcoded. pango_cairo_context_set_resolution(context_, 72.0); pango_layout_set_ellipsize(layout_, ellipse_mode_); pango_layout_set_alignment(layout_, alignment_); pango_layout_set_wrap(layout_, PANGO_WRAP_WORD_CHAR); /* * Set the pango spacing a bit bigger since the default is deemed to small * http://www.wesnoth.org/forum/viewtopic.php?p=358832#p358832 */ pango_layout_set_spacing(layout_, 2 * PANGO_SCALE); cairo_font_options_t *fo = cairo_font_options_create(); cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL); cairo_font_options_set_hint_metrics(fo, CAIRO_HINT_METRICS_ON); #ifdef _WIN32 // Cairo on Windows (at least the latest available version from gtk.org // as of 2014-02-22, version 1.10.2) has issues with ClearType resulting // in glitchy anti-aliasing with CAIRO_ANTIALIAS_SUBPIXEL or // CAIRO_ANTIALIAS_DEFAULT, but not CAIRO_ANTIALIAS_GRAY, so we use that // as a workaround until the Windows package is updated to use a newer // version of Cairo (see Wesnoth bug #21648). cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_GRAY); #endif pango_cairo_context_set_font_options(context_, fo); cairo_font_options_destroy(fo); }
GdkPixbuf * gitg_label_renderer_render_ref (GtkWidget *widget, PangoFontDescription *description, GitgRef *ref, gint height, gint minwidth) { PangoContext *ctx = gtk_widget_get_pango_context(widget); PangoLayout *layout = pango_layout_new(ctx); pango_layout_set_font_description(layout, description); gint width = MAX(get_label_width (layout, ref), minwidth); cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width + 2, height + 2); cairo_t *context = cairo_create (surface); cairo_set_line_width (context, 1); render_label (context, layout, ref, 1, 1, height, FALSE); guint8 *data = cairo_image_surface_get_data (surface); GdkPixbuf *ret = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width + 2, height + 2); guint8 *pixdata = gdk_pixbuf_get_pixels (ret); convert_bgra_to_rgba (data, pixdata, width + 2, height + 2); cairo_destroy (context); cairo_surface_destroy (surface); g_object_unref (layout); return ret; }
//________________________________________________________ long GetVisibleStringWidth (_String& s, _HYFont& f) { static PangoLayout* textLayout = pango_layout_new (screenPContext); static PangoFontDescription * fd = pango_font_description_new (); static _HYFont stashedFont; if (s.sLength) { if (stashedFont.size!=f.size || stashedFont.style != f.style || stashedFont.face != f.face) { HYFont2PangoFontDesc(f,fd); pango_layout_set_width (textLayout,-1); pango_layout_set_font_description(textLayout,fd); stashedFont = f; } pango_layout_set_text (textLayout, s.sData,s.sLength); //PangoRectangle charPos; //pango_layout_index_to_pos (textLayout,s.sLength-1,&charPos); //return PANGO_PIXELS(charPos.x+charPos.width); PangoRectangle extents, logical_ext; pango_layout_get_pixel_extents (textLayout,&extents,&logical_ext); return logical_ext.width; } else { return 0; } }
// Get Gtk needed elements, if we have not them yet. void wxTextMeasure::BeginMeasuring() { if ( m_dc ) { #ifndef __WXGTK3__ m_wdc = wxDynamicCast(m_dc->GetImpl(), wxWindowDCImpl); if ( m_wdc ) { m_context = m_wdc->m_context; m_layout = m_wdc->m_layout; } #endif // GTK+ < 3 } else if ( m_win ) { m_context = gtk_widget_get_pango_context( m_win->GetHandle() ); if ( m_context ) m_layout = pango_layout_new(m_context); } // set the font to use if ( m_layout ) { pango_layout_set_font_description(m_layout, GetFont().GetNativeFontInfo()->description); } }
gint gitg_label_renderer_width(GtkWidget *widget, PangoFontDescription *font, GSList *labels) { gint width = 0; GSList *item; if (labels == NULL) return 0; PangoContext *ctx = gtk_widget_get_pango_context(widget); PangoLayout *layout = pango_layout_new(ctx); pango_layout_set_font_description(layout, font); for (item = labels; item; item = item->next) { gint w; GitgRef *ref = (GitgRef *)item->data; gchar *smaller = g_strdup_printf("<span size='smaller'>%s</span>", ref->shortname); pango_layout_set_markup(layout, smaller, -1); pango_layout_get_pixel_size(layout, &w, NULL); width += w + PADDING * 2 + MARGIN; g_free(smaller); } g_object_unref(layout); //g_object_unref(ctx); return width + MARGIN; }
static PangoLayout * pango_layout_create(JoyStyle *self) { struct Private *priv = GET_PRIVATE(self); if (G_UNLIKELY(!priv->context)) { goto error; } PangoLayout *layout = pango_layout_new(priv->context); if (G_UNLIKELY(!layout)) { goto error; } g_signal_connect(self, "context-changed", G_CALLBACK(on_context_changed), layout); exit: { PangoFontDescription *desc = joy_style_get_font_description(self); if (desc) { pango_layout_set_font_description(layout, desc); } return layout; } error: { JoyStyle *parent = joy_style_get_parent(self); if (!parent) { return NULL; } layout = joy_style_pango_layout_create(parent); goto exit; } }
GtkWidget * lmplayer_lyric_widget_da_new() { LmplayerLyricWidgetDa *lyric; LmplayerLyricWidgetDaPrivate *priv; lyric = g_object_new(LMPLAYER_TYPE_LYRIC_WIDGET_DA, NULL); priv = lyric->priv; priv->alignment = gtk_alignment_new(0, 0, 1, 1); gtk_widget_show(priv->alignment); priv->da = gtk_drawing_area_new(); gtk_widget_show(priv->da); //priv->da_gc = gdk_gc_new(priv->da->window); priv->pango_context = gtk_widget_get_pango_context(priv->da); priv->pango_layout = pango_layout_new(priv->pango_context); gtk_container_add(GTK_CONTAINER(priv->alignment), priv->da); gtk_container_add(GTK_CONTAINER(lyric), priv->alignment); gtk_widget_set_events(priv->da, GDK_EXPOSURE_MASK); g_signal_connect(G_OBJECT(lyric), "expose-event", G_CALLBACK(layout_expose_cb), lyric); g_signal_connect(G_OBJECT(priv->da), "expose-event", G_CALLBACK(da_expose_cb), lyric); g_signal_connect(G_OBJECT(priv->da), "configure-event", G_CALLBACK(da_configure_cb), lyric); return GTK_WIDGET(lyric); }
LoadGraph *load_graph_new(gint size) { LoadGraph *lg; lg = g_new0(LoadGraph, 1); size++; lg->suffix = g_strdup(""); lg->area = gtk_drawing_area_new(); lg->size = (size * 3) / 2; lg->data = g_new0(gint, lg->size); lg->scale = 1.0; lg->width = size * 6; lg->height = size * 2; lg->max_value = 1; lg->remax_count = 0; lg->layout = pango_layout_new(gtk_widget_get_pango_context(lg->area)); gtk_widget_set_size_request(lg->area, lg->width, lg->height); gtk_widget_show(lg->area); return lg; }
int main (int argc, char**argv) { PangoContext* context; PangoLayout * layout; Testcase * testcase; gboolean passed = TRUE; /* prepare */ gtk_init (&argc, &argv); testcase = testcase_new (); context = gdk_pango_context_get (); layout = pango_layout_new (context); pango_layout_set_text (layout, "Foo Bar Baz", -1); /* exercise */ g_signal_connect (testcase, "exercise-gdk", G_CALLBACK (test_gdk_cb), layout); g_signal_connect (testcase, "exercise-cairo", G_CALLBACK (test_cairo_cb), layout); testcase_exercise (testcase); /* verify */ passed = testcase_get_passed (testcase); /* cleanup */ g_object_unref (testcase); g_object_unref (layout); g_object_unref (context); return passed ? 0 : 1; }
//__________________________________________________________________ _HYRect _HYPullDown::_SuggestDimensions (void) { _HYRect res = {25,100,25,100,HY_COMPONENT_NO_SCROLL}; if (theMenu) { long naturalWidth = 0; PangoLayout * fontMeasurer = nil; for (long k=0; k<widgetList.lLength; k+=2) { GtkWidget * dropWidget = GTK_WIDGET (widgetList(k)); if (!fontMeasurer) { fontMeasurer = pango_layout_new (gtk_widget_get_pango_context (dropWidget)); } pango_layout_set_text(fontMeasurer,GetMenuItem(k/2)->sData ,GetMenuItem(k/2)->sLength); PangoRectangle extents, log_ext; pango_layout_get_pixel_extents (fontMeasurer,&extents,nil); if (extents.width > naturalWidth) { naturalWidth = extents.width; } } if (fontMeasurer) { g_object_unref (fontMeasurer); } res.right = res.left = naturalWidth+25; } return res; }
void draw_init_font (drawctx_t *ctx, int type, int reset) { if (reset || !ctx->pango_ready) { if (ctx->pangoctx) { g_object_unref (ctx->pangoctx); ctx->pangoctx = NULL; } if (ctx->pangolayout) { g_object_unref (ctx->pangolayout); ctx->pangolayout = NULL; } if (ctx->font_style) { g_object_unref (ctx->font_style); ctx->font_style = NULL; } ctx->font_style = gtk_style_new (); if (ctx->font_style->font_desc) { pango_font_description_free (ctx->font_style->font_desc); ctx->font_style->font_desc = get_new_font_description_from_type (type); } ctx->pangoctx = gdk_pango_context_get (); ctx->pangolayout = pango_layout_new (ctx->pangoctx); pango_layout_set_ellipsize (ctx->pangolayout, PANGO_ELLIPSIZE_END); PangoFontDescription *desc = ctx->font_style->font_desc; ctx->font_weight = pango_font_description_get_weight (desc); pango_layout_set_font_description (ctx->pangolayout, desc); ctx->pango_ready = 1; } else if (ctx->pango_ready) { PangoFontDescription *desc = ctx->font_style->font_desc; pango_layout_set_font_description (ctx->pangolayout, desc); } }
static gboolean file_view_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard, GtkTooltip* tooltip) { AnjutaFileView* view = ANJUTA_FILE_VIEW (widget); AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view); GtkTreeModel* model_sort; GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model); GtkTreePath* path; GtkTreeIter iter; GtkTreeIter real_iter; gchar* filename; gboolean result = TRUE; GdkRectangle visible_rect, column_rect; GdkScreen *screen = gdk_screen_get_default (); PangoContext *context; PangoLayout *layout; gint width, height; if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view), &x, &y, keyboard, &model_sort, &path, &iter)) return FALSE; gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model_sort), &real_iter, &iter); filename = file_model_get_filename (FILE_MODEL (file_model), &real_iter); context = gdk_pango_context_get_for_screen (screen); layout = pango_layout_new (context); pango_layout_set_text (layout, filename, -1); pango_layout_get_pixel_size (layout, &width, &height); gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (view), &visible_rect); gtk_tree_view_get_cell_area (GTK_TREE_VIEW (view), path, gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), &column_rect); if (column_rect.x + width > visible_rect.x + visible_rect.width || column_rect.x < visible_rect.x) { gtk_tooltip_set_text (tooltip, filename); gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view), tooltip, path); } else { result = FALSE; } g_free (filename); gtk_tree_path_free (path); g_object_unref (layout); g_object_unref (context); return result; }
PangoLayout * VwGraphicsCairo::GetPangoLayoutHelper() { if (m_fontMap == NULL) m_fontMap = pango_cairo_font_map_get_default(); if (m_context == NULL) { m_context = pango_context_new(); pango_context_set_font_map(m_context, m_fontMap); } if (m_layout == NULL) { m_layout = pango_layout_new(m_context); PangoAttrList* list = pango_attr_list_new(); PangoAttribute * fallbackAttrib = pango_attr_fallback_new(true); pango_attr_list_insert(list, fallbackAttrib); pango_layout_set_attributes(m_layout, list); pango_attr_list_unref(list); pango_layout_set_single_paragraph_mode(m_layout, true); } return m_layout; }
static PangoLayout * get_pango_layout (GtkNumerableIcon *self) { PangoContext *context; GdkScreen *screen; PangoLayout *layout; if (self->priv->style != NULL) { screen = gtk_style_context_get_screen (self->priv->style); context = gdk_pango_context_get_for_screen (screen); layout = pango_layout_new (context); if (self->priv->font != NULL) pango_layout_set_font_description (layout, self->priv->font); pango_layout_set_text (layout, self->priv->rendered_string, -1); g_object_unref (context); } else { GtkWidget *fake; /* steal gtk text settings from the window */ fake = gtk_window_new (GTK_WINDOW_TOPLEVEL); layout = gtk_widget_create_pango_layout (fake, self->priv->rendered_string); gtk_widget_destroy (fake); } return layout; }
static int ol_scroll_window_get_font_height (OlScrollWindow *scroll) { ol_assert_ret (OL_IS_SCROLL_WINDOW (scroll), 0); OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (scroll); PangoContext *pango_context = gdk_pango_context_get (); PangoLayout *pango_layout = pango_layout_new (pango_context); PangoFontDescription *font_desc = pango_font_description_from_string (priv->font_name); pango_layout_set_font_description (pango_layout, font_desc); PangoFontMetrics *metrics = pango_context_get_metrics (pango_context, pango_layout_get_font_description (pango_layout), /* font desc */ NULL); /* languague */ int height = 0; int ascent, descent; ascent = pango_font_metrics_get_ascent (metrics); descent = pango_font_metrics_get_descent (metrics); pango_font_metrics_unref (metrics); height += PANGO_PIXELS (ascent + descent); pango_font_description_free (font_desc); g_object_unref (pango_layout); g_object_unref (pango_context); return height; }
void draw_init_font (drawctx_t *ctx, GtkStyle *new_font_style) { if (!ctx->pango_ready || (new_font_style && ctx->font_style != new_font_style)) { if (ctx->pangoctx) { g_object_unref (ctx->pangoctx); ctx->pangoctx = NULL; } if (ctx->pangolayout) { g_object_unref (ctx->pangolayout); ctx->pangolayout = NULL; } ctx->font_style = new_font_style ? new_font_style : gtk_widget_get_default_style (); ctx->pangoctx = gdk_pango_context_get (); ctx->pangolayout = pango_layout_new (ctx->pangoctx); pango_layout_set_ellipsize (ctx->pangolayout, PANGO_ELLIPSIZE_END); PangoFontDescription *desc = ctx->font_style->font_desc; ctx->font_weight = pango_font_description_get_weight (desc); pango_layout_set_font_description (ctx->pangolayout, desc); ctx->pango_ready = 1; } else if (new_font_style) { PangoFontDescription *desc = ctx->font_style->font_desc; pango_layout_set_font_description (ctx->pangolayout, desc); } }
struct TEXT_WIDGET_HANDLE text_widget_init ( float x_mm, float y_mm, float width_mm, float height_mm, float dpmm_x, float dpmm_y ) { struct TEXT_WIDGET_HANDLE handle; handle.d = malloc( sizeof( struct TEXT_WIDGET_PRIVATE ) ); handle.d->x_mm = x_mm; handle.d->y_mm = y_mm; handle.d->dpmm_x = dpmm_x; handle.d->dpmm_y = dpmm_y; handle.d->font_map = pango_ft2_font_map_new(); // Note: FreeType works in DPI. pango_ft2_font_map_set_resolution( (PangoFT2FontMap*)handle.d->font_map, dpmm_x * 25.4, dpmm_y * 25.4 ); handle.d->context = pango_font_map_create_context( handle.d->font_map ); handle.d->layout = pango_layout_new( handle.d->context ); // Pango works in Pango Units. Not exactly clear how the resolution of // the font and the size of the rendering box fit together. int width = pango_units_from_double( dpmm_x * width_mm ); int height = pango_units_from_double( dpmm_y * height_mm ); pango_layout_set_width( handle.d->layout, width ); pango_layout_set_height( handle.d->layout, height ); handle.d->foreground = vgCreatePaint(); vgSetParameterfv( handle.d->foreground, VG_PAINT_COLOR, 4, DEFAULT_FOREGROUND ); return handle; }
void MapPainterSVG::GetTextDimension(const Projection& projection, const MapParameter& parameter, double fontSize, const std::string& text, double& xOff, double& yOff, double& width, double& height) { #if defined(OSMSCOUT_MAP_SVG_HAVE_LIB_PANGO) PangoFontDescription *font; PangoLayout *layout=pango_layout_new(pangoContext); PangoRectangle extends; font=GetFont(projection, parameter, fontSize); pango_layout_set_font_description(layout,font); pango_layout_set_text(layout,text.c_str(),text.length()); pango_layout_get_pixel_extents(layout,&extends,NULL); xOff=extends.x; yOff=extends.y; width=extends.width; height=pango_font_description_get_size(font)/PANGO_SCALE; g_object_unref(layout); #endif }
void ZDrawSongInfo(IDirectFB *dfb, IDirectFBSurface *dfbsurface, const gchar *title, const gchar *artist, gint w, gint h, DFBColor *color, DFBColor *strokeColor, double strokeWidth, const PangoFontDescription *desc) { cairo_t *cr = NULL; cairo_surface_t *surface = NULL; cairo_surface_t *cairosurface = NULL; PangoLayout *layout = NULL; if(!dfb || !dfbsurface) return; /* prepare layout */ layout = pango_layout_new(gdk_pango_context_get()); pango_layout_set_single_paragraph_mode (layout, TRUE); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_width(layout, w* PANGO_SCALE); pango_layout_set_font_description(layout, desc); surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h); cr = cairo_create(surface); /* Draw title */ if(title) { pango_layout_set_text(layout, title, -1); cairo_move_to(cr, 0, 0); pango_cairo_layout_path(cr, layout); ZCairoSetDFBColor(cr, strokeColor); cairo_set_line_width(cr, strokeWidth); cairo_stroke_preserve(cr); ZCairoSetDFBColor(cr, color); cairo_fill(cr); } /* Draw artist */ if(artist) { pango_layout_set_text(layout, artist, -1); cairo_move_to(cr, 0, h/2); pango_cairo_layout_path(cr, layout); ZCairoSetDFBColor(cr, strokeColor); cairo_set_line_width(cr, strokeWidth); cairo_stroke_preserve(cr); ZCairoSetDFBColor(cr, color); cairo_fill(cr); } g_object_unref(layout); cairo_destroy(cr); /* Draw cairo_surface to dfbsurface */ /* create surface */ cairosurface = cairo_directfb_surface_create(dfb, dfbsurface); cr = cairo_create(cairosurface); cairo_set_source_surface(cr, surface, 0, 0); cairo_paint(cr); cairo_destroy(cr); cairo_surface_destroy(surface); cairo_surface_destroy(cairosurface); }
/* * max_window_name_width * * Returns: gint * Description: Calculate the width of the decoration required to display * the window name using pango (with 6px padding) * Returns zero if window has no name. */ gint max_window_name_width (WnckWindow *win) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); const gchar *name; gint w; /* Ensure that a layout is created */ if (!d->layout) { d->layout = pango_layout_new (d->frame->pango_context); if (!d->layout) return 0; pango_layout_set_wrap (d->layout, PANGO_WRAP_CHAR); } /* Return zero if window has no name */ name = wnck_window_get_name (win); if (!name) return 0; /* Reset the width, set hte text and get the size required */ pango_layout_set_auto_dir (d->layout, FALSE); pango_layout_set_width (d->layout, -1); pango_layout_set_text (d->layout, name, strlen (name)); pango_layout_get_pixel_size (d->layout, &w, NULL); if (d->name) pango_layout_set_text (d->layout, d->name, strlen (d->name)); return w + 6; }
int wxWindowX11::GetCharHeight() const { wxCHECK_MSG( m_font.Ok(), 0, wxT("valid window font needed") ); #if wxUSE_UNICODE // There should be an easier way. PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() ); pango_layout_set_font_description( layout, 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 WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, wxGlobalDisplay()); int direction, ascent, descent; XCharStruct overall; XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent, &descent, &overall); // return (overall.ascent + overall.descent); return (ascent + descent); #endif }
static GdkPixbuf* accessx_status_applet_get_glyph_pixbuf(AccessxStatusApplet* sapplet, GtkWidget* widget, GdkPixbuf* base, GdkColor* fg, GdkColor* bg, gchar* glyphstring) { GdkPixbuf* glyph_pixbuf; cairo_surface_t *surface; PangoLayout* layout; PangoRectangle ink, logic; PangoContext* pango_context; gint w = gdk_pixbuf_get_width(base); gint h = gdk_pixbuf_get_height(base); cairo_t *cr; surface = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR_ALPHA, w, h); pango_context = gtk_widget_get_pango_context(widget); layout = pango_layout_new(pango_context); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_text(layout, glyphstring, -1); cr = cairo_create (surface); gdk_cairo_set_source_color (cr, bg); cairo_paint (cr); gdk_cairo_set_source_color (cr, fg); pango_layout_get_pixel_extents(layout, &ink, &logic); cairo_move_to (cr, (w - ink.x - ink.width)/2, (h - ink.y - ink.height)/2); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); g_object_unref(layout); glyph_pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, w, h); cairo_surface_destroy (surface); return glyph_pixbuf; }
static PangoLayout * create_layout_with_attrs (GtkWidget *widget, GdTwoLinesRenderer *self, PangoEllipsizeMode ellipsize) { PangoLayout *layout; gint wrap_width; PangoWrapMode wrap_mode; PangoAlignment alignment; g_object_get (self, "wrap-width", &wrap_width, "wrap-mode", &wrap_mode, "alignment", &alignment, NULL); layout = pango_layout_new (gtk_widget_get_pango_context (widget)); pango_layout_set_ellipsize (layout, ellipsize); pango_layout_set_wrap (layout, wrap_mode); pango_layout_set_alignment (layout, alignment); if (wrap_width != -1) pango_layout_set_width (layout, wrap_width * PANGO_SCALE); return layout; }
text_wrapper::text_wrapper(void) { // voids everything utf8_text = NULL; uni32_text = NULL; glyph_text = NULL; utf8_length = 0; uni32_length = 0; glyph_length = 0; utf8_codepoint = NULL; uni32_codepoint = NULL; default_font = NULL; bounds = NULL; nbBound = maxBound = 0; boxes = NULL; nbBox = maxBox = 0; paras = NULL; nbPara = maxPara = 0; kern_x = kern_y = NULL; last_addition = -1; // inits the pangolayout with default params font_factory *font_src = font_factory::Default(); pLayout = pango_layout_new(font_src->fontContext); pango_layout_set_single_paragraph_mode(pLayout, true); pango_layout_set_width(pLayout, -1); }
int sg_text_width(const char *txt, PangoFontDescription *font) { int wid = 0; PangoLayout *layout = NULL; PangoContext *ctx; if (txt == NULL) return(0); if (snd_strlen(txt) == 0) return(0); if (!(g_utf8_validate(txt, -1, NULL))) { #if MUS_DEBUGGING fprintf(stderr,"text width: invalid UTF-8: %s\n", txt); abort(); #endif return(0); } ctx = gdk_pango_context_get(); layout = pango_layout_new(ctx); if (layout) { pango_layout_set_font_description(layout, font); pango_layout_set_text(layout, txt, -1); pango_layout_get_pixel_size(layout, &wid, NULL); g_object_unref(G_OBJECT(layout)); } g_object_unref(ctx); return(wid); }
wxFontProperties::wxFontProperties(wxFont* font): m_ascent(0), m_descent(0), m_lineGap(0), m_lineSpacing(0), m_xHeight(0) { PangoContext* context = gdk_pango_context_get_for_screen( gdk_screen_get_default() ); PangoLayout* layout = pango_layout_new(context); // and use it if it's valid if ( font && font->Ok() ) { pango_layout_set_font_description ( layout, font->GetNativeFontInfo()->description ); } PangoFontMetrics* metrics = pango_context_get_metrics (context, font->GetNativeFontInfo()->description, NULL); int height = font->GetPixelSize().GetHeight(); m_ascent = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics)); m_descent = PANGO_PIXELS(pango_font_metrics_get_descent(metrics)); int h; const char* x = "x"; pango_layout_set_text( layout, x, strlen(x) ); pango_layout_get_pixel_size( layout, NULL, &h ); m_xHeight = h; m_lineGap = (m_ascent + m_descent) / 4; // FIXME: How can we calculate this via Pango? m_lineSpacing = m_ascent + m_descent; pango_font_metrics_unref(metrics); }
void SetUpStatusBarStuff (GtkWidget* aWindow) { _String fName = baseDirectory & "GTKResources/striped.xpm"; statusBarLayout = pango_layout_new (screenPContext); statusBarFontDesc = pango_font_description_new (); stripedFill = gdk_pixmap_create_from_xpm (GDK_DRAWABLE(aWindow->window), NULL, NULL, fName.sData); stripedFillGC = gdk_gc_new (GDK_DRAWABLE(aWindow->window)); if (stripedFill) { gdk_gc_set_fill (stripedFillGC,GDK_TILED); gdk_gc_set_tile (stripedFillGC,stripedFill); } else { printf ("Failed to load a status bar .xpm from %s\n", fName.sData); } gdk_gc_set_line_attributes (stripedFillGC, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER); GdkColor saveFG = {0,0,0,0}; gdk_gc_set_foreground (stripedFillGC, &saveFG); pango_font_description_set_family (statusBarFontDesc, statusBarFont.face.sData); pango_font_description_set_style (statusBarFontDesc, (statusBarFont.style & HY_FONT_ITALIC) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); pango_font_description_set_weight (statusBarFontDesc, (statusBarFont.style & HY_FONT_BOLD) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL); pango_font_description_set_size (statusBarFontDesc, statusBarFont.size*PANGO_SCALE); pango_layout_set_font_description (statusBarLayout, statusBarFontDesc ); // ref ? pango_layout_set_width (statusBarLayout, -1); redButtonIcon = (GdkPixbuf*)ProcureIconResource(4000); yellowButtonIcon = (GdkPixbuf*)ProcureIconResource(4001); greenButtonIcon = (GdkPixbuf*)ProcureIconResource(4002); orangeButtonIcon = (GdkPixbuf*)ProcureIconResource(4003); }