const gchar * common_get_direction_mark (gchar *text) { PangoDirection pango_direction = PANGO_DIRECTION_NEUTRAL; GtkTextDirection gtk_direction; if (text) pango_direction = pango_find_base_dir (text, -1); switch (pango_direction) { case PANGO_DIRECTION_LTR: gtk_direction = GTK_TEXT_DIR_LTR; break; case PANGO_DIRECTION_RTL: gtk_direction = GTK_TEXT_DIR_RTL; break; default: gtk_direction = gtk_widget_get_default_direction (); break; } switch (gtk_direction) { case GTK_TEXT_DIR_RTL: return "\342\200\217"; /* U+200F RIGHT-TO-LEFT MARK */ case GTK_TEXT_DIR_LTR: return "\342\200\216"; /* U+200E LEFT-TO-RIGHT MARK */ default: return ""; } }
static void position_action_menu (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data) { WnckWindow *win = (WnckWindow *) user_data; decor_frame_t *frame = gwd_get_decor_frame (get_frame_type (win)); decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); gint bx, by, width, height; wnck_window_get_client_window_geometry (win, x, y, &width, &height); if (d->decorated) { if ((*theme_get_button_position) (d, BUTTON_MENU, width, height, &bx, &by, &width, &height)) *x = *x - frame->win_extents.left + bx; } gwd_decor_frame_unref (frame); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) { GtkRequisition req; gtk_widget_size_request (GTK_WIDGET (menu), &req); *x = MAX (0, *x - req.width + width); } *push_in = TRUE; }
GdkPixbuf *CreateStockIcon(const char *stockid, GtkIconSize size) { // FIXME: This code is not 100% correct, because stock pixmap are // context-dependent and may be affected by theme engine, the // correct value can only be obtained for given GtkWidget object. // // Fool-proof implementation of stock bitmaps would extend wxBitmap // with "stock-id" representation (in addition to pixmap and pixbuf // ones) and would convert it to pixbuf when rendered. GtkWidget* widget = wxGTKPrivate::GetButtonWidget(); #ifdef __WXGTK3__ GtkStyleContext* sc = gtk_widget_get_style_context(widget); GtkIconSet* iconset = gtk_style_context_lookup_icon_set(sc, stockid); GdkPixbuf* pixbuf = NULL; if (iconset) pixbuf = gtk_icon_set_render_icon_pixbuf(iconset, sc, size); return pixbuf; #else GtkStyle* style = gtk_widget_get_style(widget); GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid); if (!iconset) return NULL; return gtk_icon_set_render_icon(iconset, style, gtk_widget_get_default_direction(), GTK_STATE_NORMAL, size, NULL, NULL); #endif }
MetaUIDirection meta_ui_get_direction (void) { if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL) return META_UI_DIRECTION_RTL; return META_UI_DIRECTION_LTR; }
const gchar * common_get_app_direction (void) { GtkTextDirection gtk_direction; gtk_direction = gtk_widget_get_default_direction (); if (gtk_direction == GTK_TEXT_DIR_RTL) return ("rtl"); else return ("ltr"); }
gboolean ge_widget_is_ltr (GtkWidget *widget) { GtkTextDirection dir = GTK_TEXT_DIR_NONE; if (GE_IS_WIDGET (widget)) dir = gtk_widget_get_direction (widget); if (dir == GTK_TEXT_DIR_NONE) dir = gtk_widget_get_default_direction (); if (dir == GTK_TEXT_DIR_RTL) return FALSE; else return TRUE; }
static GtkWidget * padded_label_new (const gchar *text, RowLabelPosition position, RowTravelDirection direction, gboolean dim_label) { GtkWidget *widget; GtkWidget *label; GtkWidget *arrow; gdouble alignment; gboolean rtl; rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL); if (position == ROW_LABEL_POSITION_START) alignment = 0.0; else if (position == ROW_LABEL_POSITION_CENTER) alignment = 0.5; else alignment = 1.0; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); if (direction == ROW_TRAVEL_DIRECTION_BACKWARD) { arrow = gtk_image_new_from_icon_name (rtl ? ARROW_NEXT : ARROW_PREV, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (widget), arrow, FALSE, TRUE, 0); } label = gtk_label_new (text); gtk_misc_set_alignment (GTK_MISC (label), alignment, 0.5); set_row_widget_margins (label); gtk_box_pack_start (GTK_BOX (widget), label, TRUE, TRUE, 0); if (dim_label) gtk_style_context_add_class (gtk_widget_get_style_context (label), "dim-label"); if (direction == ROW_TRAVEL_DIRECTION_FORWARD) { arrow = gtk_image_new_from_icon_name (rtl ? ARROW_PREV : ARROW_NEXT, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (widget), arrow, FALSE, TRUE, 0); } return widget; }
static void ygtk_steps_init (YGtkSteps *steps) { gtk_box_set_spacing (GTK_BOX (steps), 8); gtk_orientable_set_orientation (GTK_ORIENTABLE (steps), GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (steps), 4); const gchar *check = "\u2714", *current = "\u25b6", *todo = "\u26ab"; if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL) current = "\u25c0"; PangoContext *context = gtk_widget_get_pango_context (GTK_WIDGET (steps)); steps->check_mark_layout = pango_layout_new (context); steps->current_mark_layout = pango_layout_new (context); steps->todo_mark_layout = pango_layout_new (context); pango_layout_set_text (steps->check_mark_layout, check, -1); pango_layout_set_text (steps->current_mark_layout, current, -1); pango_layout_set_text (steps->todo_mark_layout, todo, -1); steps->current_mark_timeout_id = steps->current_mark_frame = 0; }
static void gimp_text_editor_init (GimpTextEditor *editor) { editor->view = NULL; editor->file_dialog = NULL; editor->ui_manager = NULL; switch (gtk_widget_get_default_direction ()) { case GTK_TEXT_DIR_NONE: case GTK_TEXT_DIR_LTR: editor->base_dir = GIMP_TEXT_DIRECTION_LTR; break; case GTK_TEXT_DIR_RTL: editor->base_dir = GIMP_TEXT_DIRECTION_RTL; break; } }
static gfloat item_list_title_alignment (gchar *title) { if (!title || strlen(title) == 0) return 0.; /* debug5 (DEBUG_HTML, "title ***%s*** first bytes %02hhx%02hhx%02hhx pango %d", title, title[0], title[1], title[2], pango_find_base_dir (title, -1)); */ int txt_direction = pango_find_base_dir (title, -1); int app_direction = gtk_widget_get_default_direction (); if ((txt_direction == PANGO_DIRECTION_LTR && app_direction == GTK_TEXT_DIR_LTR) || (txt_direction == PANGO_DIRECTION_RTL && app_direction == GTK_TEXT_DIR_RTL)) return 0.; /* same direction, regular ("left") alignment */ else return 1.; }
static void e_minicard_label_resize_children (EMinicardLabel *e_minicard_label) { gdouble left_width; gdouble fieldnamewidth; gdouble fieldwidth; gboolean is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL); if (e_minicard_label->max_field_name_length != -1 && ((e_minicard_label->width / 2) - 4 > e_minicard_label->max_field_name_length)) left_width = e_minicard_label->max_field_name_length; else left_width = e_minicard_label->width / 2 - 4; fieldnamewidth = (double) MAX ( left_width, 0 ); fieldwidth = (double) MAX ( e_minicard_label->width - 8 - left_width, 0 ); gnome_canvas_item_set ( e_minicard_label->fieldname, "clip_width", is_rtl ? fieldwidth : fieldnamewidth, NULL ); gnome_canvas_item_set ( e_minicard_label->field, "clip_width", is_rtl ? fieldnamewidth : fieldwidth, NULL ); }
/** * ephy_title_box_set_address: * @title_box: an #EphyTitleBox * @address: (nullable): the URI to use for the subtitle of this #EphyTitleBox * * Sets the address of @title_box to @address */ void ephy_title_box_set_address (EphyTitleBox *title_box, const char *address) { EphyEmbedShellMode mode; g_return_if_fail (EPHY_IS_TITLE_BOX (title_box)); mode = ephy_embed_shell_get_mode (ephy_embed_shell_get_default ()); if (address == NULL || mode == EPHY_EMBED_SHELL_MODE_APPLICATION) { gtk_label_set_text (GTK_LABEL (title_box->subtitle), address); } else { gboolean rtl; char *subtitle; rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; subtitle = g_strconcat (rtl ? "▾ " : address, rtl ? address : " ▾", NULL); gtk_label_set_text (GTK_LABEL (title_box->subtitle), subtitle); g_free (subtitle); } }
static void ygtk_fixed_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { YGtkFixed *fixed = YGTK_FIXED (widget); fixed->set_size_cb (fixed, allocation->width, allocation->height, fixed->data); GSList *i; for (i = fixed->children; i; i = i->next) { YGtkFixedChild *child = i->data; int x = child->x; if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL) x = allocation->width - (child->x + child->width); x += allocation->x; int y = child->y + allocation->y; GtkAllocation child_alloc = { x, y, MAX (child->width, 1), MAX (child->height, 1) }; GtkRequisition min_child_req; GtkRequisition nat_child_req; gtk_widget_get_preferred_size (child->widget, &min_child_req, &nat_child_req); gtk_widget_size_allocate (child->widget, &child_alloc); } GTK_WIDGET_CLASS (ygtk_fixed_parent_class)->size_allocate (widget, allocation); }
/* Same as gtk_image_new_from_stock except that it mirrors the icons for RTL * languages */ GtkWidget * rb_image_new_from_stock (const gchar *stock_id, GtkIconSize size) { if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_LTR) { return gtk_image_new_from_stock (stock_id, size); } else { GtkWidget *image; GdkPixbuf *pixbuf; GdkPixbuf *mirror; image = gtk_image_new (); if (image == NULL) { return NULL; } pixbuf = gtk_widget_render_icon (image, stock_id, size, NULL); g_assert (pixbuf != NULL); mirror = gdk_pixbuf_copy (pixbuf); g_object_unref (pixbuf); if (!mirror) return NULL; totem_pixbuf_mirror (mirror); gtk_image_set_from_pixbuf (GTK_IMAGE (image), mirror); g_object_unref (mirror); return image; } return NULL; }
static void gth_media_viewer_page_real_activate (GthViewerPage *base, GthBrowser *browser) { GthMediaViewerPage *self; gboolean rtl; if (! gstreamer_init ()) return; self = (GthMediaViewerPage*) base; self->priv->browser = browser; g_action_map_add_action_entries (G_ACTION_MAP (browser), actions, G_N_ELEMENTS (actions), browser); self->priv->screenshot_button = gth_browser_add_header_bar_button (browser, GTH_BROWSER_HEADER_SECTION_VIEWER_VIEW, "camera-photo-symbolic", _("Take a screenshot"), "win.video-screenshot", NULL); rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; /* video area */ self->priv->area = gtk_drawing_area_new (); /* do not use the rgba visual on the drawing area */ { GdkVisual *visual; visual = gdk_screen_get_system_visual (gtk_widget_get_screen (GTK_WIDGET (self->priv->area))); if (visual != NULL) gtk_widget_set_visual (GTK_WIDGET (self->priv->area), visual); } gtk_widget_set_double_buffered (self->priv->area, FALSE); gtk_widget_add_events (self->priv->area, (gtk_widget_get_events (self->priv->area) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK | GDK_SCROLL_MASK)); gtk_widget_set_can_focus (self->priv->area, TRUE); gtk_widget_show (self->priv->area); g_signal_connect (G_OBJECT (self->priv->area), "realize", G_CALLBACK (video_area_realize_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "unrealize", G_CALLBACK (video_area_unrealize_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "draw", G_CALLBACK (video_area_draw_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "button_press_event", G_CALLBACK (video_area_button_press_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "popup-menu", G_CALLBACK (video_area_popup_menu_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "scroll_event", G_CALLBACK (video_area_scroll_event_cb), self); g_signal_connect (G_OBJECT (self->priv->area), "key_press_event", G_CALLBACK (video_area_key_press_cb), self); /* mediabar */ self->priv->builder = _gtk_builder_new_from_file ("mediabar.ui", "gstreamer_tools"); self->priv->mediabar = GET_WIDGET ("mediabar"); gtk_widget_set_halign (self->priv->mediabar, GTK_ALIGN_FILL); gtk_widget_set_valign (self->priv->mediabar, GTK_ALIGN_END); gtk_image_set_from_icon_name (GTK_IMAGE (GET_WIDGET ("play_slower_image")), rtl ? "media-seek-backward-rtl-symbolic" : "media-seek-backward-symbolic", GTK_ICON_SIZE_MENU); gtk_image_set_from_icon_name (GTK_IMAGE (GET_WIDGET ("play_faster_image")), rtl ? "media-seek-forward-rtl-symbolic" : "media-seek-forward-symbolic", GTK_ICON_SIZE_MENU); g_signal_connect (GET_WIDGET ("volume_adjustment"), "value-changed", G_CALLBACK (volume_value_changed_cb), self); g_signal_connect (GET_WIDGET ("position_adjustment"), "value-changed", G_CALLBACK (position_value_changed_cb), self); g_signal_connect (GET_WIDGET ("play_button"), "clicked", G_CALLBACK (play_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("play_slower_button"), "clicked", G_CALLBACK (play_slower_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("play_faster_button"), "clicked", G_CALLBACK (play_faster_button_clicked_cb), self); self->priv->mediabar_revealer = gtk_revealer_new (); gtk_revealer_set_transition_type (GTK_REVEALER (self->priv->mediabar_revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP); gtk_widget_set_halign (self->priv->mediabar_revealer, GTK_ALIGN_FILL); gtk_widget_set_valign (self->priv->mediabar_revealer, GTK_ALIGN_END); gtk_widget_show (self->priv->mediabar_revealer); gtk_container_add (GTK_CONTAINER (self->priv->mediabar_revealer), self->priv->mediabar); self->priv->area_box = gtk_overlay_new (); gtk_container_add (GTK_CONTAINER (self->priv->area_box), self->priv->area); gtk_overlay_add_overlay (GTK_OVERLAY (self->priv->area_box), self->priv->mediabar_revealer); gtk_widget_show (self->priv->area_box); gth_browser_set_viewer_widget (browser, self->priv->area_box); gtk_widget_realize (self->priv->area); gth_browser_register_viewer_control (self->priv->browser, self->priv->mediabar); gth_viewer_page_focus (GTH_VIEWER_PAGE (self)); }
static void nautilus_toolbar_constructed (GObject *obj) { NautilusToolbar *self = NAUTILUS_TOOLBAR (obj); GtkWidget *toolbar; GtkWidget *button; GtkWidget *menu; GtkWidget *box; GtkWidget *separator; GtkUIManager *ui_manager; gboolean rtl; G_OBJECT_CLASS (nautilus_toolbar_parent_class)->constructed (obj); gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (self)), "header-bar"); self->priv->toolbar = toolbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_set (toolbar, "margin", 8, NULL); gtk_container_add (GTK_CONTAINER (self), toolbar); rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; ui_manager = nautilus_window_get_ui_manager (self->priv->window); gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)), GTK_JUNCTION_BOTTOM); /* Back and Forward */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); /* Back */ button = toolbar_create_toolbutton (self, FALSE, FALSE, NAUTILUS_ACTION_BACK, NULL); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_action_set_icon_name (gtk_activatable_get_related_action (GTK_ACTIVATABLE (button)), rtl ? "go-previous-rtl-symbolic" : "go-previous-symbolic"); navigation_button_setup_menu (self, button, NAUTILUS_NAVIGATION_DIRECTION_BACK); gtk_container_add (GTK_CONTAINER (box), button); /* Forward */ button = toolbar_create_toolbutton (self, FALSE, FALSE, NAUTILUS_ACTION_FORWARD, NULL); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_action_set_icon_name (gtk_activatable_get_related_action (GTK_ACTIVATABLE (button)), rtl ? "go-next-rtl-symbolic" : "go-next-symbolic"); navigation_button_setup_menu (self, button, NAUTILUS_NAVIGATION_DIRECTION_FORWARD); gtk_container_add (GTK_CONTAINER (box), button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_box_pack_start (GTK_BOX (toolbar), box, FALSE, FALSE, 0); if (rtl) { gtk_widget_set_margin_left (box, 12); } else { gtk_widget_set_margin_right (box, 12); } /* regular path bar */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL); gtk_box_pack_start (GTK_BOX (box), self->priv->path_bar, TRUE, TRUE, 0); /* entry-like location bar */ self->priv->location_entry = nautilus_location_entry_new (); gtk_box_pack_start (GTK_BOX (box), self->priv->location_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (toolbar), box, TRUE, TRUE, 0); /* search */ button = toolbar_create_toolbutton (self, FALSE, TRUE, NAUTILUS_ACTION_SEARCH, NULL); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (toolbar), button); if (rtl) { gtk_widget_set_margin_right (button, 76); } else { gtk_widget_set_margin_left (button, 76); } /* View buttons */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); button = toolbar_create_toolbutton (self, FALSE, TRUE, NAUTILUS_ACTION_VIEW_LIST, NULL); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (box), button); button = toolbar_create_toolbutton (self, FALSE, TRUE, NAUTILUS_ACTION_VIEW_GRID, NULL); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (box), button); button = toolbar_create_toolbutton (self, TRUE, FALSE, "go-down-symbolic", _("View options")); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (box), button); menu = gtk_ui_manager_get_widget (ui_manager, "/ViewMenu"); gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), menu); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (toolbar), box); if (rtl) { gtk_widget_set_margin_right (box, 12); } else { gtk_widget_set_margin_left (box, 12); } /* Action Menu */ button = toolbar_create_toolbutton (self, TRUE, FALSE, "emblem-system-symbolic", _("Location options")); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); menu = gtk_ui_manager_get_widget (ui_manager, "/ActionMenu"); gtk_widget_set_halign (menu, GTK_ALIGN_END); gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), menu); gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "win.gear-menu"); g_signal_connect (menu, "key-press-event", G_CALLBACK (gear_menu_key_press), self); gtk_container_add (GTK_CONTAINER (toolbar), button); if (rtl) { gtk_widget_set_margin_right (button, 12); } else { gtk_widget_set_margin_left (button, 12); } /* Separator and Close */ separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (toolbar), separator); if (rtl) { gtk_widget_set_margin_right (separator, 8); } else { gtk_widget_set_margin_left (separator, 8); } button = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); g_signal_connect (button, "clicked", G_CALLBACK (close_button_clicked), self); gtk_container_add (GTK_CONTAINER (toolbar), button); if (rtl) { gtk_widget_set_margin_right (button, 6); } else { gtk_widget_set_margin_left (button, 6); } g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY, G_CALLBACK (toolbar_update_appearance), self); gtk_widget_show_all (toolbar); toolbar_update_appearance (self); }
void meta_update_button_layout (const char *value) { MetaButtonLayout new_layout; MetaButtonFunction f; char **sides; int i; meta_initialize_button_layout (&new_layout); sides = g_strsplit (value, ":", 2); if (sides[0] != NULL) { char **buttons; int b; gboolean used[META_BUTTON_FUNCTION_LAST]; for (i = 0; i < META_BUTTON_FUNCTION_LAST; ++i) used[i] = FALSE; buttons = g_strsplit (sides[0], ",", -1); i = b = 0; while (buttons[b] != NULL) { f = meta_button_function_from_string (buttons[b]); if (i > 0 && strcmp ("spacer", buttons[b]) == 0) { new_layout.left_buttons_has_spacer[i - 1] = TRUE; f = meta_button_opposite_function (f); if (f != META_BUTTON_FUNCTION_LAST) new_layout.left_buttons_has_spacer[i - 2] = TRUE; } else { if (f != META_BUTTON_FUNCTION_LAST && !used[f]) { used[f] = TRUE; new_layout.left_buttons[i++] = f; f = meta_button_opposite_function (f); if (f != META_BUTTON_FUNCTION_LAST) new_layout.left_buttons[i++] = f; } else { fprintf (stderr, "%s: Ignoring unknown or already-used " "button name \"%s\"\n", program_name, buttons[b]); } } ++b; } new_layout.left_buttons[i] = META_BUTTON_FUNCTION_LAST; g_strfreev (buttons); if (sides[1] != NULL) { for (i = 0; i < META_BUTTON_FUNCTION_LAST; ++i) used[i] = FALSE; buttons = g_strsplit (sides[1], ",", -1); i = b = 0; while (buttons[b] != NULL) { f = meta_button_function_from_string (buttons[b]); if (i > 0 && strcmp ("spacer", buttons[b]) == 0) { new_layout.right_buttons_has_spacer[i - 1] = TRUE; f = meta_button_opposite_function (f); if (f != META_BUTTON_FUNCTION_LAST) new_layout.right_buttons_has_spacer[i - 2] = TRUE; } else { if (f != META_BUTTON_FUNCTION_LAST && !used[f]) { used[f] = TRUE; new_layout.right_buttons[i++] = f; f = meta_button_opposite_function (f); if (f != META_BUTTON_FUNCTION_LAST) new_layout.right_buttons[i++] = f; } else { fprintf (stderr, "%s: Ignoring unknown or " "already-used button name \"%s\"\n", program_name, buttons[b]); } } ++b; } new_layout.right_buttons[i] = META_BUTTON_FUNCTION_LAST; g_strfreev (buttons); } } g_strfreev (sides); /* Invert the button layout for RTL languages */ if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) { MetaButtonLayout rtl_layout; int j; meta_initialize_button_layout (&rtl_layout); i = 0; while (new_layout.left_buttons[i] != META_BUTTON_FUNCTION_LAST) ++i; for (j = 0; j < i; ++j) { rtl_layout.right_buttons[j] = new_layout.left_buttons[i - j - 1]; if (j == 0) rtl_layout.right_buttons_has_spacer[i - 1] = new_layout.left_buttons_has_spacer[i - j - 1]; else rtl_layout.right_buttons_has_spacer[j - 1] = new_layout.left_buttons_has_spacer[i - j - 1]; } i = 0; while (new_layout.right_buttons[i] != META_BUTTON_FUNCTION_LAST) ++i; for (j = 0; j < i; ++j) { rtl_layout.left_buttons[j] = new_layout.right_buttons[i - j - 1]; if (j == 0) rtl_layout.left_buttons_has_spacer[i - 1] = new_layout.right_buttons_has_spacer[i - j - 1]; else rtl_layout.left_buttons_has_spacer[j - 1] = new_layout.right_buttons_has_spacer[i - j - 1]; } new_layout = rtl_layout; } meta_button_layout = new_layout; }
static VALUE rg_s_default_direction(G_GNUC_UNUSED VALUE self) { return GENUM2RVAL(gtk_widget_get_default_direction(), GTK_TYPE_TEXT_DIRECTION); }
void e_mail_formatter_format_text_header (EMailFormatter *formatter, GString *buffer, const gchar *label, const gchar *value, guint32 flags) { GtkTextDirection direction; const gchar *fmt, *html; const gchar *display; gchar *mhtml = NULL; g_return_if_fail (E_IS_MAIL_FORMATTER (formatter)); g_return_if_fail (buffer != NULL); g_return_if_fail (label != NULL); if (value == NULL) return; while (*value == ' ') value++; if (!(flags & E_MAIL_FORMATTER_HEADER_FLAG_HTML)) { CamelMimeFilterToHTMLFlags text_format_flags; text_format_flags = e_mail_formatter_get_text_format_flags (formatter); html = mhtml = camel_text_to_html ( value, text_format_flags, 0); } else { html = value; } direction = gtk_widget_get_default_direction (); if (flags & E_MAIL_FORMATTER_HEADER_FLAG_NOCOLUMNS) { if (flags & E_MAIL_FORMATTER_HEADER_FLAG_BOLD) { fmt = "<tr style=\"display: %s\">" "<td><b>%s:</b> %s</td></tr>"; } else { fmt = "<tr style=\"display: %s\">" "<td>%s: %s</td></tr>"; } } else if (flags & E_MAIL_FORMATTER_HEADER_FLAG_NODEC) { if (direction == GTK_TEXT_DIR_RTL) fmt = "<tr class=\"header\" style=\"display: %s\">" "<th class=\"header rtl\">%s</th>" "<td class=\"header rtl\">%s</td>" "</tr>"; else fmt = "<tr class=\"header\" style=\"display: %s\">" "<th class=\"header ltr\">%s</th>" "<td class=\"header ltr\">%s</td>" "</tr>"; } else { if (direction == GTK_TEXT_DIR_RTL) fmt = "<tr class=\"header\" style=\"display: %s\">" "<th class=\"header rtl\">%s:</th>" "<td class=\"header rtl\">%s</td>" "</tr>"; else fmt = "<tr class=\"header\" style=\"display: %s\">" "<th class=\"header ltr\">%s:</th>" "<td class=\"header ltr\">%s</td>" "</tr>"; } if (flags & E_MAIL_FORMATTER_HEADER_FLAG_HIDDEN) display = "none"; else display = "table-row"; g_string_append_printf (buffer, fmt, display, label, html); g_free (mhtml); }
static const gchar * document_read_contents (YelpDocument *document, const gchar *page_id) { gchar *real, *str, **colors; g_mutex_lock (&document->priv->mutex); if (page_id != NULL && g_str_has_prefix (page_id, "search=")) { gchar *tmp, *tmp2, *txt; GVariant *value; GVariantIter *iter; gchar *url, *title, *desc, *icon; /* do not free */ gchar *index_title; GString *ret = g_string_new ("<html><head><style type='text/css'>"); colors = yelp_settings_get_colors (yelp_settings_get_default ()); g_string_append_printf (ret, "html { height: 100%%; } " "body { margin: 0; padding: 0;" " background-color: %s; color: %s;" " direction: %s; } " "div.header { margin-bottom: 1em; } " "div.trails { " " margin: 0; padding: 0.2em 12px 0 12px;" " background-color: %s;" " border-bottom: solid 1px %s; } " "div.trail { text-indent: -1em;" " margin: 0 1em 0.2em 1em; padding: 0; color: %s; } " "div.body { margin: 0 12px 0 12px; padding: 0 0 12px 0; max-width: 60em; } " "div, p { margin: 1em 0 0 0; padding: 0; } " "div:first-child, p:first-child { margin-top: 0; } " "h1 { margin: 0; padding: 0; color: %s; font-size: 1.44em; } " "a { color: %s; text-decoration: none; } " "a.linkdiv { display: block; } " "div.linkdiv { margin: 0; padding: 0.5em; }" "a:hover div.linkdiv {" " outline: solid 1px %s;" " background: -webkit-gradient(linear, left top, left 80, from(%s), to(%s)); } " "div.title { margin-bottom: 0.2em; font-weight: bold; } " "div.desc { margin: 0; color: %s; } " "</style></head><body><div class='header'>", colors[YELP_SETTINGS_COLOR_BASE], colors[YELP_SETTINGS_COLOR_TEXT], (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "rtl" : "ltr"), colors[YELP_SETTINGS_COLOR_GRAY_BASE], colors[YELP_SETTINGS_COLOR_GRAY_BORDER], colors[YELP_SETTINGS_COLOR_TEXT_LIGHT], colors[YELP_SETTINGS_COLOR_TEXT_LIGHT], colors[YELP_SETTINGS_COLOR_LINK], colors[YELP_SETTINGS_COLOR_BLUE_BASE], colors[YELP_SETTINGS_COLOR_BLUE_BASE], colors[YELP_SETTINGS_COLOR_BASE], colors[YELP_SETTINGS_COLOR_TEXT_LIGHT] ); index_title = yelp_storage_get_root_title (yelp_storage_get_default (), document->priv->doc_uri); if (index_title != NULL) { tmp = g_markup_printf_escaped ("<div class='trails'><div class='trail'>" "<a href='xref:'>%s</a> %s " "</div></div>", index_title, (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "«" : "»") ); g_string_append (ret, tmp); g_free (tmp); } g_string_append (ret, "</div><div class='body'>"); g_strfreev (colors); str = hash_lookup (document->priv->contents, real); if (str) { str_ref (str); g_mutex_unlock (&document->priv->mutex); return (const gchar *) str; } txt = g_uri_unescape_string (page_id + 7, NULL); tmp2 = g_strdup_printf (_("Search results for “%s”"), txt); tmp = g_markup_printf_escaped ("<h1>%s</h1>", tmp2); g_string_append (ret, tmp); g_free (tmp2); g_free (tmp); value = yelp_storage_search (yelp_storage_get_default (), document->priv->doc_uri, txt); iter = g_variant_iter_new (value); if (g_variant_iter_n_children (iter) == 0) { if (index_title != NULL) { gchar *t = g_strdup_printf (_("No matching help pages found in “%s”."), index_title); tmp = g_markup_printf_escaped ("<p>%s</p>", t); g_free (t); } else { tmp = g_markup_printf_escaped ("<p>%s</p>", _("No matching help pages found.")); } g_string_append (ret, tmp); g_free (tmp); } else { while (g_variant_iter_loop (iter, "(&s&s&s&s)", &url, &title, &desc, &icon)) { tmp = g_markup_printf_escaped ("<div><a class='linkdiv' href='%s'><div class='linkdiv'>" "<div class='title'>%s</div>" "<div class='desc'>%s</div>" "</div></a></div>", url, title, desc); g_string_append (ret, tmp); g_free (tmp); } } g_variant_iter_free (iter); g_variant_unref (value); if (index_title != NULL) g_free (index_title); g_free (txt); g_string_append (ret, "</div></body></html>"); hash_replace (document->priv->contents, page_id, g_string_free (ret, FALSE)); str = hash_lookup (document->priv->contents, page_id); str_ref (str); g_mutex_unlock (&document->priv->mutex); return (const gchar *) str; } real = hash_lookup (document->priv->page_ids, page_id); str = hash_lookup (document->priv->contents, real); if (str) str_ref (str); g_mutex_unlock (&document->priv->mutex); return (const gchar *) str; }
static void gtr_message_table_init (GtrMessageTable * table) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtrMessageTablePrivate *priv; priv = gtr_message_table_get_instance_private (table); gtk_orientable_set_orientation (GTK_ORIENTABLE (table), GTK_ORIENTATION_VERTICAL); gtk_widget_init_template (GTK_WIDGET (table)); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes (_("Status"), renderer, "icon-name", GTR_MESSAGE_TABLE_MODEL_ICON_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (column, GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("ID"), renderer, "text", GTR_MESSAGE_TABLE_MODEL_ID_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (column, GTR_MESSAGE_TABLE_MODEL_ID_COLUMN); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) g_object_set (renderer, "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes (_("Original Message"), renderer, "text", GTR_MESSAGE_TABLE_MODEL_ORIGINAL_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (column, GTR_MESSAGE_TABLE_MODEL_ORIGINAL_COLUMN); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Translated Message"), renderer, "text", GTR_MESSAGE_TABLE_MODEL_TRANSLATION_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id (column, GTR_MESSAGE_TABLE_MODEL_TRANSLATION_COLUMN); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (gtr_message_table_selection_changed), table); }
static void GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data) { GtkWidget *hbox, *vbox; GtkWidget *toolbar; GtkWidget *tmp; GtkWidget *dicebox; GtkWidget *undo_button; GtkWidget *menu_button; GtkWidget *icon; GtkBuilder *builder; GMenuModel *appmenu; int i, j; window = gtk_application_window_new (application); gtk_window_set_application (GTK_WINDOW (window), application); gtk_window_set_title (GTK_WINDOW (window), _(appName)); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE); gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali"); //games_conf_add_window (GTK_WINDOW (window), NULL); g_signal_connect (GTK_WIDGET (window), "key_press_event", G_CALLBACK (key_press), NULL); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); const gchar *vaccels_help[] = {"F1", NULL}; const gchar *vaccels_new[] = {"<Primary>n", NULL}; const gchar *vaccels_roll[] = {"<Primary>r", NULL}; const gchar *vaccels_undo[] = {"<Primary>z", NULL}; gtk_application_set_accels_for_action (application, "app.help", vaccels_help); gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new); gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll); gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo); scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores"); undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo"); update_undo_sensitivity (); /*--- Headerbar ---*/ hbar = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE); gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName)); gtk_widget_show (hbar); gtk_window_set_titlebar (GTK_WINDOW (window), hbar); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON); else undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER); gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo"); gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move")); gtk_widget_show (undo_button); gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button); builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui"); appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu"); menu_button = gtk_menu_button_new(); icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (menu_button), icon); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu); gtk_widget_show (menu_button); gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button); /*---- Content ----*/ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); /* Retreive dice pixmaps from memory or files */ LoadDicePixmaps (); /* Put all the dice in a vertical column */ dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0); gtk_widget_show (dicebox); rollLabel = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE); gtk_widget_show (rollLabel); gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5); mbutton = gtk_button_new_with_label (_("Roll!")); gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5); g_signal_connect (GTK_BUTTON (mbutton), "clicked", G_CALLBACK (roll_button_pressed_cb), NULL); gtk_widget_show (GTK_WIDGET (mbutton)); toolbar = gtk_toolbar_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE); gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0); for (i = 0; i < NUMBER_OF_DICE; i++) { tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); for (j = 0; j < NUMBER_OF_PIXMAPS; j++) { gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0); } diceBox[i] = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp); g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked", G_CALLBACK (modify_dice), &DiceValues[i]); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (diceBox[i]), -1); gtk_widget_show (GTK_WIDGET (diceBox[i])); gtk_widget_show (tmp); /*gtk_widget_show (dicePixmaps[i][0][game_type]);*/ } gtk_widget_show (toolbar); /* Scores displayed in score list */ ScoreList = create_score_list (); gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0); setup_score_list (ScoreList); gtk_widget_show (ScoreList); gtk_widget_show (hbox); gtk_widget_show (vbox); }
void liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState) { GtkUIManager *ui_manager; GtkAccelGroup *accel_group; GError *error = NULL; gboolean toggle; gchar *id; debug_enter ("liferea_shell_create"); g_object_new (LIFEREA_SHELL_TYPE, NULL); shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow")); gtk_window_set_application (GTK_WINDOW (shell->priv->window), app); /* 1.) menu creation */ debug0 (DEBUG_GUI, "Setting up menues"); shell->priv->itemlist = itemlist_create (); /* Prepare some toggle button states */ conf_get_bool_value (REDUCED_FEEDLIST, &toggle); liferea_shell_feedlist_toggle_entries[0].is_active = toggle; ui_manager = gtk_ui_manager_new (); shell->priv->generalActions = gtk_action_group_new ("GeneralActions"); gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE); gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv); gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0); shell->priv->addActions = gtk_action_group_new ("AddActions"); gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE); gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0); shell->priv->feedActions = gtk_action_group_new ("FeedActions"); gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE); gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0); shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions"); gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE); gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0); shell->priv->itemActions = gtk_action_group_new ("ItemActions"); gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE); gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group); g_object_unref (accel_group); g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL); if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error)) g_error ("building menus failed: %s", error->message); if (gtk_widget_get_default_direction () != GTK_TEXT_DIR_RTL) { if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_tb_desc, -1, &error)) g_error ("building menus failed: %s", error->message); } else { if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_tb_rtl_desc, -1, &error)) g_error ("building menus failed: %s", error->message); } shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar"); shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar"); /* Ensure GTK3 toolbar shadows... */ gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar"); /* what a pain, why is there no markup for this option? */ g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL); /* 2.) setup containers */ debug0 (DEBUG_GUI, "Setting up widget containers"); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0); gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar)); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event", G_CALLBACK (on_notebook_scroll_event_null_cb), NULL); g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv); /* 3.) setup status bar */ debug0 (DEBUG_GUI, "Setting up status bar"); shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar")); shell->priv->statusbarLocked = FALSE; shell->priv->statusbarLockTimer = 0; shell->priv->statusbar_feedsinfo_evbox = gtk_event_box_new (); shell->priv->statusbar_feedsinfo = gtk_label_new(""); gtk_container_add (GTK_CONTAINER (shell->priv->statusbar_feedsinfo_evbox), shell->priv->statusbar_feedsinfo); gtk_widget_show_all (shell->priv->statusbar_feedsinfo_evbox); gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo_evbox, FALSE, FALSE, 5); g_signal_connect (G_OBJECT (shell->priv->statusbar_feedsinfo_evbox), "button_release_event", G_CALLBACK (on_next_unread_item_activate), NULL); /* 4.) setup tabs */ debug0 (DEBUG_GUI, "Setting up tabbed browsing"); shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs"))); /* 5.) setup feed list */ debug0 (DEBUG_GUI, "Setting up feed list"); shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist")); feed_list_view_init (shell->priv->feedlistView); /* 6.) setup menu sensivity */ debug0 (DEBUG_GUI, "Initialising menues"); /* On start, no item or feed is selected, so Item menu should be insensitive: */ liferea_shell_update_item_menu (FALSE); /* necessary to prevent selection signals when filling the feed list and setting the 2/3 pane mode view */ gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE); /* 7.) setup item view */ debug0 (DEBUG_GUI, "Setting up item view"); shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window)); /* 8.) load icons as required */ debug0 (DEBUG_GUI, "Loading icons"); icons_load (); /* 9.) update and restore all menu elements */ liferea_shell_update_toolbar (); liferea_shell_update_history_actions (); liferea_shell_setup_URL_receiver (); liferea_shell_restore_state (overrideWindowState); gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE); /* 10.) After main window is realized get theme colors and set up feed list and tray icon */ render_init_theme_colors (GTK_WIDGET (shell->priv->window)); shell->priv->feedlist = feedlist_create (); g_signal_connect (shell->priv->feedlist, "new-items", G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist); /* 11.) Restore latest selection */ // FIXME: Move to feed list code if (conf_get_str_value (LAST_NODE_SELECTED, &id)) { feed_list_view_select (node_from_id (id)); g_free (id); } /* 12. Setup shell plugins */ shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()), LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL); liferea_plugins_engine_set_default_signals (shell->priv->extensions, shell); /* 14. Rebuild search folders if needed */ if (searchFolderRebuild) vfolder_foreach (vfolder_rebuild); debug_exit ("liferea_shell_create"); }
/* Create new notification */ GtkWindow * create_notification(UrlClickedCb url_clicked) { GtkWidget *win; GtkWidget *drawbox; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *padding; AtkObject *atkobj; WindowData *windata; GdkColormap *colormap; GdkScreen *screen; windata = g_new0(WindowData, 1); windata->urgency = URGENCY_NORMAL; windata->url_clicked = url_clicked; win = gtk_window_new(GTK_WINDOW_POPUP); windata->win = win; windata->rtl = gtk_widget_get_default_direction(); windata->enable_transparency = FALSE; screen = gtk_window_get_screen(GTK_WINDOW(win)); colormap = gdk_screen_get_rgba_colormap(screen); if (colormap != NULL) { gtk_widget_set_colormap(win, colormap); if (gdk_screen_is_composited(screen)) windata->enable_transparency = TRUE; } gtk_window_set_title(GTK_WINDOW(win), "Notification"); gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_widget_realize(win); g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify)destroy_windata); atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT); g_signal_connect(G_OBJECT(win), "configure_event", G_CALLBACK(configure_event_cb), windata); /* * For some reason, there are occasionally graphics glitches when * repainting the window. Despite filling the window with a background * color, parts of the other windows on the screen or the shadows around * notifications will appear on the notification. Somehow, adding this * eventbox makes that problem just go away. Whatever works for now. */ drawbox = gtk_event_box_new(); gtk_widget_show(drawbox); gtk_container_add(GTK_CONTAINER(win), drawbox); main_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(main_vbox); gtk_container_add(GTK_CONTAINER(drawbox), main_vbox); g_signal_connect(G_OBJECT(main_vbox), "expose_event", G_CALLBACK(paint_window), windata); padding = gtk_alignment_new(0, 0, 0, 0); gtk_widget_show(padding); gtk_box_pack_start(GTK_BOX(main_vbox), padding, FALSE, FALSE, 0); g_object_set(G_OBJECT(padding), "top-padding", 8, "right-padding", 8, NULL); windata->main_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(windata->main_hbox); gtk_container_add(GTK_CONTAINER(padding), windata->main_hbox); gtk_container_set_border_width(GTK_CONTAINER(windata->main_hbox), 13); /* The icon goes at the left */ windata->iconbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(windata->iconbox); gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0); windata->icon = gtk_image_new(); gtk_box_pack_start(GTK_BOX(windata->iconbox), windata->icon, FALSE, FALSE, 0); /* The title and the text at the right */ padding = gtk_alignment_new(0, 0.5, 0, 0); gtk_widget_show(padding); gtk_box_pack_start(GTK_BOX(windata->main_hbox), padding, TRUE, TRUE, 0); g_object_set(G_OBJECT(padding), "left-padding", 8, NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(padding), vbox); windata->summary_label = gtk_label_new(NULL); gtk_widget_show(windata->summary_label); gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0); gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE); atkobj = gtk_widget_get_accessible(windata->summary_label); atk_object_set_description(atkobj, "Notification summary text."); windata->body_label = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0); gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE); g_signal_connect(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(activate_link), windata); atkobj = gtk_widget_get_accessible(windata->body_label); atk_object_set_description(atkobj, "Notification body text."); /* Disabled for now */ alignment = gtk_alignment_new(1, 0.5, 0, 0); gtk_widget_show(alignment); gtk_widget_hide(alignment); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0); windata->actions_box = gtk_hbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box); return GTK_WINDOW(win); }
gint main (gint argc, gchar **argv) { GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window; GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu; gint i; static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)", "both (horizontal)" }; GtkToolItem *item; GtkListStore *store; GtkWidget *image; GtkWidget *menuitem; GtkWidget *button; GtkWidget *label; GIcon *gicon; GSList *group; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); toolbar = gtk_toolbar_new (); gtk_widget_set_vexpand (toolbar, TRUE); gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5); gtk_widget_set_vexpand (hbox1, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5); gtk_widget_set_vexpand (hbox2, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1); checkbox = gtk_check_button_new_with_mnemonic("_Vertical"); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_orientation), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_show_arrow), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); gtk_widget_set_sensitive (option_menu, FALSE); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]); gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), gtk_toolbar_get_style (GTK_TOOLBAR (toolbar))); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (change_toolbar_style), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); gtk_widget_set_sensitive (option_menu, FALSE); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar"); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (icon_size_history_changed), toolbar); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_hexpand (scrolled_window, TRUE); gtk_widget_set_vexpand (scrolled_window, TRUE); gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1); store = create_items_list (&treeview); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label"); add_item_to_list (store, item, "New"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item); gtk_tool_item_set_expand (item, TRUE); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("Menuitem %d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "Open"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("A%d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "BackWithHistory"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG); item = gtk_tool_item_new (); gtk_widget_show (image); gtk_container_add (GTK_CONTAINER (item), image); add_item_to_list (store, item, "(Custom Item)"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); add_item_to_list (store, item, "Back"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward"); add_item_to_list (store, item, "Forward"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold"); g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL); add_item_to_list (store, item, "Bold"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0); item = gtk_radio_tool_button_new (NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left"); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Left"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center"); make_prop_editor (G_OBJECT (item)); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Center"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right"); add_item_to_list (store, item, "Right"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple"); add_item_to_list (store, item, "Apple"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE); gicon = g_content_type_get_icon ("video/ogg"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR); g_object_unref (gicon); item = gtk_tool_button_new (image, "Video"); add_item_to_list (store, item, "Video"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR); item = gtk_tool_button_new (image, "Terminal"); add_item_to_list (store, item, "Terminal"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_spinner_new (); gtk_spinner_start (GTK_SPINNER (image)); item = gtk_tool_button_new (image, "Spinner"); add_item_to_list (store, item, "Spinner"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_set_hexpand (hbox, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1); button = gtk_button_new_with_label ("Drag me to the toolbar"); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Drop index:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); checkbox = gtk_check_button_new_with_mnemonic("_Right to left"); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE); g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL); gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0); gtk_drag_source_set (button, GDK_BUTTON1_MASK, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); g_signal_connect (toolbar, "drag_motion", G_CALLBACK (toolbar_drag_motion), NULL); g_signal_connect (toolbar, "drag_leave", G_CALLBACK (toolbar_drag_leave), NULL); g_signal_connect (toolbar, "drag_drop", G_CALLBACK (toolbar_drag_drop), label); gtk_widget_show_all (window); make_prop_editor (G_OBJECT (toolbar)); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL); gtk_main (); return 0; }
gint main (gint argc, gchar **argv) { GtkWidget *window, *main_box, *container, *child; GtkWidget *box, *toolbar; GtkStyleProvider *provider; GtkTextBuffer *css; gtk_init (&argc, &argv); css = gtk_text_buffer_new (NULL); gtk_text_buffer_create_tag (css, "warning", "background", "rgba(255,255,0,0.3)", NULL); gtk_text_buffer_create_tag (css, "error", "background", "rgba(255,0,0,0.3)", NULL); provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ()); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), provider, GTK_STYLE_PROVIDER_PRIORITY_FORCE); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), main_box); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_TEXT); gtk_box_pack_start (GTK_BOX (main_box), toolbar, FALSE, TRUE, 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_box), box, FALSE, TRUE, 0); container = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (container), 200); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (container), 200); gtk_box_pack_start (GTK_BOX (main_box), container, TRUE, TRUE, 0); child = gtk_text_view_new_with_buffer (css); gtk_container_add (GTK_CONTAINER (container), child); g_signal_connect (css, "changed", G_CALLBACK (css_text_changed), provider); gtk_text_buffer_set_text (css, DEFAULT_CSS, -1); g_signal_connect (provider, "parsing-error", G_CALLBACK (show_parsing_error), gtk_text_view_get_buffer (GTK_TEXT_VIEW (child))); container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_box), container, FALSE, TRUE, 0); child = gtk_switch_new (); gtk_switch_set_active (GTK_SWITCH (child), gtk_widget_get_default_direction () == GTK_TEXT_DIR_LTR); g_signal_connect (child, "notify::active", G_CALLBACK (set_orientation), NULL); gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_label_new ("left-to-right"); gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_button_new_with_label ("Add button"); g_signal_connect_swapped (child, "clicked", G_CALLBACK (add_button), box); gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_button_new_with_label ("Add toolbutton"); g_signal_connect_swapped (child, "clicked", G_CALLBACK (add_toolbutton), toolbar); gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); gtk_widget_show_all (window); gtk_main (); return 0; }
nsresult nsIconChannel::Init(nsIURI* aURI) { nsCOMPtr<nsIMozIconURI> iconURI = do_QueryInterface(aURI); NS_ASSERTION(iconURI, "URI is not an nsIMozIconURI"); nsAutoCString stockIcon; iconURI->GetStockIcon(stockIcon); if (stockIcon.IsEmpty()) { #ifdef MOZ_ENABLE_GNOMEUI return InitWithGnome(iconURI); #else #ifdef MOZ_ENABLE_GIO return InitWithGIO(iconURI); #else return NS_ERROR_NOT_AVAILABLE; #endif #endif } // Search for stockIcon nsAutoCString iconSizeString; iconURI->GetIconSize(iconSizeString); nsAutoCString iconStateString; iconURI->GetIconState(iconStateString); GtkIconSize icon_size = moz_gtk_icon_size(iconSizeString.get()); GtkStateType state = iconStateString.EqualsLiteral("disabled") ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL; // First lookup the icon by stock id and text direction. GtkTextDirection direction = GTK_TEXT_DIR_NONE; if (StringEndsWith(stockIcon, NS_LITERAL_CSTRING("-ltr"))) { direction = GTK_TEXT_DIR_LTR; } else if (StringEndsWith(stockIcon, NS_LITERAL_CSTRING("-rtl"))) { direction = GTK_TEXT_DIR_RTL; } bool forceDirection = direction != GTK_TEXT_DIR_NONE; nsAutoCString stockID; bool useIconName = false; if (!forceDirection) { direction = gtk_widget_get_default_direction(); stockID = stockIcon; } else { // GTK versions < 2.22 use icon names from concatenating stock id with // -(rtl|ltr), which is how the moz-icon stock name is interpreted here. stockID = Substring(stockIcon, 0, stockIcon.Length() - 4); // However, if we lookup bidi icons by the stock name, then GTK versions // >= 2.22 will use a bidi lookup convention that most icon themes do not // yet follow. Therefore, we first check to see if the theme supports the // old icon name as this will have bidi support (if found). GtkIconTheme *icon_theme = gtk_icon_theme_get_default(); // Micking what gtk_icon_set_render_icon does with sizes, though it's not // critical as icons will be scaled to suit size. It just means we follow // the same pathes and so share caches. gint width, height; if (gtk_icon_size_lookup(icon_size, &width, &height)) { gint size = NS_MIN(width, height); // We use gtk_icon_theme_lookup_icon() without // GTK_ICON_LOOKUP_USE_BUILTIN instead of gtk_icon_theme_has_icon() so // we don't pick up fallback icons added by distributions for backward // compatibility. GtkIconInfo *icon = gtk_icon_theme_lookup_icon(icon_theme, stockIcon.get(), size, (GtkIconLookupFlags)0); if (icon) { useIconName = true; gtk_icon_info_free(icon); } } } ensure_stock_image_widget(); GtkStyle *style = gtk_widget_get_style(gStockImageWidget); GtkIconSet *icon_set = NULL; if (!useIconName) { icon_set = gtk_style_lookup_icon_set(style, stockID.get()); } if (!icon_set) { // Either we have choosen icon-name lookup for a bidi icon, or stockIcon is // not a stock id so we assume it is an icon name. useIconName = true; // Creating a GtkIconSet is a convenient way to allow the style to // render the icon, possibly with variations suitable for insensitive // states. icon_set = gtk_icon_set_new(); GtkIconSource *icon_source = gtk_icon_source_new(); gtk_icon_source_set_icon_name(icon_source, stockIcon.get()); gtk_icon_set_add_source(icon_set, icon_source); gtk_icon_source_free(icon_source); } GdkPixbuf *icon = gtk_icon_set_render_icon (icon_set, style, direction, state, icon_size, gStockImageWidget, NULL); if (useIconName) { gtk_icon_set_unref(icon_set); } // According to documentation, gtk_icon_set_render_icon() never returns // NULL, but it does return NULL when we have the problem reported here: // https://bugzilla.gnome.org/show_bug.cgi?id=629878#c13 if (!icon) return NS_ERROR_NOT_AVAILABLE; nsresult rv = moz_gdk_pixbuf_to_channel(icon, iconURI, getter_AddRefs(mRealChannel)); g_object_unref(icon); return rv; }
static void do_notify (RBNotificationPlugin *plugin, guint timeout, const char *primary, const char *secondary, const char *image_uri, gboolean playback) { GError *error = NULL; NotifyNotification *notification; if (notify_is_initted () == FALSE) { GList *caps; if (notify_init ("Rhythmbox") == FALSE) { g_warning ("libnotify initialization failed"); return; } /* ask the notification server if it supports actions */ caps = notify_get_server_caps (); if (g_list_find_custom (caps, "actions", (GCompareFunc)g_strcmp0) != NULL) { rb_debug ("notification server supports actions"); plugin->notify_supports_actions = TRUE; if (g_list_find_custom (caps, "action-icons", (GCompareFunc)g_strcmp0) != NULL) { rb_debug ("notifiction server supports icon buttons"); plugin->notify_supports_icon_buttons = TRUE; } } else { rb_debug ("notification server does not support actions"); } if (g_list_find_custom (caps, "persistence", (GCompareFunc)g_strcmp0) != NULL) { rb_debug ("notification server supports persistence"); plugin->notify_supports_persistence = TRUE; } else { rb_debug ("notification server does not support persistence"); } rb_list_deep_free (caps); } if (primary == NULL) primary = ""; if (secondary == NULL) secondary = ""; if (playback) { notification = plugin->notification; } else { notification = plugin->misc_notification; } if (notification == NULL) { notification = notify_notification_new (primary, secondary, RB_APP_ICON); g_signal_connect_object (notification, "closed", G_CALLBACK (notification_closed_cb), plugin, 0); if (playback) { plugin->notification = notification; } else { plugin->misc_notification = notification; } } else { notify_notification_clear_hints (notification); notify_notification_update (notification, primary, secondary, RB_APP_ICON); } notify_notification_set_timeout (notification, timeout); if (image_uri != NULL) { notify_notification_clear_hints (notification); notify_notification_set_hint (notification, "image_path", g_variant_new_string (image_uri)); } if (playback) notify_notification_set_category (notification, "x-gnome.music"); notify_notification_set_hint (notification, "desktop-entry", g_variant_new_string ("rhythmbox")); notify_notification_clear_actions (notification); if (playback && plugin->notify_supports_actions) { gboolean rtl; const char *play_icon; rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL); play_icon = rtl ? "media-playback-start-rtl" : "media-playback-start"; if (plugin->notify_supports_icon_buttons) { gboolean playing = FALSE; rb_shell_player_get_playing (plugin->shell_player, &playing, NULL); notify_notification_add_action (notification, rtl ? "media-skip-backward-rtl" : "media-skip-backward", _("Previous"), (NotifyActionCallback) notification_previous_cb, plugin, NULL); notify_notification_add_action (notification, playing ? "media-playback-pause" : play_icon, playing ? _("Pause") : _("Play"), (NotifyActionCallback) notification_playpause_cb, plugin, NULL); notify_notification_set_hint (notification, "action-icons", g_variant_new_boolean (TRUE)); } notify_notification_add_action (notification, rtl ? "media-skip-forward-rtl" : "media-skip-forward", _("Next"), (NotifyActionCallback) notification_next_cb, plugin, NULL); } if (plugin->notify_supports_persistence) { const char *hint; if (playback) { hint = "resident"; } else { hint = "transient"; } notify_notification_set_hint (notification, hint, g_variant_new_boolean (TRUE)); } if (notify_notification_show (notification, &error) == FALSE) { g_warning ("Failed to send notification (%s): %s", primary, error->message); g_error_free (error); } }