static bool_t init (void) { search_tool = aud_plugin_lookup_basename ("search-tool"); aud_config_set_defaults ("gtkui", gtkui_defaults); pw_col_init (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE); g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL); accel = gtk_accel_group_new (); gtk_window_add_accel_group ((GtkWindow *) window, accel); vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add ((GtkContainer *) window, vbox_outer); menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS); GtkStyleContext * context = gtk_widget_get_style_context (toolbar); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0); /* search button */ if (search_tool) { search_button = toggle_button_new ("edit-find", toggle_search_tool); gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1); gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button, aud_plugin_get_enabled (search_tool)); aud_plugin_add_watch (search_tool, search_tool_toggled, NULL); } /* playback buttons */ toolbar_button_add (toolbar, button_open_pressed, "document-open"); toolbar_button_add (toolbar, button_add_pressed, "list-add"); button_play = toolbar_button_add (toolbar, aud_drct_play_pause, "media-playback-start"); button_stop = toolbar_button_add (toolbar, aud_drct_stop, "media-playback-stop"); toolbar_button_add (toolbar, aud_drct_pl_prev, "media-skip-backward"); toolbar_button_add (toolbar, aud_drct_pl_next, "media-skip-forward"); /* time slider and label */ GtkToolItem * boxitem1 = gtk_tool_item_new (); gtk_tool_item_set_expand (boxitem1, TRUE); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1); GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem1, box1); slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL); gtk_range_set_increments ((GtkRange *) slider, 5000, 5000); gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE); gtk_widget_set_size_request(slider, 120, -1); gtk_widget_set_valign (slider, GTK_ALIGN_CENTER); gtk_widget_set_can_focus(slider, FALSE); gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6); label_time = markup_label_new(NULL); gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6); gtk_widget_set_no_show_all (slider, TRUE); gtk_widget_set_no_show_all (label_time, TRUE); /* repeat and shuffle buttons */ button_repeat = toggle_button_new ("media-playlist-repeat", toggle_repeat); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1); button_shuffle = toggle_button_new ("media-playlist-shuffle", toggle_shuffle); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1); /* volume button */ GtkToolItem * boxitem2 = gtk_tool_item_new (); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1); GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem2, box2); volume = gtk_volume_button_new(); gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE); gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0))); gtk_widget_set_can_focus(volume, FALSE); int lvol = 0, rvol = 0; aud_drct_get_volume(&lvol, &rvol); gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2); gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0); /* main UI layout */ layout_load (); GtkWidget * layout = layout_new (); gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); layout_add_center (vbox); ui_playlist_notebook_new (); gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0); /* optional UI elements */ show_menu (aud_get_bool ("gtkui", "menu_visible")); show_infoarea (aud_get_bool ("gtkui", "infoarea_visible")); if (aud_get_bool ("gtkui", "statusbar_visible")) { statusbar = ui_statusbar_new (); gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0); } AUDDBG("hooks associate\n"); ui_hooks_associate(); AUDDBG("playlist associate\n"); ui_playlist_notebook_populate(); g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL); g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL); g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL); volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL); g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL); g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL); update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume); g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL); g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL); g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL); if (aud_drct_get_playing ()) { ui_playback_begin (); if (aud_drct_get_ready ()) ui_playback_ready (); } else ui_playback_stop (); title_change_cb (); gtk_widget_show_all (vbox_outer); update_toggles (NULL, NULL); menu_rclick = make_menu_rclick (accel); menu_tab = make_menu_tab (accel); return TRUE; }
/* Create a new TilemKeypadDialog. */ TilemKeypadDialog *tilem_keypad_dialog_new(TilemDebugger *dbg) { TilemKeypadDialog *kpdlg; GtkWidget *tbl1, *tbl2, *hbox, *vbox, *btn, *lbl; int i, j; char buf[20]; g_return_val_if_fail(dbg != NULL, NULL); kpdlg = g_slice_new0(TilemKeypadDialog); kpdlg->dbg = dbg; kpdlg->window = gtk_dialog_new_with_buttons (_("Keypad"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); g_signal_connect(kpdlg->window, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); tbl1 = gtk_table_new(NGROUPS, NKEYS, TRUE); hbox = gtk_hbox_new(TRUE, 0); vbox = gtk_vbox_new(TRUE, 0); /* Keypad buttons (labels will be filled in, and buttons shown/hidden, by tilem_keypad_dialog_calc_changed()) Buttons are displayed right to left, top to bottom; this way, the layout of groups 1-5 roughly corresponds to the physical layout of the keys, and the "input" value can be read across the bottom as a binary number. */ for (i = 0; i < NGROUPS; i++) { for (j = 0; j < NKEYS; j++) { btn = gtk_toggle_button_new_with_label(""); kpdlg->keys[i][j] = btn; gtk_table_attach(GTK_TABLE(tbl1), btn, NKEYS - j - 1, NKEYS - j, i, i + 1, GTK_FILL, GTK_FILL, 2, 2); g_signal_connect(btn, "toggled", G_CALLBACK(key_toggled), kpdlg); gtk_widget_set_no_show_all(btn, TRUE); } } /* Check buttons for key groups (output bits) */ for (i = 0; i < NGROUPS; i++) { g_snprintf(buf, sizeof(buf), _("Group %d"), i); btn = gtk_check_button_new_with_label(buf); kpdlg->output[i] = btn; gtk_box_pack_start(GTK_BOX(vbox), btn, FALSE, TRUE, 2); g_signal_connect(btn, "toggled", G_CALLBACK(group_toggled), kpdlg); } /* Labels for input bits */ for (j = NKEYS - 1; j >= 0; j--) { kpdlg->input[j] = lbl = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(hbox), lbl, FALSE, TRUE, 2); } tbl2 = gtk_table_new(3, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(tbl2), 6); gtk_table_set_row_spacings(GTK_TABLE(tbl2), 12); gtk_table_set_col_spacings(GTK_TABLE(tbl2), 12); lbl = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(lbl), _("<b>Scan Groups</b>")); gtk_table_attach(GTK_TABLE(tbl2), lbl, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); lbl = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(lbl), _("<b>Keys</b>")); gtk_table_attach(GTK_TABLE(tbl2), lbl, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); lbl = gtk_label_new(_("Input Value:")); gtk_table_attach(GTK_TABLE(tbl2), lbl, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tbl2), vbox, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tbl2), tbl1, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(tbl2), hbox, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show_all(tbl2); vbox = gtk_dialog_get_content_area(GTK_DIALOG(kpdlg->window)); gtk_box_pack_start(GTK_BOX(vbox), tbl2, FALSE, FALSE, 0); tilem_keypad_dialog_calc_changed(kpdlg); return kpdlg; }
GtkWidget * gimp_thumb_box_new (GimpContext *context) { GimpThumbBox *box; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *ebox; GtkWidget *hbox; GtkWidget *button; GtkWidget *label; gchar *str; gint h, v; GtkRequisition info_requisition; GtkRequisition progress_requisition; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); box = g_object_new (GIMP_TYPE_THUMB_BOX, NULL); box->context = context; ebox = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (box), ebox); gtk_widget_show (ebox); g_signal_connect (ebox, "button-press-event", G_CALLBACK (gimp_thumb_box_ebox_button_press), box); str = g_strdup_printf (_("Click to update preview\n" "%s%sClick to force update even " "if preview is up-to-date"), gimp_get_mod_string (GDK_CONTROL_MASK), gimp_get_mod_separator ()); gimp_help_set_help_data (ebox, str, NULL); g_free (str); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (ebox), vbox); gtk_widget_show (vbox); button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); label = gtk_label_new_with_mnemonic (_("Pr_eview")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_container_add (GTK_CONTAINER (button), label); gtk_widget_show (label); g_signal_connect (button, "button-press-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (button, "button-release-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (button, "enter-notify-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (button, "leave-notify-event", G_CALLBACK (gtk_true), NULL); vbox2 = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 2); gtk_container_add (GTK_CONTAINER (vbox), vbox2); gtk_widget_show (vbox2); hbox = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); box->imagefile = gimp_imagefile_new (context->gimp, NULL); g_signal_connect (box->imagefile, "info-changed", G_CALLBACK (gimp_thumb_box_imagefile_info_changed), box); g_signal_connect (box->imagefile->thumbnail, "notify::thumb-state", G_CALLBACK (gimp_thumb_box_thumb_state_notify), box); gimp_view_renderer_get_frame_size (&h, &v); box->preview = gimp_view_new (context, GIMP_VIEWABLE (box->imagefile), /* add padding for the shadow frame */ context->gimp->config->thumbnail_size + MAX (h, v), 0, FALSE); gtk_box_pack_start (GTK_BOX (hbox), box->preview, TRUE, FALSE, 2); gtk_widget_show (box->preview); gtk_label_set_mnemonic_widget (GTK_LABEL (label), box->preview); g_signal_connect (box->preview, "clicked", G_CALLBACK (gimp_thumb_box_thumbnail_clicked), box); box->filename = gtk_label_new (_("No selection")); gtk_label_set_ellipsize (GTK_LABEL (box->filename), PANGO_ELLIPSIZE_MIDDLE); gtk_label_set_justify (GTK_LABEL (box->filename), GTK_JUSTIFY_CENTER); gimp_label_set_attributes (GTK_LABEL (box->filename), PANGO_ATTR_STYLE, PANGO_STYLE_OBLIQUE, -1); gtk_box_pack_start (GTK_BOX (vbox2), box->filename, FALSE, FALSE, 0); gtk_widget_show (box->filename); box->info = gtk_label_new (" \n \n \n "); gtk_misc_set_alignment (GTK_MISC (box->info), 0.5, 0.0); gtk_label_set_justify (GTK_LABEL (box->info), GTK_JUSTIFY_CENTER); gimp_label_set_attributes (GTK_LABEL (box->info), PANGO_ATTR_SCALE, PANGO_SCALE_SMALL, -1); gtk_box_pack_start (GTK_BOX (vbox2), box->info, FALSE, FALSE, 0); gtk_widget_show (box->info); box->progress = gtk_progress_bar_new (); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "Fog"); gtk_box_pack_end (GTK_BOX (vbox2), box->progress, FALSE, FALSE, 0); gtk_widget_set_no_show_all (box->progress, TRUE); /* don't gtk_widget_show (box->progress); */ /* eek */ gtk_widget_size_request (box->info, &info_requisition); gtk_widget_size_request (box->progress, &progress_requisition); gtk_widget_set_size_request (box->info, progress_requisition.width, info_requisition.height); gtk_widget_set_size_request (box->filename, progress_requisition.width, -1); gtk_widget_set_size_request (box->progress, -1, progress_requisition.height); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), ""); return GTK_WIDGET (box); }
Compose * compose_new(Config * config) { Compose * compose; GtkAccelGroup * group; GtkWidget * vbox; GtkWidget * toolbar; GtkToolItem * toolitem; GtkSizeGroup * sizegroup; GtkWidget * vpaned; GtkWidget * vbox2; GtkWidget * widget; GtkCellRenderer * renderer; GtkTreeViewColumn * column; GtkTreeIter iter; char const * headers[] = { "To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:", "Followup-To:" }; size_t i; gint size; if((compose = malloc(sizeof(*compose))) == NULL) { compose_error(NULL, strerror(errno), 0); return NULL; } compose->mime = mime_new(NULL); /* check errors */ if(compose->mime == NULL) { free(compose); return NULL; } compose->config = config; compose->standalone = FALSE; /* window */ group = gtk_accel_group_new(); compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(compose->window), group); g_object_unref(group); #ifndef EMBEDDED gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384); #else gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300); #endif gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose")); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer"); #endif g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event", G_CALLBACK(_compose_on_closex), compose); #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #else vbox = gtk_vbox_new(FALSE, 0); #endif /* menubar */ #ifndef EMBEDDED widget = desktop_menubar_create(_compose_menubar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); #endif /* toolbar */ toolbar = desktop_toolbar_create(_compose_toolbar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); /* from */ sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("From: ")); #if GTK_CHECK_VERSION(3, 14, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); #endif gtk_widget_set_size_request(widget, 80, -1); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); #if GTK_CHECK_VERSION(2, 24, 0) compose->from = gtk_combo_box_text_new_with_entry(); #else compose->from = gtk_combo_box_entry_new_text(); #endif toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->from); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* paned */ #if GTK_CHECK_VERSION(3, 0, 0) vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL); #else vpaned = gtk_vpaned_new(); #endif if(gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &size, &size) != TRUE) size = 24; gtk_paned_set_position(GTK_PANED(vpaned), size * 2); /* headers */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL( compose->h_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER( compose->h_store_filter), _compose_on_headers_filter, compose, NULL); compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( compose->h_store_filter)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE); compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for(i = 0; i < sizeof(headers) / sizeof(*headers); i++) { gtk_list_store_append(compose->h_headers, &iter); gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1, headers[i], -1); } renderer = gtk_cell_renderer_combo_new(); g_object_set(renderer, "editable", TRUE, "model", compose->h_headers, "text-column", 1, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_field_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_HEADER, NULL); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_VALUE, NULL); #if GTK_CHECK_VERSION(2, 4, 0) gtk_tree_view_column_set_expand(column, TRUE); #endif gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); /* default to 8-bits transfers with UTF-8 encoding */ compose_set_header(compose, "Content-Transfer-Encoding:", "8bit", FALSE); compose_set_header(compose, "Content-Type:", "text/plain; charset=UTF-8", FALSE); compose_add_field(compose, "To:", NULL); gtk_container_add(GTK_CONTAINER(widget), compose->h_view); gtk_paned_add1(GTK_PANED(vpaned), widget); /* paned */ #if GTK_CHECK_VERSION(3, 0, 0) vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #else vbox2 = gtk_vbox_new(FALSE, 0); #endif /* subject */ toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("Subject: ")); #if GTK_CHECK_VERSION(3, 14, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); #endif gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); compose->subject = gtk_entry_new(); toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->subject); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0); /* view */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->view = _new_text_view(compose); compose_set_font(compose, _compose_get_font(compose)); gtk_container_add(GTK_CONTAINER(widget), compose->view); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); gtk_paned_add2(GTK_PANED(vpaned), vbox2); gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); /* attachments */ compose->a_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER); compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL( compose->a_store)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view), CAC_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view), CAC_BASENAME); gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view); gtk_widget_show_all(compose->a_view); gtk_widget_set_no_show_all(compose->a_window, TRUE); gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0); /* statusbar */ compose->statusbar = gtk_statusbar_new(); compose->statusbar_id = 0; gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(compose->window), vbox); /* about dialog */ compose->ab_window = NULL; /* signature */ compose_append_signature(compose); compose_set_modified(compose, FALSE); compose_scroll_to_offset(compose, 0); /* display */ gtk_widget_grab_focus(compose->view); gtk_widget_show_all(vbox); gtk_widget_show(compose->window); return compose; }
static void edit_preset(const char *name_in, dt_iop_module_t *module) { gchar *name = NULL; if(name_in == NULL) { name = get_active_preset_name(module); if(name == NULL) return; } else name = g_strdup(name_in); GtkWidget *dialog; /* Create the widgets */ char title[1024]; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); snprintf(title, sizeof(title), _("edit `%s' for module `%s'"), name, module->name()); dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, _("_ok"), GTK_RESPONSE_ACCEPT, _("_cancel"), GTK_RESPONSE_REJECT, NULL); GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_container_add(content_area, GTK_WIDGET(box)); GtkWidget *label; dt_gui_presets_edit_dialog_t *g = (dt_gui_presets_edit_dialog_t *)malloc(sizeof(dt_gui_presets_edit_dialog_t)); g->old_id = -1; g->original_name = name; g->module = module; g->name = GTK_ENTRY(gtk_entry_new()); gtk_entry_set_text(g->name, name); gtk_box_pack_start(box, GTK_WIDGET(g->name), FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(g->name), _("name of the preset")); g->description = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(g->description), FALSE, FALSE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(g->description), _("description or further information")); g->autoapply = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto apply this preset to matching images"))); gtk_box_pack_start(box, GTK_WIDGET(g->autoapply), FALSE, FALSE, 0); g->filter = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("only show this preset for matching images"))); gtk_widget_set_tooltip_text(GTK_WIDGET(g->filter), _("be very careful with this option. " "this might be the last time you see your preset.")); gtk_box_pack_start(box, GTK_WIDGET(g->filter), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(g->autoapply), "toggled", G_CALLBACK(check_buttons_activated), g); g_signal_connect(G_OBJECT(g->filter), "toggled", G_CALLBACK(check_buttons_activated), g); int line = 0; g->details = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(g->details), DT_PIXEL_APPLY_DPI(5)); gtk_grid_set_column_spacing(GTK_GRID(g->details), DT_PIXEL_APPLY_DPI(10)); gtk_box_pack_start(box, GTK_WIDGET(g->details), TRUE, TRUE, 0); // model, maker, lens g->model = gtk_entry_new(); gtk_widget_set_hexpand(GTK_WIDGET(g->model), TRUE); gtk_widget_set_tooltip_text(g->model, _("string to match model (use % as wildcard)")); label = gtk_label_new(_("model")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->model, label, GTK_POS_RIGHT, 2, 1); g->maker = gtk_entry_new(); gtk_widget_set_tooltip_text(g->maker, _("string to match maker (use % as wildcard)")); label = gtk_label_new(_("maker")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->maker, label, GTK_POS_RIGHT, 2, 1); g->lens = gtk_entry_new(); gtk_widget_set_tooltip_text(g->lens, _("string to match lens (use % as wildcard)")); label = gtk_label_new(_("lens")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->lens, label, GTK_POS_RIGHT, 2, 1); // iso label = gtk_label_new(_("ISO")); gtk_widget_set_halign(label, GTK_ALIGN_START); g->iso_min = gtk_spin_button_new_with_range(0, 51200, 100); gtk_widget_set_tooltip_text(g->iso_min, _("minimum ISO value")); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->iso_min), 0); g->iso_max = gtk_spin_button_new_with_range(0, 51200, 100); gtk_widget_set_tooltip_text(g->iso_max, _("maximum ISO value")); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->iso_max), 0); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->iso_min, label, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->iso_max, g->iso_min, GTK_POS_RIGHT, 1, 1); // exposure label = gtk_label_new(_("exposure")); gtk_widget_set_halign(label, GTK_ALIGN_START); g->exposure_min = dt_bauhaus_combobox_new(NULL); g->exposure_max = dt_bauhaus_combobox_new(NULL); gtk_widget_set_tooltip_text(g->exposure_min, _("minimum exposure time")); gtk_widget_set_tooltip_text(g->exposure_max, _("maximum exposure time")); for(int k = 0; k < dt_gui_presets_exposure_value_cnt; k++) dt_bauhaus_combobox_add(g->exposure_min, dt_gui_presets_exposure_value_str[k]); for(int k = 0; k < dt_gui_presets_exposure_value_cnt; k++) dt_bauhaus_combobox_add(g->exposure_max, dt_gui_presets_exposure_value_str[k]); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->exposure_min, label, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->exposure_max, g->exposure_min, GTK_POS_RIGHT, 1, 1); // aperture label = gtk_label_new(_("aperture")); gtk_widget_set_halign(label, GTK_ALIGN_START); g->aperture_min = dt_bauhaus_combobox_new(NULL); g->aperture_max = dt_bauhaus_combobox_new(NULL); gtk_widget_set_tooltip_text(g->aperture_min, _("minimum aperture value")); gtk_widget_set_tooltip_text(g->aperture_max, _("maximum aperture value")); for(int k = 0; k < dt_gui_presets_aperture_value_cnt; k++) dt_bauhaus_combobox_add(g->aperture_min, dt_gui_presets_aperture_value_str[k]); for(int k = 0; k < dt_gui_presets_aperture_value_cnt; k++) dt_bauhaus_combobox_add(g->aperture_max, dt_gui_presets_aperture_value_str[k]); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->aperture_min, label, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->aperture_max, g->aperture_min, GTK_POS_RIGHT, 1, 1); // focal length label = gtk_label_new(_("focal length")); gtk_widget_set_halign(label, GTK_ALIGN_START); g->focal_length_min = gtk_spin_button_new_with_range(0, 1000, 10); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->focal_length_min), 0); g->focal_length_max = gtk_spin_button_new_with_range(0, 1000, 10); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->focal_length_max), 0); gtk_widget_set_tooltip_text(g->focal_length_min, _("minimum focal length")); gtk_widget_set_tooltip_text(g->focal_length_max, _("maximum focal length")); gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->focal_length_min, label, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to(GTK_GRID(g->details), g->focal_length_max, g->focal_length_min, GTK_POS_RIGHT, 1, 1); // raw/hdr/ldr label = gtk_label_new(_("format")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(g->details), label, 0, line, 1, 1); for(int i = 0; i < 3; i++) { g->format_btn[i] = gtk_check_button_new_with_label(_(dt_gui_presets_format_value_str[i])); gtk_grid_attach(GTK_GRID(g->details), g->format_btn[i], 1, line + i, 2, 1); } gtk_widget_set_no_show_all(GTK_WIDGET(g->details), TRUE); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT rowid, description, model, maker, lens, iso_min, iso_max, " "exposure_min, exposure_max, aperture_min, aperture_max, focal_length_min, " "focal_length_max, autoapply, filter, format FROM presets WHERE name = ?1 AND " "operation = ?2 AND op_version = ?3", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, module->version()); if(sqlite3_step(stmt) == SQLITE_ROW) { g->old_id = sqlite3_column_int(stmt, 0); gtk_entry_set_text(GTK_ENTRY(g->description), (const char *)sqlite3_column_text(stmt, 1)); gtk_entry_set_text(GTK_ENTRY(g->model), (const char *)sqlite3_column_text(stmt, 2)); gtk_entry_set_text(GTK_ENTRY(g->maker), (const char *)sqlite3_column_text(stmt, 3)); gtk_entry_set_text(GTK_ENTRY(g->lens), (const char *)sqlite3_column_text(stmt, 4)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_min), sqlite3_column_double(stmt, 5)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_max), sqlite3_column_double(stmt, 6)); float val = sqlite3_column_double(stmt, 7); int k = 0; for(; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++) ; dt_bauhaus_combobox_set(g->exposure_min, k); val = sqlite3_column_double(stmt, 8); for(k = 0; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++) ; dt_bauhaus_combobox_set(g->exposure_max, k); val = sqlite3_column_double(stmt, 9); for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++) ; dt_bauhaus_combobox_set(g->aperture_min, k); val = sqlite3_column_double(stmt, 10); for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++) ; dt_bauhaus_combobox_set(g->aperture_max, k); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_min), sqlite3_column_double(stmt, 11)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_max), sqlite3_column_double(stmt, 12)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoapply), sqlite3_column_int(stmt, 13)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->filter), sqlite3_column_int(stmt, 14)); const int format = sqlite3_column_int(stmt, 15); for(k = 0; k < 3; k++) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->format_btn[k]), format & (dt_gui_presets_format_flag[k])); } else { gtk_entry_set_text(GTK_ENTRY(g->description), ""); gtk_entry_set_text(GTK_ENTRY(g->model), "%"); gtk_entry_set_text(GTK_ENTRY(g->maker), "%"); gtk_entry_set_text(GTK_ENTRY(g->lens), "%"); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_min), 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_max), 51200); float val = 0; int k = 0; for(; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++) ; dt_bauhaus_combobox_set(g->exposure_min, k); val = 100000000; for(k = 0; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++) ; dt_bauhaus_combobox_set(g->exposure_max, k); val = 0; for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++) ; dt_bauhaus_combobox_set(g->aperture_min, k); val = 100000000; for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++) ; dt_bauhaus_combobox_set(g->aperture_max, k); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_min), 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_max), 1000); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoapply), 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->filter), 0); for(k = 0; k < 3; k++) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->format_btn[k]), TRUE); } sqlite3_finalize(stmt); g_signal_connect(dialog, "response", G_CALLBACK(edit_preset_response), g); gtk_widget_show_all(dialog); }
static void polkit_mate_authentication_dialog_constructed (GObject *object) { PolkitMateAuthenticationDialog *dialog; GtkWidget *hbox; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *table_alignment; GtkWidget *table; GtkWidget *details_expander; GtkWidget *details_vbox; GtkWidget *label; GtkWidget *image; GtkWidget *content_area; GtkWidget *action_area; gboolean have_user_combobox; gchar *s; guint rows; dialog = POLKIT_MATE_AUTHENTICATION_DIALOG (object); if (G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed != NULL) G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed (object); have_user_combobox = FALSE; dialog->priv->cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); dialog->priv->auth_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Authenticate"), GTK_RESPONSE_OK); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog)); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5); gtk_box_set_spacing (GTK_BOX (action_area), 6); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); image = get_image (dialog); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); main_vbox = gtk_vbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0); /* main message */ label = gtk_label_new (NULL); s = g_strdup_printf ("<big><b>%s</b></big>", dialog->priv->message); gtk_label_set_markup (GTK_LABEL (label), s); g_free (s); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); /* secondary message */ label = gtk_label_new (NULL); if (g_strv_length (dialog->priv->users) > 1) { gtk_label_set_markup (GTK_LABEL (label), _("An application is attempting to perform an action that requires privileges. " "Authentication as one of the users below is required to perform this action.")); } else { if (strcmp (g_get_user_name (), dialog->priv->users[0]) == 0) { gtk_label_set_markup (GTK_LABEL (label), _("An application is attempting to perform an action that requires privileges. " "Authentication is required to perform this action.")); } else { gtk_label_set_markup (GTK_LABEL (label), _("An application is attempting to perform an action that requires privileges. " "Authentication as the super user is required to perform this action.")); } } gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); /* user combobox */ if (g_strv_length (dialog->priv->users) > 1) { dialog->priv->user_combobox = gtk_combo_box_new (); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (dialog->priv->user_combobox), FALSE, FALSE, 0); create_user_combobox (dialog); have_user_combobox = TRUE; } else { dialog->priv->selected_user = g_strdup (dialog->priv->users[0]); } /* password entry */ vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_box_pack_start (GTK_BOX (vbox), table_alignment, FALSE, FALSE, 0); table = gtk_table_new (1, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (table_alignment), table); dialog->priv->password_entry = gtk_entry_new (); gtk_entry_set_visibility (GTK_ENTRY (dialog->priv->password_entry), FALSE); dialog->priv->prompt_label = add_row (table, 0, _("_Password:"******"activate", G_CALLBACK (gtk_window_activate_default), dialog); dialog->priv->table_alignment = table_alignment; /* initially never show the password entry stuff; we'll toggle it on/off so it's * only shown when prompting for a password */ gtk_widget_set_no_show_all (dialog->priv->table_alignment, TRUE); /* A label for showing PAM_TEXT_INFO and PAM_TEXT_ERROR messages */ label = gtk_label_new (NULL); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); dialog->priv->info_label = label; /* Details */ details_expander = gtk_expander_new_with_mnemonic (_("<small><b>_Details</b></small>")); gtk_expander_set_use_markup (GTK_EXPANDER (details_expander), TRUE); gtk_box_pack_start (GTK_BOX (content_area), details_expander, FALSE, FALSE, 0); details_vbox = gtk_vbox_new (FALSE, 10); gtk_container_add (GTK_CONTAINER (details_expander), details_vbox); table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_box_pack_start (GTK_BOX (details_vbox), table_alignment, FALSE, FALSE, 0); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (table_alignment), table); /* TODO: sort keys? */ rows = 0; if (dialog->priv->details != NULL) { guint n; gchar **keys; keys = polkit_details_get_keys (dialog->priv->details); for (n = 0; keys[n] != NULL; n++) { const gchar *key = keys[n]; const gchar *value; value = polkit_details_lookup (dialog->priv->details, key); label = gtk_label_new (NULL); s = g_strdup_printf ("<small>%s</small>", value); gtk_label_set_markup (GTK_LABEL (label), s); g_free (s); gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0); s = g_strdup_printf ("<small><b>%s:</b></small>", key); add_row (table, rows, s, label); g_free (s); rows++; } g_strfreev (keys); } /* --- */ label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>", dialog->priv->action_id, dialog->priv->action_id); gtk_label_set_markup (GTK_LABEL (label), s); g_free (s); gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0); add_row (table, rows++, _("<small><b>Action:</b></small>"), label); g_signal_connect (label, "activate-link", G_CALLBACK (action_id_activated), NULL); s = g_strdup_printf (_("Click to edit %s"), dialog->priv->action_id); gtk_widget_set_tooltip_markup (label, s); g_free (s); /* --- */ label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>", dialog->priv->vendor_url, dialog->priv->vendor); gtk_label_set_markup (GTK_LABEL (label), s); g_free (s); gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0); add_row (table, rows++, _("<small><b>Vendor:</b></small>"), label); s = g_strdup_printf (_("Click to open %s"), dialog->priv->vendor_url); gtk_widget_set_tooltip_markup (label, s); g_free (s); if (have_user_combobox) { /* ... and make the password entry and "Authenticate" button insensitive */ gtk_widget_set_sensitive (dialog->priv->prompt_label, FALSE); gtk_widget_set_sensitive (dialog->priv->password_entry, FALSE); gtk_widget_set_sensitive (dialog->priv->auth_button, FALSE); } else { } gtk_widget_realize (GTK_WIDGET (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 void impl_constructed (GObject *object) { RBPodcastAddDialog *dialog; GtkBuilder *builder; GtkWidget *widget; GtkWidget *paned; GtkTreeViewColumn *column; GtkCellRenderer *renderer; RBEntryView *episodes; RBShellPlayer *shell_player; RhythmDBQuery *query; RhythmDBQueryModel *query_model; const char *episode_strings[3]; RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object); dialog = RB_PODCAST_ADD_DIALOG (object); g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL); builder = rb_builder_load ("podcast-add-dialog.ui", NULL); dialog->priv->info_bar_message = gtk_label_new (""); dialog->priv->info_bar = gtk_info_bar_new (); g_object_set (dialog->priv->info_bar, "spacing", 0, NULL); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))), dialog->priv->info_bar_message); gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE); gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0); gtk_widget_show (dialog->priv->info_bar_message); dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button")); g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE); dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view")); g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)), "changed", G_CALLBACK (feed_selection_changed_cb), dialog); dialog->priv->search_entry = rb_search_entry_new (FALSE); gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1); g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL); g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog); g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")), GTK_WIDGET (dialog->priv->search_entry)); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->feed_model = gtk_list_store_new (7, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* author */ GDK_TYPE_PIXBUF, /* image */ G_TYPE_FILE, /* image file */ G_TYPE_INT, /* episode count */ G_TYPE_POINTER, /* RBPodcastChannel */ G_TYPE_ULONG); /* date */ gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model)); column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL); episode_strings[0] = "0000"; episode_strings[1] = _("Episodes"); episode_strings[2] = NULL; rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog")); gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE); /* set up episode view */ g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL); episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog); /* date column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); { const char *sample_strings[3]; sample_strings[0] = _("Date"); sample_strings[1] = rb_entry_view_get_time_date_column_sample (); sample_strings[2] = NULL; rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings); } gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) podcast_post_date_cell_data_func, dialog, NULL); rb_entry_view_append_column_custom (episodes, column, _("Date"), "Date", (GCompareDataFunc) podcast_post_date_sort_func, 0, NULL); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE); rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING); g_signal_connect (episodes, "notify::sort-order", G_CALLBACK (episodes_sort_changed_cb), dialog); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH, RHYTHMDB_QUERY_END); query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (episodes, query_model); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query); rhythmdb_query_free (query); g_object_unref (query_model); paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned")); g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (episodes), TRUE, FALSE); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
static void main_window_error_display (EmpathyMainWindow *window, TpAccount *account, const gchar *message) { GtkWidget *info_bar; GtkWidget *content_area; GtkWidget *label; GtkWidget *image; GtkWidget *retry_button; GtkWidget *edit_button; GtkWidget *close_button; GtkWidget *action_area; GtkWidget *action_table; gchar *str; const gchar *icon_name; str = g_markup_printf_escaped ("<b>%s</b>\n%s", tp_account_get_display_name (account), message); info_bar = g_hash_table_lookup (window->errors, account); if (info_bar) { label = g_object_get_data (G_OBJECT (info_bar), "label"); /* Just set the latest error and return */ gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); return; } info_bar = gtk_info_bar_new (); gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_ERROR); gtk_widget_set_no_show_all (info_bar, TRUE); gtk_box_pack_start (GTK_BOX (window->errors_vbox), info_bar, FALSE, TRUE, 0); gtk_widget_show (info_bar); icon_name = tp_account_get_icon_name (account); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_show (image); label = gtk_label_new (str); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_widget_show (label); g_free (str); content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar)); gtk_box_pack_start (GTK_BOX (content_area), image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0); image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_BUTTON); retry_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (retry_button), image); gtk_widget_set_tooltip_text (retry_button, _("Reconnect")); gtk_widget_show (retry_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); edit_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (edit_button), image); gtk_widget_set_tooltip_text (edit_button, _("Edit Account")); gtk_widget_show (edit_button); image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON); close_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (close_button), image); gtk_widget_set_tooltip_text (close_button, _("Close")); gtk_widget_show (close_button); action_table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (action_table), 2); gtk_widget_show (action_table); action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (info_bar)); gtk_box_pack_start (GTK_BOX (action_area), action_table, FALSE, FALSE, 0); gtk_table_attach (GTK_TABLE (action_table), retry_button, 0, 1, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); gtk_table_attach (GTK_TABLE (action_table), edit_button, 1, 2, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); gtk_table_attach (GTK_TABLE (action_table), close_button, 2, 3, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); g_object_set_data (G_OBJECT (info_bar), "label", label); g_object_set_data_full (G_OBJECT (info_bar), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (edit_button), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (close_button), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (retry_button), "account", g_object_ref (account), g_object_unref); g_signal_connect (edit_button, "clicked", G_CALLBACK (main_window_error_edit_clicked_cb), window); g_signal_connect (close_button, "clicked", G_CALLBACK (main_window_error_close_clicked_cb), window); g_signal_connect (retry_button, "clicked", G_CALLBACK (main_window_error_retry_clicked_cb), window); gtk_widget_show (window->errors_vbox); g_hash_table_insert (window->errors, g_object_ref (account), info_bar); }
static void init_capplet (void) { GtkWidget *dialog; GtkWidget *preview; GtkWidget *treeview; GtkWidget *list_scroller; GtkWidget *activate_delay_hscale; GtkWidget *activate_delay_hbox; GtkWidget *label; GtkWidget *enabled_checkbox; GtkWidget *lock_checkbox; GtkWidget *root_warning_label; GtkWidget *preview_button; GtkWidget *gpm_button; GtkWidget *fullscreen_preview_window; GtkWidget *fullscreen_preview_previous; GtkWidget *fullscreen_preview_next; GtkWidget *fullscreen_preview_area; GtkWidget *fullscreen_preview_close; char *gtk_builder_file; gdouble activate_delay; gboolean enabled; gboolean is_writable; GSettings *settings; GError *error=NULL; gint mode; gtk_builder_file = g_build_filename (GTKBUILDERDIR, GTK_BUILDER_FILE, NULL); builder = gtk_builder_new(); if (!gtk_builder_add_from_file(builder, gtk_builder_file, &error)) { g_warning("Couldn't load builder file: %s", error->message); g_error_free(error); } g_free (gtk_builder_file); if (builder == NULL) { dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not load the main interface")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Please make sure that the screensaver is properly installed")); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); exit (1); } preview = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area")); dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog")); treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); list_scroller = GTK_WIDGET (gtk_builder_get_object (builder, "themes_scrolled_window")); activate_delay_hscale = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hscale")); activate_delay_hbox = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hbox")); enabled_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "enable_checkbox")); lock_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox")); root_warning_label = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_label")); preview_button = GTK_WIDGET (gtk_builder_get_object (builder, "preview_button")); gpm_button = GTK_WIDGET (gtk_builder_get_object (builder, "gpm_button")); fullscreen_preview_window = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_window")); fullscreen_preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_area")); fullscreen_preview_close = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_close")); fullscreen_preview_previous = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_previous_button")); fullscreen_preview_next = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_next_button")); label = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_label")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), activate_delay_hscale); label = GTK_WIDGET (gtk_builder_get_object (builder, "savers_label")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview); gtk_widget_set_no_show_all (root_warning_label, TRUE); widget_set_best_colormap (preview); if (! is_program_in_path (GPM_COMMAND)) { gtk_widget_set_no_show_all (gpm_button, TRUE); gtk_widget_hide (gpm_button); } activate_delay = config_get_activate_delay (&is_writable); ui_set_delay (activate_delay); if (! is_writable) { gtk_widget_set_sensitive (activate_delay_hbox, FALSE); } g_signal_connect (activate_delay_hscale, "format-value", G_CALLBACK (format_value_callback_time), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (lock_checkbox), config_get_lock (&is_writable)); if (! is_writable) { gtk_widget_set_sensitive (lock_checkbox, FALSE); } g_signal_connect (lock_checkbox, "toggled", G_CALLBACK (lock_checkbox_toggled), NULL); enabled = config_get_enabled (&is_writable); ui_set_enabled (enabled); if (! is_writable) { gtk_widget_set_sensitive (enabled_checkbox, FALSE); } g_signal_connect (enabled_checkbox, "toggled", G_CALLBACK (enabled_checkbox_toggled), NULL); setup_list_size_constraint (list_scroller, treeview); gtk_widget_set_size_request (preview, 480, 300); gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver"); gtk_window_set_icon_name (GTK_WINDOW (fullscreen_preview_window), "screensaver"); gtk_drag_dest_set (dialog, GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE); g_signal_connect (dialog, "drag-motion", G_CALLBACK (drag_motion_cb), NULL); g_signal_connect (dialog, "drag-leave", G_CALLBACK (drag_leave_cb), NULL); g_signal_connect (dialog, "drag-data-received", G_CALLBACK (drag_data_received_cb), NULL); gtk_widget_show_all (dialog); /* Update list of themes if using random screensaver */ settings = g_settings_new (GSETTINGS_SCHEMA); mode = g_settings_get_enum (settings, KEY_MODE); if (mode == GS_MODE_RANDOM) { gchar **list; list = get_all_theme_ids (theme_manager); g_settings_set_strv (settings, KEY_THEMES, (const gchar * const*) list); g_strfreev (list); } g_signal_connect (settings, "changed", G_CALLBACK (key_changed_cb), NULL); g_object_unref (settings); preview_clear (preview); gs_job_set_widget (job, preview); if (check_is_root_user ()) { setup_for_root_user (); } g_signal_connect (activate_delay_hscale, "value-changed", G_CALLBACK (activate_delay_value_changed_cb), NULL); g_signal_connect (dialog, "response", G_CALLBACK (response_cb), NULL); g_signal_connect (preview_button, "clicked", G_CALLBACK (fullscreen_preview_start_cb), treeview); g_signal_connect (fullscreen_preview_close, "clicked", G_CALLBACK (fullscreen_preview_cancelled_cb), NULL); g_signal_connect (fullscreen_preview_previous, "clicked", G_CALLBACK (fullscreen_preview_previous_cb), NULL); g_signal_connect (fullscreen_preview_next, "clicked", G_CALLBACK (fullscreen_preview_next_cb), NULL); g_idle_add ((GSourceFunc)setup_treeview_idle, NULL); }
/** * vinagre_connect: * @window: A Window * * Return value: (allow-none) (transfer full): */ VinagreConnection * vinagre_connect (VinagreWindow *window) { VinagreConnection *conn = NULL; gint result; VinagreConnectDialog dialog; dialog.xml = vinagre_utils_get_builder (); if (!dialog.xml) return NULL; dialog.dialog = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "connect_dialog")); gtk_window_set_transient_for (GTK_WINDOW (dialog.dialog), GTK_WINDOW (window)); dialog.protocol_combo = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "protocol_combo")); dialog.protocol_description_label = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "protocol_description_label")); dialog.host_entry = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "host_entry")); dialog.find_button = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "find_button")); dialog.fullscreen_check = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "fullscreen_check")); dialog.plugin_box = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "plugin_options_connect_vbox")); dialog.connect_button = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "connect_button")); setup_protocol (&dialog); setup_combo (&dialog); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check), vinagre_cache_prefs_get_boolean ("connection", "fullscreen", FALSE)); #ifdef VINAGRE_HAVE_AVAHI g_signal_connect (dialog.find_button, "clicked", G_CALLBACK (vinagre_connect_find_button_cb), &dialog); #else gtk_widget_hide (dialog.find_button); gtk_widget_set_no_show_all (dialog.find_button, TRUE); #endif gtk_widget_show_all (dialog.dialog); result = gtk_dialog_run (GTK_DIALOG (dialog.dialog)); if (result == GTK_RESPONSE_HELP) { vinagre_utils_show_help (GTK_WINDOW (window), "connect"); } else if (result == GTK_RESPONSE_OK) { gchar *host = NULL, *error_msg = NULL, *protocol = NULL, *actual_host; gint port; GtkWidget *options; GtkTreeIter iter; VinagreProtocol *ext; host = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (dialog.host_entry)); gtk_widget_hide (GTK_WIDGET (dialog.dialog)); if (!host || !g_strcmp0 (host, "")) goto fail; save_history (dialog.host_entry); if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (dialog.protocol_combo), &iter)) { g_warning (_("Could not get the active protocol from the protocol list.")); goto fail; } gtk_tree_model_get (GTK_TREE_MODEL (dialog.protocol_store), &iter, PROTOCOL_NAME, &protocol, PROTOCOL_OPTIONS, &options, PROTOCOL_PLUGIN, &ext, -1); vinagre_cache_prefs_set_string ("connection", "last-protocol", protocol); g_free (protocol); vinagre_cache_prefs_set_boolean ("connection", "fullscreen", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check))); conn = vinagre_protocol_new_connection (ext); if (vinagre_connection_split_string (host, vinagre_connection_get_protocol (conn), &protocol, &actual_host, &port, &error_msg)) { g_object_set (conn, "host", actual_host, "port", port, "fullscreen", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check)), NULL); if (options) vinagre_connection_parse_options_widget (conn, options); g_free (protocol); g_free (actual_host); } else { vinagre_utils_show_error_dialog (NULL, error_msg ? error_msg : _("Unknown error"), GTK_WINDOW (window)); } g_object_unref (ext); if (options) g_object_unref (options); fail: g_free (host); g_free (error_msg); } gtk_widget_destroy (dialog.dialog); g_object_unref (dialog.xml); return conn; }
void gui_init (dt_imageio_module_storage_t *self) { self->gui_data = (dt_storage_picasa_gui_data_t *)malloc(sizeof(dt_storage_picasa_gui_data_t)); memset(self->gui_data,0,sizeof(dt_storage_picasa_gui_data_t)); dt_storage_picasa_gui_data_t *ui= self->gui_data; self->widget = gtk_vbox_new(TRUE, 0); GtkWidget *hbox1=gtk_hbox_new(FALSE,5); GtkWidget *vbox1=gtk_vbox_new(FALSE,0); GtkWidget *vbox2=gtk_vbox_new(FALSE,0); ui->label1 = GTK_LABEL( gtk_label_new( _("user") ) ); ui->label2 = GTK_LABEL( gtk_label_new( _("password") ) ); ui->label3 = GTK_LABEL( gtk_label_new( _("albums") ) ); ui->label4 = GTK_LABEL( gtk_label_new( NULL ) ); ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) ); ui->label7 = GTK_LABEL( gtk_label_new( _("rights") ) ); gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label2), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label7), 0.0, 0.5); ui->entry1 = GTK_ENTRY( gtk_entry_new() ); ui->entry2 = GTK_ENTRY( gtk_entry_new() ); ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry1)); dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry2)); dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry3)); dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry4)); /* gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL); gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK); g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL); g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL); */ GHashTable* table = dt_pwstorage_get("picasa"); gchar* _username = g_strdup( g_hash_table_lookup(table, "username")); gchar* _password = g_strdup( g_hash_table_lookup(table, "password")); g_hash_table_destroy(table); gtk_entry_set_text( ui->entry1, _username == NULL?"":_username ); gtk_entry_set_text( ui->entry2, _password == NULL?"":_password ); gtk_entry_set_text( ui->entry3, _("my new album") ); gtk_entry_set_text( ui->entry4, _("exported from darktable") ); gtk_entry_set_visibility(ui->entry2, FALSE); GtkWidget *albumlist=gtk_hbox_new(FALSE,0); ui->comboBox1=GTK_COMBO_BOX( gtk_combo_box_new_text()); // Available albums dt_ellipsize_combo(ui->comboBox1); ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) ); g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL); gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE); gtk_combo_box_set_row_separator_func(ui->comboBox1,combobox_separator,ui->comboBox1,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0); ui->checkButton1 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("public album")) ); ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) ); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE); // Auth gtk_box_pack_start(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label2 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry2 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0); // Create Album ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE); vbox1=gtk_vbox_new(FALSE,0); vbox2=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label7 ), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton1 ), TRUE, FALSE, 0); // Setup signals // add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1)); g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(button1_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(entry_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->entry2), "changed", G_CALLBACK(entry_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(album_changed), (gpointer)ui); // If username and password is stored, let's populate the combo // if( _username && _password ) // refresh_albums(ui); if( _username ) g_free( _username ); if( _password ) g_free( _password ); gtk_combo_box_set_active( ui->comboBox1, 0); }
static void _lib_recentcollection_updated(gpointer instance, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_recentcollect_t *d = (dt_lib_recentcollect_t *)self->data; // serialize, check for recently used char confname[200]; const int bufsize = 4096; char buf[bufsize]; if(dt_collection_serialize(buf, bufsize)) return; // is the current position, i.e. the one to be stored with the old collection (pos0, pos1-to-be) uint32_t curr_pos = dt_view_lighttable_get_position(darktable.view_manager); uint32_t new_pos = -1; if(!d->inited) { new_pos = dt_conf_get_int("plugins/lighttable/recentcollect/pos0"); d->inited = 1; dt_view_lighttable_set_position(darktable.view_manager, new_pos); } else if(curr_pos != -1) { dt_conf_set_int("plugins/lighttable/recentcollect/pos0", curr_pos); } int n = -1; for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++) { // is it already in the current list? snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k); gchar *line = dt_conf_get_string(confname); if(!line) continue; if(!strcmp(line, buf)) { snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k); new_pos = dt_conf_get_int(confname); n = k; break; } g_free(line); } if(n < 0) { const int num_items = CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); if(num_items < NUM_LINES) { // new, unused entry n = num_items; dt_conf_set_int("plugins/lighttable/recentcollect/num_items", num_items + 1); } else { // kill least recently used entry: n = num_items - 1; } } if(n >= 0 && n < NUM_LINES) { // sort n to the top for(int k = n; k > 0; k--) { snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k - 1); gchar *line1 = dt_conf_get_string(confname); snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k - 1); uint32_t pos1 = dt_conf_get_int(confname); if(line1 && line1[0] != '\0') { snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k); dt_conf_set_string(confname, line1); snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k); dt_conf_set_int(confname, pos1); } g_free(line1); } dt_conf_set_string("plugins/lighttable/recentcollect/line0", buf); dt_conf_set_int("plugins/lighttable/recentcollect/pos0", (new_pos != -1 ? new_pos : (curr_pos != -1 ? curr_pos : 0))); } // update button descriptions: for(int k = 0; k < NUM_LINES; k++) { char str[2048] = { 0 }; char str_cut[200] = { 0 }; char str_pretty[200] = { 0 }; snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k); gchar *line2 = dt_conf_get_string(confname); if(line2 && line2[0] != '\0') pretty_print(line2, str, sizeof(str)); g_free(line2); g_object_set(G_OBJECT(d->item[k].button), "tooltip-text", str, (char *)NULL); const int cut = 45; if(g_utf8_validate(str, -1, NULL)) { if(g_utf8_strlen(str, -1) > cut) { g_utf8_strncpy(str_cut, str, cut); snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut); gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty); } else { gtk_button_set_label(GTK_BUTTON(d->item[k].button), str); } } else if(strlen(str) > cut) { g_strlcpy(str_cut, str, cut); snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut); gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty); } else { gtk_button_set_label(GTK_BUTTON(d->item[k].button), str); } GtkWidget *child = gtk_bin_get_child(GTK_BIN(d->item[k].button)); if(child) gtk_widget_set_halign(child, GTK_ALIGN_START); gtk_widget_set_no_show_all(d->item[k].button, TRUE); gtk_widget_set_visible(d->item[k].button, FALSE); } for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++) { gtk_widget_set_no_show_all(d->item[k].button, FALSE); gtk_widget_set_visible(d->item[k].button, TRUE); } if((new_pos != -1) && (new_pos != curr_pos)) dt_view_lighttable_set_position(darktable.view_manager, new_pos); }
static void activate (GApplication *gapp) { GtkApplication *app = GTK_APPLICATION (gapp); GtkWidget *window; GtkWidget *box; GtkWidget *grid; GtkWidget *label; GtkWidget *spin; GtkWidget *check; GtkWidget *bar; window = gtk_application_window_new (app); gtk_application_add_window (app, GTK_WINDOW (window)); bar = gtk_action_bar_new (); gtk_widget_set_no_show_all (bar, TRUE); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); grid = gtk_grid_new (); g_object_set (grid, "halign", GTK_ALIGN_CENTER, "margin", 20, "row-spacing", 12, "column-spacing", 12, NULL); gtk_box_pack_start (GTK_BOX (box), grid, FALSE, FALSE); label = gtk_label_new ("Start"); gtk_widget_set_halign (label, GTK_ALIGN_END); spin = gtk_spin_button_new_with_range (0, 10, 1); g_signal_connect (spin, "notify::value", G_CALLBACK (change_start), bar); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), spin, 1, 0, 1, 1); label = gtk_label_new ("Center"); gtk_widget_set_halign (label, GTK_ALIGN_END); check = gtk_check_button_new (); g_signal_connect (check, "notify::active", G_CALLBACK (toggle_center), bar); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), check, 1, 1, 1, 1); label = gtk_label_new ("End"); gtk_widget_set_halign (label, GTK_ALIGN_END); spin = gtk_spin_button_new_with_range (0, 10, 1); g_signal_connect (spin, "notify::value", G_CALLBACK (change_end), bar); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); gtk_grid_attach (GTK_GRID (grid), spin, 1, 2, 1, 1); label = gtk_label_new ("Visible"); gtk_widget_set_halign (label, GTK_ALIGN_END); check = gtk_check_button_new (); g_signal_connect (check, "notify::active", G_CALLBACK (toggle_visibility), bar); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); gtk_grid_attach (GTK_GRID (grid), check, 1, 3, 1, 1); gtk_box_pack_end (GTK_BOX (box), bar, FALSE, FALSE); gtk_container_add (GTK_CONTAINER (window), box); gtk_widget_show_all (window); }
static void bluetooth_chooser_init(BluetoothChooser *self) { BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self); GtkWidget *vbox; GtkWidget *hbox; gtk_widget_push_composite_child (); g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL); priv->client = bluetooth_client_new (); /* Setup the widget itself */ gtk_box_set_spacing (GTK_BOX(self), 18); gtk_container_set_border_width (GTK_CONTAINER(self), 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (self), vbox, TRUE, TRUE, 0); /* The treeview label */ priv->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 24); gtk_widget_set_name (priv->search_hbox, "search_hbox"); if (priv->show_searching) gtk_widget_show (priv->search_hbox); gtk_box_pack_end (GTK_BOX (vbox), priv->search_hbox, FALSE, TRUE, 0); gtk_widget_set_no_show_all (priv->search_hbox, TRUE); /* Setup the adapter disco mode callback for the search button */ priv->adapter_model = bluetooth_client_get_adapter_model (priv->client); g_signal_connect (priv->adapter_model, "row-changed", G_CALLBACK (adapter_model_row_changed), self); /* The searching label */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_set_name (hbox, "searching label hbox"); priv->spinner = gtk_spinner_new (); gtk_container_add (GTK_CONTAINER (hbox), priv->spinner); gtk_widget_show (priv->spinner); priv->search_label = gtk_label_new (_("Searching for devices…")); gtk_container_add (GTK_CONTAINER (hbox), priv->search_label); gtk_widget_show (priv->search_label); gtk_widget_show (hbox); if (priv->show_searching) { gboolean discovering; g_object_get (G_OBJECT (priv->client), "default-adapter-discovering", &discovering, NULL); set_search_label (self, discovering); } gtk_box_pack_start (GTK_BOX (priv->search_hbox), hbox, FALSE, TRUE, 0); /* The treeview */ priv->scrolled_window = create_treeview (self); gtk_widget_show_all (priv->scrolled_window); gtk_box_pack_start (GTK_BOX (vbox), priv->scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_SHADOW_IN); /* The filters */ priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS, G_TYPE_STRING, G_TYPE_INT)); priv->filters_vbox = bluetooth_filter_widget_new (); gtk_widget_show (priv->filters_vbox); gtk_box_pack_start (GTK_BOX (self), priv->filters_vbox, FALSE, TRUE, 0); gtk_widget_set_no_show_all (priv->filters_vbox, TRUE); /* if filters are not visible hide the vbox */ if (!priv->show_device_type && !priv->show_device_category) gtk_widget_hide (priv->filters_vbox); priv->default_adapter_changed_id = g_signal_connect (priv->client, "notify::default-adapter", G_CALLBACK (default_adapter_changed), self); g_signal_connect(self, "notify::device-type-filter", G_CALLBACK(filter_type_changed_cb), NULL); g_signal_connect(self, "notify::device-category-filter", G_CALLBACK(filter_category_changed_cb), NULL); gtk_widget_pop_composite_child (); }
static void create_account_details_ui (GoaProvider *provider, GtkDialog *dialog, GtkBox *vbox, gboolean new_account, AddAccountData *data) { GtkWidget *grid0; GtkWidget *grid1; GtkWidget *grid2; GtkWidget *hbox; gint width; goa_utils_set_dialog_title (provider, dialog, new_account); grid0 = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid0), 5); gtk_widget_set_margin_bottom (grid0, 6); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid0), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (grid0), 12); gtk_container_add (GTK_CONTAINER (vbox), grid0); data->cluebar = gtk_info_bar_new (); gtk_info_bar_set_message_type (GTK_INFO_BAR (data->cluebar), GTK_MESSAGE_ERROR); gtk_widget_set_hexpand (data->cluebar, TRUE); gtk_widget_set_no_show_all (data->cluebar, TRUE); gtk_container_add (GTK_CONTAINER (grid0), data->cluebar); data->cluebar_label = gtk_label_new (""); gtk_label_set_line_wrap (GTK_LABEL (data->cluebar_label), TRUE); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (data->cluebar))), data->cluebar_label); grid1 = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (grid1), 12); grid2 = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (grid2), 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (grid0), hbox); add_entry (grid1, grid2, _("_E-mail"), &data->email_address); add_entry (grid1, grid2, _("_Password"), &data->password); if (new_account) { data->expander = gtk_expander_new_with_mnemonic (_("_Custom")); gtk_expander_set_expanded (GTK_EXPANDER (data->expander), FALSE); gtk_expander_set_resize_toplevel (GTK_EXPANDER (data->expander), TRUE); gtk_container_add (GTK_CONTAINER (grid0), data->expander); grid1 = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (grid1), 12); grid2 = gtk_grid_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (grid2), 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (data->expander), hbox); add_entry (grid1, grid2, _("User_name"), &data->username); add_entry (grid1, grid2, _("_Server"), &data->server); } gtk_entry_set_visibility (GTK_ENTRY (data->password), FALSE); gtk_widget_grab_focus ((new_account) ? data->email_address : data->password); g_signal_connect (data->email_address, "changed", G_CALLBACK (on_email_address_or_password_changed), data); g_signal_connect (data->password, "changed", G_CALLBACK (on_email_address_or_password_changed), data); data->spinner_button = goa_spinner_button_new_from_stock (GTK_STOCK_CONNECT); gtk_dialog_add_action_widget (data->dialog, data->spinner_button, GTK_RESPONSE_OK); gtk_dialog_set_default_response (data->dialog, GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive (data->dialog, GTK_RESPONSE_OK, FALSE); gtk_window_get_size (GTK_WINDOW (data->dialog), &width, NULL); gtk_widget_set_size_request (GTK_WIDGET (data->dialog), width, -1); }
/* construct widget above */ void gui_init(struct dt_imageio_module_storage_t *self) { self->gui_data = g_malloc0(sizeof(dt_storage_gphoto_gui_data_t)); dt_storage_gphoto_gui_data_t *ui = self->gui_data; ui->gphoto_api = gphoto_api_init(); self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); // create labels ui->label_album_title = GTK_LABEL(gtk_label_new(_("title"))); ui->label_status = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START); // create entries GtkListStore *model_username = gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); // text, token, refresh_token, id ui->combo_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username))); GtkCellRenderer *p_cell = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35, (gchar *)0); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_username), p_cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_username), p_cell, "text", 0, NULL); ui->entry_album_title = GTK_ENTRY(gtk_entry_new()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->combo_username)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title)); // retrieve saved accounts ui_refresh_users(ui); //////// album list ///////// GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkListStore *model_album = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id ui->combo_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album))); p_cell = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35, (gchar *)0); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_album), p_cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_album), p_cell, "text", 0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(ui->combo_album), FALSE); gtk_combo_box_set_row_separator_func(ui->combo_album, combobox_separator, ui->combo_album, NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->combo_album), TRUE, TRUE, 0); ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login"))); ui->connected = FALSE; // pack the ui ////the auth box GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->combo_username), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2); ////the album creation box ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0); // connect buttons to signals g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->combo_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->combo_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui); g_object_unref(model_username); g_object_unref(model_album); }
static GoaObject * add_account (GoaProvider *provider, GoaClient *client, GtkDialog *dialog, GtkBox *vbox, GError **error) { AddAccountData data; GVariantBuilder credentials; GVariantBuilder details; GoaEwsClient *ews_client; GoaObject *ret; gboolean accept_ssl_errors; const gchar *email_address; const gchar *server; const gchar *password; const gchar *username; const gchar *provider_type; gint response; ews_client = NULL; accept_ssl_errors = FALSE; ret = NULL; memset (&data, 0, sizeof (AddAccountData)); data.loop = g_main_loop_new (NULL, FALSE); data.dialog = dialog; data.error = NULL; create_account_details_ui (provider, dialog, vbox, TRUE, &data); gtk_widget_show_all (GTK_WIDGET (vbox)); ews_client = goa_ews_client_new (); ews_again: response = gtk_dialog_run (dialog); if (response != GTK_RESPONSE_OK) { g_set_error (&data.error, GOA_ERROR, GOA_ERROR_DIALOG_DISMISSED, _("Dialog was dismissed")); goto out; } email_address = gtk_entry_get_text (GTK_ENTRY (data.email_address)); password = gtk_entry_get_text (GTK_ENTRY (data.password)); username = gtk_entry_get_text (GTK_ENTRY (data.username)); server = gtk_entry_get_text (GTK_ENTRY (data.server)); /* See if there's already an account of this type with the * given identity */ provider_type = goa_provider_get_provider_type (provider); if (!goa_utils_check_duplicate (client, username, provider_type, (GoaPeekInterfaceFunc) goa_object_peek_password_based, &data.error)) goto out; goa_ews_client_autodiscover (ews_client, email_address, password, username, server, accept_ssl_errors, NULL, autodiscover_cb, &data); goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button)); g_main_loop_run (data.loop); if (data.error != NULL) { gchar *markup; if (data.error->code == GOA_ERROR_SSL) { goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Ignore")); accept_ssl_errors = TRUE; } else { goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Try Again")); accept_ssl_errors = FALSE; } markup = g_strdup_printf ("<b>%s:</b> %s", _("Error connecting to Microsoft Exchange server"), data.error->message); g_clear_error (&data.error); gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup); g_free (markup); gtk_expander_set_expanded (GTK_EXPANDER (data.expander), TRUE); gtk_widget_set_no_show_all (data.cluebar, FALSE); gtk_widget_show_all (data.cluebar); goto ews_again; } gtk_widget_hide (GTK_WIDGET (dialog)); g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&credentials, "{sv}", "password", g_variant_new_string (password)); g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}")); g_variant_builder_add (&details, "{ss}", "MailEnabled", "true"); g_variant_builder_add (&details, "{ss}", "CalendarEnabled", "true"); g_variant_builder_add (&details, "{ss}", "ContactsEnabled", "true"); g_variant_builder_add (&details, "{ss}", "Host", server); g_variant_builder_add (&details, "{ss}", "AcceptSslErrors", (accept_ssl_errors) ? "true" : "false"); /* OK, everything is dandy, add the account */ /* we want the GoaClient to update before this method returns (so it * can create a proxy for the new object) so run the mainloop while * waiting for this to complete */ goa_manager_call_add_account (goa_client_get_manager (client), goa_provider_get_provider_type (provider), username, email_address, g_variant_builder_end (&credentials), g_variant_builder_end (&details), NULL, /* GCancellable* */ (GAsyncReadyCallback) add_account_cb, &data); g_main_loop_run (data.loop); if (data.error != NULL) goto out; ret = GOA_OBJECT (g_dbus_object_manager_get_object (goa_client_get_object_manager (client), data.account_object_path)); out: /* We might have an object even when data.error is set. * eg., if we failed to store the credentials in the keyring. */ if (data.error != NULL) g_propagate_error (error, data.error); else g_assert (ret != NULL); g_free (data.account_object_path); if (data.loop != NULL) g_main_loop_unref (data.loop); if (ews_client != NULL) g_object_unref (ews_client); return ret; }
/* construct widget above */ void gui_init(struct dt_imageio_module_storage_t *self) { self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t)); dt_storage_facebook_gui_data_t *ui = self->gui_data; ui->facebook_api = fb_api_init(); self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); // create labels ui->label_album_title = GTK_LABEL(gtk_label_new(_("title"))); ui->label_album_summary = GTK_LABEL(gtk_label_new(_("summary"))); ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy"))); ui->label_status = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START); gtk_widget_set_halign(GTK_WIDGET(ui->label_album_summary), GTK_ALIGN_START); gtk_widget_set_halign(GTK_WIDGET(ui->label_album_privacy), GTK_ALIGN_START); // create entries GtkListStore *model_username = gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); // text, token, id ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username))); GtkCellRenderer *p_cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, "text", 0, NULL); ui->entry_album_title = GTK_ENTRY(gtk_entry_new()); ui->entry_album_summary = GTK_ENTRY(gtk_entry_new()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary)); gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_title), 0); gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_summary), 0); // retrieve saved accounts ui_refresh_users(ui); //////// album list ///////// GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkListStore *model_album = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album))); p_cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, "text", 0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE); gtk_combo_box_set_row_separator_func(ui->comboBox_album, combobox_separator, ui->comboBox_album, NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0); ui->comboBox_privacy = GTK_COMBO_BOX(gtk_combo_box_text_new()); GtkListStore *list_store = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1); gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store)); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login"))); ui->connected = FALSE; // pack the ui ////the auth box GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2); ////the album creation box ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0); // connect buttons to signals g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui); g_object_unref(model_username); g_object_unref(model_album); g_object_unref(list_store); }
static gboolean refresh_account (GoaProvider *provider, GoaClient *client, GoaObject *object, GtkWindow *parent, GError **error) { AddAccountData data; GVariantBuilder builder; GoaAccount *account; GoaEwsClient *ews_client; GoaExchange *exchange; GtkWidget *dialog; GtkWidget *vbox; gboolean accept_ssl_errors; gboolean ret; const gchar *email_address; const gchar *server; const gchar *password; const gchar *username; gint response; g_return_val_if_fail (GOA_IS_EXCHANGE_PROVIDER (provider), FALSE); g_return_val_if_fail (GOA_IS_CLIENT (client), FALSE); g_return_val_if_fail (GOA_IS_OBJECT (object), FALSE); g_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); ews_client = NULL; ret = FALSE; dialog = gtk_dialog_new_with_buttons (NULL, parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), 12); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (vbox), 12); memset (&data, 0, sizeof (AddAccountData)); data.loop = g_main_loop_new (NULL, FALSE); data.dialog = GTK_DIALOG (dialog); data.error = NULL; create_account_details_ui (provider, GTK_DIALOG (dialog), GTK_BOX (vbox), FALSE, &data); account = goa_object_peek_account (object); email_address = goa_account_get_presentation_identity (account); gtk_entry_set_text (GTK_ENTRY (data.email_address), email_address); gtk_editable_set_editable (GTK_EDITABLE (data.email_address), FALSE); gtk_widget_show_all (dialog); ews_client = goa_ews_client_new (); ews_again: response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response != GTK_RESPONSE_OK) { g_set_error (error, GOA_ERROR, GOA_ERROR_DIALOG_DISMISSED, _("Dialog was dismissed")); goto out; } password = gtk_entry_get_text (GTK_ENTRY (data.password)); username = goa_account_get_identity (account); exchange = goa_object_peek_exchange (object); accept_ssl_errors = goa_util_lookup_keyfile_boolean (object, "AcceptSslErrors"); server = goa_exchange_get_host (exchange); goa_ews_client_autodiscover (ews_client, email_address, password, username, server, accept_ssl_errors, NULL, autodiscover_cb, &data); goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button)); g_main_loop_run (data.loop); if (data.error != NULL) { GtkWidget *button; gchar *markup; markup = g_strdup_printf ("<b>%s:</b> %s", _("Error connecting to Microsoft Exchange server"), data.error->message); g_clear_error (&data.error); gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup); g_free (markup); button = gtk_dialog_get_widget_for_response (data.dialog, GTK_RESPONSE_OK); gtk_button_set_label (GTK_BUTTON (button), _("_Try Again")); gtk_widget_set_no_show_all (data.cluebar, FALSE); gtk_widget_show_all (data.cluebar); goto ews_again; } /* TODO: run in worker thread */ g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&builder, "{sv}", "password", g_variant_new_string (password)); if (!goa_utils_store_credentials_for_object_sync (provider, object, g_variant_builder_end (&builder), NULL, /* GCancellable */ error)) goto out; goa_account_call_ensure_credentials (account, NULL, /* GCancellable */ NULL, NULL); /* callback, user_data */ ret = TRUE; out: gtk_widget_destroy (dialog); if (data.loop != NULL) g_main_loop_unref (data.loop); if (ews_client != NULL) g_object_unref (ews_client); return ret; }
void gui_init(struct dt_iop_module_t *self) { const int high_quality_processing = dt_conf_get_bool("plugins/lighttable/export/force_lcms2"); self->gui_data = malloc(sizeof(dt_iop_colorout_gui_data_t)); memset(self->gui_data,0,sizeof(dt_iop_colorout_gui_data_t)); dt_iop_colorout_gui_data_t *g = (dt_iop_colorout_gui_data_t *)self->gui_data; g->profiles = NULL; dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t)); g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename)); g_strlcpy(prof->name, "sRGB", sizeof(prof->name)); int pos; int display_pos; prof->pos = 0; prof->display_pos = 0; g->profiles = g_list_append(g->profiles, prof); prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t)); g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename)); g_strlcpy(prof->name, "adobergb", sizeof(prof->name)); prof->pos = 1; prof->display_pos = 1; g->profiles = g_list_append(g->profiles, prof); prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t)); g_strlcpy(prof->filename, "X profile", sizeof(prof->filename)); g_strlcpy(prof->name, "X profile", sizeof(prof->name)); prof->pos = -1; prof->display_pos = 2; g->profiles = g_list_append(g->profiles, prof); prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t)); g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename)); g_strlcpy(prof->name, "linear_rgb", sizeof(prof->name)); pos = prof->pos = 2; display_pos = prof->display_pos = 3; g->profiles = g_list_append(g->profiles, prof); // read {conf,data}dir/color/out/*.icc char datadir[DT_MAX_PATH_LEN]; char confdir[DT_MAX_PATH_LEN]; char dirname[DT_MAX_PATH_LEN]; char filename[DT_MAX_PATH_LEN]; dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN); dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN); snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir); if(!g_file_test(dirname, G_FILE_TEST_IS_DIR)) snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir); cmsHPROFILE tmpprof; const gchar *d_name; GDir *dir = g_dir_open(dirname, 0, NULL); if(dir) { while((d_name = g_dir_read_name(dir))) { snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name); tmpprof = cmsOpenProfileFromFile(filename, "r"); if(tmpprof) { char *lang = getenv("LANG"); if (!lang) lang = "en_US"; dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t)); dt_colorspaces_get_profile_name(tmpprof, lang, lang+3, prof->name, sizeof(prof->name)); g_strlcpy(prof->filename, d_name, sizeof(prof->filename)); prof->pos = ++pos; prof->display_pos = ++display_pos; cmsCloseProfile(tmpprof); g->profiles = g_list_append(g->profiles, prof); } } g_dir_close(dir); } self->widget = gtk_vbox_new(TRUE, DT_BAUHAUS_SPACE); // TODO: g->cbox1 = dt_bauhaus_combobox_new(self); gtk_box_pack_start(GTK_BOX(self->widget), g->cbox1, TRUE, TRUE, 0); dt_bauhaus_widget_set_label(g->cbox1, NULL, _("output intent")); dt_bauhaus_combobox_add(g->cbox1, _("perceptual")); dt_bauhaus_combobox_add(g->cbox1, _("relative colorimetric")); dt_bauhaus_combobox_add(g->cbox1, C_("rendering intent", "saturation")); dt_bauhaus_combobox_add(g->cbox1, _("absolute colorimetric")); g->cbox4 = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->cbox4, NULL, _("display intent")); gtk_box_pack_start(GTK_BOX(self->widget), g->cbox4, TRUE, TRUE, 0); dt_bauhaus_combobox_add(g->cbox4, _("perceptual")); dt_bauhaus_combobox_add(g->cbox4, _("relative colorimetric")); dt_bauhaus_combobox_add(g->cbox4, C_("rendering intent", "saturation")); dt_bauhaus_combobox_add(g->cbox4, _("absolute colorimetric")); if (!high_quality_processing) { gtk_widget_set_no_show_all(g->cbox1, TRUE); gtk_widget_set_visible(g->cbox1, FALSE); gtk_widget_set_no_show_all(g->cbox4, TRUE); gtk_widget_set_visible(g->cbox4, FALSE); } g->cbox2 = dt_bauhaus_combobox_new(self); g->cbox3 = dt_bauhaus_combobox_new(self); g->cbox5 = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->cbox2, NULL, _("output profile")); dt_bauhaus_widget_set_label(g->cbox5, NULL, _("softproof profile")); dt_bauhaus_widget_set_label(g->cbox3, NULL, _("display profile")); gtk_box_pack_start(GTK_BOX(self->widget), g->cbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->cbox5, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->cbox3, TRUE, TRUE, 0); GList *l = g->profiles; while(l) { dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)l->data; if(!strcmp(prof->name, "X profile")) { // the system display profile is only suitable for display purposes dt_bauhaus_combobox_add(g->cbox3, _("system display profile")); } else if(!strcmp(prof->name, "linear_rgb")) { dt_bauhaus_combobox_add(g->cbox2, _("linear Rec709 RGB")); dt_bauhaus_combobox_add(g->cbox3, _("linear Rec709 RGB")); dt_bauhaus_combobox_add(g->cbox5, _("linear Rec709 RGB")); } else if(!strcmp(prof->name, "sRGB")) { dt_bauhaus_combobox_add(g->cbox2, _("sRGB (web-safe)")); dt_bauhaus_combobox_add(g->cbox3, _("sRGB (web-safe)")); dt_bauhaus_combobox_add(g->cbox5, _("sRGB (web-safe)")); } else if(!strcmp(prof->name, "adobergb")) { dt_bauhaus_combobox_add(g->cbox2, _("Adobe RGB (compatible)")); dt_bauhaus_combobox_add(g->cbox3, _("Adobe RGB (compatible)")); dt_bauhaus_combobox_add(g->cbox5, _("Adobe RGB (compatible)")); } else { dt_bauhaus_combobox_add(g->cbox2, prof->name); dt_bauhaus_combobox_add(g->cbox3, prof->name); dt_bauhaus_combobox_add(g->cbox5, prof->name); } l = g_list_next(l); } char tooltip[1024]; g_object_set(G_OBJECT(g->cbox1), "tooltip-text", _("rendering intent"), (char *)NULL); snprintf(tooltip, sizeof(tooltip), _("ICC profiles in %s/color/out or %s/color/out"), confdir, datadir); g_object_set(G_OBJECT(g->cbox2), "tooltip-text", tooltip, (char *)NULL); snprintf(tooltip, sizeof(tooltip), _("display ICC profiles in %s/color/out or %s/color/out"), confdir, datadir); g_object_set(G_OBJECT(g->cbox3), "tooltip-text", tooltip, (char *)NULL); snprintf(tooltip, sizeof(tooltip), _("softproof ICC profiles in %s/color/out or %s/color/out"), confdir, datadir); g_object_set(G_OBJECT(g->cbox5), "tooltip-text", tooltip, (char *)NULL); g_signal_connect (G_OBJECT (g->cbox1), "value-changed", G_CALLBACK (intent_changed), (gpointer)self); g_signal_connect (G_OBJECT (g->cbox4), "value-changed", G_CALLBACK (display_intent_changed), (gpointer)self); g_signal_connect (G_OBJECT (g->cbox2), "value-changed", G_CALLBACK (output_profile_changed), (gpointer)self); g_signal_connect (G_OBJECT (g->cbox3), "value-changed", G_CALLBACK (display_profile_changed), (gpointer)self); g_signal_connect (G_OBJECT (g->cbox5), "value-changed", G_CALLBACK (softproof_profile_changed), (gpointer)self); // reload the profiles when the display profile changed! dt_control_signal_connect(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED, G_CALLBACK(_signal_profile_changed), self->dev); }
static void pin_dialog (DBusGProxy *adapter, DBusGProxy *device, const char *name, const char *long_name, gboolean numeric, DBusGMethodInvocation *context) { GtkWidget *dialog; GtkWidget *button; GtkWidget *entry; GtkBuilder *xml; char *str; input_data *input; xml = gtk_builder_new (); if (gtk_builder_add_from_file (xml, "passkey-dialogue.ui", NULL) == 0) gtk_builder_add_from_file (xml, PKGDATADIR "/passkey-dialogue.ui", NULL); input = g_new0 (input_data, 1); input->path = g_strdup (dbus_g_proxy_get_path(adapter)); input->numeric = numeric; input->context = context; input->device = g_object_ref (device); dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog")); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); if (notification_supports_actions () != FALSE) gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE); else gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE); gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE); input->dialog = dialog; gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE); str = g_strdup_printf (_("Device '%s' wants to pair with this computer"), name); g_object_set (G_OBJECT (dialog), "text", str, NULL); g_free (str); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Please enter the PIN mentioned on device %s."), long_name); entry = GTK_WIDGET (gtk_builder_get_object (xml, "entry")); if (numeric == TRUE) { gtk_entry_set_max_length (GTK_ENTRY (entry), 6); gtk_entry_set_width_chars (GTK_ENTRY (entry), 6); g_signal_connect (G_OBJECT (entry), "insert-text", G_CALLBACK (insert_callback), input); } else { gtk_entry_set_max_length (GTK_ENTRY (entry), 16); gtk_entry_set_width_chars (GTK_ENTRY (entry), 16); gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE); } gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); input->entry = entry; g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (changed_callback), input); button = GTK_WIDGET (gtk_builder_get_object (xml, "showinput_button")); if (numeric == FALSE) { g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggled_callback), input); } else { gtk_widget_set_no_show_all (button, TRUE); gtk_widget_hide (button); } input_list = g_list_append(input_list, input); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (pin_callback), input); enable_blinking(); }
static void awn_html_dialog_new(WebApplet *webapplet) { /* create viewer */ webapplet->mainwindow = awn_dialog_new_for_widget (GTK_WIDGET(webapplet->applet)); webapplet->box = gtk_vbox_new (FALSE, 1); webapplet->viewer = html_web_view_new (); /* Load the .ini file for websites */ GError *err = NULL; webapplet->sites_file = g_key_file_new(); g_key_file_load_from_file(webapplet->sites_file, APPLETSDIR"/webapplet/webapplet-websites.ini", 0, &err); if (err) { printf("Error loading websites: %s\n", err->message); g_error_free(err); g_key_file_free(webapplet->sites_file); webapplet->sites_file = NULL; } /* If first time using this, hide WebView, show location entry/website buttons */ if (config_get_first_start(webapplet)) { gtk_widget_set_no_show_all(webapplet->viewer, TRUE); gtk_box_pack_start(GTK_BOX(webapplet->box), first_start(webapplet), FALSE, FALSE, 0); awn_applet_simple_set_tooltip_text(AWN_APPLET_SIMPLE(webapplet->applet), _("Web Applet")); } else { go_to_url(webapplet, (gchar*)config_get_uri(webapplet)); if (webapplet->sites_file) { const gchar *name = config_get_site(webapplet); if (name && strcmp(name, "") != 0) { gint size = awn_applet_get_size(webapplet->applet); WebSite *site = get_site(webapplet, (gchar*)name); gchar *path = g_strdup_printf(APPLETSDIR"/webapplet/icons/%s", site->icon); GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size(path, size, size, NULL); awn_applet_simple_set_icon_pixbuf(AWN_APPLET_SIMPLE(site->webapplet->applet), pixbuf); if (site->width && site->height) { gtk_widget_set_size_request(GTK_WIDGET(site->webapplet->box), site->width, site->height); } } } } gtk_box_pack_start(GTK_BOX(webapplet->box), webapplet->viewer, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(webapplet->mainwindow), webapplet->box); }
void init_widgets() { GtkWidget* container; GtkWidget* widget; // Creating the main window widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); darktable.gui->ui->main_window = widget; gtk_window_set_default_size(GTK_WINDOW(widget), 900, 500); gtk_window_set_icon_name(GTK_WINDOW(widget), "darktable"); gtk_window_set_title(GTK_WINDOW(widget), "Darktable"); g_signal_connect (G_OBJECT (widget), "delete_event", G_CALLBACK (dt_control_quit), NULL); g_signal_connect (G_OBJECT (widget), "key-press-event", G_CALLBACK (key_pressed_override), NULL); g_signal_connect (G_OBJECT (widget), "key-release-event", G_CALLBACK (key_released), NULL); container = widget; // Adding the outermost vbox widget = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(container), widget); gtk_widget_show(widget); /* connect to signal redraw all */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_CONTROL_REDRAW_ALL, G_CALLBACK(_ui_widget_redraw_callback), darktable.gui->ui->main_window); container = widget; // Initializing the top border widget = gtk_drawing_area_new(); darktable.gui->widgets.top_border = widget; gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0); gtk_widget_set_size_request(widget, -1, 10); gtk_widget_set_app_paintable(widget, TRUE); gtk_widget_set_events(widget, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_STRUCTURE_MASK | GDK_SCROLL_MASK); gtk_widget_show(widget); // Initializing the main table init_main_table(container); // Initializing the bottom border widget = gtk_drawing_area_new(); darktable.gui->widgets.bottom_border = widget; gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0); gtk_widget_set_size_request(widget, -1, 10); gtk_widget_set_app_paintable(widget, TRUE); gtk_widget_set_events(widget, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_STRUCTURE_MASK | GDK_SCROLL_MASK); gtk_widget_show(widget); // Showing everything gtk_widget_show_all(dt_ui_main_window(darktable.gui->ui)); /* hide panels depending on last ui state */ for(int k=0;k<DT_UI_PANEL_SIZE;k++) { /* prevent show all */ gtk_widget_set_no_show_all(GTK_WIDGET(darktable.gui->ui->containers[k]), TRUE); /* check last visible state of panel */ char key[512]; g_snprintf(key, 512, "ui_last/%s/visible", _ui_panel_config_names[k]); /* if no key, lets default to TRUE*/ if(!dt_conf_key_exists(key)) dt_conf_set_bool(key,TRUE); if (!dt_conf_get_bool(key)) gtk_widget_set_visible(darktable.gui->ui->panels[k],FALSE); } }
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 gd_main_toolbar_constructed (GObject *obj) { GdMainToolbar *self = GD_MAIN_TOOLBAR (obj); GtkToolbar *tb = GTK_TOOLBAR (obj); GtkWidget *grid; G_OBJECT_CLASS (gd_main_toolbar_parent_class)->constructed (obj); self->priv->vertical_size_group = get_vertical_size_group (); /* left section */ self->priv->left_group = gtk_tool_item_new (); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->left_group), 12); gtk_toolbar_insert (tb, self->priv->left_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->left_group)); /* left button group */ self->priv->left_grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (self->priv->left_grid), 12); gtk_container_add (GTK_CONTAINER (self->priv->left_group), self->priv->left_grid); self->priv->back = get_symbolic_button ("go-previous-symbolic"); gtk_widget_set_no_show_all (self->priv->back, TRUE); gtk_container_add (GTK_CONTAINER (self->priv->left_grid), self->priv->back); g_signal_connect (self->priv->back, "clicked", G_CALLBACK (on_back_button_clicked), self); /* center section */ self->priv->center_group = gtk_tool_item_new (); gtk_tool_item_set_expand (self->priv->center_group, TRUE); gtk_toolbar_insert (tb, self->priv->center_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->center_group)); /* centered label group */ grid = gtk_grid_new (); gtk_widget_set_halign (grid, GTK_ALIGN_CENTER); gtk_widget_set_valign (grid, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (self->priv->center_group), grid); self->priv->title_label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (self->priv->title_label), PANGO_ELLIPSIZE_END); gtk_container_add (GTK_CONTAINER (grid), self->priv->title_label); self->priv->detail_label = gtk_label_new (NULL); gtk_widget_set_no_show_all (self->priv->detail_label, TRUE); gtk_widget_set_margin_left (self->priv->detail_label, 12); gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->detail_label), "dim-label"); gtk_container_add (GTK_CONTAINER (grid), self->priv->detail_label); /* right section */ self->priv->right_group = gtk_tool_item_new (); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->right_group), 12); gtk_toolbar_insert (tb, self->priv->right_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->right_group)); self->priv->right_grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (self->priv->right_grid), 12); gtk_container_add (GTK_CONTAINER (self->priv->right_group), self->priv->right_grid); self->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->left_group)); gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->right_group)); }
void gui_init(dt_lib_module_t *self) { self->data = calloc(1, sizeof(dt_lib_live_view_t)); // Setup lib data dt_lib_live_view_t *lib = self->data; lib->splitline_x = lib->splitline_y = 0.5; // Setup gui self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); dt_gui_add_help_link(self->widget, "live_view.html#live_view"); GtkWidget *box; box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); lib->live_view_zoom = dtgtk_button_new( dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); // TODO: see _zoom_live_view_clicked lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL); lib->flip = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL); gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->live_view_zoom, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->flip, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(lib->live_view, _("toggle live view")); gtk_widget_set_tooltip_text(lib->live_view_zoom, _("zoom live view")); gtk_widget_set_tooltip_text(lib->rotate_ccw, _("rotate 90 degrees ccw")); gtk_widget_set_tooltip_text(lib->rotate_cw, _("rotate 90 degrees cw")); gtk_widget_set_tooltip_text(lib->flip, _("flip live view horizontally")); g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib); g_signal_connect(G_OBJECT(lib->live_view_zoom), "clicked", G_CALLBACK(_zoom_live_view_clicked), lib); g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib); g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib); g_signal_connect(G_OBJECT(lib->flip), "clicked", G_CALLBACK(_toggle_flip_clicked), lib); // focus buttons box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL); lib->focus_in_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL); // TODO icon not centered lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL); // TODO same here lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL); gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(lib->focus_in_big, _("move focus point in (big steps)")); gtk_widget_set_tooltip_text(lib->focus_in_small, _("move focus point in (small steps)")); gtk_widget_set_tooltip_text(lib->focus_out_small, _("move focus point out (small steps)")); gtk_widget_set_tooltip_text(lib->focus_out_big, _("move focus point out (big steps)")); // Near 3 g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked), GINT_TO_POINTER(2)); // Near 1 g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked), GINT_TO_POINTER(0)); // Far 1 g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked), GINT_TO_POINTER(4)); // Far 3 g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked), GINT_TO_POINTER(6)); // Guides lib->guide_selector = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(lib->guide_selector, NULL, _("guides")); gtk_box_pack_start(GTK_BOX(self->widget), lib->guide_selector, TRUE, TRUE, 0); lib->guides_widgets = gtk_stack_new(); gtk_stack_set_homogeneous(GTK_STACK(lib->guides_widgets), FALSE); gtk_box_pack_start(GTK_BOX(self->widget), lib->guides_widgets, TRUE, TRUE, 0); dt_bauhaus_combobox_add(lib->guide_selector, _("none")); int i = 0; for(GList *iter = darktable.guides; iter; iter = g_list_next(iter), i++) { GtkWidget *widget = NULL; dt_guides_t *guide = (dt_guides_t *)iter->data; dt_bauhaus_combobox_add(lib->guide_selector, _(guide->name)); if(guide->widget) { // generate some unique name so that we can have the same name several times char name[5]; snprintf(name, sizeof(name), "%d", i); widget = guide->widget(NULL, guide->user_data); gtk_widget_show_all(widget); gtk_stack_add_named(GTK_STACK(lib->guides_widgets), widget, name); } lib->guides_widgets_list = g_list_append(lib->guides_widgets_list, widget); } gtk_widget_set_no_show_all(lib->guides_widgets, TRUE); gtk_widget_set_tooltip_text(lib->guide_selector, _("display guide lines to help compose your photograph")); g_signal_connect(G_OBJECT(lib->guide_selector), "value-changed", G_CALLBACK(guides_presets_changed), lib); lib->flip_guides = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(lib->flip_guides, NULL, _("flip")); dt_bauhaus_combobox_add(lib->flip_guides, _("none")); dt_bauhaus_combobox_add(lib->flip_guides, _("horizontally")); dt_bauhaus_combobox_add(lib->flip_guides, _("vertically")); dt_bauhaus_combobox_add(lib->flip_guides, _("both")); gtk_widget_set_tooltip_text(lib->flip_guides, _("flip guides")); gtk_box_pack_start(GTK_BOX(self->widget), lib->flip_guides, TRUE, TRUE, 0); lib->overlay = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(lib->overlay, NULL, _("overlay")); dt_bauhaus_combobox_add(lib->overlay, _("none")); dt_bauhaus_combobox_add(lib->overlay, _("selected image")); dt_bauhaus_combobox_add(lib->overlay, _("id")); gtk_widget_set_tooltip_text(lib->overlay, _("overlay another image over the live view")); g_signal_connect(G_OBJECT(lib->overlay), "value-changed", G_CALLBACK(overlay_changed), lib); gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay, TRUE, TRUE, 0); lib->overlay_id_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *label = gtk_label_new(_("image id")); gtk_widget_set_halign(label, GTK_ALIGN_START); lib->overlay_id = gtk_spin_button_new_with_range(0, 1000000000, 1); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lib->overlay_id), 0); gtk_widget_set_tooltip_text(lib->overlay_id, _("enter image id of the overlay manually")); g_signal_connect(G_OBJECT(lib->overlay_id), "value-changed", G_CALLBACK(_overlay_id_changed), lib); gtk_spin_button_set_value(GTK_SPIN_BUTTON(lib->overlay_id), dt_conf_get_int("plugins/lighttable/live_view/overlay_imgid")); gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), lib->overlay_id, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_id_box, TRUE, TRUE, 0); gtk_widget_show(lib->overlay_id); gtk_widget_show(label); lib->overlay_mode = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(lib->overlay_mode, NULL, _("overlay mode")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "normal")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "xor")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "add")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "saturate")); #if(CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 10, 0)) dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "multiply")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "screen")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "overlay")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "darken")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "lighten")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color dodge")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color burn")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "hard light")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "soft light")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "difference")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "exclusion")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL hue")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL saturation")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL color")); dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL luminosity")); #endif gtk_widget_set_tooltip_text(lib->overlay_mode, _("mode of the overlay")); dt_bauhaus_combobox_set(lib->overlay_mode, dt_conf_get_int("plugins/lighttable/live_view/overlay_mode")); g_signal_connect(G_OBJECT(lib->overlay_mode), "value-changed", G_CALLBACK(_overlay_mode_changed), lib); gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_mode, TRUE, TRUE, 0); lib->overlay_splitline = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(lib->overlay_splitline, NULL, _("split line")); dt_bauhaus_combobox_add(lib->overlay_splitline, _("off")); dt_bauhaus_combobox_add(lib->overlay_splitline, _("on")); gtk_widget_set_tooltip_text(lib->overlay_splitline, _("only draw part of the overlay")); dt_bauhaus_combobox_set(lib->overlay_splitline, dt_conf_get_int("plugins/lighttable/live_view/splitline")); g_signal_connect(G_OBJECT(lib->overlay_splitline), "value-changed", G_CALLBACK(_overlay_splitline_changed), lib); gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_splitline, TRUE, TRUE, 0); gtk_widget_set_visible(GTK_WIDGET(lib->overlay_mode), FALSE); gtk_widget_set_visible(GTK_WIDGET(lib->overlay_id_box), FALSE); gtk_widget_set_visible(GTK_WIDGET(lib->overlay_splitline), FALSE); gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_mode), TRUE); gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_id_box), TRUE); gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_splitline), TRUE); guides_presets_set_visibility(lib, 0); }
static void theme_message_area_update (AppearanceData *data) { const MateThemeMetaInfo *theme; gboolean show_apply_background = FALSE; gboolean show_apply_font = FALSE; gboolean show_revert_font = FALSE; gboolean show_error; const gchar *message; gchar *font; GError *error = NULL; theme = theme_get_selected (GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")), data); if (!theme) { if (data->theme_message_area != NULL) gtk_widget_hide (data->theme_message_area); return; } show_error = !mate_theme_meta_info_validate (theme, &error); if (!show_error) { if (theme->background_image != NULL) { gchar *background; background = mateconf_client_get_string (data->client, BACKGROUND_KEY, NULL); show_apply_background = (!background || strcmp (theme->background_image, background) != 0); g_free (background); } if (theme->application_font) { font = mateconf_client_get_string (data->client, APPLICATION_FONT_KEY, NULL); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->documents_font) { font = mateconf_client_get_string (data->client, DOCUMENTS_FONT_KEY, NULL); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->desktop_font) { font = mateconf_client_get_string (data->client, DESKTOP_FONT_KEY, NULL); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->windowtitle_font) { font = mateconf_client_get_string (data->client, WINDOWTITLE_FONT_KEY, NULL); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } if (!show_apply_font && theme->monospace_font) { font = mateconf_client_get_string (data->client, MONOSPACE_FONT_KEY, NULL); show_apply_font = (!font || strcmp (theme->application_font, font) != 0); g_free (font); } show_revert_font = (data->revert_application_font != NULL || data->revert_documents_font != NULL || data->revert_desktop_font != NULL || data->revert_windowtitle_font != NULL || data->revert_monospace_font != NULL); } if (data->theme_message_area == NULL) { GtkWidget *hbox; GtkWidget *parent; GtkWidget *content; if (!show_apply_background && !show_revert_font && !show_apply_font && !show_error) return; data->theme_message_area = gtk_info_bar_new (); gtk_widget_set_no_show_all (data->theme_message_area, TRUE); g_signal_connect (data->theme_message_area, "response", (GCallback) theme_message_area_response_cb, data); data->apply_background_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Background"), RESPONSE_APPLY_BG); data->apply_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Apply Font"), RESPONSE_APPLY_FONT); data->revert_font_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Revert Font"), RESPONSE_REVERT_FONT); data->install_button = gtk_info_bar_add_button ( GTK_INFO_BAR (data->theme_message_area), _("Install"), RESPONSE_INSTALL_ENGINE); data->theme_message_label = gtk_label_new (NULL); gtk_widget_show (data->theme_message_label); gtk_label_set_line_wrap (GTK_LABEL (data->theme_message_label), TRUE); gtk_misc_set_alignment (GTK_MISC (data->theme_message_label), 0.0, 0.5); hbox = gtk_hbox_new (FALSE, 9); gtk_widget_show (hbox); data->theme_info_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); data->theme_error_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (data->theme_info_icon), 0.5, 0); gtk_misc_set_alignment (GTK_MISC (data->theme_error_icon), 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_info_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_error_icon, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), data->theme_message_label, TRUE, TRUE, 0); content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->theme_message_area)); gtk_container_add (GTK_CONTAINER (content), hbox); parent = appearance_capplet_get_widget (data, "theme_list_vbox"); gtk_box_pack_start (GTK_BOX (parent), data->theme_message_area, FALSE, FALSE, 0); } if (show_error) message = error->message; else if (show_apply_background && show_apply_font && show_revert_font) message = _("The current theme suggests a background and a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_revert_font) message = _("The current theme suggests a background. Also, the last applied font suggestion can be reverted."); else if (show_apply_background && show_apply_font) message = _("The current theme suggests a background and a font."); else if (show_apply_font && show_revert_font) message = _("The current theme suggests a font. Also, the last applied font suggestion can be reverted."); else if (show_apply_background) message = _("The current theme suggests a background."); else if (show_revert_font) message = _("The last applied font suggestion can be reverted."); else if (show_apply_font) message = _("The current theme suggests a font."); else message = NULL; if (show_apply_background) gtk_widget_show (data->apply_background_button); else gtk_widget_hide (data->apply_background_button); if (show_apply_font) gtk_widget_show (data->apply_font_button); else gtk_widget_hide (data->apply_font_button); if (show_revert_font) gtk_widget_show (data->revert_font_button); else gtk_widget_hide (data->revert_font_button); if (show_error && g_error_matches (error, MATE_THEME_ERROR, MATE_THEME_ERROR_GTK_ENGINE_NOT_AVAILABLE) && packagekit_available ()) gtk_widget_show (data->install_button); else gtk_widget_hide (data->install_button); if (show_error || show_apply_background || show_apply_font || show_revert_font) { gtk_widget_show (data->theme_message_area); gtk_widget_queue_draw (data->theme_message_area); if (show_error) { gtk_widget_show (data->theme_error_icon); gtk_widget_hide (data->theme_info_icon); } else { gtk_widget_show (data->theme_info_icon); gtk_widget_hide (data->theme_error_icon); } } else { gtk_widget_hide (data->theme_message_area); } gtk_label_set_text (GTK_LABEL (data->theme_message_label), message); g_clear_error (&error); }
static void gvc_combo_box_init (GvcComboBox *combobox) { GtkWidget *frame; GtkCellRenderer *renderer; frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); combobox->priv = GVC_COMBO_BOX_GET_PRIVATE (combobox); combobox->priv->model = GTK_TREE_MODEL (gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_STRING)); combobox->priv->combobox = gtk_combo_box_new_with_model (combobox->priv->model); combobox->priv->label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (combobox->priv->label), 0.0); gtk_label_set_yalign (GTK_LABEL (combobox->priv->label), 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (combobox->priv->label), combobox->priv->combobox); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox->priv->combobox), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox->priv->combobox), renderer, "text", COL_HUMAN_NAME); combobox->priv->drop_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); combobox->priv->start_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); combobox->priv->end_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); /* Make sure the combo box does not get too long on long profile names */ g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox->priv->combobox), FALSE); gtk_box_pack_start (GTK_BOX (combobox), frame, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box), combobox->priv->start_box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (combobox->priv->start_box), combobox->priv->label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box), combobox->priv->combobox, TRUE, TRUE, 0); combobox->priv->button = gtk_button_new_with_label (""); gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box), combobox->priv->button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box), combobox->priv->end_box, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), combobox->priv->drop_box); g_signal_connect (G_OBJECT (combobox->priv->combobox), "changed", G_CALLBACK (on_combo_box_changed), combobox); g_signal_connect (G_OBJECT (combobox->priv->button), "clicked", G_CALLBACK (on_combo_box_button_clicked), combobox); gtk_widget_set_no_show_all (combobox->priv->button, TRUE); gtk_widget_show_all (frame); }
void rb_media_player_source_show_properties (RBMediaPlayerSource *source) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source); RBMediaPlayerSourceClass *klass = RB_MEDIA_PLAYER_SOURCE_GET_CLASS (source); GtkBuilder *builder; GtkContainer *container; const char *ui_file; char *name; char *text; if (priv->properties_dialog != NULL) { gtk_window_present (GTK_WINDOW (priv->properties_dialog)); return; } /* load dialog UI */ ui_file = rb_file ("media-player-properties.ui"); if (ui_file == NULL) { g_warning ("Couldn't find media-player-properties.ui"); return; } builder = rb_builder_load (ui_file, NULL); if (builder == NULL) { g_warning ("Couldn't load media-player-properties.ui"); return; } priv->properties_dialog = GTK_DIALOG (gtk_builder_get_object (builder, "media-player-properties")); g_object_ref (priv->properties_dialog); g_signal_connect_object (priv->properties_dialog, "response", G_CALLBACK (properties_dialog_response_cb), source, 0); g_object_get (source, "name", &name, NULL); text = g_strdup_printf (_("%s Properties"), name); gtk_window_set_title (GTK_WINDOW (priv->properties_dialog), text); g_free (text); g_free (name); /* ensure device usage information is available and up to date */ update_sync (source); /* * fill in some common details: * - volume usage (need to hook up signals etc. to update this live) */ rb_sync_state_ui_create_bar (&priv->volume_usage, rb_media_player_source_get_capacity (source), NULL); rb_sync_state_ui_update_volume_usage (&priv->volume_usage, priv->sync_state); gtk_widget_show_all (priv->volume_usage.widget); container = GTK_CONTAINER (gtk_builder_get_object (builder, "device-usage-container")); gtk_container_add (container, priv->volume_usage.widget); /* let the subclass fill in device type specific details (model names, device names, * .. battery levels?) and add more tabs to the notebook to display 'advanced' stuff. */ if (klass->show_properties) { klass->show_properties (source, GTK_WIDGET (gtk_builder_get_object (builder, "device-info-box")), GTK_WIDGET (gtk_builder_get_object (builder, "media-player-notebook"))); } /* create sync UI */ container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-settings-ui-container")); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (container), rb_sync_settings_ui_new (source, priv->sync_settings)); container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-state-ui-container")); gtk_box_pack_start (GTK_BOX (container), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (container)); /* create encoding settings UI */ if (priv->encoding_settings) { container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-container")); gtk_container_add (container, rb_encoding_settings_new (priv->encoding_settings, priv->encoding_target, TRUE)); gtk_widget_show_all (GTK_WIDGET (container)); } else { container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-frame")); gtk_widget_hide (GTK_WIDGET (container)); gtk_widget_set_no_show_all (GTK_WIDGET (container), TRUE); } gtk_widget_show (GTK_WIDGET (priv->properties_dialog)); g_object_unref (builder); }