void draw_init_font_normal (drawctx_t *ctx) { pango_font_description_set_weight (ctx->font_style->font_desc, ctx->font_weight); pango_layout_set_font_description (ctx->pangolayout, ctx->font_style->font_desc); }
/*---------------------------------------------------------------------------------------------- Set up to draw text using the properties specified. super/subscript are ignored, as is baseline adjust; client is presumed to have handled them. Sets colors and HFONT. ----------------------------------------------------------------------------------------------*/ HRESULT VwGraphicsCairo::SetupGraphics(VwCharRenderProps * pchrp) { #if DEBUG if (m_loggingFile != NULL) { UnicodeString8 szFaceName(pchrp->szFaceName, (int)32); UnicodeString8 szFontVar(pchrp->szFontVar, (int)64); fprintf(m_loggingFile, "SetupGraphics %p %u %u %u %d %d %d %d %d %d %d %d %d \"%s\" \"%s\"\n", this, pchrp->clrFore, pchrp->clrBack, pchrp->clrUnder, pchrp->dympOffset, pchrp->ws, pchrp->fWsRtl, pchrp->nDirDepth, pchrp->ssv, pchrp->unt, pchrp->ttvBold, pchrp->ttvItalic, pchrp->dympHeight, szFaceName.c_str(), szFontVar.c_str()); fflush(m_loggingFile); } #endif BEGIN_COM_METHOD; CheckDc(); m_chrp = *pchrp; double fontSize = 0; // TODO-Linux: Work around for FWNX-179. // dympHeight should be in mp. const int tooSmall = 100; // A Converative hueristic of a small milli point value which means a invalid value has been specified. Assert(m_chrp.dympHeight >= tooSmall || m_chrp.dympHeight == 0); if (m_chrp.dympHeight < tooSmall) { fontSize = m_chrp.dympHeight; } else { fontSize = m_chrp.dympHeight * GetYInch() / kdzmpInch; } UnicodeString8 fontNameUtf8(pchrp->szFaceName); const char* fontName = fontNameUtf8.c_str(); if (pchrp->clrFore == kclrTransparent) { VwColor newCol; newCol.m_transparent = true; m_textColor = newCol; } else { VwColor newCol(pchrp->clrFore); m_textColor = newCol; } if (pchrp->clrBack == kclrTransparent) { VwColor newCol; newCol.m_transparent = true; m_textBackColor = newCol; } else { VwColor newCol(pchrp->clrBack); m_textBackColor = newCol; } m_pangoFontDescription = pango_font_description_new(); m_ascent = -1; m_descent = -1; pango_font_description_set_family(m_pangoFontDescription, fontName); pango_font_description_set_weight(m_pangoFontDescription, m_chrp.ttvBold == kttvOff ? PANGO_WEIGHT_NORMAL : PANGO_WEIGHT_BOLD); pango_font_description_set_style(m_pangoFontDescription, m_chrp.ttvItalic == kttvOff ? PANGO_STYLE_NORMAL : PANGO_STYLE_ITALIC); pango_font_description_set_absolute_size(m_pangoFontDescription, fontSize * PANGO_SCALE); END_COM_METHOD(g_fact, IID_IVwGraphics); }
static void file_list_ready_cb (GList *files, gpointer user_data) { MarlinFileConflictDialog *fcd = MARLIN_FILE_CONFLICT_DIALOG (user_data); GOFFile *src, *dest, *dest_dir; gboolean should_show_type; MarlinFileConflictDialogDetails *details; char *primary_text, *message, *secondary_text; const gchar *message_extra; char *label_text; GdkPixbuf *pixbuf; GtkWidget *label; GString *str; PangoFontDescription *desc; details = fcd->details; details->handle = NULL; dest_dir = g_list_nth_data (files, 0); dest = g_list_nth_data (files, 1); src = g_list_nth_data (files, 2); const gchar *src_ftype = gof_file_get_ftype (src); const gchar *dest_ftype = gof_file_get_ftype (dest); should_show_type = strcmp(src_ftype, dest_ftype); const gchar *dest_display_name = gof_file_get_display_name (dest); const gchar *dest_dir_display_name = gof_file_get_display_name (dest_dir); /* Set up the right labels */ if (dest->is_directory) { if (src->is_directory) { primary_text = g_strdup_printf (_("Merge folder \"%s\"?"), dest_display_name); message_extra = _("Merging will ask for confirmation before replacing any files in " "the folder that conflict with the files being copied."); if (src->modified > dest->modified) { message = g_strdup_printf ( _("An older folder with the same name already exists in \"%s\"."), dest_dir_display_name); } else if (src->modified < dest->modified) { message = g_strdup_printf ( _("A newer folder with the same name already exists in \"%s\"."), dest_dir_display_name); } else { message = g_strdup_printf ( _("Another folder with the same name already exists in \"%s\"."), dest_dir_display_name); } } else { message_extra = _("Replacing it will remove all files in the folder."); primary_text = g_strdup_printf (_("Replace folder \"%s\"?"), dest_display_name); message = g_strdup_printf (_("A folder with the same name already exists in \"%s\"."), dest_dir_display_name); } } else { primary_text = g_strdup_printf (_("Replace file \"%s\"?"), dest_display_name); message_extra = _("Replacing it will overwrite its content."); if (src->modified > dest->modified) { message = g_strdup_printf ( _("An older file with the same name already exists in \"%s\"."), dest_dir_display_name); } else if (src->modified < dest->modified) { message = g_strdup_printf ( _("A newer file with the same name already exists in \"%s\"."), dest_dir_display_name); } else { message = g_strdup_printf ( _("Another file with the same name already exists in \"%s\"."), dest_dir_display_name); } } secondary_text = g_strdup_printf ("%s\n%s", message, message_extra); g_free (message); label = gtk_label_new (primary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR); gtk_widget_set_size_request (label, 350, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_modify_font (label, NULL); desc = pango_font_description_new (); pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (desc, pango_font_description_get_size (gtk_widget_get_style (label)->font_desc) * PANGO_SCALE_LARGE); gtk_widget_modify_font (label, desc); pango_font_description_free (desc); gtk_widget_show (label); label = gtk_label_new (secondary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_widget_set_size_request (label, 350, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (primary_text); g_free (secondary_text); /* Set up file icons */ pixbuf = gof_file_get_icon_pixbuf (dest, FILE_ICON_SIZE_LARGE, TRUE, GOF_FILE_ICON_FLAGS_USE_THUMBNAILS); details->dest_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->first_hbox), details->dest_image, FALSE, FALSE, 0); gtk_widget_show (details->dest_image); g_object_unref (pixbuf); pixbuf = gof_file_get_icon_pixbuf (src, FILE_ICON_SIZE_LARGE, TRUE, GOF_FILE_ICON_FLAGS_USE_THUMBNAILS); details->src_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->second_hbox), details->src_image, FALSE, FALSE, 0); gtk_widget_show (details->src_image); g_object_unref (pixbuf); /* Set up labels */ label = gtk_label_new (NULL); str = g_string_new (NULL); g_string_append_printf (str, "<b>%s</b>\n", _("Original file")); g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), dest->format_size); if (should_show_type) { g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), dest_ftype); } g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), dest->formated_modified); label_text = str->str; gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->first_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_string_erase (str, 0, -1); /* Second label */ label = gtk_label_new (NULL); g_string_append_printf (str, "<b>%s</b>\n", _("Replace with")); g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), src->format_size); if (should_show_type) { g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), src_ftype); } g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), src->formated_modified); label_text = g_string_free (str, FALSE); gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->second_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (label_text); /* Populate the entry */ details->conflict_name = g_strdup (dest_display_name); gtk_entry_set_text (GTK_ENTRY (details->entry), details->conflict_name); if (src->is_directory && dest->is_directory) { gtk_button_set_label (GTK_BUTTON (details->replace_button), _("Merge")); } //TODO //marlin_file_monitor_add (src, fcd, MARLIN_FILE_ATTRIBUTES_FOR_ICON); //marlin_file_monitor_add (dest, fcd, MARLIN_FILE_ATTRIBUTES_FOR_ICON); details->src_handler_id = g_signal_connect (src, "changed", G_CALLBACK (file_icons_changed), fcd); details->dest_handler_id = g_signal_connect (dest, "changed", G_CALLBACK (file_icons_changed), fcd); }
static Bool textRenderTextToSurface (CompScreen *s, const char *text, TextSurfaceData *data, const CompTextAttrib *attrib) { int width, height, layoutWidth; pango_font_description_set_family (data->font, attrib->family); pango_font_description_set_absolute_size (data->font, attrib->size * PANGO_SCALE); pango_font_description_set_style (data->font, PANGO_STYLE_NORMAL); if (attrib->flags & CompTextFlagStyleBold) pango_font_description_set_weight (data->font, PANGO_WEIGHT_BOLD); if (attrib->flags & CompTextFlagStyleItalic) pango_font_description_set_style (data->font, PANGO_STYLE_ITALIC); pango_layout_set_font_description (data->layout, data->font); if (attrib->flags & CompTextFlagEllipsized) pango_layout_set_ellipsize (data->layout, PANGO_ELLIPSIZE_END); pango_layout_set_auto_dir (data->layout, FALSE); pango_layout_set_text (data->layout, text, -1); pango_layout_get_pixel_size (data->layout, &width, &height); if (attrib->flags & CompTextFlagWithBackground) { width += 2 * attrib->bgHMargin; height += 2 * attrib->bgVMargin; } width = MIN (attrib->maxWidth, width); height = MIN (attrib->maxHeight, height); /* update the size of the pango layout */ layoutWidth = attrib->maxWidth; if (attrib->flags & CompTextFlagWithBackground) layoutWidth -= 2 * attrib->bgHMargin; pango_layout_set_width (data->layout, layoutWidth * PANGO_SCALE); if (!textUpdateSurface (s, data, width, height)) return FALSE; pango_cairo_update_layout (data->cr, data->layout); cairo_save (data->cr); cairo_set_operator (data->cr, CAIRO_OPERATOR_CLEAR); cairo_paint (data->cr); cairo_restore (data->cr); cairo_set_operator (data->cr, CAIRO_OPERATOR_OVER); if (attrib->flags & CompTextFlagWithBackground) { textDrawTextBackground (data->cr, 0, 0, width, height, MIN (attrib->bgHMargin, attrib->bgVMargin)); cairo_set_source_rgba (data->cr, attrib->bgColor[0] / 65535.0, attrib->bgColor[1] / 65535.0, attrib->bgColor[2] / 65535.0, attrib->bgColor[3] / 65535.0); cairo_fill (data->cr); cairo_move_to (data->cr, attrib->bgHMargin, attrib->bgVMargin); } cairo_set_source_rgba (data->cr, attrib->color[0] / 65535.0, attrib->color[1] / 65535.0, attrib->color[2] / 65535.0, attrib->color[3] / 65535.0); pango_cairo_show_layout (data->cr, data->layout); return TRUE; }
GtkWidget * stroke_dialog_new (GimpItem *item, GimpContext *context, const gchar *title, const gchar *stock_id, const gchar *help_id, GtkWidget *parent) { GimpStrokeOptions *options; GimpStrokeOptions *saved_options; GimpImage *image; GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *radio_box; GtkWidget *cairo_radio; GtkWidget *paint_radio; GSList *group; GtkWidget *frame; g_return_val_if_fail (GIMP_IS_ITEM (item), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL); image = gimp_item_get_image (item); options = gimp_stroke_options_new (context->gimp, context, TRUE); saved_options = g_object_get_data (G_OBJECT (context->gimp), "saved-stroke-options"); if (saved_options) gimp_config_sync (G_OBJECT (saved_options), G_OBJECT (options), 0); dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (item), context, title, "gimp-stroke-options", stock_id, _("Choose Stroke Style"), parent, gimp_standard_help_func, help_id, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, stock_id, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); g_signal_connect (dialog, "response", G_CALLBACK (stroke_dialog_response), dialog); g_object_set_data (G_OBJECT (dialog), "gimp-item", item); g_object_set_data_full (G_OBJECT (dialog), "gimp-stroke-options", options, (GDestroyNotify) g_object_unref); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); radio_box = gimp_prop_enum_radio_box_new (G_OBJECT (options), "method", -1, -1); group = gtk_radio_button_get_group (g_object_get_data (G_OBJECT (radio_box), "radio-button")); cairo_radio = g_object_ref (group->next->data); gtk_container_remove (GTK_CONTAINER (radio_box), cairo_radio); paint_radio = g_object_ref (group->data); gtk_container_remove (GTK_CONTAINER (radio_box), paint_radio); g_object_ref_sink (radio_box); g_object_unref (radio_box); { PangoFontDescription *font_desc; font_desc = pango_font_description_new (); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (cairo_radio)), font_desc); gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (paint_radio)), font_desc); pango_font_description_free (font_desc); } /* the stroke frame */ frame = gimp_frame_new (NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_frame_set_label_widget (GTK_FRAME (frame), cairo_radio); g_object_unref (cairo_radio); { GtkWidget *stroke_editor; gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); stroke_editor = gimp_stroke_editor_new (options, yres, FALSE); gtk_container_add (GTK_CONTAINER (frame), stroke_editor); gtk_widget_show (stroke_editor); g_object_bind_property (cairo_radio, "active", stroke_editor, "sensitive", G_BINDING_SYNC_CREATE); } /* the paint tool frame */ frame = gimp_frame_new (NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_frame_set_label_widget (GTK_FRAME (frame), paint_radio); g_object_unref (paint_radio); { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *combo; GtkWidget *button; vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); g_object_bind_property (paint_radio, "active", vbox, "sensitive", G_BINDING_SYNC_CREATE); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Paint tool:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_container_combo_box_new (image->gimp->paint_info_list, GIMP_CONTEXT (options), 16, 0); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); g_object_set_data (G_OBJECT (dialog), "gimp-tool-menu", combo); button = gimp_prop_check_button_new (G_OBJECT (options), "emulate-brush-dynamics", _("_Emulate brush dynamics")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } return dialog; }
SetIconText(GtkStatusIcon *tray_icon, const char *text, const char *color) { // build background from image GdkPixbuf* special_icon = gdk_pixbuf_new_from_file("message-mail-new.png", NULL); // GError **error); GdkPixbuf *dest = gdk_pixbuf_copy(special_icon); int w=gdk_pixbuf_get_width(special_icon); int h=gdk_pixbuf_get_height(special_icon); // prepare colors/alpha GdkColormap* cmap=gdk_screen_get_system_colormap(gdk_screen_get_default()); int screen_depth=24; GdkVisual* visual = gdk_colormap_get_visual(cmap); screen_depth = visual->depth; GdkColor fore = { 0, 0, 0, 0 }; GdkColor alpha = { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF}; gdk_color_parse(color, &fore); if(fore.red==alpha.red && fore.green==alpha.green && fore.blue==alpha.blue) { alpha.red=0; // make sure alpha is different from fore } gdk_colormap_alloc_color (cmap, &fore, TRUE, TRUE); gdk_colormap_alloc_color (cmap, &alpha, TRUE, TRUE); // build pixmap with rectangle GdkPixmap *pm = gdk_pixmap_new (NULL, w, h, screen_depth); cairo_t *cr = gdk_cairo_create(pm); gdk_cairo_set_source_color(cr, &alpha); /* void gdk_cairo_set_source_color (cairo_t *cr, */ /* const GdkColor *color); */ cairo_rectangle(cr, 0, 0, w, h); /* void cairo_rectangle (cairo_t *cr, */ /* double x, */ /* double y, */ /* double width, */ /* double height); */ cairo_set_source_rgb(cr, 1, 1, 1); cairo_fill(cr); // build text GtkWidget *scratch = gtk_window_new(GTK_WINDOW_TOPLEVEL); PangoLayout *layout = gtk_widget_create_pango_layout(scratch, NULL); gtk_widget_destroy(scratch); PangoFontDescription *fnt = pango_font_description_from_string("Sans 18"); pango_font_description_set_weight (fnt,PANGO_WEIGHT_SEMIBOLD); pango_layout_set_spacing (layout,0); pango_layout_set_font_description (layout, fnt); pango_layout_set_text (layout, (gchar *)text,-1); int tw=0; int th=0; int sz; int border=4; pango_layout_get_pixel_size(layout, &tw, &th); while( (tw>w - border || th > h - border)) //fit text to the icon by decreasing font size { sz=pango_font_description_get_size (fnt); if(sz<MIN_FONT_SIZE) { sz=MIN_FONT_SIZE; break; } sz-=PANGO_SCALE; pango_font_description_set_size (fnt,sz); pango_layout_set_font_description (layout, fnt); pango_layout_get_pixel_size(layout, &tw, &th); } pango_font_description_free (fnt); // center text int px, py; px=(w-tw)/2; py=(h-th)/2; // draw text on pixmap gdk_cairo_set_source_color(cr, &fore); cairo_move_to (cr, px, py); pango_cairo_show_layout (cr, layout); cairo_destroy(cr); g_object_unref (layout); GdkPixbuf *buf = gdk_pixbuf_get_from_drawable (NULL, pm, NULL, 0, 0, 0, 0, w, h); g_object_unref (pm); GdkPixbuf *alpha_buf = gdk_pixbuf_add_alpha(buf, TRUE, (guchar)alpha.red, (guchar)alpha.green, (guchar)alpha.blue); g_object_unref (buf); //merge the rendered text on top gdk_pixbuf_composite(alpha_buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255); g_object_unref(alpha_buf); /* gdk_pixbuf_composite(buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255); */ /* g_object_unref(buf); */ gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(tray_icon), GDK_PIXBUF(dest)); }
static GnmFont * style_font_new_simple (PangoContext *context, char const *font_name, double size_pts, gboolean bold, gboolean italic) { GnmFont *font; GnmFont key; if (font_name == NULL) { g_warning ("font_name == NULL, using %s", DEFAULT_FONT); font_name = DEFAULT_FONT; } if (size_pts <= 0) { g_warning ("font_size <= 0, using %f", DEFAULT_SIZE); size_pts = DEFAULT_SIZE; } /* This cast does not mean we will change the name. */ key.font_name = (char *)font_name; key.size_pts = size_pts; key.is_bold = bold; key.is_italic = italic; key.context = context; font = (GnmFont *) g_hash_table_lookup (style_font_hash, &key); if (font == NULL) { PangoFontDescription *desc; PangoFont *pango_font; if (g_hash_table_lookup (style_font_negative_hash, &key)) return NULL; font = g_new0 (GnmFont, 1); font->font_name = g_strdup (font_name); font->size_pts = size_pts; font->is_bold = bold; font->is_italic = italic; font->context = g_object_ref (context); /* One reference for the cache, one for the caller. */ font->ref_count = 2; desc = pango_font_description_new (); pango_font_description_set_family (desc, font_name); pango_font_description_set_weight (desc, bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL); pango_font_description_set_style (desc, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); pango_font_description_set_size (desc, size_pts * PANGO_SCALE); pango_font = pango_context_load_font (context, desc); if (pango_font == NULL) { /* if we fail, try to be smart and map to something similar */ char const *sub = get_substitute_font (font_name); if (sub != NULL) { pango_font_description_set_family (desc, font_name); pango_font = pango_context_load_font (context, desc); } if (pango_font == NULL) { pango_font_description_free (desc); g_hash_table_insert (style_font_negative_hash, font, font); return NULL; } } if (pango_font) g_object_unref (pango_font); font->go.font = go_font_new_by_desc (desc); font->go.metrics = go_font_metrics_new (context, font->go.font); g_hash_table_insert (style_font_hash, font, font); } else font->ref_count++; #ifdef DEBUG_REF_COUNT g_message (__FUNCTION__ " font=%p name=%s%s%s ref_count=%d\n", font, font->font_name, font->is_bold ? " bold" : "", font->is_italic ? " italic" : "", font->ref_count); #endif return font; }
cairo_surface_t* render_text_to_surface (gchar* text, gint width, gint height, const cairo_font_options_t* font_opts, gdouble dpi) { cairo_surface_t* surface; cairo_t* cr; PangoFontDescription* desc; PangoLayout* layout; // sanity check if (!text || width <= 0 || height <= 0) return NULL; // create surface surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) return NULL; // create context cr = cairo_create (surface); if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (surface); return NULL; } // clear context cairo_scale (cr, 1.0f, 1.0f); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); // layout = pango_cairo_create_layout (cr); desc = pango_font_description_new (); pango_font_description_set_size (desc, 12 * PANGO_SCALE); pango_font_description_set_family_static (desc, "Candara"); pango_font_description_set_weight (desc, PANGO_WEIGHT_NORMAL); pango_font_description_set_style (desc, PANGO_STYLE_NORMAL); pango_layout_set_wrap (layout, PANGO_WRAP_WORD); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); pango_layout_set_width (layout, width * PANGO_SCALE); pango_layout_set_height (layout, height * PANGO_SCALE); pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); // print and layout string (pango-wise) pango_layout_set_text (layout, text, -1); // make sure system-wide font-options like hinting, antialiasing etc. // are taken into account pango_cairo_context_set_font_options (pango_layout_get_context (layout), font_opts); pango_cairo_context_set_resolution (pango_layout_get_context (layout), dpi); pango_layout_context_changed (layout); // draw pango-text to our cairo-context cairo_move_to (cr, 0.0f, 0.0f); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 1.0f); // this call leaks 3803 bytes, I've no idea how to fix that pango_cairo_show_layout (cr, layout); // clean up g_object_unref (layout); cairo_destroy (cr); return surface; }
static void input_dialog_create(gboolean is_password) { static PangoFontDescription *font_desc; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *cancel_button; GtkWidget *confirm_area; dialog = gtk_dialog_new(); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100); gtk_window_set_title(GTK_WINDOW(dialog), ""); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(dialog); vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (vbox), 14); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); /* for title label */ icon_q = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (icon_q), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), icon_q, FALSE, FALSE, 0); icon_p = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (icon_p), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), icon_p, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); msg_title = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5); gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT); gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE); gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0); gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE); if (!font_desc) { gint size; size = pango_font_description_get_size (gtk_widget_get_style(msg_title)->font_desc); font_desc = pango_font_description_new(); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (font_desc, size * PANGO_SCALE_LARGE); } if (font_desc) gtk_widget_modify_font(msg_title, font_desc); msg_label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(msg_label), 0, 0.5); gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 0); gtk_widget_show(msg_label); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(entry_activated), NULL); #if !GTK_CHECK_VERSION(2, 24, 0) combo = gtk_combo_box_entry_new_text(); #else combo = gtk_combo_box_text_new_with_entry(); #endif gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN((combo)))), "activate", G_CALLBACK(combo_activated), NULL); remember_checkbtn = gtk_check_button_new_with_label(_("Remember this")); gtk_box_pack_start(GTK_BOX(vbox), remember_checkbtn, FALSE, FALSE, 0); hbox = gtk_hbox_new(TRUE, 0); gtkut_stock_button_set_create(&confirm_area, &cancel_button, GTK_STOCK_CANCEL, &ok_button, GTK_STOCK_OK, NULL, NULL); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))), confirm_area, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); gtk_widget_hide(remember_checkbtn); if (is_password) gtk_widget_hide(icon_q); else gtk_widget_hide(icon_p); is_pass = is_password; gtk_widget_grab_default(ok_button); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(ok_clicked), NULL); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(cancel_clicked), NULL); }
bool TextSurface::render (const CompText::Attrib &attrib, const CompString &text) { int width, height, layoutWidth; if (!valid ()) return false; pango_font_description_set_family (font, attrib.family); pango_font_description_set_absolute_size (font, attrib.size * PANGO_SCALE); pango_font_description_set_style (font, PANGO_STYLE_NORMAL); if (attrib.flags & CompText::StyleBold) pango_font_description_set_weight (font, PANGO_WEIGHT_BOLD); if (attrib.flags & CompText::StyleItalic) pango_font_description_set_style (font, PANGO_STYLE_ITALIC); pango_layout_set_font_description (layout, font); if (attrib.flags & CompText::Ellipsized) pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); pango_layout_set_auto_dir (layout, false); pango_layout_set_text (layout, text.c_str (), -1); pango_layout_get_pixel_size (layout, &width, &height); if (attrib.flags & CompText::WithBackground) { width += 2 * attrib.bgHMargin; height += 2 * attrib.bgVMargin; } width = MIN (attrib.maxWidth, width); height = MIN (attrib.maxHeight, height); /* update the size of the pango layout */ layoutWidth = attrib.maxWidth; if (attrib.flags & CompText::WithBackground) layoutWidth -= 2 * attrib.bgHMargin; pango_layout_set_width (layout, layoutWidth * PANGO_SCALE); if (!update (width, height)) return false; pango_cairo_update_layout (cr, layout); cairo_save (cr); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_restore (cr); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); if (attrib.flags & CompText::WithBackground) { drawBackground (0, 0, width, height, MIN (attrib.bgHMargin, attrib.bgVMargin)); cairo_set_source_rgba (cr, attrib.bgColor[0] / 65535.0, attrib.bgColor[1] / 65535.0, attrib.bgColor[2] / 65535.0, attrib.bgColor[3] / 65535.0); cairo_fill (cr); cairo_move_to (cr, attrib.bgHMargin, attrib.bgVMargin); } cairo_set_source_rgba (cr, attrib.color[0] / 65535.0, attrib.color[1] / 65535.0, attrib.color[2] / 65535.0, attrib.color[3] / 65535.0); pango_cairo_show_layout (cr, layout); return true; }
static void set_font() { font_description = pango_font_description_new (); pango_font_description_set_family (font_description, "serif"); pango_font_description_set_weight (font_description, PANGO_WEIGHT_BOLD); pango_font_description_set_absolute_size (font_description, 32 * PANGO_SCALE); }
static void freetuxtv_cellrenderer_channelslist_render (GtkCellRenderer *cell, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, guint flags) #endif { FreetuxTVCellRendererChannelsList *self = FREETUXTV_CELLRENDERER_CHANNELSLIST (cell); gint width, height; PangoLayout *layout; gboolean is_selected = FALSE; gboolean is_playing = FALSE; if ((flags & GTK_CELL_RENDERER_SELECTED) != 0){ is_selected = TRUE; } if(self->type == CELLRENDERER_TYPE_CHANNEL){ if(self->is_playing){ is_playing = TRUE; } } #if GTK_API_VERSION == 3 // Set the cell state GtkStateFlags state = GTK_STATE_FLAG_NORMAL; if(is_selected){ if(self->type == CELLRENDERER_TYPE_CHANNEL){ state = GTK_STATE_FLAG_SELECTED; }else{ state = GTK_STATE_FLAG_ACTIVE; } } // Define the style of the row. GtkStyleContext *pStyleContext; pStyleContext = gtk_widget_get_style_context (GTK_WIDGET(widget)); gtk_style_context_save(pStyleContext); gtk_style_context_set_state(pStyleContext, state); if(self->type == CELLRENDERER_TYPE_CHANNEL){ gtk_style_context_add_class (pStyleContext, GTK_STYLE_CLASS_CELL); }else{ gtk_style_context_add_class (pStyleContext, GTK_STYLE_CLASS_BUTTON); } freetuxtv_cellrenderer_channelslist_get_preferred_width(cell, widget, NULL, &width); freetuxtv_cellrenderer_channelslist_get_preferred_height_for_width(cell, widget, width, NULL, &height); #else GtkStyle* pStyle; pStyle = widget->style; GtkStateType state; state = GTK_STATE_NORMAL; if(is_selected){ state = GTK_STATE_SELECTED; } freetuxtv_cellrenderer_channelslist_get_size (cell, widget, cell_area, NULL, NULL, &width, &height); #endif // Build the layout layout = gtk_widget_create_pango_layout (widget, self->name); //pango_layout_set_width(layout, 700); //pango_layout_set_height(layout, 20); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); if(is_playing){ PangoFontDescription *desc; desc = pango_font_description_new(); pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD); pango_font_description_set_style (desc, PANGO_STYLE_ITALIC); pango_layout_set_font_description (layout, desc); pango_font_description_free(desc); } // gtk_paint_flat_box (widget->style, window, GTK_STATE_SELECTED, // GTK_SHADOW_NONE , NULL, widget, // NULL, // 0, cell_area->y, // cell_area->x + width, cell_area->height); // gtk_paint_hline (widget->style, window, state, // NULL, widget, NULL, // 0, widget->allocation.width, cell_area->y); // gtk_paint_hline (widget->style, window, state, // NULL, widget, NULL, // cell_area->x, cell_area->width, cell_area->y + 2); // gtk_paint_hline (widget->style, window, state, // NULL, widget, NULL, // 0, 176, cell_area->y + 3); GdkPixbuf* logo; // If the cell contain a channel if(self->type == CELLRENDERER_TYPE_CHANNEL){ // Backgroung of the cell #if GTK_API_VERSION == 3 gtk_style_context_set_state (pStyleContext, state); // gtk_style_context_set_background (pStyleContext, window); // This block the main loop gtk_render_background (pStyleContext, cr, 0, cell_area->y, cell_area->x + width, cell_area->height); gtk_render_frame (pStyleContext, cr, 0, cell_area->y, cell_area->x + width, cell_area->height); #else if(state != GTK_STATE_NORMAL){ // gtk_style_set_background (pStyle, window, state); // This block the main loop gtk_style_apply_default_background (pStyle, window, TRUE, state, NULL, 0, cell_area->y, cell_area->x + width, cell_area->height); } #endif //static int count = 0; //count++; //g_print("cell(%d) : %d %d\n", count, cell_area->x, width); // Display the logo and text of the cell logo = gdk_pixbuf_new_from_file(self->logo, NULL); int cell_xpad; int cell_ypad; #if GTK_API_VERSION == 3 gtk_cell_renderer_get_padding (cell, &cell_xpad, &cell_ypad); // Render the logo gdk_cairo_set_source_pixbuf(cr, logo, (double)cell_xpad + 1.0, cell_area->y + (double)cell_ypad + 1.0); cairo_paint(cr); // Render the channel name gtk_render_layout (pStyleContext, cr, cell_xpad * 2 + gdk_pixbuf_get_width(logo) + 5, cell_area->y + 15, layout); #else cell_xpad = cell->xpad; cell_ypad = cell->ypad; // Render the logo gdk_draw_pixbuf (GDK_DRAWABLE(window), NULL, logo, 0, 0, cell_xpad + 1, cell_area->y + cell_ypad + 1, -1, -1, GDK_RGB_DITHER_NONE, 0,0); // Render the channel name gtk_paint_layout (widget->style, window, state, TRUE, NULL, widget, NULL, cell->xpad * 2 + gdk_pixbuf_get_width(logo) + 5, cell_area->y + 15, layout); #endif if(logo){ g_object_unref(logo); logo = NULL; } } // If the cell contain a group if(self->type == CELLRENDERER_TYPE_CHANNELS_GROUP){ #if GTK_API_VERSION == 3 int x = background_area->x; int y = background_area->y; width = background_area->width; height = background_area->height; // Background of the cell gtk_render_background (pStyleContext, cr, x, y, width, height); gtk_render_frame (pStyleContext, cr, x, y, width, height); //g_print("cell_bg %s : x=%d, y=%d\n", self->name, background_area->x, background_area->y); //g_print("cell %s : x=%d, y=%d, w=%d, h=%d\n", self->name, x, y, width, height); // Render the group name gtk_render_layout (pStyleContext, cr, cell_area->x, cell_area->y + 3, layout); #else // Background of the cell gtk_style_apply_default_background (widget->style, window, TRUE, state, NULL, 0, cell_area->y, cell_area->x + width, cell_area->height); // Render the group name gtk_paint_layout (widget->style, window, state, TRUE, NULL, widget, NULL, cell_area->x, cell_area->y + 3, layout); #endif } #if GTK_API_VERSION == 3 gtk_style_context_restore(pStyleContext); #endif }
/* preview_init */ static Preview * _preview_init(BrowserPluginHelper * helper) { Preview * preview; PangoFontDescription * font; GtkWidget * vbox; GtkWidget * widget; String const * p; if((preview = object_new(sizeof(*preview))) == NULL) return NULL; preview->helper = helper; preview->path = NULL; preview->source = 0; if((p = helper->config_get(helper->browser, "preview", "size")) != NULL) preview->view_image_how = strtol(p, NULL, 0); else preview->view_image_how = PREVIEW_IMAGE_HOW_FIT; /* widgets */ vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); preview->widget = vbox; /* toolbar */ preview->toolbar = gtk_toolbar_new(); gtk_widget_set_no_show_all(preview->toolbar, TRUE); /* mime */ preview->open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); g_signal_connect_swapped(preview->open, "clicked", G_CALLBACK( _preview_on_open), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->open, -1); preview->edit = gtk_tool_button_new_from_stock(GTK_STOCK_EDIT); g_signal_connect_swapped(preview->edit, "clicked", G_CALLBACK( _preview_on_edit), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->edit, -1); /* copy */ preview->copy = gtk_tool_button_new_from_stock(GTK_STOCK_COPY); g_signal_connect_swapped(preview->copy, "clicked", G_CALLBACK( _preview_on_copy), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->copy, -1); /* select all */ #if GTK_CHECK_VERSION(2, 10, 0) preview->select_all = gtk_tool_button_new_from_stock( GTK_STOCK_SELECT_ALL); #else widget = gtk_image_new_from_icon_name("edit-select-all", gtk_toolbar_get_icon_size(GTK_TOOLBAR( preview->toolbar))); preview->select_all = gtk_tool_button_new(widget, "Select all"); #endif g_signal_connect_swapped(preview->select_all, "clicked", G_CALLBACK( _preview_on_select_all), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->select_all, -1); /* zoom */ preview->zoom_100 = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_100); g_signal_connect_swapped(preview->zoom_100, "clicked", G_CALLBACK( _preview_on_zoom_100), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->zoom_100, -1); preview->zoom_fit = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_FIT); g_signal_connect_swapped(preview->zoom_fit, "clicked", G_CALLBACK( _preview_on_zoom_fit), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->zoom_fit, -1); preview->zoom_out = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_OUT); g_signal_connect_swapped(preview->zoom_out, "clicked", G_CALLBACK( _preview_on_zoom_out), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->zoom_out, -1); preview->zoom_in = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_IN); g_signal_connect_swapped(preview->zoom_in, "clicked", G_CALLBACK( _preview_on_zoom_in), preview); gtk_toolbar_insert(GTK_TOOLBAR(preview->toolbar), preview->zoom_in, -1); gtk_box_pack_start(GTK_BOX(vbox), preview->toolbar, FALSE, TRUE, 0); /* name */ preview->name = gtk_label_new(NULL); gtk_label_set_ellipsize(GTK_LABEL(preview->name), PANGO_ELLIPSIZE_MIDDLE); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(preview->name, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(preview->name), 0.0, 0.5); #endif font = pango_font_description_new(); pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(preview->name, font); #else gtk_widget_modify_font(preview->name, font); #endif pango_font_description_free(font); if((p = helper->config_get(helper->browser, "preview", "label")) != NULL && strtol(p, NULL, 0) == 0) gtk_widget_set_no_show_all(preview->name, TRUE); gtk_box_pack_start(GTK_BOX(vbox), preview->name, FALSE, TRUE, 0); /* image */ preview->view_image = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(preview->view_image), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_no_show_all(preview->view_image, TRUE); preview->view_image_image = gtk_image_new(); gtk_widget_show(preview->view_image_image); #if GTK_CHECK_VERSION(3, 0, 0) gtk_container_add(GTK_CONTAINER(preview->view_image), preview->view_image_image); #else gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(preview->view_image), preview->view_image_image); #endif preview->view_image_scale = 1.0; preview->view_image_height = -1; preview->view_image_width = -1; gtk_box_pack_start(GTK_BOX(vbox), preview->view_image, TRUE, TRUE, 0); /* text */ preview->view_text = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(preview->view_text), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_no_show_all(preview->view_text, TRUE); font = pango_font_description_new(); pango_font_description_set_family(font, "monospace"); widget = gtk_text_view_new(); preview->view_text_tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW( widget)); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(widget), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, font); #else gtk_widget_modify_font(widget, font); #endif gtk_widget_show(widget); pango_font_description_free(font); #if GTK_CHECK_VERSION(3, 0, 0) gtk_container_add(GTK_CONTAINER(preview->view_text), widget); #else gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW( preview->view_text), widget); #endif gtk_box_pack_start(GTK_BOX(vbox), preview->view_text, TRUE, TRUE, 0); gtk_widget_show_all(vbox); return preview; }
void *dt_control_expose(void *voidptr) { int width, height, pointerx, pointery; if(!darktable.gui->surface) return NULL; width = dt_cairo_image_surface_get_width(darktable.gui->surface); height = dt_cairo_image_surface_get_height(darktable.gui->surface); GtkWidget *widget = dt_ui_center(darktable.gui->ui); #if GTK_CHECK_VERSION(3, 20, 0) gdk_window_get_device_position(gtk_widget_get_window(widget), gdk_seat_get_pointer(gdk_display_get_default_seat(gtk_widget_get_display(widget))), &pointerx, &pointery, NULL); #else GdkDevice *device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget))); gdk_window_get_device_position(gtk_widget_get_window(widget), device, &pointerx, &pointery, NULL); #endif // create a gtk-independent surface to draw on cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(cst); // TODO: control_expose: only redraw the part not overlapped by temporary control panel show! // float tb = 8; // fmaxf(10, width/100.0); darktable.control->tabborder = tb; darktable.control->width = width; darktable.control->height = height; GdkRGBA color; GtkStyleContext *context = gtk_widget_get_style_context(widget); gboolean color_found = gtk_style_context_lookup_color (context, "bg_color", &color); if(!color_found) { color.red = 1.0; color.green = 0.0; color.blue = 0.0; color.alpha = 1.0; } gdk_cairo_set_source_rgba(cr, &color); cairo_set_line_width(cr, tb); cairo_rectangle(cr, tb / 2., tb / 2., width - tb, height - tb); cairo_stroke(cr); cairo_set_line_width(cr, 1.5); color_found = gtk_style_context_lookup_color (context, "really_dark_bg_color", &color); if(!color_found) { color.red = 1.0; color.green = 0.0; color.blue = 0.0; color.alpha = 1.0; } gdk_cairo_set_source_rgba(cr, &color); cairo_rectangle(cr, tb, tb, width - 2 * tb, height - 2 * tb); cairo_stroke(cr); cairo_save(cr); cairo_translate(cr, tb, tb); cairo_rectangle(cr, 0, 0, width - 2 * tb, height - 2 * tb); cairo_clip(cr); cairo_new_path(cr); // draw view dt_view_manager_expose(darktable.view_manager, cr, width - 2 * tb, height - 2 * tb, pointerx - tb, pointery - tb); cairo_restore(cr); // draw log message, if any dt_pthread_mutex_lock(&darktable.control->log_mutex); if(darktable.control->log_ack != darktable.control->log_pos) { PangoRectangle ink; PangoLayout *layout; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); const float fontsize = DT_PIXEL_APPLY_DPI(14); pango_font_description_set_absolute_size(desc, fontsize * PANGO_SCALE); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); layout = pango_cairo_create_layout(cr); pango_layout_set_font_description(layout, desc); pango_layout_set_text(layout, darktable.control->log_message[darktable.control->log_ack], -1); pango_layout_get_pixel_extents(layout, &ink, NULL); const float pad = DT_PIXEL_APPLY_DPI(20.0f), xc = width / 2.0; const float yc = height * 0.85 + DT_PIXEL_APPLY_DPI(10), wd = pad + ink.width * .5f; float rad = DT_PIXEL_APPLY_DPI(14); cairo_set_line_width(cr, 1.); cairo_move_to(cr, xc - wd, yc + rad); for(int k = 0; k < 5; k++) { cairo_arc(cr, xc - wd, yc, rad, M_PI / 2.0, 3.0 / 2.0 * M_PI); cairo_line_to(cr, xc + wd, yc - rad); cairo_arc(cr, xc + wd, yc, rad, 3.0 * M_PI / 2.0, M_PI / 2.0); cairo_line_to(cr, xc - wd, yc + rad); if(k == 0) { color_found = gtk_style_context_lookup_color (context, "selected_bg_color", &color); if(!color_found) { color.red = 1.0; color.green = 0.0; color.blue = 0.0; color.alpha = 1.0; } gdk_cairo_set_source_rgba(cr, &color); cairo_fill_preserve(cr); } cairo_set_source_rgba(cr, 0., 0., 0., 1.0 / (1 + k)); cairo_stroke(cr); rad += .5f; } color_found = gtk_style_context_lookup_color (context, "fg_color", &color); if(!color_found) { color.red = 1.0; color.green = 0.0; color.blue = 0.0; color.alpha = 1.0; } gdk_cairo_set_source_rgba(cr, &color); cairo_move_to(cr, xc - wd + .5f * pad, (yc + 1. / 3. * fontsize) - fontsize); pango_cairo_show_layout(cr, layout); pango_font_description_free(desc); g_object_unref(layout); } // draw busy indicator if(darktable.control->log_busy > 0) { PangoRectangle ink; PangoLayout *layout; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); const float fontsize = DT_PIXEL_APPLY_DPI(14); pango_font_description_set_absolute_size(desc, fontsize * PANGO_SCALE); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); layout = pango_cairo_create_layout(cr); pango_layout_set_font_description(layout, desc); pango_layout_set_text(layout, _("working.."), -1); pango_layout_get_pixel_extents(layout, &ink, NULL); const float xc = width / 2.0, yc = height * 0.85 - DT_PIXEL_APPLY_DPI(30), wd = ink.width * .5f; cairo_move_to(cr, xc - wd, yc + 1. / 3. * fontsize - fontsize); pango_cairo_layout_path(cr, layout); cairo_set_source_rgb(cr, 0.7, 0.7, 0.7); cairo_fill_preserve(cr); cairo_set_line_width(cr, 0.7); cairo_set_source_rgb(cr, 0.3, 0.3, 0.3); cairo_stroke(cr); pango_font_description_free(desc); g_object_unref(layout); } dt_pthread_mutex_unlock(&darktable.control->log_mutex); cairo_destroy(cr); cairo_t *cr_pixmap = cairo_create(darktable.gui->surface); cairo_set_source_surface(cr_pixmap, cst, 0, 0); cairo_paint(cr_pixmap); cairo_destroy(cr_pixmap); cairo_surface_destroy(cst); return NULL; }
static int _progress(Prefs * prefs, char * argv[]) { Progress p; struct stat st; GtkWidget * vbox; GtkWidget * hbox; GtkSizeGroup * left; GtkSizeGroup * right; GtkWidget * widget; PangoFontDescription * bold; char const * q; unsigned long id; memset(&p, 0, sizeof(p)); p.prefs = prefs; if(prefs->bufsiz == 0) errno = EINVAL; if(prefs->bufsiz == 0 || (p.buf = malloc(prefs->bufsiz)) == NULL) return _progress_error(&p, "malloc", 1); p.bufsiz = prefs->bufsiz; if(pipe(p.fds) != 0) return _progress_error(&p, "pipe", 1); if((p.pid = fork()) == -1) { close(p.fds[0]); close(p.fds[1]); return _progress_error(&p, "fork", 1); } if(p.pid != 0) return _progress_exec(&p, argv); close(p.fds[0]); if(gettimeofday(&p.tv, NULL) != 0) return _progress_error(&p, "gettimeofday", 1); if(prefs->filename == NULL) prefs->filename = _("Standard input"); else if((p.fd = open(prefs->filename, O_RDONLY)) < 0) return _progress_error(&p, prefs->filename, 1); else if(fstat(p.fd, &st) == 0 && S_ISREG(st.st_mode)) prefs->length = st.st_size; p.in_channel = g_io_channel_unix_new(p.fd); g_io_channel_set_encoding(p.in_channel, NULL, NULL); p.in_id = 0; g_idle_add(_progress_idle_in, &p); p.out_channel = g_io_channel_unix_new(p.fds[1]); g_io_channel_set_encoding(p.out_channel, NULL, NULL); p.out_id = 0; /* graphical interface */ if((prefs->flags & PREFS_x) == 0) { p.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); #if GTK_CHECK_VERSION(3, 0, 0) && !GTK_CHECK_VERSION(3, 14, 0) gtk_window_set_has_resize_grip(GTK_WINDOW(p.window), FALSE); #endif gtk_window_set_title(GTK_WINDOW(p.window), prefs->title != NULL ? prefs->title : _("Progress")); g_signal_connect_swapped(p.window, "delete-event", G_CALLBACK( _progress_closex), p.window); } else { p.window = gtk_plug_new(0); g_signal_connect_swapped(p.window, "embedded", G_CALLBACK( _progress_embedded), &p); } #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else vbox = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); #endif left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* file */ widget = gtk_label_new(_("File: ")); bold = pango_font_description_new(); pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); if((q = g_filename_to_utf8(prefs->filename, -1, NULL, NULL, NULL)) == NULL) q = prefs->filename; widget = gtk_label_new(q); gtk_label_set_ellipsize(GTK_LABEL(widget), PANGO_ELLIPSIZE_MIDDLE); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(right, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* done */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(_("Done: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); p.done = gtk_label_new(_("0.0 kB")); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(p.done, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(p.done), 0.0, 0.5); #endif gtk_size_group_add_widget(right, p.done); gtk_box_pack_start(GTK_BOX(hbox), p.done, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); /* remaining */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(_("Remaining: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); p.remaining = gtk_label_new(""); g_timeout_add(250, _progress_timeout, &p); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(p.remaining, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(p.remaining), 0.0, 0.5); #endif gtk_size_group_add_widget(right, p.remaining); gtk_box_pack_start(GTK_BOX(hbox), p.remaining, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); /* progress */ p.progress = gtk_progress_bar_new(); p.pulse = 0; if(prefs->prefix != NULL) { #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(prefs->prefix); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); gtk_size_group_add_widget(right, p.progress); gtk_box_pack_start(GTK_BOX(hbox), p.progress, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); } else gtk_box_pack_start(GTK_BOX(vbox), p.progress, TRUE, TRUE, 4); /* cancel */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif #if GTK_CHECK_VERSION(3, 10, 0) widget = gtk_button_new_with_label(_("Cancel")); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON)); #else widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL); #endif g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK( _progress_cancel), NULL); gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(p.window), vbox); gtk_container_set_border_width(GTK_CONTAINER(p.window), 4); gtk_widget_show_all(vbox); if((prefs->flags & PREFS_x) == 0) /* show the window */ gtk_widget_show(p.window); else { /* print the window ID and force a flush */ id = gtk_plug_get_id(GTK_PLUG(p.window)); printf("%lu\n", id); fclose(stdout); } gtk_main(); close(p.fd); close(p.fds[1]); return p.ret; }
FontPlatformData::FontPlatformData(const FontDescription& fontDescription, const UChar *characters, int length) : m_context(0) , m_font(0) , m_size(fontDescription.computedSize()) , m_syntheticBold(false) , m_syntheticOblique(false) , m_scaledFont(0) { FontPlatformData::init(); const UChar character = characters[0]; char const *family; switch (fontDescription.genericFamily()) { case FontDescription::SerifFamily: family = "serif"; break; case FontDescription::SansSerifFamily: family = "sans"; break; case FontDescription::MonospaceFamily: family = "monospace"; break; case FontDescription::NoFamily: case FontDescription::StandardFamily: default: family = "sans"; break; } m_context = pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(m_fontMap)); PangoFontDescription* description = pango_font_description_new(); pango_font_description_set_absolute_size(description, fontDescription.computedSize() * PANGO_SCALE); if (fontDescription.weight() >= FontWeight600) pango_font_description_set_weight(description, PANGO_WEIGHT_BOLD); if (fontDescription.italic()) pango_font_description_set_style(description, PANGO_STYLE_ITALIC); pango_font_description_set_family(description, family); pango_context_set_font_description(m_context, description); PangoFontset *fset = pango_font_map_load_fontset (m_fontMap, m_context, description, NULL); // Get the font from the fontset which contains the best glyph for this character m_font = pango_fontset_get_font(fset, (guint)character); #if PANGO_VERSION_CHECK(1,18,0) if (m_font) m_scaledFont = cairo_scaled_font_reference(pango_cairo_font_get_scaled_font(PANGO_CAIRO_FONT(m_font))); #else // This compatibility code for older versions of Pango is not well-tested. if (m_font) { PangoFcFont* fcfont = PANGO_FC_FONT(m_font); cairo_font_face_t* face = cairo_ft_font_face_create_for_pattern(fcfont->font_pattern); double size; if (FcPatternGetDouble(fcfont->font_pattern, FC_PIXEL_SIZE, 0, &size) != FcResultMatch) size = 12.0; cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_font_options_t* fontOptions; if (pango_cairo_context_get_font_options(m_context)) fontOptions = cairo_font_options_copy(pango_cairo_context_get_font_options(m_context)); else fontOptions = cairo_font_options_create(); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); m_scaledFont = cairo_scaled_font_create(face, &fontMatrix, &ctm, fontOptions); cairo_font_options_destroy(fontOptions); cairo_font_face_destroy(face); } #endif pango_font_description_free(description); }
guac_terminal_display* guac_terminal_display_alloc(guac_client* client, const char* font_name, int font_size, int dpi, int foreground, int background) { PangoFontMap* font_map; PangoFont* font; PangoFontMetrics* metrics; PangoContext* context; /* Allocate display */ guac_terminal_display* display = malloc(sizeof(guac_terminal_display)); display->client = client; /* Create default surface */ display->display_layer = guac_client_alloc_layer(client); display->select_layer = guac_client_alloc_layer(client); display->display_surface = guac_common_surface_alloc(client, client->socket, display->display_layer, 0, 0); /* Select layer is a child of the display layer */ guac_protocol_send_move(client->socket, display->select_layer, display->display_layer, 0, 0, 0); /* Get font */ display->font_desc = pango_font_description_new(); pango_font_description_set_family(display->font_desc, font_name); pango_font_description_set_weight(display->font_desc, PANGO_WEIGHT_NORMAL); pango_font_description_set_size(display->font_desc, font_size * PANGO_SCALE * dpi / 96); font_map = pango_cairo_font_map_get_default(); context = pango_font_map_create_context(font_map); font = pango_font_map_load_font(font_map, context, display->font_desc); if (font == NULL) { guac_client_abort(display->client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Unable to get font \"%s\"", font_name); return NULL; } metrics = pango_font_get_metrics(font, NULL); if (metrics == NULL) { guac_client_abort(display->client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Unable to get font metrics for font \"%s\"", font_name); return NULL; } display->default_foreground = display->glyph_foreground = foreground; display->default_background = display->glyph_background = background; /* Calculate character dimensions */ display->char_width = pango_font_metrics_get_approximate_digit_width(metrics) / PANGO_SCALE; display->char_height = (pango_font_metrics_get_descent(metrics) + pango_font_metrics_get_ascent(metrics)) / PANGO_SCALE; /* Initially empty */ display->width = 0; display->height = 0; display->operations = NULL; /* Initially nothing selected */ display->text_selected = display->selection_committed = false; return display; }
static gboolean _lib_histogram_draw_callback(GtkWidget *widget, cairo_t *crf, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_histogram_t *d = (dt_lib_histogram_t *)self->data; dt_develop_t *dev = darktable.develop; uint32_t *hist = dev->histogram; float hist_max = dev->histogram_type == DT_DEV_HISTOGRAM_LINEAR ? dev->histogram_max : logf(1.0 + dev->histogram_max); const int inset = DT_HIST_INSET; GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); int width = allocation.width, height = allocation.height; cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(cst); gtk_render_background(gtk_widget_get_style_context(widget), cr, 0, 0, allocation.width, allocation.height); cairo_translate(cr, 4 * inset, inset); width -= 2 * 4 * inset; height -= 2 * inset; if(d->mode_x == 0) { d->color_w = 0.06 * width; d->button_spacing = 0.01 * width; d->button_h = 0.06 * width; d->button_y = d->button_spacing; d->mode_w = d->color_w; d->mode_x = width - 3 * (d->color_w + d->button_spacing) - (d->mode_w + d->button_spacing); d->red_x = width - 3 * (d->color_w + d->button_spacing); d->green_x = width - 2 * (d->color_w + d->button_spacing); d->blue_x = width - (d->color_w + d->button_spacing); } // TODO: probably this should move to the configure-event callback! That would be future proof if we ever // (again) allow to resize the side panels. const gint stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); // this code assumes that the first expose comes before the first (preview) pipe is processed and that the // size of the widget doesn't change! if(dev->histogram_waveform_width == 0) { dev->histogram_waveform = (uint32_t *)calloc(height * stride / 4, sizeof(uint32_t)); dev->histogram_waveform_stride = stride; dev->histogram_waveform_height = height; dev->histogram_waveform_width = width; // return TRUE; // there are enough expose events following ... } #if 1 // draw shadow around float alpha = 1.0f; cairo_set_line_width(cr, 0.2); for(int k = 0; k < inset; k++) { cairo_rectangle(cr, -k, -k, width + 2 * k, height + 2 * k); cairo_set_source_rgba(cr, 0, 0, 0, alpha); alpha *= 0.5f; cairo_fill(cr); } cairo_set_line_width(cr, 1.0); #else cairo_set_line_width(cr, 1.0); cairo_set_source_rgb(cr, .1, .1, .1); cairo_rectangle(cr, 0, 0, width, height); cairo_stroke(cr); #endif cairo_rectangle(cr, 0, 0, width, height); cairo_clip(cr); cairo_set_source_rgb(cr, .3, .3, .3); cairo_rectangle(cr, 0, 0, width, height); cairo_fill(cr); if(d->highlight == 1) { cairo_set_source_rgb(cr, .5, .5, .5); cairo_rectangle(cr, 0, 0, .2 * width, height); cairo_fill(cr); } else if(d->highlight == 2) { cairo_set_source_rgb(cr, .5, .5, .5); cairo_rectangle(cr, 0.2 * width, 0, width, height); cairo_fill(cr); } // draw grid cairo_set_line_width(cr, .4); cairo_set_source_rgb(cr, .1, .1, .1); if(dev->histogram_type == DT_DEV_HISTOGRAM_WAVEFORM) dt_draw_waveform_lines(cr, 0, 0, width, height); else dt_draw_grid(cr, 4, 0, 0, width, height); if(hist_max > 0.0f) { cairo_save(cr); if(dev->histogram_type == DT_DEV_HISTOGRAM_WAVEFORM) { // make the color channel selector work: uint8_t *buf = (uint8_t *)malloc(sizeof(uint8_t) * height * stride); uint8_t mask[3] = { d->blue, d->green, d->red }; memcpy(buf, dev->histogram_waveform, sizeof(uint8_t) * height * stride); for(int y = 0; y < height; y++) for(int x = 0; x < width; x++) for(int k = 0; k < 3; k++) { buf[y * stride + x * 4 + k] *= mask[k]; } cairo_surface_t *source = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32, width, height, stride); cairo_set_source_surface(cr, source, 0.0, 0.0); cairo_set_operator(cr, CAIRO_OPERATOR_ADD); cairo_paint(cr); cairo_surface_destroy(source); free(buf); } else { // cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); cairo_translate(cr, 0, height); cairo_scale(cr, width / 63.0, -(height - 10) / hist_max); cairo_set_operator(cr, CAIRO_OPERATOR_ADD); // cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_set_line_width(cr, 1.); if(d->red) { cairo_set_source_rgba(cr, 1., 0., 0., 0.2); dt_draw_histogram_8(cr, hist, 0, dev->histogram_type == DT_DEV_HISTOGRAM_LINEAR); } if(d->green) { cairo_set_source_rgba(cr, 0., 1., 0., 0.2); dt_draw_histogram_8(cr, hist, 1, dev->histogram_type == DT_DEV_HISTOGRAM_LINEAR); } if(d->blue) { cairo_set_source_rgba(cr, 0., 0., 1., 0.2); dt_draw_histogram_8(cr, hist, 2, dev->histogram_type == DT_DEV_HISTOGRAM_LINEAR); } cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); // cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT); } cairo_restore(cr); } cairo_set_source_rgb(cr, .25, .25, .25); cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); PangoLayout *layout; PangoRectangle ink; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); layout = pango_cairo_create_layout(cr); pango_font_description_set_absolute_size(desc, .1 * height * PANGO_SCALE); pango_layout_set_font_description(layout, desc); char exifline[50]; dt_image_print_exif(&dev->image_storage, exifline, 50); pango_layout_set_text(layout, exifline, -1); pango_layout_get_pixel_extents(layout, &ink, NULL); cairo_move_to(cr, .02 * width, .98 * height - ink.height - ink.y); cairo_save(cr); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.0)); cairo_set_source_rgba(cr, 1, 1, 1, 0.3); pango_cairo_layout_path(cr, layout); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, .25, .25, .25); cairo_fill(cr); cairo_restore(cr); // buttons to control the display of the histogram: linear/log, r, g, b if(d->highlight != 0) { _draw_mode_toggle(cr, d->mode_x, d->button_y, d->mode_w, d->button_h, dev->histogram_type); cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 0.4); _draw_color_toggle(cr, d->red_x, d->button_y, d->color_w, d->button_h, d->red); cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 0.4); _draw_color_toggle(cr, d->green_x, d->button_y, d->color_w, d->button_h, d->green); cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 0.4); _draw_color_toggle(cr, d->blue_x, d->button_y, d->color_w, d->button_h, d->blue); } cairo_destroy(cr); cairo_set_source_surface(crf, cst, 0, 0); cairo_paint(crf); cairo_surface_destroy(cst); pango_font_description_free(desc); g_object_unref(layout); return TRUE; }
gboolean cd_do_render_listing_notification (gpointer pUserData, CDListing *pListing, cairo_t *pCairoContext) { //g_print ("%s ()\n", __func__); int iWidth = pListing->container.iWidth, iHeight = pListing->container.iHeight; int iLeftMargin = myDialogs.dialogTextDescription.iSize + 2, iRightMargin = (myDialogs.dialogTextDescription.iSize + 2) / 2; int iTopMargin = (myDialogs.dialogTextDescription.iSize + 2) + GAP, iBottomMargin = (myDialogs.dialogTextDescription.iSize + 2) * 4 + GAP; CDEntry *pEntry; // on dessine un cadre et un fond double fRadius = MIN (6, myDialogs.dialogTextDescription.iSize/2+1); double fLineWidth = 1.; cairo_set_line_width (pCairoContext, fLineWidth); cairo_save (pCairoContext); cairo_translate (pCairoContext, 0, fLineWidth); cairo_dock_draw_rounded_rectangle (pCairoContext, fRadius, fLineWidth, iWidth - 2 * fRadius - fLineWidth, iTopMargin - GAP); cairo_set_source_rgba (pCairoContext, .8, .8, 1., 1.); cairo_stroke_preserve (pCairoContext); cairo_set_source_rgba (pCairoContext, 1., 1., 1., .7); cairo_fill (pCairoContext); cairo_translate (pCairoContext, 0, iTopMargin + fLineWidth); cairo_dock_draw_rounded_rectangle (pCairoContext, fRadius, fLineWidth, iWidth - 2 * fRadius - fLineWidth, iHeight - iTopMargin - iBottomMargin - GAP); cairo_set_source_rgba (pCairoContext, .8, .8, 1., 1.); cairo_stroke_preserve (pCairoContext); cairo_set_source_rgba (pCairoContext, 1., 1., 1., .7); cairo_fill (pCairoContext); cairo_translate (pCairoContext, 0, iHeight - iTopMargin - 2*fLineWidth - iBottomMargin + GAP); cairo_dock_draw_rounded_rectangle (pCairoContext, fRadius, fLineWidth, iWidth - 2 * fRadius - fLineWidth, iBottomMargin - GAP - fLineWidth); cairo_set_source_rgba (pCairoContext, .8, .8, 1., 1.); cairo_stroke_preserve (pCairoContext); cairo_set_source_rgba (pCairoContext, 1., 1., 1., .7); cairo_fill (pCairoContext); cairo_restore (pCairoContext); PangoLayout *pLayout = pango_cairo_create_layout (pCairoContext); PangoFontDescription *pDesc = pango_font_description_new (); pango_font_description_set_absolute_size (pDesc, myDialogs.dialogTextDescription.iSize * PANGO_SCALE); pango_font_description_set_family_static (pDesc, myDialogs.dialogTextDescription.cFont); pango_font_description_set_weight (pDesc, myDialogs.dialogTextDescription.iWeight); pango_font_description_set_style (pDesc, myLabels.iconTextDescription.iStyle); pango_layout_set_font_description (pLayout, pDesc); pango_font_description_free (pDesc); // on dessine les entrees. if (pListing->pEntries != NULL) { // on dessine chaque entree. int iNbSteps = _listing_compute_nb_steps (pListing); // nb d'etapes pour l'apparition du texte. int iOffsetX = NB_STEPS_FOR_1_ENTRY - (iNbSteps - pListing->iAppearanceAnimationCount) - 1; if (pListing->iNbEntries >= myConfig.iNbLinesInListing) iOffsetX += myConfig.iNbLinesInListing/4*NB_STEPS_LATE; // permet de donner une transparence aux 25% dernieres lignes. double dx, dy, dm = myConfig.iNbLinesInListing * (myDialogs.dialogTextDescription.iSize + 2) / 2; dm = 0; dy = iTopMargin - pListing->fCurrentOffset + 1 + dm; double ymax = MIN (iTopMargin + pListing->iNbEntries * (myDialogs.dialogTextDescription.iSize + 2), iHeight - iBottomMargin); GList *e; for (e = pListing->pEntries; e != NULL; e = e->next) { if (iOffsetX >= NB_STEPS_FOR_1_ENTRY) // en dehors a droite a partir de celui-ci. break ; pEntry = e->data; if (pEntry->bHidden) continue ; dx = myDialogs.dialogTextDescription.iSize + 2; // marge a gauche. //if (iOffsetX > 0 && pListing->iAppearanceAnimationCount > 0) // dx += (double) iOffsetX * (iWidth - (myDialogs.dialogTextDescription.iSize + 2)) / NB_STEPS_FOR_1_ENTRY; dy += (myDialogs.dialogTextDescription.iSize + 2); while (dy + myDialogs.dialogTextDescription.iSize + 2 <= iTopMargin + 1) dy += pListing->iNbEntries * (myDialogs.dialogTextDescription.iSize + 2); while (dy > ymax) dy -= pListing->iNbEntries * (myDialogs.dialogTextDescription.iSize + 2); if (dy > ymax || dy + myDialogs.dialogTextDescription.iSize + 2 <= iTopMargin + 1) continue; cairo_save (pCairoContext); cairo_translate (pCairoContext, dx, dy); // on fait un clip si necessaire. if (dy + myDialogs.dialogTextDescription.iSize + 2 > iHeight - iBottomMargin || dy < iTopMargin) // cette entree n'est que partiellement visible. { if (dy < iTopMargin) // elle depasse en haut. cairo_rectangle (pCairoContext, -iLeftMargin, iTopMargin - dy, iWidth, myDialogs.dialogTextDescription.iSize + 2 -(iTopMargin - dy)); else // elle depasse en bas. cairo_rectangle (pCairoContext, -iLeftMargin, 0, iWidth, iHeight - iBottomMargin - dy); cairo_clip (pCairoContext); } // on dessine l'icone. if (pEntry->pIconSurface != NULL) { cairo_set_source_surface (pCairoContext, pEntry->pIconSurface, - iLeftMargin + 1, 0.); cairo_paint (pCairoContext); } // on souligne l'entree courante. if (e == pListing->pCurrentEntry) { double f = 1. - (double) pListing->iCurrentEntryAnimationCount / NB_STEPS_FOR_CURRENT_ENTRY; if (f != 0) { cairo_save (pCairoContext); double rx = .5*(iWidth - iLeftMargin - iRightMargin); double ry = .5*(myDialogs.dialogTextDescription.iSize + 2); cairo_pattern_t *pPattern = cairo_pattern_create_radial (ry, ry, 0., ry, ry, f * ry); cairo_pattern_set_extend (pPattern, CAIRO_EXTEND_NONE); cairo_pattern_add_color_stop_rgba (pPattern, 0., 0., 0., 1., .3); cairo_pattern_add_color_stop_rgba (pPattern, 1., 0., 0., 0., 0.); cairo_scale (pCairoContext, rx/ry, 1.); cairo_set_source (pCairoContext, pPattern); cairo_paint (pCairoContext); cairo_pattern_destroy (pPattern); cairo_restore (pCairoContext); // on dessine l'indicateur de sous-listing. if (pEntry->list != NULL) { cairo_set_source_rgba (pCairoContext, 0., 0., 0., f); cairo_move_to (pCairoContext, iWidth - iLeftMargin - iRightMargin, myDialogs.dialogTextDescription.iSize/4); cairo_rel_line_to (pCairoContext, iRightMargin, myDialogs.dialogTextDescription.iSize/4); cairo_rel_line_to (pCairoContext, -iRightMargin, myDialogs.dialogTextDescription.iSize/4); cairo_close_path (pCairoContext); cairo_stroke (pCairoContext); } } } // on dessine le texte. cairo_set_source_rgba (pCairoContext, 0., 0., 0., 1. - (double) iOffsetX / NB_STEPS_FOR_1_ENTRY); pango_layout_set_text (pLayout, pEntry->cName, -1); pango_cairo_show_layout (pCairoContext, pLayout); // on separe la 1ere entree de la derniere. if (e->prev == NULL) { cairo_set_source_rgba (pCairoContext, 0., 0., 0., .5); cairo_move_to (pCairoContext, 0., 1.); cairo_rel_line_to (pCairoContext, iWidth - iLeftMargin - iRightMargin, 0.); double dashes = 2.; cairo_set_dash (pCairoContext, &dashes, 1, 0.); cairo_stroke (pCairoContext); cairo_set_dash (pCairoContext, &dashes, 0, 0.); } cairo_restore (pCairoContext); iOffsetX += NB_STEPS_LATE; } // on dessine le chemin de l'entree courante. if (pListing->pCurrentEntry) { pEntry = pListing->pCurrentEntry->data; cairo_save (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); cairo_translate (pCairoContext, fRadius - pListing->iTitleOffset, 0.); pango_layout_set_text (pLayout, pEntry->cPath ? pEntry->cPath : pEntry->cName, -1); PangoRectangle ink, log; pango_layout_get_pixel_extents (pLayout, &ink, &log); pListing->iTitleWidth = ink.width; pango_cairo_show_layout (pCairoContext, pLayout); cairo_restore (pCairoContext); } } // on dessine l'etat de la recherche. cairo_translate (pCairoContext, 0, iHeight - iBottomMargin); cairo_set_source_surface (pCairoContext, myData.pScoobySurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); cairo_translate (pCairoContext, 2 * (myDialogs.dialogTextDescription.iSize + 2), GAP); if (myData.cStatus != NULL) { pango_layout_set_text (pLayout, myData.cStatus, -1); } pango_cairo_show_layout (pCairoContext, pLayout); // on dessine le filtre. cairo_translate (pCairoContext, 0., myDialogs.dialogTextDescription.iSize + 2); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_MATCH_CASE) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F1) Match case"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, iWidth/3, 0.); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_MUSIC) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F2) Music"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, iWidth/3, 0.); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_IMAGE) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F3) Image"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, -2*iWidth/3, myDialogs.dialogTextDescription.iSize + 2); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_VIDEO) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F4) Video"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, iWidth/3, 0.); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_TEXT) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F5) Text"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, iWidth/3, 0.); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_HTML) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F6) Html"), -1); pango_cairo_show_layout (pCairoContext, pLayout); cairo_translate (pCairoContext, -2*iWidth/3, myDialogs.dialogTextDescription.iSize + 2); cairo_set_source_surface (pCairoContext, (myData.iCurrentFilter & DO_TYPE_SOURCE) ? myData.pActiveButtonSurface : myData.pInactiveButtonSurface, 0., 0.); cairo_paint (pCairoContext); cairo_set_source_rgb (pCairoContext, 0., 0., 0.); pango_layout_set_text (pLayout, D_("(F7) Sources"), -1); pango_cairo_show_layout (pCairoContext, pLayout); g_object_unref (pLayout); }
static CVS * _cvs_init(BrowserPluginHelper * helper) { CVS * cvs; PangoFontDescription * font; GtkSizeGroup * group; GtkSizeGroup * bgroup; GtkWidget * widget; if((cvs = object_new(sizeof(*cvs))) == NULL) return NULL; cvs->helper = helper; cvs->filename = NULL; cvs->source = 0; /* widgets */ cvs->widget = gtk_vbox_new(FALSE, 4); font = pango_font_description_new(); pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD); group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); bgroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* label */ cvs->name = gtk_label_new(""); gtk_label_set_ellipsize(GTK_LABEL(cvs->name), PANGO_ELLIPSIZE_MIDDLE); gtk_misc_set_alignment(GTK_MISC(cvs->name), 0.0, 0.0); gtk_widget_modify_font(cvs->name, font); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->name, FALSE, TRUE, 0); cvs->status = gtk_label_new(""); gtk_label_set_ellipsize(GTK_LABEL(cvs->status), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment(GTK_MISC(cvs->status), 0.0, 0.0); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->status, FALSE, TRUE, 0); /* directory */ cvs->directory = gtk_vbox_new(FALSE, 4); widget = _init_label(group, _("Root:"), &cvs->d_root); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_label(group, _("Repository:"), &cvs->d_repository); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_label(group, _("Tag:"), &cvs->d_tag); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Request diff"), G_CALLBACK(_cvs_on_diff), cvs); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Annotate"), G_CALLBACK(_cvs_on_annotate), cvs); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("View log"), G_CALLBACK(_cvs_on_log), cvs); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_REFRESH, _("Update"), G_CALLBACK(_cvs_on_update), cvs); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_JUMP_TO, _("Commit"), G_CALLBACK(_cvs_on_commit), cvs); gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0); gtk_widget_show_all(cvs->directory); gtk_widget_set_no_show_all(cvs->directory, TRUE); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->directory, FALSE, TRUE, 0); /* file */ cvs->file = gtk_vbox_new(FALSE, 4); widget = _init_label(group, _("Revision:"), &cvs->f_revision); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Request diff"), G_CALLBACK(_cvs_on_diff), cvs); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Annotate"), G_CALLBACK(_cvs_on_annotate), cvs); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_INDEX, _("View log"), G_CALLBACK(_cvs_on_log), cvs); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_REFRESH, _("Update"), G_CALLBACK(_cvs_on_update), cvs); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); widget = _init_button(bgroup, GTK_STOCK_JUMP_TO, _("Commit"), G_CALLBACK(_cvs_on_commit), cvs); gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0); gtk_widget_show_all(cvs->file); gtk_widget_set_no_show_all(cvs->file, TRUE); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->file, FALSE, TRUE, 0); /* additional actions */ cvs->add = _init_button(bgroup, GTK_STOCK_ADD, _("Add to repository"), G_CALLBACK(_cvs_on_add), cvs); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->add, FALSE, TRUE, 0); cvs->make = _init_button(bgroup, GTK_STOCK_EXECUTE, _("Run make"), G_CALLBACK(_cvs_on_make), cvs); gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->make, FALSE, TRUE, 0); gtk_widget_show_all(cvs->widget); pango_font_description_free(font); /* tasks */ cvs->tasks = NULL; cvs->tasks_cnt = 0; return cvs; }
static void alertpanel_create(const gchar *title, const gchar *message, const gchar *button1_label, const gchar *button2_label, const gchar *button3_label, AlertFocus focus, gboolean can_disable, GtkWidget *custom_widget, gint alert_type) { static PangoFontDescription *font_desc; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *disable_checkbtn; GtkWidget *confirm_area; GtkWidget *button1; GtkWidget *button2; GtkWidget *button3; GtkWidget *focusbutton; const gchar *label2; const gchar *label3; gchar *tmp = title?g_markup_printf_escaped("%s", title) :g_strdup(""); gchar *title_full = g_strdup_printf("<span weight=\"bold\" " "size=\"larger\">%s</span>", tmp); g_free(tmp); debug_print("Creating alert panel dialog...\n"); dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), title); gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE); gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(alertpanel_deleted), (gpointer)G_ALERTCANCEL); g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(alertpanel_close), (gpointer)G_ALERTCANCEL); /* for title icon, label and message */ hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 12); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0); /* title icon */ switch (alert_type) { case ALERT_QUESTION: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); break; case ALERT_WARNING: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); break; case ALERT_ERROR: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); break; case ALERT_NOTICE: default: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); break; } gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new(title_full); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_label_set_use_markup(GTK_LABEL (label), TRUE); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); if (!font_desc) { gint size; size = pango_font_description_get_size (gtk_widget_get_style(label)->font_desc); font_desc = pango_font_description_new(); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (font_desc, size * PANGO_SCALE_LARGE); } if (font_desc) gtk_widget_modify_font(label, font_desc); g_free(title_full); label = gtk_label_new(message); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_widget_set_can_focus(label, FALSE); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); /* Claws: custom widget */ if (custom_widget) { gtk_box_pack_start(GTK_BOX(vbox), custom_widget, FALSE, FALSE, 0); } if (can_disable) { hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX( gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0); disable_checkbtn = gtk_check_button_new_with_label (_("Show this message next time")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_checkbtn), TRUE); gtk_box_pack_start(GTK_BOX(hbox), disable_checkbtn, FALSE, FALSE, 12); g_signal_connect(G_OBJECT(disable_checkbtn), "toggled", G_CALLBACK(alertpanel_button_toggled), GUINT_TO_POINTER(G_ALERTDISABLE)); } /* for button(s) */ if (!button1_label) button1_label = GTK_STOCK_OK; label2 = button2_label; label3 = button3_label; gtkut_stock_button_set_create(&confirm_area, &button1, button1_label, button2_label ? &button2 : NULL, label2, button3_label ? &button3 : NULL, label3); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))), confirm_area, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5); /* Set focus on correct button as requested. */ focusbutton = button1; switch (focus) { case ALERTFOCUS_SECOND: if (button2_label != NULL) focusbutton = button2; break; case ALERTFOCUS_THIRD: if (button3_label != NULL) focusbutton = button3; break; case ALERTFOCUS_FIRST: default: focusbutton = button1; break; } gtk_widget_grab_default(focusbutton); gtk_widget_grab_focus(focusbutton); g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTDEFAULT)); if (button2_label) g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTALTERNATE)); if (button3_label) g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTOTHER)); gtk_widget_show_all(dialog); }
static void file_list_ready_cb (GList *files, gpointer user_data) { CajaFileConflictDialog *fcd = user_data; CajaFile *src, *dest, *dest_dir; time_t src_mtime, dest_mtime; GtkDialog *dialog; gboolean source_is_dir, dest_is_dir, should_show_type; CajaFileConflictDialogDetails *details; char *primary_text, *message, *secondary_text; const gchar *message_extra; char *src_name, *dest_name, *dest_dir_name, *edit_name; char *label_text; char *size, *date, *type = NULL; GdkPixbuf *pixbuf; GtkWidget *label; GString *str; PangoFontDescription *desc; dialog = GTK_DIALOG (fcd); details = fcd->details; details->handle = NULL; dest_dir = g_list_nth_data (files, 0); dest = g_list_nth_data (files, 1); src = g_list_nth_data (files, 2); src_mtime = caja_file_get_mtime (src); dest_mtime = caja_file_get_mtime (dest); src_name = caja_file_get_display_name (src); dest_name = caja_file_get_display_name (dest); dest_dir_name = caja_file_get_display_name (dest_dir); source_is_dir = caja_file_is_directory (src); dest_is_dir = caja_file_is_directory (dest); type = caja_file_get_mime_type (dest); should_show_type = !caja_file_is_mime_type (src, type); g_free (type); type = NULL; /* Set up the right labels */ if (dest_is_dir) { if (source_is_dir) { primary_text = g_strdup_printf (_("Merge folder \"%s\"?"), dest_name); message_extra = _("Merging will ask for confirmation before replacing any files in " "the folder that conflict with the files being copied."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older folder with the same name already exists in \"%s\"."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer folder with the same name already exists in \"%s\"."), dest_dir_name); } else { message = g_strdup_printf ( _("Another folder with the same name already exists in \"%s\"."), dest_dir_name); } } else { message_extra = _("Replacing it will remove all files in the folder."); primary_text = g_strdup_printf (_("Replace folder \"%s\"?"), dest_name); message = g_strdup_printf (_("A folder with the same name already exists in \"%s\"."), dest_dir_name); } } else { primary_text = g_strdup_printf (_("Replace file \"%s\"?"), dest_name); message_extra = _("Replacing it will overwrite its content."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older file with the same name already exists in \"%s\"."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer file with the same name already exists in \"%s\"."), dest_dir_name); } else { message = g_strdup_printf ( _("Another file with the same name already exists in \"%s\"."), dest_dir_name); } } secondary_text = g_strdup_printf ("%s\n%s", message, message_extra); g_free (message); label = gtk_label_new (primary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR); gtk_widget_set_size_request (label, 350, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_modify_font (label, NULL); desc = pango_font_description_new (); pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (desc, pango_font_description_get_size (gtk_widget_get_style (label)->font_desc) * PANGO_SCALE_LARGE); gtk_widget_modify_font (label, desc); pango_font_description_free (desc); gtk_widget_show (label); label = gtk_label_new (secondary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_widget_set_size_request (label, 350, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (primary_text); g_free (secondary_text); /* Set up file icons */ pixbuf = caja_file_get_icon_pixbuf (dest, CAJA_ICON_SIZE_LARGE, TRUE, CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS); details->dest_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->first_hbox), details->dest_image, FALSE, FALSE, 0); gtk_widget_show (details->dest_image); g_object_unref (pixbuf); pixbuf = caja_file_get_icon_pixbuf (src, CAJA_ICON_SIZE_LARGE, TRUE, CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS); details->src_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->second_hbox), details->src_image, FALSE, FALSE, 0); gtk_widget_show (details->src_image); g_object_unref (pixbuf); /* Set up labels */ label = gtk_label_new (NULL); date = caja_file_get_string_attribute (dest, "date_modified"); size = caja_file_get_string_attribute (dest, "size"); if (should_show_type) { type = caja_file_get_string_attribute (dest, "type"); } str = g_string_new (NULL); g_string_append_printf (str, "<b>%s</b>\n", _("Original file")); g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type); } g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date); label_text = str->str; gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->first_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (type); g_free (date); g_string_erase (str, 0, -1); /* Second label */ label = gtk_label_new (NULL); date = caja_file_get_string_attribute (src, "date_modified"); size = caja_file_get_string_attribute (src, "size"); if (should_show_type) { type = caja_file_get_string_attribute (src, "type"); } g_string_append_printf (str, "<b>%s</b>\n", _("Replace with")); g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type); } g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date); label_text = g_string_free (str, FALSE); gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->second_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (date); g_free (type); g_free (label_text); /* Populate the entry */ edit_name = caja_file_get_edit_name (dest); details->conflict_name = edit_name; gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name); if (source_is_dir && dest_is_dir) { gtk_button_set_label (GTK_BUTTON (details->replace_button), _("Merge")); } /* If meld is installed, and source and destination arent binary * files, show the diff button */ gtk_widget_hide (details->diff_button); if (!source_is_dir && !dest_is_dir) { if (g_find_program_in_path ("meld")) { gboolean src_is_binary; gboolean dest_is_binary; src_is_binary = caja_file_is_binary (details->source); dest_is_binary = caja_file_is_binary (details->destination); if (!src_is_binary && !dest_is_binary) gtk_widget_show (details->diff_button); } } caja_file_monitor_add (src, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON); caja_file_monitor_add (dest, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON); details->src_handler_id = g_signal_connect (src, "changed", G_CALLBACK (file_icons_changed), fcd); details->dest_handler_id = g_signal_connect (dest, "changed", G_CALLBACK (file_icons_changed), fcd); }
static GLboolean glgdGraphNodeDrawLabel(glgdGraph *graph, glgdNode *node) { int i; GLint width; GLuint texture; GLfloat s0, s1, t0, t1; GLfloat a; guint32 alpha, rgb, *t; guint8 *row, *row_end; PangoContext *pangoContext; PangoFontDescription *fontDesc; PangoLayout *layout; PangoRectangle extents; FT_Bitmap bitmap; glgdVec2 center, pnt[2]; glgdStroke *stroke; glgdTexture *tex; if (graph && graph->pangoFT2Context) { stroke = &graph->stroke; tex = &graph->textTexture; if (tex->width <= 0 || tex->height <= 0) { glgdTrace(1, "Invalid texture dimension (%d,%d)\n", tex->width, tex->height); return GL_FALSE; } /* Pango font description */ width = 10 * _PANGO_SCALE; pangoContext = gtk_widget_get_pango_context(graph->gtkWindow); fontDesc = pango_context_get_font_description(pangoContext); pango_font_description_set_size(fontDesc, PANGO_SCALE * width); pango_font_description_set_weight(fontDesc, PANGO_WEIGHT_NORMAL); pango_context_set_font_description(graph->pangoFT2Context, fontDesc); /* Text layout */ width = (int)graph->dim[0] * _PANGO_SCALE; layout = graph->layout; pango_layout_set_width(layout, PANGO_SCALE * width); pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER); pango_layout_set_text(layout, node->label, -1); pango_layout_get_extents(layout, NULL, &extents); if (extents.width == 0 || extents.height == 0) { glgdTrace(1, "Invalid extents (%d,%d)\n", extents.width, extents.height); return GL_FALSE; } /* Bitmap creation */ bitmap.rows = PANGO_PIXELS(extents.height); bitmap.width = PANGO_PIXELS(extents.width); if (bitmap.width > tex->width || bitmap.rows > tex->height) { return GL_FALSE; } bitmap.pitch = bitmap.width; bitmap.buffer = GLGD_MALLOC(bitmap.rows * bitmap.width); bitmap.num_grays = 256; bitmap.pixel_mode = ft_pixel_mode_grays; memset(bitmap.buffer, 0, bitmap.rows * bitmap.width); pango_ft2_render_layout(&bitmap, layout, PANGO_PIXELS(-extents.x), 0); #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN rgb =((guint32)(stroke->col[0] * 255.0)) | (((guint32)(stroke->col[1] * 255.0)) << 8) | (((guint32)(stroke->col[2] * 255.0)) << 16); #else rgb =(((guint32)(stroke->col[0] * 255.0)) << 24) | (((guint32)(stroke->col[1] * 255.0)) << 16) | (((guint32)(stroke->col[2] * 255.0)) << 8); #endif /* Bitmap transfer to <glgdTexture> */ a = stroke->col[3]; alpha = (guint32)(255.0 * a); row = bitmap.buffer + bitmap.rows * bitmap.width; row_end = bitmap.buffer; t = (guint32 *)tex->texels; if (graph->flags & GLGDGRAPH_FLAG_PANGOBOLD) { do { row -= bitmap.width; for (i=0; i<bitmap.width; i++) { #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN if (row[i] > 0) *t++ = rgb | (alpha << 24); else *t++ = rgb; #else if (row[i] > 0) *t++ = rgb | alpha; else *t++ = rgb; #endif } } while (row != row_end); } else { do { row -= bitmap.width; for (i=0; i<bitmap.width; i++) { #if !defined(GL_VERSION_1_2) && G_BYTE_ORDER == G_LITTLE_ENDIAN *t++ = rgb | ((guint32)(a * row[i]) << 24); #else *t++ = rgb | (guint32)(a * row[i]); #endif } } while (row != row_end); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glBindTexture(GL_TEXTURE_2D, tex->name); #if !defined(GL_VERSION_1_2) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width, bitmap.rows, GL_RGBA, GL_UNSIGNED_BYTE, tex->texels); #else glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width, bitmap.rows, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, tex->texels); #endif /* <glgdTexture> render */ s0 = 0.0; s1 = (GLdouble)bitmap.width / (GLdouble)tex->width; t0 = 0.0; t1 = (GLdouble)bitmap.rows / (GLdouble)tex->height; center[0] = node->pos[0] + GLGD_HALF(graph->dim[0]); center[1] = node->pos[1] + GLGD_HALF(graph->dim[1]); pnt[0][0] = center[0] - GLGD_HALF(bitmap.width / _PANGO_SCALE); pnt[0][1] = center[1] - GLGD_HALF(bitmap.rows / _PANGO_SCALE); pnt[1][0] = center[0] + GLGD_HALF(bitmap.width / _PANGO_SCALE); pnt[1][1] = center[1] + GLGD_HALF(bitmap.rows / _PANGO_SCALE); GLGD_FREE(bitmap.buffer); glColor3d(stroke->col[0], stroke->col[1], stroke->col[2]); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_2D, tex->name); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glBegin(GL_QUADS); glTexCoord2f(s0, t0); glVertex3f(pnt[0][0], pnt[0][1], 0.0); glTexCoord2f(s0, t1); glVertex3f(pnt[0][0], pnt[1][1], 0.0); glTexCoord2f(s1, t1); glVertex3f(pnt[1][0], pnt[1][1], 0.0); glTexCoord2f(s1, t0); glVertex3f(pnt[1][0], pnt[0][1], 0.0); glEnd(); glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); return GL_TRUE; } return GL_FALSE; }
unsigned Gosu::pango::textWidth(const std::wstring& text, const std::wstring& fontFace, unsigned fontHeight, unsigned fontFlags) { g_type_init(); int dpi_x = 100, dpi_y = 100; context = pango_ft2_get_context(dpi_x, dpi_y); pango_context_set_language(context, pango_language_from_string ("en_US")); PangoDirection init_dir = PANGO_DIRECTION_LTR; pango_context_set_base_dir(context, init_dir); // static PangoFontDescription *font_description; font_description = pango_font_description_new(); pango_font_description_set_family(font_description, g_strdup(narrow(fontFace).c_str())); pango_font_description_set_style(font_description, (fontFlags & ffItalic) ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); pango_font_description_set_variant(font_description, PANGO_VARIANT_NORMAL); pango_font_description_set_weight(font_description, (fontFlags & ffBold) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL); pango_font_description_set_stretch(font_description, PANGO_STRETCH_NORMAL); int init_scale = int(fontHeight/2.0 + 0.5); pango_font_description_set_size(font_description, init_scale * PANGO_SCALE); pango_context_set_font_description(context, font_description); layout = pango_layout_new(context); if(fontFlags & ffUnderline) { // PangoAttribute *attr; attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE); attr->start_index = 0; attr->end_index = text.length(); // PangoAttrList* attrList; attrList = pango_attr_list_new(); pango_attr_list_insert(attrList, attr); pango_layout_set_attributes(layout, attrList); pango_attr_list_unref(attrList); } // IMPR: Catch errors? (Last NULL-Pointer) gchar* utf8Str = g_ucs4_to_utf8((gunichar*)text.c_str(), text.length(), NULL, NULL, NULL); pango_layout_set_text(layout, utf8Str, -1); g_free(utf8Str); PangoDirection base_dir = pango_context_get_base_dir(context); pango_layout_set_alignment(layout, base_dir == PANGO_DIRECTION_LTR ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT); pango_layout_set_width(layout, -1); PangoRectangle logical_rect; pango_layout_get_pixel_extents(layout, NULL, &logical_rect); height = logical_rect.height; width = logical_rect.width; return width; }
FontPlatformData::FontPlatformData(const FontDescription& fontDescription, const AtomicString& familyName) : m_context(0) , m_font(0) , m_size(fontDescription.computedSize()) , m_syntheticBold(false) , m_syntheticOblique(false) , m_scaledFont(0) { FontPlatformData::init(); CString stored_family = familyName.string().utf8(); char const* families[] = { stored_family.data(), NULL }; switch (fontDescription.genericFamily()) { case FontDescription::SerifFamily: families[1] = "serif"; break; case FontDescription::SansSerifFamily: families[1] = "sans"; break; case FontDescription::MonospaceFamily: families[1] = "monospace"; break; case FontDescription::NoFamily: case FontDescription::StandardFamily: default: families[1] = "sans"; break; } PangoFontDescription* description = pango_font_description_new(); pango_font_description_set_absolute_size(description, fontDescription.computedSize() * PANGO_SCALE); // FIXME: Map all FontWeight values to Pango font weights. if (fontDescription.weight() >= FontWeight600) pango_font_description_set_weight(description, PANGO_WEIGHT_BOLD); if (fontDescription.italic()) pango_font_description_set_style(description, PANGO_STYLE_ITALIC); #if PANGO_VERSION_CHECK(1,21,5) // deprecated in 1.21 m_context = pango_font_map_create_context(m_fontMap); #else m_context = pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(m_fontMap)); #endif for (unsigned int i = 0; !m_font && i < G_N_ELEMENTS(families); i++) { pango_font_description_set_family(description, families[i]); pango_context_set_font_description(m_context, description); m_font = pango_font_map_load_font(m_fontMap, m_context, description); } #if PANGO_VERSION_CHECK(1,18,0) if (m_font) m_scaledFont = cairo_scaled_font_reference(pango_cairo_font_get_scaled_font(PANGO_CAIRO_FONT(m_font))); #else // This compatibility code for older versions of Pango is not well-tested. if (m_font) { PangoFcFont* fcfont = PANGO_FC_FONT(m_font); cairo_font_face_t* face = cairo_ft_font_face_create_for_pattern(fcfont->font_pattern); double size; if (FcPatternGetDouble(fcfont->font_pattern, FC_PIXEL_SIZE, 0, &size) != FcResultMatch) size = 12.0; cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_font_options_t* fontOptions; if (pango_cairo_context_get_font_options(m_context)) fontOptions = cairo_font_options_copy(pango_cairo_context_get_font_options(m_context)); else fontOptions = cairo_font_options_create(); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); m_scaledFont = cairo_scaled_font_create(face, &fontMatrix, &ctm, fontOptions); cairo_font_options_destroy(fontOptions); cairo_font_face_destroy(face); } #endif pango_font_description_free(description); }
static void alertpanel_create(const gchar *title, const gchar *message, AlertType type, AlertValue default_value, gboolean can_disable, const gchar *button1_label, const gchar *button2_label, const gchar *button3_label) { static PangoFontDescription *font_desc; GtkWidget *image; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *disable_chkbtn; GtkWidget *confirm_area; GtkWidget *button1; GtkWidget *button2; GtkWidget *button3; const gchar *label2; const gchar *label3; debug_print(_("Creating alert panel dialog...\n")); dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), title); gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); manage_window_set_transient(GTK_WINDOW(dialog)); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_widget_realize(dialog); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(alertpanel_deleted), (gpointer)G_ALERTCANCEL); g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(alertpanel_close), (gpointer)G_ALERTCANCEL); g_signal_connect(G_OBJECT(dialog), "focus_out_event", G_CALLBACK(alertpanel_focus_out), NULL); /* for title icon, label and message */ hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 12); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); /* title icon */ switch (type) { case ALERT_QUESTION: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); break; case ALERT_WARNING: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); break; case ALERT_ERROR: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); break; case ALERT_NOTICE: default: image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); break; } gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); /* for title and message */ vbox = gtk_vbox_new(FALSE, 12); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); label = gtk_label_new(title); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); if (!font_desc) { gint size; size = pango_font_description_get_size (label->style->font_desc); font_desc = pango_font_description_new(); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (font_desc, size * PANGO_SCALE_LARGE); } if (font_desc) gtk_widget_modify_font(label, font_desc); /* message label */ label = gtk_label_new(message); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); GTK_WIDGET_UNSET_FLAGS(label, GTK_CAN_FOCUS); #ifdef G_OS_WIN32 { GtkStyle *style; style = gtk_widget_get_style(dialog); gtk_widget_modify_base(label, GTK_STATE_ACTIVE, &style->base[GTK_STATE_SELECTED]); gtk_widget_modify_text(label, GTK_STATE_ACTIVE, &style->text[GTK_STATE_SELECTED]); } #endif if (can_disable) { hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); disable_chkbtn = gtk_check_button_new_with_label (_("Show this message next time")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_chkbtn), TRUE); gtk_box_pack_start(GTK_BOX(hbox), disable_chkbtn, FALSE, FALSE, 12); g_signal_connect(G_OBJECT(disable_chkbtn), "toggled", G_CALLBACK(alertpanel_button_toggled), GUINT_TO_POINTER(G_ALERTDISABLE)); } /* for button(s) */ if (!button1_label) button1_label = GTK_STOCK_OK; label2 = button2_label; label3 = button3_label; if (label2 && *label2 == '+') label2++; if (label3 && *label3 == '+') label3++; gtkut_stock_button_set_create(&confirm_area, &button1, button1_label, button2_label ? &button2 : NULL, label2, button3_label ? &button3 : NULL, label3); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area), confirm_area, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5); gtk_widget_grab_default(button1); gtk_widget_grab_focus(button1); if (button2_label && (default_value == G_ALERTALTERNATE || *button2_label == '+')) { gtk_widget_grab_default(button2); gtk_widget_grab_focus(button2); } if (button3_label && (default_value == G_ALERTOTHER || *button3_label == '+')) { gtk_widget_grab_default(button3); gtk_widget_grab_focus(button3); } g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTDEFAULT)); if (button2_label) g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTALTERNATE)); if (button3_label) g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(alertpanel_button_clicked), GUINT_TO_POINTER(G_ALERTOTHER)); gtk_widget_show_all(dialog); }
Download * download_new(DownloadPrefs * prefs, char const * url) { Download * download; char * p; char buf[256]; GtkWidget * vbox; GtkWidget * hbox; GtkSizeGroup * left; GtkWidget * widget; PangoFontDescription * bold; unsigned long id; /* verify arguments */ if(prefs == NULL || url == NULL) { errno = EINVAL; _download_error(NULL, NULL, 1); return NULL; } if((download = malloc(sizeof(*download))) == NULL) { _download_error(NULL, "malloc", 1); return NULL; } /* initialize structure */ download->prefs.output = (prefs->output != NULL) ? strdup(prefs->output) : NULL; download->prefs.user_agent = (prefs->user_agent != NULL) ? strdup(prefs->user_agent) : NULL; if((p = _ghtml_make_url(NULL, url)) != NULL) url = p; download->url = strdup(url); free(p); if(download->url != NULL && prefs->output == NULL) download->prefs.output = strdup(basename(download->url)); download->conn = NULL; download->data_received = 0; download->content_length = 0; download->timeout = 0; download->pulse = 0; /* verify initialization */ if((prefs->output != NULL && download->prefs.output == NULL) || (prefs->user_agent != NULL && download->prefs.user_agent == NULL) || download->url == NULL || gettimeofday(&download->tv, NULL) != 0) { _download_error(NULL, "gettimeofday", 1); download_delete(download); return NULL; } /* window */ if(prefs->embedded == 0) { download->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); snprintf(buf, sizeof(buf), "%s %s", _("Download"), download->url); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(download->window), "stock_download"); #endif gtk_window_set_resizable(GTK_WINDOW(download->window), FALSE); gtk_window_set_title(GTK_WINDOW(download->window), buf); g_signal_connect_swapped(download->window, "delete-event", G_CALLBACK(_download_on_closex), download); } else { download->window = gtk_plug_new(0); g_signal_connect_swapped(download->window, "embedded", G_CALLBACK(_download_on_embedded), download); } #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); #else vbox = gtk_vbox_new(FALSE, 2); #endif bold = pango_font_description_new(); pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD); left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* address */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); #else hbox = gtk_hbox_new(FALSE, 4); #endif widget = gtk_label_new(_("Address: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); download->address = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(download->address), download->url); gtk_editable_set_editable(GTK_EDITABLE(download->address), FALSE); gtk_box_pack_start(GTK_BOX(hbox), download->address, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* labels */ _download_label(vbox, bold, left, _("File: "), &download->filename, download->prefs.output); _download_label(vbox, bold, left, _("Status: "), &download->status, _("Resolving...")); _download_label(vbox, bold, left, _("Received: "), &download->received, _("0.0 kB")); _download_label(vbox, bold, left, _("Remaining: "), &download->remaining, _("Unknown")); /* progress bar */ download->progress = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), download->progress, FALSE, FALSE, 0); /* checkbox */ download->check = gtk_check_button_new_with_label( _("Close window when the download is complete")); gtk_box_pack_start(GTK_BOX(vbox), download->check, FALSE, FALSE, 0); /* button */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); #else hbox = gtk_hbox_new(FALSE, 4); #endif download->cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped(download->cancel, "clicked", G_CALLBACK( _download_on_cancel), download); gtk_box_pack_end(GTK_BOX(hbox), download->cancel, FALSE, TRUE, 0); download->browse = gtk_button_new_with_mnemonic("_Open folder"); gtk_widget_set_no_show_all(download->browse, TRUE); widget = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(download->browse), widget); g_signal_connect_swapped(download->browse, "clicked", G_CALLBACK( _download_on_browse), download); gtk_box_pack_end(GTK_BOX(hbox), download->browse, FALSE, TRUE, 0); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(download->window), 4); gtk_container_add(GTK_CONTAINER(download->window), vbox); download->timeout = g_idle_add(_download_on_idle, download); _download_refresh(download); gtk_widget_show_all(vbox); if(prefs->embedded == 0) gtk_widget_show(download->window); else { id = gtk_plug_get_id(GTK_PLUG(download->window)); printf("%lu\n", id); fclose(stdout); } _download_cnt++; return download; }
static gboolean lowlight_draw(GtkWidget *widget, cairo_t *crf, gpointer user_data) { dt_iop_module_t *self = (dt_iop_module_t *)user_data; dt_iop_lowlight_gui_data_t *c = (dt_iop_lowlight_gui_data_t *)self->gui_data; dt_iop_lowlight_params_t p = *(dt_iop_lowlight_params_t *)self->params; dt_draw_curve_set_point(c->transition_curve, 0, p.transition_x[DT_IOP_LOWLIGHT_BANDS - 2] - 1.0, p.transition_y[0]); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) dt_draw_curve_set_point(c->transition_curve, k + 1, p.transition_x[k], p.transition_y[k]); dt_draw_curve_set_point(c->transition_curve, DT_IOP_LOWLIGHT_BANDS + 1, p.transition_x[1] + 1.0, p.transition_y[DT_IOP_LOWLIGHT_BANDS - 1]); const int inset = DT_IOP_LOWLIGHT_INSET; GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); int width = allocation.width, height = allocation.height; cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(cst); cairo_set_source_rgb(cr, .2, .2, .2); cairo_paint(cr); cairo_translate(cr, inset, inset); width -= 2 * inset; height -= 2 * inset; cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.0)); cairo_set_source_rgb(cr, .1, .1, .1); cairo_rectangle(cr, 0, 0, width, height); cairo_stroke(cr); cairo_set_source_rgb(cr, .3, .3, .3); cairo_rectangle(cr, 0, 0, width, height); cairo_fill(cr); // draw grid cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(.4)); cairo_set_source_rgb(cr, .1, .1, .1); dt_draw_grid(cr, 8, 0, 0, width, height); if(c->mouse_y > 0 || c->dragging) { // draw min/max curves: dt_iop_lowlight_get_params(&p, c->mouse_x, 1., c->mouse_radius); dt_draw_curve_set_point(c->transition_curve, 0, p.transition_x[DT_IOP_LOWLIGHT_BANDS - 2] - 1.0, p.transition_y[0]); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) dt_draw_curve_set_point(c->transition_curve, k + 1, p.transition_x[k], p.transition_y[k]); dt_draw_curve_set_point(c->transition_curve, DT_IOP_LOWLIGHT_BANDS + 1, p.transition_x[1] + 1.0, p.transition_y[DT_IOP_LOWLIGHT_BANDS - 1]); dt_draw_curve_calc_values(c->transition_curve, 0.0, 1.0, DT_IOP_LOWLIGHT_RES, c->draw_min_xs, c->draw_min_ys); p = *(dt_iop_lowlight_params_t *)self->params; dt_iop_lowlight_get_params(&p, c->mouse_x, .0, c->mouse_radius); dt_draw_curve_set_point(c->transition_curve, 0, p.transition_x[DT_IOP_LOWLIGHT_BANDS - 2] - 1.0, p.transition_y[0]); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) dt_draw_curve_set_point(c->transition_curve, k + 1, p.transition_x[k], p.transition_y[k]); dt_draw_curve_set_point(c->transition_curve, DT_IOP_LOWLIGHT_BANDS + 1, p.transition_x[1] + 1.0, p.transition_y[DT_IOP_LOWLIGHT_BANDS - 1]); dt_draw_curve_calc_values(c->transition_curve, 0.0, 1.0, DT_IOP_LOWLIGHT_RES, c->draw_max_xs, c->draw_max_ys); } cairo_save(cr); // draw x positions cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.)); const float arrw = DT_PIXEL_APPLY_DPI(7.0f); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) { cairo_move_to(cr, width * p.transition_x[k], height + inset - DT_PIXEL_APPLY_DPI(1)); cairo_rel_line_to(cr, -arrw * .5f, 0); cairo_rel_line_to(cr, arrw * .5f, -arrw); cairo_rel_line_to(cr, arrw * .5f, arrw); cairo_close_path(cr); if(c->x_move == k) cairo_fill(cr); else cairo_stroke(cr); } // draw selected cursor cairo_translate(cr, 0, height); // cairo_set_operator(cr, CAIRO_OPERATOR_ADD); // cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.)); cairo_set_source_rgba(cr, .7, .7, .7, 1.0); p = *(dt_iop_lowlight_params_t *)self->params; dt_draw_curve_set_point(c->transition_curve, 0, p.transition_x[DT_IOP_LOWLIGHT_BANDS - 2] - 1.0, p.transition_y[0]); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) dt_draw_curve_set_point(c->transition_curve, k + 1, p.transition_x[k], p.transition_y[k]); dt_draw_curve_set_point(c->transition_curve, DT_IOP_LOWLIGHT_BANDS + 1, p.transition_x[1] + 1.0, p.transition_y[DT_IOP_LOWLIGHT_BANDS - 1]); dt_draw_curve_calc_values(c->transition_curve, 0.0, 1.0, DT_IOP_LOWLIGHT_RES, c->draw_xs, c->draw_ys); cairo_move_to(cr, 0 * width / (float)(DT_IOP_LOWLIGHT_RES - 1), -height * c->draw_ys[0]); for(int k = 1; k < DT_IOP_LOWLIGHT_RES; k++) cairo_line_to(cr, k * width / (float)(DT_IOP_LOWLIGHT_RES - 1), -height * c->draw_ys[k]); cairo_stroke(cr); // draw dots on knots cairo_set_source_rgb(cr, 0.7, 0.7, 0.7); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.)); for(int k = 0; k < DT_IOP_LOWLIGHT_BANDS; k++) { cairo_arc(cr, width * p.transition_x[k], -height * p.transition_y[k], DT_PIXEL_APPLY_DPI(3.0), 0.0, 2.0 * M_PI); if(c->x_move == k) cairo_fill(cr); else cairo_stroke(cr); } if(c->mouse_y > 0 || c->dragging) { // draw min/max, if selected cairo_set_source_rgba(cr, .7, .7, .7, .6); cairo_move_to(cr, 0, -height * c->draw_min_ys[0]); for(int k = 1; k < DT_IOP_LOWLIGHT_RES; k++) cairo_line_to(cr, k * width / (float)(DT_IOP_LOWLIGHT_RES - 1), -height * c->draw_min_ys[k]); for(int k = DT_IOP_LOWLIGHT_RES - 1; k >= 0; k--) cairo_line_to(cr, k * width / (float)(DT_IOP_LOWLIGHT_RES - 1), -height * c->draw_max_ys[k]); cairo_close_path(cr); cairo_fill(cr); // draw mouse focus circle cairo_set_source_rgba(cr, .9, .9, .9, .5); const float pos = DT_IOP_LOWLIGHT_RES * c->mouse_x; int k = (int)pos; const float f = k - pos; if(k >= DT_IOP_LOWLIGHT_RES - 1) k = DT_IOP_LOWLIGHT_RES - 2; float ht = -height * (f * c->draw_ys[k] + (1 - f) * c->draw_ys[k + 1]); cairo_arc(cr, c->mouse_x * width, ht, c->mouse_radius * width, 0, 2. * M_PI); cairo_stroke(cr); } cairo_restore(cr); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); // draw labels: PangoLayout *layout; PangoRectangle ink; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); pango_font_description_set_absolute_size(desc,(.06 * height) * PANGO_SCALE); layout = pango_cairo_create_layout(cr); pango_layout_set_font_description(layout, desc); cairo_set_source_rgb(cr, .1, .1, .1); pango_layout_set_text(layout, _("dark"), -1); pango_layout_get_pixel_extents(layout, &ink, NULL); cairo_move_to(cr, .02 * width - ink.y, .5 * (height + ink.width)); cairo_save(cr); cairo_rotate(cr, -M_PI * .5f); pango_cairo_show_layout(cr, layout); cairo_restore(cr); pango_layout_set_text(layout, _("bright"), -1); pango_layout_get_pixel_extents(layout, &ink, NULL); cairo_move_to(cr, .98 * width - ink.height, .5 * (height + ink.width)); cairo_save(cr); cairo_rotate(cr, -M_PI * .5f); pango_cairo_show_layout(cr, layout); cairo_restore(cr); pango_layout_set_text(layout, _("day vision"), -1); pango_layout_get_pixel_extents(layout, &ink, NULL); cairo_move_to(cr, .5 * (width - ink.width), .08 * height - ink.height); pango_cairo_show_layout(cr, layout); pango_layout_set_text(layout, _("night vision"), -1); pango_layout_get_pixel_extents(layout, &ink, NULL); cairo_move_to(cr, .5 * (width - ink.width), .97 * height - ink.height); pango_cairo_show_layout(cr, layout); pango_font_description_free(desc); g_object_unref(layout); cairo_destroy(cr); cairo_set_source_surface(crf, cst, 0, 0); cairo_paint(crf); cairo_surface_destroy(cst); return TRUE; }
static void draw_cell (Hitori *hitori, GtkStyleContext *style_context, cairo_t *cr, gfloat cell_size, gdouble x_pos, gdouble y_pos, HitoriVector iter) { gchar *text; PangoLayout *layout; gint text_width, text_height; GtkStateFlags state; gboolean painted = FALSE; PangoFontDescription *font_desc; GtkBorder border; GdkRGBA colour = {0.0, 0.0, 0.0, 0.0}; state = gtk_style_context_get_state (style_context); if (hitori->board[iter.x][iter.y].status & CELL_PAINTED) { painted = TRUE; state = GTK_STATE_FLAG_INSENSITIVE; gtk_style_context_set_state (style_context, state); } /* Set up the border */ gtk_style_context_get_border (style_context, state, &border); border.left = BORDER_LEFT; /* Hack! */ /* Draw the fill */ if (hitori->debug == TRUE) { g_debug ("State: %u", state); } if (painted) { lookup_color (style_context, "painted-bg-color", &colour); } else { lookup_color (style_context, "unpainted-bg-color", &colour); } gdk_cairo_set_source_rgba (cr, &colour); cairo_rectangle (cr, x_pos, y_pos, cell_size, cell_size); cairo_fill (cr); /* If the cell is tagged, draw the tag dots */ if (hitori->board[iter.x][iter.y].status & CELL_TAG1) { if (painted) { lookup_color (style_context, "tag1-painted-color", &colour); } else { lookup_color (style_context, "tag1-unpainted-color", &colour); } gdk_cairo_set_source_rgba (cr, &colour); cairo_move_to (cr, x_pos, y_pos + TAG_OFFSET); cairo_line_to (cr, x_pos, y_pos); cairo_line_to (cr, x_pos + TAG_OFFSET, y_pos); cairo_arc (cr, x_pos + TAG_OFFSET, y_pos + TAG_OFFSET, TAG_RADIUS * cell_size, 0.0, 0.5 * M_PI); cairo_fill (cr); } if (hitori->board[iter.x][iter.y].status & CELL_TAG2) { if (painted) { lookup_color (style_context, "tag2-painted-color", &colour); } else { lookup_color (style_context, "tag2-unpainted-color", &colour); } gdk_cairo_set_source_rgba (cr, &colour); cairo_move_to (cr, x_pos + cell_size - TAG_OFFSET, y_pos); cairo_line_to (cr, x_pos + cell_size, y_pos); cairo_line_to (cr, x_pos + cell_size, y_pos + TAG_OFFSET); cairo_arc (cr, x_pos + cell_size - TAG_OFFSET, y_pos + TAG_OFFSET, TAG_RADIUS * cell_size, 0.5 * M_PI, 1.0 * M_PI); cairo_fill (cr); } /* Draw the border */ if (painted) { lookup_color (style_context, "painted-border-color", &colour); } else { lookup_color (style_context, "unpainted-border-color", &colour); } gdk_cairo_set_source_rgba (cr, &colour); cairo_set_line_width (cr, border.left); cairo_rectangle (cr, x_pos, y_pos, cell_size, cell_size); cairo_stroke (cr); /* Draw the text */ text = g_strdup_printf ("%u", hitori->board[iter.x][iter.y].num); layout = pango_cairo_create_layout (cr); pango_layout_set_text (layout, text, -1); font_desc = (painted == TRUE) ? hitori->painted_font_desc : hitori->normal_font_desc; if (hitori->board[iter.x][iter.y].status & CELL_ERROR) { lookup_color (style_context, "mistaken-number-color", &colour); gdk_cairo_set_source_rgba (cr, &colour); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); } else if (painted) { lookup_color (style_context, "painted-number-color", &colour); gdk_cairo_set_source_rgba (cr, &colour); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_NORMAL); } else { g_assert (!painted); lookup_color (style_context, "unpainted-number-color", &colour); gdk_cairo_set_source_rgba (cr, &colour); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_NORMAL); } pango_layout_set_font_description (layout, font_desc); pango_layout_get_pixel_size (layout, &text_width, &text_height); cairo_move_to (cr, x_pos + (cell_size - text_width) / 2, y_pos + (cell_size - text_height) / 2); pango_cairo_show_layout (cr, layout); g_free (text); g_object_unref (layout); }
static gboolean _lib_navigation_draw_callback(GtkWidget *widget, cairo_t *crf, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data; const int inset = DT_NAVIGATION_INSET; GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); int width = allocation.width, height = allocation.height; dt_develop_t *dev = darktable.develop; /* double buffering of image data: only take new data if valid */ if(dev->preview_pipe->backbuf && dev->preview_status == DT_DEV_PIXELPIPE_VALID) { /* re-allocate in case of changed image dimensions */ if(d->buffer == NULL || dev->preview_pipe->backbuf_width != d->wd || dev->preview_pipe->backbuf_height != d->ht) { g_free(d->buffer); d->wd = dev->preview_pipe->backbuf_width; d->ht = dev->preview_pipe->backbuf_height; d->buffer = g_malloc0((size_t)d->wd * d->ht * 4 * sizeof(unsigned char)); } /* update buffer if new data is available */ if(d->buffer && dev->preview_pipe->input_timestamp > d->timestamp) { dt_pthread_mutex_t *mutex = &dev->preview_pipe->backbuf_mutex; dt_pthread_mutex_lock(mutex); memcpy(d->buffer, dev->preview_pipe->backbuf, (size_t)d->wd * d->ht * 4 * sizeof(unsigned char)); d->timestamp = dev->preview_pipe->input_timestamp; dt_pthread_mutex_unlock(mutex); } } /* get the current style */ cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cairo_t *cr = cairo_create(cst); GtkStyleContext *context = gtk_widget_get_style_context(widget); gtk_render_background(context, cr, 0, 0, allocation.width, allocation.height); width -= 2 * inset; height -= 2 * inset; cairo_translate(cr, inset, inset); /* draw navigation image if available */ if(d->buffer) { cairo_save(cr); const int wd = d->wd; const int ht = d->ht; const float scale = fminf(width / (float)wd, height / (float)ht); const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, wd); cairo_surface_t *surface = cairo_image_surface_create_for_data(d->buffer, CAIRO_FORMAT_RGB24, wd, ht, stride); cairo_translate(cr, width / 2.0, height / 2.0f); cairo_scale(cr, scale, scale); cairo_translate(cr, -.5f * wd, -.5f * ht); // draw shadow around float alpha = 1.0f; for(int k = 0; k < 4; k++) { cairo_rectangle(cr, -k / scale, -k / scale, wd + 2 * k / scale, ht + 2 * k / scale); cairo_set_source_rgba(cr, 0, 0, 0, alpha); alpha *= 0.6f; cairo_fill(cr); } cairo_rectangle(cr, 0, 0, wd - 2, ht - 1); cairo_set_source_surface(cr, surface, 0, 0); cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_FAST); cairo_fill(cr); cairo_surface_destroy(surface); // draw box where we are dt_dev_zoom_t zoom = dt_control_get_dev_zoom(); int closeup = dt_control_get_dev_closeup(); float zoom_x = dt_control_get_dev_zoom_x(); float zoom_y = dt_control_get_dev_zoom_y(); const float min_scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, closeup ? 2.0 : 1.0, 0); const float cur_scale = dt_dev_get_zoom_scale(dev, zoom, closeup ? 2.0 : 1.0, 0); // avoid numerical instability for small resolutions: double h, w; if(cur_scale > min_scale) { float boxw = 1, boxh = 1; dt_dev_check_zoom_bounds(darktable.develop, &zoom_x, &zoom_y, zoom, closeup, &boxw, &boxh); cairo_translate(cr, wd * (.5f + zoom_x), ht * (.5f + zoom_y)); cairo_set_source_rgb(cr, 0., 0., 0.); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1.f / scale)); boxw *= wd; boxh *= ht; cairo_rectangle(cr, -boxw / 2 - 1, -boxh / 2 - 1, boxw + 2, boxh + 2); cairo_stroke(cr); cairo_set_source_rgb(cr, 1., 1., 1.); cairo_rectangle(cr, -boxw / 2, -boxh / 2, boxw, boxh); cairo_stroke(cr); } cairo_restore(cr); if(fabsf(cur_scale - min_scale) > 0.001f) { /* Zoom % */ PangoLayout *layout; PangoRectangle ink; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); layout = pango_cairo_create_layout(cr); const float fontsize = DT_PIXEL_APPLY_DPI(11); pango_font_description_set_absolute_size(desc, fontsize * PANGO_SCALE); pango_layout_set_font_description(layout, desc); cairo_translate(cr, 0, height); cairo_set_source_rgba(cr, 1., 1., 1., 0.5); cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); char zoomline[5]; snprintf(zoomline, sizeof(zoomline), "%.0f%%", cur_scale * 100); pango_layout_set_text(layout, zoomline, -1); pango_layout_get_pixel_extents(layout, &ink, NULL); h = d->zoom_h = ink.height; w = d->zoom_w = ink.width; cairo_move_to(cr, width - w - h * 1.1 - ink.x, - fontsize); cairo_save(cr); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.0)); GdkRGBA *color; gtk_style_context_get(context, gtk_widget_get_state_flags(widget), "background-color", &color, NULL); gdk_cairo_set_source_rgba(cr, color); pango_cairo_layout_path(cr, layout); cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); cairo_fill(cr); cairo_restore(cr); gdk_rgba_free(color); pango_font_description_free(desc); g_object_unref(layout); } else { // draw the zoom-to-fit icon cairo_translate(cr, 0, height); cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); static int height = -1; if(height == -1) { PangoLayout *layout; PangoRectangle ink; PangoFontDescription *desc = pango_font_description_copy_static(darktable.bauhaus->pango_font_desc); pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD); layout = pango_cairo_create_layout(cr); pango_font_description_set_absolute_size(desc, DT_PIXEL_APPLY_DPI(11) * PANGO_SCALE); pango_layout_set_font_description(layout, desc); pango_layout_set_text(layout, "100%", -1); // dummy text, just to get the height pango_layout_get_pixel_extents(layout, &ink, NULL); height = ink.height; pango_font_description_free(desc); g_object_unref(layout); } h = d->zoom_h = height; w = h * 1.5; float sp = h * 0.6; d->zoom_w = w + sp; cairo_move_to(cr, width - w - h - sp, -1.0 * h); cairo_rectangle(cr, width - w - h - sp, -1.0 * h, w, h); cairo_set_source_rgb(cr, 0.2, 0.2, 0.2); cairo_fill(cr); cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(2.0)); cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); cairo_move_to(cr, width - w * 0.8 - h - sp, -1.0 * h); cairo_line_to(cr, width - w - h - sp, -1.0 * h); cairo_line_to(cr, width - w - h - sp, -0.7 * h); cairo_stroke(cr); cairo_move_to(cr, width - w - h - sp, -0.3 * h); cairo_line_to(cr, width - w - h - sp, 0); cairo_line_to(cr, width - w * 0.8 - h - sp, 0); cairo_stroke(cr); cairo_move_to(cr, width - w * 0.2 - h - sp, 0); cairo_line_to(cr, width - h - sp, 0); cairo_line_to(cr, width - h - sp, -0.3 * h); cairo_stroke(cr); cairo_move_to(cr, width - h - sp, -0.7 * h); cairo_line_to(cr, width - h - sp, -1.0 * h); cairo_line_to(cr, width - w * 0.2 - h - sp, -1.0 * h); cairo_stroke(cr); } cairo_move_to(cr, width - 0.95 * h, -0.9 * h); cairo_line_to(cr, width - 0.05 * h, -0.9 * h); cairo_line_to(cr, width - 0.5 * h, -0.1 * h); cairo_fill(cr); } /* blit memsurface into widget */ cairo_destroy(cr); cairo_set_source_surface(crf, cst, 0, 0); cairo_paint(crf); cairo_surface_destroy(cst); return TRUE; }