GtkWidget * entry_create_widget (GtkWidget * dlg) { GtkWidget *c, *l = NULL, *w = NULL; #if !GTK_CHECK_VERSION(3,0,0) w = gtk_hbox_new (FALSE, 5); #else w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); #endif if (options.entry_data.entry_label) { l = gtk_label_new (NULL); if (options.data.no_markup) gtk_label_set_text_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); else gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); gtk_widget_set_name (l, "yad-entry-label"); gtk_box_pack_start (GTK_BOX (w), l, FALSE, FALSE, 1); } if (options.entry_data.numeric) { gdouble min, max, step, val; guint prec; min = 0.0; max = 65535.0; step = 1.0; prec = 0; val = 0.0; if (options.extra_data && options.extra_data[0]) { min = g_ascii_strtod (options.extra_data[0], NULL); if (options.extra_data[1]) max = g_ascii_strtod (options.extra_data[1], NULL); if (options.extra_data[2]) step = g_ascii_strtod (options.extra_data[2], NULL); if (options.extra_data[3]) { prec = (guint) g_ascii_strtoull (options.extra_data[3], NULL, 0); if (prec > 20) prec = 20; } } c = entry = gtk_spin_button_new_with_range (min, max, step); gtk_entry_set_alignment (GTK_ENTRY (c), 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (c), prec); gtk_widget_set_name (entry, "yad-entry-spin"); if (options.entry_data.entry_text) { val = g_ascii_strtod (options.entry_data.entry_text, NULL); if (min >= max) { g_printerr (_("Maximum value must be greater than minimum value.\n")); min = 0.0; max = 65535.0; } if (val < min) { g_printerr (_("Initial value less than minimal.\n")); val = min; } else if (val > max) { g_printerr (_("Initial value greater than maximum.\n")); val = max; } } gtk_spin_button_set_value (GTK_SPIN_BUTTON (c), val); } else if (!options.entry_data.completion && options.extra_data && *options.extra_data) { gint active, i; if (options.common_data.editable || settings.combo_always_editable) { #if GTK_CHECK_VERSION(2,24,0) c = gtk_combo_box_text_new_with_entry (); #else c = gtk_combo_box_entry_new_text (); #endif gtk_widget_set_name (c, "yad-entry-edit-combo"); entry = gtk_bin_get_child (GTK_BIN (c)); if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } else { #if GTK_CHECK_VERSION(2,24,0) c = entry = gtk_combo_box_text_new (); #else c = entry = gtk_combo_box_new_text (); #endif gtk_widget_set_name (c, "yad-entry-combo"); is_combo = TRUE; } i = 0; active = -1; while (options.extra_data[i] != NULL) { if (options.entry_data.entry_text && g_ascii_strcasecmp (options.extra_data[i], options.entry_data.entry_text) == 0) active = i; #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (c), options.extra_data[i]); #else gtk_combo_box_append_text (GTK_COMBO_BOX (c), options.extra_data[i]); #endif i++; } if (options.entry_data.entry_text && active == -1) { #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (c), options.entry_data.entry_text); #else gtk_combo_box_prepend_text (GTK_COMBO_BOX (c), options.entry_data.entry_text); #endif } /* set first iter active */ if (!options.common_data.editable) gtk_combo_box_set_active (GTK_COMBO_BOX (c), (active != -1 ? active : 0)); } else { c = entry = gtk_entry_new (); gtk_widget_set_name (c, "yad-entry-widget"); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); if (options.entry_data.entry_text) gtk_entry_set_text (GTK_ENTRY (entry), options.entry_data.entry_text); if (options.entry_data.hide_text) g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL); if (options.entry_data.completion) { GtkEntryCompletion *completion; GtkTreeModel *completion_model; completion = gtk_entry_completion_new (); gtk_entry_set_completion (GTK_ENTRY (entry), completion); completion_model = create_completion_model (); gtk_entry_completion_set_model (completion, completion_model); g_object_unref (completion_model); gtk_entry_completion_set_text_column (completion, 0); if (options.common_data.complete != YAD_COMPLETE_SIMPLE) gtk_entry_completion_set_match_func (completion, check_complete, NULL, NULL); g_object_unref (completion); } if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } if (l) gtk_label_set_mnemonic_widget (GTK_LABEL (l), entry); if (!is_combo) g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (entry_activate_cb), dlg); else g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (combo_activate_cb), dlg); if (options.entry_data.licon || options.entry_data.ricon) g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (icon_cb), NULL); gtk_box_pack_start (GTK_BOX (w), c, TRUE, TRUE, 1); return w; }
static void gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpColorPickState pick_state, const Babl *sample_format, const GimpRGB *color, gint color_index) { GimpTool *tool = GIMP_TOOL (color_tool); GimpContext *context; /* use this tool's own options here (NOT color_tool->options) */ context = GIMP_CONTEXT (gimp_tool_get_options (tool)); if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND || color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND) { GtkWidget *widget; if (babl_format_is_palette (sample_format)) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-indexed-palette"); if (widget) { GimpColormapEditor *editor; editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); gimp_colormap_editor_set_index (editor, color_index, NULL); } } if (TRUE) { widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (), "gimp-palette-editor"); if (widget) { GimpPaletteEditor *editor; gint index; editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget))); index = gimp_palette_editor_get_index (editor, color); if (index != -1) gimp_palette_editor_set_index (editor, index, NULL); } } } switch (color_tool->pick_mode) { case GIMP_COLOR_PICK_MODE_NONE: break; case GIMP_COLOR_PICK_MODE_FOREGROUND: gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_MODE_BACKGROUND: gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_MODE_PALETTE: { GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell)); GtkWidget *dockable; dockable = gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)), tool->display->gimp, gimp_dialog_factory_get_singleton (), screen, "gimp-palette-editor"); if (dockable) { GtkWidget *palette_editor; GimpData *data; /* don't blink like mad when updating */ if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE) gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable)); palette_editor = gtk_bin_get_child (GTK_BIN (dockable)); data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor)); if (! data) { data = GIMP_DATA (gimp_context_get_palette (context)); gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor), data); } gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor), color, pick_state); } } break; } }
GValue* ghb_widget_value(GtkWidget *widget) { GValue *value = NULL; const gchar *name; GType type; if (widget == NULL) { g_debug("NULL widget\n"); return NULL; } type = G_OBJECT_TYPE(widget); name = ghb_get_setting_key(widget); g_debug("ghb_widget_value widget (%s)\n", name); if (type == GTK_TYPE_ENTRY) { const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget)); value = ghb_string_value_new(str); } else if (type == GTK_TYPE_RADIO_BUTTON) { g_debug("\tradio_button"); gboolean bval; bval = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(widget)); if (bval) { value = ghb_boolean_value_new(FALSE); } else { bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } } else if (type == GTK_TYPE_CHECK_BUTTON) { g_debug("\tcheck_button"); gboolean bval; bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON) { g_debug("\ttoggle_tool_button"); gboolean bval; bval = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_TOGGLE_BUTTON) { g_debug("\ttoggle_button"); gboolean bval; bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_CHECK_MENU_ITEM) { g_debug("\tcheck_menu_item"); gboolean bval; bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_COMBO_BOX) { g_debug("\tcombo_box"); GtkTreeModel *store; GtkTreeIter iter; gchar *shortOpt; store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter)) { gtk_tree_model_get(store, &iter, 2, &shortOpt, -1); value = ghb_string_value_new(shortOpt); g_free(shortOpt); } else if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget))) { const gchar *str; str = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)))); if (str == NULL) str = ""; value = ghb_string_value_new(str); } else { value = ghb_string_value_new(""); } } else if (type == GTK_TYPE_SPIN_BUTTON) { gint ival; ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)); value = ghb_int64_value_new(ival); } else if (type == GTK_TYPE_SCALE) { gdouble dval; gint digits; digits = gtk_scale_get_digits(GTK_SCALE(widget)); dval = gtk_range_get_value(GTK_RANGE(widget)); if (digits) { value = ghb_double_value_new(dval); } else { value = ghb_int_value_new(dval); } } else if (type == GTK_TYPE_SCALE_BUTTON) { gdouble dval; dval = gtk_scale_button_get_value(GTK_SCALE_BUTTON(widget)); value = ghb_double_value_new(dval); } else if (type == GTK_TYPE_TEXT_VIEW) { GtkTextBuffer *buffer; GtkTextIter start, end; gchar *str; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_get_bounds(buffer, &start, &end); str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); value = ghb_string_value_new(str); g_free(str); } else if (type == GTK_TYPE_LABEL) { const gchar *str; str = gtk_label_get_text (GTK_LABEL(widget)); value = ghb_string_value_new(str); } else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON) { gchar *str = NULL; str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget)); if (str == NULL) { str = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget)); } value = ghb_string_value_new(str); if (str != NULL) g_free(str); } else { g_debug("Attempt to set unknown widget type: %s\n", name); g_free(value); value = NULL; } return value; }
GtkImage* CagEImage::Image() { GtkWidget* wid = gtk_bin_get_child(GTK_BIN(iWidget)); return GTK_IMAGE(wid); }
static gchar *input_dialog_open(const gchar *title, const gchar *message, const gchar *checkbtn_label, const gchar *default_string, gboolean default_checkbtn_state, gboolean *remember) { gchar *str; if (dialog && gtk_widget_get_visible(dialog)) return NULL; if (!dialog) input_dialog_create(FALSE); if (checkbtn_label) gtk_button_set_label(GTK_BUTTON(remember_checkbtn), checkbtn_label); else gtk_button_set_label(GTK_BUTTON(remember_checkbtn), _("Remember this")); input_dialog_set(title, message, default_string); gtk_window_present(GTK_WINDOW(dialog)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remember_checkbtn), default_checkbtn_state); if (remember) gtk_widget_show(remember_checkbtn); else gtk_widget_hide(remember_checkbtn); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); manage_window_set_transient(GTK_WINDOW(dialog)); ack = fin = FALSE; while (fin == FALSE) gtk_main_iteration(); manage_window_focus_out(dialog, NULL, NULL); if (ack) { GtkEditable *editable; if (type == INPUT_DIALOG_COMBO) editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((combo)))); else editable = GTK_EDITABLE(entry); str = gtk_editable_get_chars(editable, 0, -1); if (str && *str == '\0' && !is_pass) { g_free(str); str = NULL; } } else str = NULL; GTK_EVENTS_FLUSH(); if (remember) { *remember = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remember_checkbtn)); } gtk_widget_destroy(dialog); dialog = NULL; if (is_pass) debug_print("return string = %s\n", str ? "********": ("none")); else debug_print("return string = %s\n", str ? str : "(none)"); return str; }
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 prefs_create_dialog(void) { GtkWidget *label; GtkWidget *dialog_vbox; GtkWidget *notebook; GtkTable *top_table = NULL; /* top level table for the tab */ GtkTable *current_table = NULL; int i; int tab_idx = -1; if (prefs_dialog != NULL) return; prefs_dialog = gtk_dialog_new_with_buttons( _("Preferences"), GTK_WINDOW(interface_get_toolbox_shell()), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG(prefs_dialog), GTK_RESPONSE_OK); gtk_window_set_resizable (GTK_WINDOW (prefs_dialog), TRUE); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (prefs_dialog)); gtk_window_set_role (GTK_WINDOW (prefs_dialog), "preferences_window"); g_signal_connect(G_OBJECT (prefs_dialog), "response", G_CALLBACK (prefs_respond), NULL); g_signal_connect (G_OBJECT (prefs_dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); g_signal_connect (G_OBJECT (prefs_dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &prefs_dialog); notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (dialog_vbox), notebook, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (notebook), 2); gtk_widget_show (notebook); for (i=0;i<NUM_PREFS_TABS;i++) { GtkWidget *table; GtkWidget *notebook_page; label = gtk_label_new(gettext(prefs_tabs[i].title)); gtk_widget_show(label); table = gtk_table_new (9, 2, FALSE); prefs_tabs[i].table = GTK_TABLE(table); gtk_widget_set_size_request(table, -1, -1); gtk_widget_show(table); #ifdef SCROLLED_PAGES notebook_page = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_page), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(notebook_page); #else notebook_page = table; #endif/* SCROLLED_PAGES */ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), notebook_page, label); #ifdef SCROLLED_PAGES gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(notebook_page), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN(notebook_page))), GTK_SHADOW_NONE); #endif /* SCROLLED_PAGES */ } gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT); tab_idx = -1; for (i=0;i<NUM_PREFS_DATA;i++) { GtkWidget *widget = NULL; int row; if (prefs_data[i].hidden) continue; if (tab_idx != prefs_data[i].tab) { tab_idx = prefs_data[i].tab; top_table = prefs_tabs[prefs_data[i].tab].table; current_table = top_table; } row = prefs_tabs[tab_idx].row++; switch(prefs_data[i].type) { case PREF_NONE: widget = gtk_frame_new(gettext(prefs_data[i].label_text)); gtk_widget_show (widget); gtk_table_attach (current_table, widget, 0, 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); current_table = GTK_TABLE(gtk_table_new (9, 2, FALSE)); gtk_container_add(GTK_CONTAINER(widget), GTK_WIDGET(current_table)); gtk_widget_show(GTK_WIDGET(current_table)); break; case PREF_END_GROUP: current_table = top_table; break; case PREF_BOOLEAN: widget = gtk_check_button_new_with_label (gettext(prefs_data[i].label_text)); gtk_widget_show (widget); gtk_table_attach (current_table, widget, 0, 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); break; default: label = gtk_label_new (gettext(prefs_data[i].label_text)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.3); gtk_widget_show (label); gtk_table_attach (current_table, label, 0, 1, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1); widget = prefs_get_property_widget(&prefs_data[i]); if (widget != NULL) { gtk_table_attach (current_table, widget, 1, 2, row, row + 1, GTK_FILL, GTK_FILL, 1, 1); } break; } prefs_data[i].widget = widget; } gtk_widget_show (prefs_dialog); }
void gui_init(dt_lib_module_t *self) { GtkBox *hbox; GtkWidget *button; GtkWidget *label; GtkEntryCompletion *completion; int line = 0; dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5)); gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10)); g_signal_connect(self->widget, "draw", G_CALLBACK(draw), self); struct { char *name; GtkComboBox **box; } entries[] = { // clang-format off {N_("title"), &d->title}, {N_("description"), &d->description}, {N_("creator"), &d->creator}, {N_("publisher"), &d->publisher}, {N_("rights"), &d->rights} // clang-format on }; for(line = 0; line < sizeof(entries) / sizeof(entries[0]); line++) { label = gtk_label_new(_(entries[line].name)); g_object_set(G_OBJECT(label), "xalign", 0.0, NULL); GtkWidget *combobox = gtk_combo_box_text_new_with_entry(); *(entries[line].box) = GTK_COMBO_BOX(combobox); gtk_widget_set_hexpand(combobox, TRUE); GtkWidget *entry = gtk_bin_get_child(GTK_BIN(combobox)); dt_gui_key_accel_block_on_focus_connect(entry); completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(combobox))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(entry), completion); g_object_unref(completion); g_signal_connect(entry, "key-press-event", G_CALLBACK(key_pressed), self); gtk_entry_set_width_chars(GTK_ENTRY(entry), 0); gtk_grid_attach(GTK_GRID(self->widget), label, 0, line, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), combobox, label, GTK_POS_RIGHT, 1, 1); } // reset/apply buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("clear")); d->clear_button = button; gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE); g_object_set(G_OBJECT(button), "tooltip-text", _("remove metadata from selected images"), (char *)NULL); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clear_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); button = gtk_button_new_with_label(_("apply")); d->apply_button = button; gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE); g_object_set(G_OBJECT(button), "tooltip-text", _("write metadata for selected images"), (char *)NULL); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(apply_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_widget_set_margin_top(GTK_WIDGET(hbox), DT_PIXEL_APPLY_DPI(5)); gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(hbox), 0, line, 2, 1); /* lets signup for mouse over image change signals */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_mouse_over_image_callback), self); }
static void spamassassin_create_widget_func(PrefsPage * _page, GtkWindow * window, gpointer data) { struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page; SpamAssassinConfig *config; guint i, active; GtkWidget *vbox1, *vbox2; GtkWidget *frame_transport, *table_transport, *vbox_transport; GtkWidget *hbox_spamd, *hbox_max_size, *hbox_timeout; GtkWidget *hbox_process_emails, *hbox_save_spam; GtkWidget *hbox_mark_as_read, *hbox_whitelist; GtkWidget *whitelist_ab_checkbtn; GtkWidget *whitelist_ab_folder_combo; GtkWidget *whitelist_ab_select_btn; GtkWidget *enable_sa_checkbtn; GtkWidget *transport_label; GtkWidget *transport_optmenu; GtkWidget *user_label; GtkWidget *user_entry; GtkWidget *spamd_label; GtkWidget *spamd_hostname_entry; GtkWidget *spamd_colon_label; GtkAdjustment *spamd_port_spinbtn_adj; GtkWidget *spamd_port_spinbtn; GtkWidget *spamd_socket_entry; GtkWidget *max_size_label; GtkAdjustment *max_size_spinbtn_adj; GtkWidget *max_size_spinbtn; GtkWidget *max_size_kb_label; GtkWidget *timeout_label; GtkAdjustment *timeout_spinbtn_adj; GtkWidget *timeout_spinbtn; GtkWidget *timeout_seconds_label; GtkWidget *process_emails_checkbtn; GtkWidget *save_spam_checkbtn; GtkWidget *save_spam_folder_entry; GtkWidget *save_spam_folder_select; GtkWidget *mark_as_read_checkbtn; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; vbox1 = gtk_vbox_new (FALSE, VSPACING); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER); vbox2 = gtk_vbox_new (FALSE, 4); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0); enable_sa_checkbtn = gtk_check_button_new_with_label(_("Enable SpamAssassin plugin")); gtk_widget_show(enable_sa_checkbtn); gtk_box_pack_start(GTK_BOX(vbox2), enable_sa_checkbtn, TRUE, TRUE, 0); vbox_transport = gtkut_get_options_frame(vbox2, &frame_transport, _("Transport")); table_transport = gtk_table_new (3, 3, FALSE); gtk_widget_show (table_transport); gtk_box_pack_start(GTK_BOX(vbox_transport), table_transport, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table_transport), 4); gtk_table_set_col_spacings (GTK_TABLE (table_transport), 8); transport_label = gtk_label_new(_("Type of transport")); gtk_widget_show(transport_label); gtk_table_attach (GTK_TABLE (table_transport), transport_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(transport_label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(transport_label), 1, 0.5); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER); transport_optmenu = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(transport_optmenu), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(transport_optmenu), renderer, "text", 0, NULL); gtk_widget_show(transport_optmenu); gtk_table_attach (GTK_TABLE (table_transport), transport_optmenu, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); user_label = gtk_label_new(_("User")); gtk_widget_show(user_label); gtk_table_attach (GTK_TABLE (table_transport), user_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(user_label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(user_label), 1, 0.5); user_entry = gtk_entry_new(); gtk_widget_show(user_entry); gtk_table_attach (GTK_TABLE (table_transport), user_entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); CLAWS_SET_TIP(user_entry, _("User to use with spamd server")); spamd_label = gtk_label_new(_("spamd")); gtk_widget_show(spamd_label); gtk_table_attach (GTK_TABLE (table_transport), spamd_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(spamd_label), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(spamd_label), 1, 0.5); hbox_spamd = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_spamd); gtk_table_attach (GTK_TABLE (table_transport), hbox_spamd, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); spamd_hostname_entry = gtk_entry_new(); gtk_widget_show(spamd_hostname_entry); gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_hostname_entry, TRUE, TRUE, 0); CLAWS_SET_TIP(spamd_hostname_entry, _("Hostname or IP address of spamd server")); spamd_colon_label = gtk_label_new(":"); gtk_widget_show(spamd_colon_label); gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_colon_label, FALSE, FALSE, 0); spamd_port_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(783, 1, 65535, 1, 10, 0)); spamd_port_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(spamd_port_spinbtn_adj), 1, 0); gtk_widget_show(spamd_port_spinbtn); gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_port_spinbtn, FALSE, FALSE, 0); CLAWS_SET_TIP(spamd_port_spinbtn, _("Port of spamd server")); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spamd_port_spinbtn), TRUE); spamd_socket_entry = gtk_entry_new(); gtk_widget_show(spamd_socket_entry); gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_socket_entry, TRUE, TRUE, 0); CLAWS_SET_TIP(spamd_socket_entry, _("Path of Unix socket")); hbox_max_size = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_max_size); gtk_box_pack_start (GTK_BOX (vbox2), hbox_max_size, TRUE, TRUE, 0); max_size_label = gtk_label_new(_("Maximum size")); gtk_widget_show(max_size_label); gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_label, FALSE, FALSE, 0); max_size_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(250, 0, 10000, 10, 10, 0)); max_size_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(max_size_spinbtn_adj), 1, 0); gtk_widget_show(max_size_spinbtn); gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_spinbtn, FALSE, FALSE, 0); CLAWS_SET_TIP(max_size_spinbtn, _("Messages larger than this will not be checked")); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(max_size_spinbtn), TRUE); max_size_kb_label = gtk_label_new(_("KB")); gtk_widget_show(max_size_kb_label); gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_kb_label, FALSE, FALSE, 0); hbox_timeout = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_timeout); gtk_box_pack_start (GTK_BOX (vbox2), hbox_timeout, TRUE, TRUE, 0); timeout_label = gtk_label_new(_("Timeout")); gtk_widget_show(timeout_label); gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_label, FALSE, FALSE, 0); timeout_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(60, 0, 10000, 10, 10, 0)); timeout_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(timeout_spinbtn_adj), 1, 0); gtk_widget_show(timeout_spinbtn); gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_spinbtn, FALSE, FALSE, 0); CLAWS_SET_TIP(timeout_spinbtn, _("Maximum time allowed for checking. If the check takes longer " "it will be aborted.")); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(timeout_spinbtn), TRUE); timeout_seconds_label = gtk_label_new(_("seconds")); gtk_widget_show(timeout_seconds_label); gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_seconds_label, FALSE, FALSE, 0); hbox_process_emails = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_process_emails); gtk_box_pack_start (GTK_BOX (vbox2), hbox_process_emails, TRUE, TRUE, 0); process_emails_checkbtn = gtk_check_button_new_with_label( _("Process messages on receiving")); gtk_widget_show(process_emails_checkbtn); gtk_box_pack_start(GTK_BOX(hbox_process_emails), process_emails_checkbtn, TRUE, TRUE, 0); hbox_save_spam = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_save_spam); gtk_box_pack_start (GTK_BOX (vbox2), hbox_save_spam, TRUE, TRUE, 0); save_spam_checkbtn = gtk_check_button_new_with_label(_("Save spam in")); gtk_widget_show(save_spam_checkbtn); gtk_box_pack_start(GTK_BOX(hbox_save_spam), save_spam_checkbtn, FALSE, FALSE, 0); save_spam_folder_entry = gtk_entry_new(); gtk_widget_show (save_spam_folder_entry); gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_entry, TRUE, TRUE, 0); CLAWS_SET_TIP(save_spam_folder_entry, _("Folder for storing identified spam. Leave empty to use the trash folder.")); save_spam_folder_select = gtkut_get_browse_directory_btn(_("_Browse")); gtk_widget_show (save_spam_folder_select); gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_select, FALSE, FALSE, 0); CLAWS_SET_TIP(save_spam_folder_select, _("Click this button to select a folder for storing spam")); hbox_mark_as_read = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_mark_as_read); gtk_box_pack_start (GTK_BOX (vbox2), hbox_mark_as_read, TRUE, TRUE, 0); mark_as_read_checkbtn = gtk_check_button_new_with_label( _("Mark spam as read")); gtk_widget_show(mark_as_read_checkbtn); gtk_box_pack_start(GTK_BOX(hbox_mark_as_read), mark_as_read_checkbtn, TRUE, TRUE, 0); hbox_whitelist = gtk_hbox_new(FALSE, 8); gtk_widget_show(hbox_whitelist); gtk_box_pack_start (GTK_BOX (vbox2), hbox_whitelist, TRUE, TRUE, 0); whitelist_ab_checkbtn = gtk_check_button_new_with_label(_("Whitelist senders found in address book/folder")); gtk_widget_show(whitelist_ab_checkbtn); gtk_box_pack_start(GTK_BOX(hbox_whitelist), whitelist_ab_checkbtn, FALSE, FALSE, 0); CLAWS_SET_TIP(whitelist_ab_checkbtn, _("Messages coming from your address book contacts will be received in the normal folder even if detected as spam")); whitelist_ab_folder_combo = combobox_text_new(TRUE, _("Any"), NULL); gtk_widget_set_size_request(whitelist_ab_folder_combo, 100, -1); gtk_box_pack_start (GTK_BOX (hbox_whitelist), whitelist_ab_folder_combo, TRUE, TRUE, 0); whitelist_ab_select_btn = gtk_button_new_with_label(_("Select...")); gtk_widget_show (whitelist_ab_select_btn); gtk_box_pack_start (GTK_BOX (hbox_whitelist), whitelist_ab_select_btn, FALSE, FALSE, 0); CLAWS_SET_TIP(whitelist_ab_select_btn, _("Click this button to select a book or folder in the address book")); SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, frame_transport); SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_max_size); SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_timeout); SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_save_spam); SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_entry); SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_select); SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_process_emails); SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, mark_as_read_checkbtn); SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_folder_combo); #ifndef USE_NEW_ADDRBOOK SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_select_btn); #endif config = spamassassin_get_config(); g_signal_connect(G_OBJECT(save_spam_folder_select), "clicked", G_CALLBACK(foldersel_cb), page); #ifndef USE_NEW_ADDRBOOK g_signal_connect(G_OBJECT (whitelist_ab_select_btn), "clicked", G_CALLBACK(spamassassin_whitelist_ab_select_cb), page); #else gtk_widget_set_sensitive(GTK_WIDGET(whitelist_ab_select_btn), FALSE); #endif gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_sa_checkbtn), config->enable); if (config->username != NULL) gtk_entry_set_text(GTK_ENTRY(user_entry), config->username); if (config->hostname != NULL) gtk_entry_set_text(GTK_ENTRY(spamd_hostname_entry), config->hostname); if (config->socket != NULL) gtk_entry_set_text(GTK_ENTRY(spamd_socket_entry), config->socket); if (config->whitelist_ab_folder != NULL) { /* translate "Any" (stored UNtranslated) */ if (strcasecmp(config->whitelist_ab_folder, "Any") == 0) gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))), config->whitelist_ab_folder); else /* backward compatibility (when translated "Any" was stored) */ if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))), config->whitelist_ab_folder); else gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))), config->whitelist_ab_folder); } gtk_spin_button_set_value(GTK_SPIN_BUTTON(spamd_port_spinbtn), (float) config->port); gtk_spin_button_set_value(GTK_SPIN_BUTTON(max_size_spinbtn), (float) config->max_size); gtk_spin_button_set_value(GTK_SPIN_BUTTON(timeout_spinbtn), (float) config->timeout); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(process_emails_checkbtn), config->process_emails); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(save_spam_checkbtn), config->receive_spam); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(whitelist_ab_checkbtn), config->whitelist_ab); if (config->save_folder != NULL) gtk_entry_set_text(GTK_ENTRY(save_spam_folder_entry), config->save_folder); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mark_as_read_checkbtn), config->mark_as_read); page->enable_sa_checkbtn = enable_sa_checkbtn; page->transport_label = transport_label; page->transport_optmenu = transport_optmenu; page->username = user_entry; page->hostname = spamd_hostname_entry; page->colon = spamd_colon_label; page->port = spamd_port_spinbtn; page->socket = spamd_socket_entry; page->max_size = max_size_spinbtn; page->timeout = timeout_spinbtn; page->process_emails = process_emails_checkbtn; page->receive_spam = save_spam_checkbtn; page->save_folder = save_spam_folder_entry; page->save_folder_select = save_spam_folder_select; page->mark_as_read = mark_as_read_checkbtn; page->whitelist_ab = whitelist_ab_checkbtn; page->whitelist_ab_folder_combo = whitelist_ab_folder_combo; active = 0; for (i = 0; i < (sizeof(transports) / sizeof(struct Transport)); i++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, gettext(transports[i].name), 1, &transports[i], -1); if (config->transport == transports[i].transport) { show_transport(page, &transports[i]); active = i; } else if (config->transport == SPAMASSASSIN_DISABLED && transports[i].transport == SPAMASSASSIN_TRANSPORT_LOCALHOST) { show_transport(page, &transports[i]); active = i; /* and disable via new way */ config->enable = FALSE; gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(enable_sa_checkbtn), config->enable); } } gtk_combo_box_set_active(GTK_COMBO_BOX(transport_optmenu), active); g_signal_connect(G_OBJECT(transport_optmenu), "changed", G_CALLBACK(transport_sel_cb), page); page->page.widget = vbox1; }
gboolean create_folder_subscription_dialog (ExchangeAccount *account, const gchar *fname) { ENameSelector *name_selector; GtkWidget *dialog; GtkWidget *dialog_vbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label3; GtkWidget *user_picker_placeholder; GtkWidget *button_user; GtkWidget *folder_name_combo; GtkWidget *server_combobox; SubscriptionInfo *subscription_info; gint mode; exchange_account_is_offline (account, &mode); if (mode == OFFLINE_MODE) return FALSE; subscription_info = g_new0 (SubscriptionInfo, 1); subscription_info->account = account; dialog = gtk_dialog_new_with_buttons ( _("Subscribe to folder of other user"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_widget_show (dialog_vbox1); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 2); gtk_table_set_row_spacings (GTK_TABLE (table1), 3); gtk_table_set_col_spacings (GTK_TABLE (table1), 3); label1 = gtk_label_new_with_mnemonic (_("_Account:")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_CENTER); label3 = gtk_label_new_with_mnemonic (_("_Folder Name:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_CENTER); user_picker_placeholder = gtk_hbox_new (FALSE, 0); gtk_widget_show (user_picker_placeholder); gtk_table_attach (GTK_TABLE (table1), user_picker_placeholder, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); button_user = gtk_button_new_with_mnemonic (_("_User:"******"changed", G_CALLBACK (user_name_entry_changed_callback), dialog); setup_server_combobox (server_combobox, account->account_name); setup_folder_name_combo (folder_name_combo, fname); subscription_info->folder_name_entry = gtk_bin_get_child (GTK_BIN (folder_name_combo)); g_signal_connect (dialog, "response", G_CALLBACK (subscribe_to_folder), subscription_info); gtk_widget_show (dialog); /* Connect the callback to set the OK button insensitive when there is * no text in the folder_name_entry. Notice that we put a value there * by default so the OK button is sensitive by default. */ g_signal_connect (subscription_info->folder_name_entry, "changed", G_CALLBACK (folder_name_entry_changed_callback), dialog); return TRUE; }
GtkWidget * gimp_paint_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GimpPaintOptions *options = GIMP_PAINT_OPTIONS (tool_options); GtkWidget *vbox = gimp_tool_options_gui (tool_options); GtkWidget *menu; GtkWidget *scale; GType tool_type; tool_type = tool_options->tool_info->tool_type; /* the paint mode menu */ menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE); gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (menu), _("Mode")); g_object_set (menu, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_HEAL_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { gtk_widget_set_sensitive (menu, FALSE); } /* the opacity scale */ scale = gimp_prop_spin_scale_new (config, "opacity", _("Opacity"), 0.01, 0.1, 0); gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_widget_show (scale); /* temp debug foo */ if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL)) { GtkWidget *button; button = gimp_prop_check_button_new (config, "use-applicator", "Use GimpApplicator"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } /* the brush */ if (g_type_is_a (tool_type, GIMP_TYPE_BRUSH_TOOL)) { GtkWidget *button; GtkWidget *hbox; GtkWidget *frame; button = gimp_prop_brush_box_new (NULL, GIMP_CONTEXT (tool_options), _("Brush"), 2, "brush-view-type", "brush-view-size", "gimp-brush-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-size", _("Size"), 1.0, 10.0, 2); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_size), options); gimp_help_set_help_data (button, _("Reset size to brush's native size"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-aspect-ratio", _("Aspect Ratio"), 0.1, 1.0, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio), options); gimp_help_set_help_data (button, _("Reset aspect ratio to brush's native"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-angle", _("Angle"), 1.0, 5.0, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_angle), options); gimp_help_set_help_data (button, _("Reset angle to zero"), NULL); button = gimp_prop_dynamics_box_new (NULL, GIMP_CONTEXT (tool_options), _("Dynamics"), 2, "dynamics-view-type", "dynamics-view-size", "gimp-dynamics-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); frame = dynamics_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = jitter_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "smooth stroke" options */ if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL)) { GtkWidget *frame; frame = smoothing_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "incremental" toggle */ if (tool_type == GIMP_TYPE_PENCIL_TOOL || tool_type == GIMP_TYPE_PAINTBRUSH_TOOL || tool_type == GIMP_TYPE_ERASER_TOOL) { GtkWidget *button; button = gimp_prop_enum_check_button_new (config, "application-mode", _("Incremental"), GIMP_PAINT_CONSTANT, GIMP_PAINT_INCREMENTAL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } /* the "hard edge" toggle */ if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CLONE_TOOL || tool_type == GIMP_TYPE_HEAL_TOOL || tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { GtkWidget *button; button = gimp_prop_check_button_new (config, "hard", _("Hard edge")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } return vbox; }
static void empathy_presence_chooser_init (EmpathyPresenceChooser *chooser) { EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser, EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv); GtkWidget *entry; GtkCellRenderer *renderer; chooser->priv = priv; presence_chooser_create_model (chooser); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (chooser), COL_STATUS_TEXT); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser), combo_row_separator_func, NULL, NULL); entry = gtk_bin_get_child (GTK_BIN (chooser)); gtk_entry_set_icon_activatable (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, FALSE); g_signal_connect_swapped (entry, "icon-release", G_CALLBACK (presence_chooser_entry_icon_release_cb), chooser); g_signal_connect_swapped (entry, "activate", G_CALLBACK (presence_chooser_entry_activate_cb), chooser); g_signal_connect_swapped (entry, "key-press-event", G_CALLBACK (presence_chooser_entry_key_press_event_cb), chooser); g_signal_connect_swapped (entry, "button-press-event", G_CALLBACK (presence_chooser_entry_button_press_event_cb), chooser); gtk_cell_layout_clear (GTK_CELL_LAYOUT (chooser)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer, "icon-name", COL_STATE_ICON_NAME, NULL); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_MENU, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer, "markup", COL_DISPLAY_MARKUP, NULL); g_signal_connect (chooser, "notify::popup-shown", G_CALLBACK (presence_chooser_popup_shown_cb), NULL); g_signal_connect (chooser, "changed", G_CALLBACK (presence_chooser_changed_cb), NULL); g_signal_connect_swapped (entry, "changed", G_CALLBACK (presence_chooser_entry_changed_cb), chooser); g_signal_connect_swapped (entry, "focus-out-event", G_CALLBACK (presence_chooser_entry_focus_out_cb), chooser); priv->idle = empathy_idle_dup_singleton (); presence_chooser_presence_changed_cb (chooser); g_signal_connect_swapped (priv->idle, "notify", G_CALLBACK (presence_chooser_presence_changed_cb), chooser); /* FIXME: this string sucks */ gtk_widget_set_tooltip_text (GTK_WIDGET (chooser), _("Set your presence and current status")); }
static void presence_chooser_changed_cb (GtkComboBox *self, gpointer user_data) { EmpathyPresenceChooserPriv *priv = GET_PRIV (self); GtkTreeIter iter; char *icon_name; TpConnectionPresenceType new_state; gboolean customisable = TRUE; PresenceChooserEntryType type = -1; GtkWidget *entry; GtkTreeModel *model; if (priv->block_changed || !gtk_combo_box_get_active_iter (self, &iter)) { return; } model = gtk_combo_box_get_model (self); gtk_tree_model_get (model, &iter, COL_STATE_ICON_NAME, &icon_name, COL_STATE, &new_state, COL_STATUS_CUSTOMISABLE, &customisable, COL_TYPE, &type, -1); entry = gtk_bin_get_child (GTK_BIN (self)); /* some types of status aren't editable, set the editability of the * entry appropriately. Unless we're just about to reset it anyway, * in which case, don't fiddle with it */ if (type != ENTRY_TYPE_EDIT_CUSTOM) { gtk_editable_set_editable (GTK_EDITABLE (entry), customisable); priv->state = new_state; } if (type == ENTRY_TYPE_EDIT_CUSTOM) { GtkWidget *window, *dialog; presence_chooser_reset_status (EMPATHY_PRESENCE_CHOOSER (self)); /* attempt to get the toplevel for this widget */ window = gtk_widget_get_toplevel (GTK_WIDGET (self)); if (!GTK_WIDGET_TOPLEVEL (window) || !GTK_IS_WINDOW (window)) { window = NULL; } dialog = empathy_status_preset_dialog_new (GTK_WINDOW (window)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else if (type == ENTRY_TYPE_CUSTOM) { gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon_name); /* preseed the status */ if (priv->previous_type == ENTRY_TYPE_BUILTIN) { /* if their previous entry was a builtin, don't * preseed */ gtk_entry_set_text (GTK_ENTRY (entry), ""); } else { /* else preseed the text of their currently entered * status message */ const char *status; status = empathy_idle_get_status (priv->idle); gtk_entry_set_text (GTK_ENTRY (entry), status); } /* grab the focus */ gtk_widget_grab_focus (entry); } else { char *status; /* just in case we were setting a new status when * things were changed */ presence_chooser_set_status_editing ( EMPATHY_PRESENCE_CHOOSER (self), FALSE); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon_name); gtk_tree_model_get (model, &iter, COL_STATUS_TEXT, &status, -1); empathy_idle_set_presence (priv->idle, priv->state, status); g_free (status); } if (type != ENTRY_TYPE_EDIT_CUSTOM) { priv->previous_type = type; } g_free (icon_name); }
GtkWidget * gimp_foreground_select_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GtkWidget *vbox = gimp_selection_options_gui (tool_options); GtkWidget *hbox; GtkWidget *button; GtkWidget *frame; GtkWidget *scale; GtkWidget *combo; GtkWidget *table; gchar *title; gint row = 0; GimpForegroundSelectOptions *options = GIMP_FOREGROUND_SELECT_OPTIONS (config); frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", title, 0,0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* stroke width */ scale = gimp_prop_spin_scale_new (config, "stroke-width", _("Stroke width"), 1.0, 10.0, 2); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_foreground_select_options_gui_reset_stroke_width), tool_options); gimp_help_set_help_data (button, _("Reset stroke width native size"), NULL); /* mask color */ frame = gimp_frame_new (_("Preview color:")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); combo = gimp_prop_enum_combo_box_new (config, "mask-color", GIMP_RED_CHANNEL, GIMP_GRAY_CHANNEL); gtk_container_add (GTK_CONTAINER (frame), combo); gtk_widget_show (combo); /* engine */ frame = gimp_frame_new (_("Engine:")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); combo = gimp_prop_enum_combo_box_new (config, "engine", 0, 0); gtk_container_add (GTK_CONTAINER (frame), combo); gtk_widget_show (combo); /* parameters */ table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); options->dynamic_widgets.levels = gimp_prop_scale_entry_new (config, "levels", GTK_TABLE (table), 0, row++, "Levels", 1, 1, 0, FALSE, 0, 0); options->dynamic_widgets.active_levels = gimp_prop_scale_entry_new (config, "active-levels", GTK_TABLE (table), 0, row++, "Act. Levels", 1, 1, 0, FALSE, 0, 0); options->dynamic_widgets.iterations = gimp_prop_scale_entry_new (config, "iterations", GTK_TABLE (table), 0, row++, "Iterations", 1, 1, 0, FALSE, 0, 0); g_signal_connect_object (config, "notify::engine", G_CALLBACK (gimp_foreground_select_notify_engine), NULL, 0); gimp_foreground_select_notify_engine(tool_options,NULL,NULL); return vbox; }
static GtkWidget* find_label_child (GtkContainer *container, gint *index, gboolean allow_many) { GList *children, *tmp_list; GtkWidget *child; children = gtk_container_get_children (container); child = NULL; for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next) { if (GTK_IS_LABEL (tmp_list->data)) { if (!allow_many) { if (child) { child = NULL; break; } child = GTK_WIDGET (tmp_list->data); } else { if (*index == 0) { child = GTK_WIDGET (tmp_list->data); break; } (*index)--; } } /* * Label for button which are GtkTreeView column headers are in a * GtkHBox in a GtkAlignment. */ else if (GTK_IS_ALIGNMENT (tmp_list->data)) { GtkWidget *widget; widget = gtk_bin_get_child (GTK_BIN (tmp_list->data)); if (GTK_IS_LABEL (widget)) { if (!allow_many) { if (child) { child = NULL; break; } child = widget; } else { if (*index == 0) { child = widget; break; } (*index)--; } } } else if (GTK_IS_CONTAINER (tmp_list->data)) { child = find_label_child (GTK_CONTAINER (tmp_list->data), index, allow_many); if (child) break; } } g_list_free (children); return child; }
static void spamassassin_save_func(PrefsPage *_page) { struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page; SpamAssassinConfig *config; debug_print("Saving SpamAssassin Page\n"); config = spamassassin_get_config(); /* enable */ config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn)); config->transport = page->trans; /* username */ g_free(config->username); config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1); spamassassin_check_username(); /* hostname */ g_free(config->hostname); config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1); /* port */ config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port)); /* hostname */ g_free(config->socket); config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1); /* process_emails */ config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails)); /* receive_spam */ config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam)); /* save_folder */ g_free(config->save_folder); config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1); /* max_size */ config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size)); /* timeout */ config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout)); /* mark_as_read */ config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read)); /* whitelist_ab */ config->whitelist_ab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->whitelist_ab)); g_free(config->whitelist_ab_folder); config->whitelist_ab_folder = gtk_editable_get_chars( GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((page->whitelist_ab_folder_combo)))), 0, -1); /* store UNtranslated "Any" */ if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) { g_free(config->whitelist_ab_folder); config->whitelist_ab_folder = g_strdup("Any"); } if (config->process_emails) { spamassassin_register_hook(); } else { spamassassin_unregister_hook(); } if (!config->enable) { procmsg_unregister_spam_learner(spamassassin_learn); procmsg_spam_set_folder(NULL, NULL); } else { if (config->transport == SPAMASSASSIN_TRANSPORT_TCP) debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n"); procmsg_register_spam_learner(spamassassin_learn); procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder); } spamassassin_save_config(); }
static void gimp_action_set_proxy (GimpAction *action, GtkWidget *proxy) { if (! GTK_IS_IMAGE_MENU_ITEM (proxy)) return; if (action->color) { GtkWidget *area; area = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy)); if (GIMP_IS_COLOR_AREA (area)) { gimp_color_area_set_color (GIMP_COLOR_AREA (area), action->color); } else { gint width, height; area = gimp_color_area_new (action->color, GIMP_COLOR_AREA_SMALL_CHECKS, 0); gimp_color_area_set_draw_border (GIMP_COLOR_AREA (area), TRUE); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy), GTK_ICON_SIZE_MENU, &width, &height); gtk_widget_set_size_request (area, width, height); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), area); gtk_widget_show (area); } } else if (action->viewable) { GtkWidget *view; view = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy)); if (GIMP_IS_VIEW (view) && g_type_is_a (G_TYPE_FROM_INSTANCE (action->viewable), GIMP_VIEW (view)->renderer->viewable_type)) { gimp_view_set_viewable (GIMP_VIEW (view), action->viewable); } else { GtkIconSize size; gint width, height; gint border_width; if (GIMP_IS_IMAGEFILE (action->viewable)) { size = GTK_ICON_SIZE_LARGE_TOOLBAR; border_width = 0; } else { size = GTK_ICON_SIZE_MENU; border_width = 1; } gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy), size, &width, &height); view = gimp_view_new_full (action->context, action->viewable, width, height, border_width, FALSE, FALSE, FALSE); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), view); gtk_widget_show (view); } } else { GtkWidget *image; image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy)); if (GIMP_IS_VIEW (image) || GIMP_IS_COLOR_AREA (image)) { gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), NULL); g_object_notify (G_OBJECT (action), "icon-name"); } } { GtkWidget *child = gtk_bin_get_child (GTK_BIN (proxy)); if (GTK_IS_LABEL (child)) { GtkLabel *label = GTK_LABEL (child); gtk_label_set_ellipsize (label, action->ellipsize); gtk_label_set_max_width_chars (label, action->max_width_chars); } } }
/** * @brief Build the GUI * * @return */ GtkWidget* buildDisplayUI() { GtkWidget* label; GtkWidget* box; //display = gtk_window_new (GTK_WINDOW_TOPLEVEL); ////gtk_widget_modify_bg(display,GTK_STATE_NORMAL,&background); //gtk_window_set_title(GTK_WINDOW(display),"Display and Decode"); displayFixed=gtk_fixed_new(); //gtk_widget_modify_bg(displayFixed,GTK_STATE_NORMAL,&background); spectrum=newSpectrumDisplay(spectrumWIDTH); gtk_fixed_put((GtkFixed*)displayFixed,spectrum,0,0); box=gtk_hbox_new(FALSE,5); speed48K=gtk_radio_button_new_with_label(NULL,"48K"); label=gtk_bin_get_child((GtkBin*)speed48K); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); //gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white); //gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white); g_signal_connect(G_OBJECT(speed48K),"clicked",G_CALLBACK(speed48ButtonCallback),NULL); gtk_widget_show(speed48K); gtk_box_pack_start(GTK_BOX(box),speed48K,FALSE,FALSE,2); speed96K=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(speed48K),"96K"); label=gtk_bin_get_child((GtkBin*)speed96K); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); //gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white); //gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white); g_signal_connect(G_OBJECT(speed96K),"clicked",G_CALLBACK(speed96ButtonCallback),NULL); gtk_widget_show(speed96K); gtk_box_pack_start(GTK_BOX(box),speed96K,FALSE,FALSE,2); speed192K=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(speed48K),"192K"); label=gtk_bin_get_child((GtkBin*)speed192K); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); //gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white); //gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white); g_signal_connect(G_OBJECT(speed192K),"clicked",G_CALLBACK(speed192ButtonCallback),NULL); gtk_widget_show(speed192K); gtk_box_pack_start(GTK_BOX(box),speed192K,FALSE,FALSE,2); gtk_widget_show(box); gtk_fixed_put((GtkFixed*)displayFixed,box,700,spectrumHEIGHT); buttonNone=gtk_button_new_with_label("NONE"); //gtk_widget_modify_bg(buttonNone, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonNone); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonNone),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonNone),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonNone); gtk_fixed_put((GtkFixed*)displayFixed,buttonNone,0,spectrumHEIGHT); buttonSpectrum=gtk_button_new_with_label("SPECTRUM"); //gtk_widget_modify_bg(buttonSpectrum, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonSpectrum); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonSpectrum),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonSpectrum),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonSpectrum); gtk_fixed_put((GtkFixed*)displayFixed,buttonSpectrum,100,spectrumHEIGHT); buttonPanadapter=gtk_button_new_with_label("PANADAPTER"); //gtk_widget_modify_bg(buttonPanadapter, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonPanadapter); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonPanadapter),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonPanadapter),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonPanadapter); gtk_fixed_put((GtkFixed*)displayFixed,buttonPanadapter,200,spectrumHEIGHT); buttonPanWater=gtk_button_new_with_label("PAN/WATER"); //gtk_widget_modify_bg(buttonPanWater, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonPanWater); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonPanWater),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonPanWater),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonPanWater); gtk_fixed_put((GtkFixed*)displayFixed,buttonPanWater,300,spectrumHEIGHT); buttonScope=gtk_button_new_with_label("SCOPE"); //gtk_widget_modify_bg(buttonScope, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonScope); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonScope),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonScope),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonScope); gtk_fixed_put((GtkFixed*)displayFixed,buttonScope,400,spectrumHEIGHT); buttonPhase=gtk_button_new_with_label("PHASE"); //gtk_widget_modify_bg(buttonPhase, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonPhase); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonPhase),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonPhase),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonPhase); gtk_fixed_put((GtkFixed*)displayFixed,buttonPhase,500,spectrumHEIGHT); buttonPhase2=gtk_button_new_with_label("PHASE2"); //gtk_widget_modify_bg(buttonPhase2, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)buttonPhase2); //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_set_size_request(GTK_WIDGET(buttonPhase2),100,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(buttonPhase2),"clicked",G_CALLBACK(spectrumCallback),NULL); gtk_widget_show(buttonPhase2); gtk_fixed_put((GtkFixed*)displayFixed,buttonPhase2,600,spectrumHEIGHT); gtk_widget_set_size_request(GTK_WIDGET(displayFixed),spectrumWIDTH,spectrumHEIGHT+25); gtk_widget_show(displayFixed); //gtk_container_add(GTK_CONTAINER(display), displayFixed); //gtk_window_set_position((GtkWindow*)display,GTK_WIN_POS_MOUSE); //gtk_widget_show(display.g); switch(speed) { case 0: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed48K),TRUE); break; case 1: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed96K),TRUE); break; case 2: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed192K),TRUE); break; } currentSpectrumButton=NULL; switch(spectrumMode) { case spectrumNONE: spectrumCallback(buttonNone,NULL); break; case spectrumSPECTRUM: spectrumCallback(buttonSpectrum,NULL); break; case spectrumPANADAPTER: spectrumCallback(buttonPanadapter,NULL); break; case spectrumPANWATER: spectrumCallback(buttonPanWater,NULL); break; case spectrumSCOPE: spectrumCallback(buttonScope,NULL); break; case spectrumPHASE: spectrumCallback(buttonPhase,NULL); break; case spectrumPHASE2: spectrumCallback(buttonPhase2,NULL); break; } return displayFixed; }
void ags_drum_init(AgsDrum *drum) { GtkVBox *vbox; GtkHBox *hbox; GtkToggleButton *toggle_button; GtkFrame *frame; GtkTable *table0, *table1; GtkRadioButton *radio_button; AgsAudio *audio; GList *list; guint stream_length; int i, j; g_signal_connect_after((GObject *) drum, "parent_set\0", G_CALLBACK(ags_drum_parent_set_callback), (gpointer) drum); audio = AGS_MACHINE(drum)->audio; audio->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING | AGS_AUDIO_INPUT_HAS_RECYCLING | AGS_AUDIO_INPUT_TAKES_FILE | AGS_AUDIO_SYNC | AGS_AUDIO_ASYNC); AGS_MACHINE(drum)->flags |= AGS_MACHINE_IS_SEQUENCER; AGS_MACHINE(drum)->input_pad_type = AGS_TYPE_DRUM_INPUT_PAD; AGS_MACHINE(drum)->input_line_type = AGS_TYPE_DRUM_INPUT_LINE; AGS_MACHINE(drum)->output_pad_type = AGS_TYPE_DRUM_OUTPUT_PAD; AGS_MACHINE(drum)->output_line_type = AGS_TYPE_DRUM_OUTPUT_LINE; g_signal_connect_after(G_OBJECT(audio), "set_audio_channels\0", G_CALLBACK(ags_drum_set_audio_channels), drum); g_signal_connect_after(G_OBJECT(audio), "set_pads\0", G_CALLBACK(ags_drum_set_pads), drum); drum->flags = 0; drum->name = NULL; drum->xml_type = "ags-drum\0"; /* create widgets */ drum->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) drum), (GtkWidget *) drum->vbox); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); drum->input_pad = (GtkHBox *) gtk_hbox_new(FALSE, 0); AGS_MACHINE(drum)->input = (GtkContainer *) drum->input_pad; gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->input_pad, FALSE, FALSE, 0); drum->output_pad = (GtkVBox *) gtk_vbox_new(FALSE, 0); AGS_MACHINE(drum)->output = (GtkContainer *) drum->output_pad; gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->output_pad, FALSE, FALSE, 0); drum->selected_pad = NULL; drum->selected_edit_button = NULL; hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); frame = (GtkFrame *) gtk_frame_new("kit\0"); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0); vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) frame, (GtkWidget *) vbox); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) gtk_label_new("default\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) (drum->open = (GtkButton *) gtk_button_new_from_stock(GTK_STOCK_OPEN)), FALSE, FALSE, 0); /* sequencer */ frame = (GtkFrame *) gtk_frame_new("Pattern\0"); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0); table0 = (GtkTable *) gtk_table_new(16, 4, FALSE); gtk_container_add((GtkContainer*) frame, (GtkWidget *) table0); drum->loop_button = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0"); gtk_table_attach_defaults(table0, (GtkWidget *) drum->loop_button, 0, 1, 2, 3); AGS_MACHINE(drum)->play = drum->run = (GtkToggleButton *) gtk_toggle_button_new_with_label("run\0"); gtk_table_attach_defaults(table0, (GtkWidget *) drum->run, 1, 2, 2, 3); /* bank */ table1 = (GtkTable *) gtk_table_new(3, 5, TRUE); gtk_table_attach_defaults(table0, (GtkWidget *) table1, 2, 3, 0, 3); drum->selected1 = NULL; for(i = 0; i < 3; i++) for(j = 0; j < 4; j++){ gtk_table_attach_defaults(table1, (GtkWidget *) (drum->index1[i * 4 + j] = (GtkToggleButton *) gtk_toggle_button_new()), j, j +1, i, i +1); g_object_set_data((GObject *) drum->index1[i * 4 + j], AGS_DRUM_INDEX, GUINT_TO_POINTER(i * 4 + j)); } drum->selected1 = drum->index1[0]; gtk_toggle_button_set_active(drum->index1[0], TRUE); drum->selected0 = NULL; for(j = 0; j < 4; j++){ gtk_table_attach_defaults(table1, (GtkWidget *) (drum->index0[j] = (GtkToggleButton *) gtk_toggle_button_new()), j, j +1, 4, 5); g_object_set_data((GObject *) drum->index0[j], AGS_DRUM_INDEX, GUINT_TO_POINTER(j)); } drum->selected0 = drum->index0[0]; gtk_toggle_button_set_active(drum->index0[0], TRUE); /* duration */ hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_table_attach(table0, (GtkWidget *) hbox, 6, 7, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_box_pack_start((GtkBox*) hbox, gtk_label_new("length\0"), FALSE, FALSE, 0); drum->length_spin = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 64.0, 1.0); drum->length_spin->adjustment->value = 16.0; gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) drum->length_spin, FALSE, FALSE, 0); /* led */ drum->active_led = 0; drum->led = hbox = (GtkHBox *) gtk_hbox_new(FALSE, 16); gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 1, 2); for(i = 0; i < 16; i++){ toggle_button = (GtkToggleButton *) ags_led_new(); gtk_widget_set_size_request((GtkWidget *) toggle_button, 8, 4); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0); } /* pattern */ drum->pattern = hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 2, 3); for(i = 0; i < 16; i++){ toggle_button = (GtkToggleButton *) gtk_toggle_button_new(); gtk_widget_set_size_request((GtkWidget *) toggle_button, 24, 24); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0); } /* page / offset */ drum->offset = (GtkVBox*) gtk_vbox_new(FALSE, 0); gtk_table_attach_defaults(table0, (GtkWidget *) drum->offset, 15, 16, 0, 3); radio_button = (GtkRadioButton *) gtk_radio_button_new_with_label(NULL, "1-16\0"); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) radio_button, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "17-32\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "33-48\0"), FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "49-64\0"), FALSE, FALSE, 0); }
GtkWidget * gimp_ink_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GimpInkOptions *ink_options = GIMP_INK_OPTIONS (tool_options); GtkWidget *vbox = gimp_paint_options_gui (tool_options); GtkWidget *frame; GtkWidget *table; GtkWidget *blob_vbox; GtkWidget *hbox; GtkWidget *editor; GtkObject *adj; /* adjust sliders */ frame = gimp_frame_new (_("Adjustment")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* size slider */ adj = gimp_prop_scale_entry_new (config, "size", GTK_TABLE (table), 0, 0, _("Size:"), 1.0, 2.0, 1, FALSE, 0.0, 0.0); gimp_scale_entry_set_logarithmic (adj, TRUE); /* angle adjust slider */ gimp_prop_scale_entry_new (config, "tilt-angle", GTK_TABLE (table), 0, 1, _("Angle:"), 1.0, 10.0, 1, FALSE, 0.0, 0.0); /* sens sliders */ frame = gimp_frame_new (_("Sensitivity")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); gtk_widget_show (frame); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* size sens slider */ gimp_prop_scale_entry_new (config, "size-sensitivity", GTK_TABLE (table), 0, 0, _("Size:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* tilt sens slider */ gimp_prop_scale_entry_new (config, "tilt-sensitivity", GTK_TABLE (table), 0, 1, _("Tilt:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* velocity sens slider */ gimp_prop_scale_entry_new (config, "vel-sensitivity", GTK_TABLE (table), 0, 2, _("Speed:"), 0.01, 0.1, 1, FALSE, 0.0, 0.0); /* bottom hbox */ hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* Blob type radiobuttons */ frame = gimp_prop_enum_radio_frame_new (config, "blob-type", _("Type"), 0, 0); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); { GtkWidget *frame_child = gtk_bin_get_child (GTK_BIN (frame)); GList *children; GList *list; GimpInkBlobType blob_type; children = gtk_container_get_children (GTK_CONTAINER (frame_child)); for (list = children, blob_type = GIMP_INK_BLOB_TYPE_ELLIPSE; list; list = g_list_next (list), blob_type++) { GtkWidget *radio = GTK_WIDGET (list->data); GtkWidget *blob; gtk_container_remove (GTK_CONTAINER (radio), gtk_bin_get_child (GTK_BIN (radio))); blob = blob_image_new (blob_type); gtk_container_add (GTK_CONTAINER (radio), blob); gtk_widget_show (blob); } g_list_free (children); } /* Blob shape widget */ frame = gimp_frame_new (_("Shape")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); blob_vbox = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (frame), blob_vbox); gtk_widget_show (blob_vbox); frame = gtk_aspect_frame_new (NULL, 0.0, 0.5, 1.0, FALSE); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (blob_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); editor = gimp_blob_editor_new (ink_options->blob_type, ink_options->blob_aspect, ink_options->blob_angle); gtk_widget_set_size_request (editor, 60, 60); gtk_container_add (GTK_CONTAINER (frame), editor); gtk_widget_show (editor); gimp_config_connect (config, G_OBJECT (editor), NULL); return vbox; }
static GtkWidget* gtk_widget_get_child_(GtkWidget* widget) { GtkWidget *child = gtk_bin_get_child(GTK_BIN(widget)); return child; }
void gtkui_create_menu(int live) { GtkAccelGroup *accel_group; GtkWidget *vbox, *item; GtkItemFactory *root_menu; int num_items = 0; DEBUG_MSG("gtk_create_menu"); /* remove old menu, it will be automatically destroyed by gtk_main */ vbox = gtk_bin_get_child(GTK_BIN (window)); gtk_container_remove(GTK_CONTAINER (vbox), main_menu); /* Prepare to generate menus from the definitions in ec_gtk.h */ accel_group = gtk_accel_group_new (); root_menu = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); /* Start Menu */ num_items = sizeof (gmenu_start) / sizeof (gmenu_start[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_start, NULL); /* Targets Menu */ num_items = sizeof (gmenu_targets) / sizeof (gmenu_targets[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_targets, NULL); /* Hosts Menu */ if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) { num_items = sizeof (gmenu_hosts) / sizeof (gmenu_hosts[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_hosts, NULL); } /* View Menu */ num_items = sizeof (gmenu_view) / sizeof (gmenu_view[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_view, NULL); /* MITM Menu */ if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) { num_items = sizeof (gmenu_mitm) / sizeof (gmenu_mitm[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_mitm, NULL); } /* Filters Menu */ num_items = sizeof (gmenu_filters) / sizeof (gmenu_filters[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_filters, NULL); /* Logging Menu */ num_items = sizeof (gmenu_logging) / sizeof (gmenu_logging[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_logging, NULL); #ifdef HAVE_PLUGINS /* Plugins Menu */ if(live > 0) { num_items = sizeof (gmenu_plugins) / sizeof (gmenu_plugins[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_plugins, NULL); } #endif #ifndef OS_WINDOWS /* Help Menu */ num_items = sizeof (gmenu_help) / sizeof (gmenu_help[0]); gtk_item_factory_create_items (root_menu, num_items, gmenu_help, NULL); #endif if(GBL_OPTIONS->reversed) { GBL_OPTIONS->reversed = 0; item = gtk_item_factory_get_item(root_menu, "/Targets/Reverse matching"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } if(GBL_OPTIONS->resolve) { GBL_OPTIONS->resolve = 0; item = gtk_item_factory_get_item(root_menu, "/View/Resolve IP addresses"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } if(GBL_OPTIONS->compress) { GBL_OPTIONS->compress = 0; item = gtk_item_factory_get_item(root_menu, "/Logging/Compressed file"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } /* get the menu widget and add it to the window */ main_menu = gtk_item_factory_get_widget (root_menu, "<main>"); gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0); gtk_widget_show(main_menu); }
static void input_dialog_create(gboolean is_password) { static PangoFontDescription *font_desc; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *cancel_button; GtkWidget *confirm_area; dialog = gtk_dialog_new(); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100); gtk_window_set_title(GTK_WINDOW(dialog), ""); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(dialog); vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (vbox), 14); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); /* for title label */ icon_q = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (icon_q), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), icon_q, FALSE, FALSE, 0); icon_p = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (icon_p), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), icon_p, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); msg_title = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5); gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT); gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE); gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0); gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE); if (!font_desc) { gint size; size = pango_font_description_get_size (gtk_widget_get_style(msg_title)->font_desc); font_desc = pango_font_description_new(); pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); pango_font_description_set_size (font_desc, size * PANGO_SCALE_LARGE); } if (font_desc) gtk_widget_modify_font(msg_title, font_desc); msg_label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(msg_label), 0, 0.5); gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 0); gtk_widget_show(msg_label); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(entry_activated), NULL); #if !GTK_CHECK_VERSION(2, 24, 0) combo = gtk_combo_box_entry_new_text(); #else combo = gtk_combo_box_text_new_with_entry(); #endif gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN((combo)))), "activate", G_CALLBACK(combo_activated), NULL); remember_checkbtn = gtk_check_button_new_with_label(_("Remember this")); gtk_box_pack_start(GTK_BOX(vbox), remember_checkbtn, FALSE, FALSE, 0); hbox = gtk_hbox_new(TRUE, 0); gtkut_stock_button_set_create(&confirm_area, &cancel_button, GTK_STOCK_CANCEL, &ok_button, GTK_STOCK_OK, NULL, NULL); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))), confirm_area, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); gtk_widget_hide(remember_checkbtn); if (is_password) gtk_widget_hide(icon_q); else gtk_widget_hide(icon_p); is_pass = is_password; gtk_widget_grab_default(ok_button); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(ok_clicked), NULL); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(cancel_clicked), NULL); }
static gboolean internal_init (NMAWirelessDialog *self, NMConnection *specific_connection, NMDevice *specific_device, gboolean auth_only, gboolean create) { NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self); GtkWidget *widget; char *label, *icon_name = "network-wireless"; gboolean security_combo_focus = FALSE; gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER_ALWAYS); gtk_container_set_border_width (GTK_CONTAINER (self), 6); gtk_window_set_default_size (GTK_WINDOW (self), 488, -1); gtk_window_set_resizable (GTK_WINDOW (self), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (self), FALSE); if (auth_only) icon_name = "dialog-password"; else icon_name = "network-wireless"; gtk_window_set_icon_name (GTK_WINDOW (self), icon_name); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "image1")); gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DIALOG); gtk_box_set_spacing (GTK_BOX (gtk_bin_get_child (GTK_BIN (self))), 2); widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget, FALSE, TRUE, 0, GTK_PACK_END); /* Connect/Create button */ if (create) { GtkWidget *image; widget = gtk_button_new_with_mnemonic (_("C_reate")); image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (widget), image); gtk_widget_show (widget); gtk_dialog_add_action_widget (GTK_DIALOG (self), widget, GTK_RESPONSE_OK); } else widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CONNECT, GTK_RESPONSE_OK); gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget, FALSE, TRUE, 0, GTK_PACK_END); g_object_set (G_OBJECT (widget), "can-default", TRUE, NULL); gtk_widget_grab_default (widget); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hbox1")); if (!widget) { nm_warning ("Couldn't find UI wireless_dialog widget."); return FALSE; } gtk_widget_reparent (widget, gtk_bin_get_child (GTK_BIN (self))); /* If given a valid connection, hide the SSID bits and connection combo */ if (specific_connection) { widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")); gtk_widget_hide (widget); security_combo_focus = TRUE; } else { widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")); g_signal_connect (G_OBJECT (widget), "changed", (GCallback) ssid_entry_changed, self); gtk_widget_grab_focus (widget); } gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE); if (!device_combo_init (self, specific_device)) { g_warning ("No wireless devices available."); return FALSE; } if (!connection_combo_init (self, specific_connection)) { g_warning ("Couldn't set up connection combo box."); return FALSE; } if (!security_combo_init (self)) { g_warning ("Couldn't set up wireless security combo box."); return FALSE; } if (security_combo_focus) gtk_widget_grab_focus (priv->sec_combo); security_combo_changed (priv->sec_combo, self); g_signal_connect (G_OBJECT (priv->sec_combo), "changed", G_CALLBACK (security_combo_changed), self); if (priv->connection) { char *tmp; char *esc_ssid = NULL; NMSettingWireless *s_wireless; const GByteArray *ssid; s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS)); ssid = s_wireless ? nm_setting_wireless_get_ssid (s_wireless) : NULL; if (ssid) esc_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len); tmp = g_strdup_printf (_("Passwords or encryption keys are required to access the wireless network '%s'."), esc_ssid ? esc_ssid : "<unknown>"); gtk_window_set_title (GTK_WINDOW (self), _("Wireless Network Authentication Required")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("Authentication required by wireless network"), tmp); g_free (esc_ssid); g_free (tmp); } else if (priv->adhoc_create) { gtk_window_set_title (GTK_WINDOW (self), _("Create New Wireless Network")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("New wireless network"), _("Enter a name for the wireless network you wish to create.")); } else { gtk_window_set_title (GTK_WINDOW (self), _("Connect to Hidden Wireless Network")); label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", _("Hidden wireless network"), _("Enter the name and security details of the hidden wireless network you wish to connect to.")); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "caption_label")); gtk_label_set_markup (GTK_LABEL (widget), label); g_free (label); /* Re-validate from an idle handler so that widgets like file choosers * have had time to find their files. */ g_idle_add (revalidate, self); return TRUE; }
static void mailwatch_iconbtn_clicked_cb(GtkWidget *w, gpointer user_data) { Control *c = user_data; XfceMailwatchPlugin *mwp = c->data; gint icon_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), "mailwatch-icontype")); GtkWidget *chooser, *toplevel; g_return_if_fail(icon_type == 1 || icon_type == 2); toplevel = gtk_widget_get_toplevel(w); chooser = xfce_file_chooser_dialog_new(_("Select Icon"), GTK_WINDOW(toplevel), XFCE_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) { gchar *filename = xfce_file_chooser_get_filename(XFCE_FILE_CHOOSER(chooser)); if(filename) { switch(icon_type) { case 1: { GtkWidget *vbox, *img, *lbl; g_free(mwp->normal_icon); mwp->normal_icon = filename; mailwatch_set_size(c, settings.size); gtk_container_remove(GTK_CONTAINER(w), gtk_bin_get_child(GTK_BIN(w))); vbox = gtk_vbox_new(FALSE, BORDER/2); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(w), vbox); img = gtk_image_new_from_pixbuf(mwp->pix_normal); gtk_widget_show(img); gtk_box_pack_start(GTK_BOX(vbox), img, TRUE, TRUE, 0); lbl = gtk_label_new_with_mnemonic(_("_Normal")); gtk_widget_show(lbl); gtk_box_pack_start(GTK_BOX(vbox), lbl, FALSE, FALSE, 0); } break; case 2: { GtkWidget *vbox, *img, *lbl; g_free(mwp->new_mail_icon); mwp->new_mail_icon = filename; mailwatch_set_size(c, settings.size); gtk_container_remove(GTK_CONTAINER(w), gtk_bin_get_child(GTK_BIN(w))); vbox = gtk_vbox_new(FALSE, BORDER/2); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(w), vbox); img = gtk_image_new_from_pixbuf(mwp->pix_newmail); gtk_widget_show(img); gtk_box_pack_start(GTK_BOX(vbox), img, TRUE, TRUE, 0); lbl = gtk_label_new_with_mnemonic(_("Ne_w mail")); gtk_widget_show(lbl); gtk_box_pack_start(GTK_BOX(vbox), lbl, FALSE, FALSE, 0); } break; } } } gtk_widget_destroy(chooser); }
VikLayerParamData a_uibuilder_widget_get_value ( GtkWidget *widget, VikLayerParam *param ) { VikLayerParamData rv; switch ( param->widget_type ) { case VIK_LAYER_WIDGET_COLOR: gtk_color_button_get_color ( GTK_COLOR_BUTTON(widget), &(rv.c) ); break; case VIK_LAYER_WIDGET_CHECKBUTTON: rv.b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); break; case VIK_LAYER_WIDGET_COMBOBOX: if ( param->type == VIK_LAYER_PARAM_UINT ) { rv.i = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) ); if ( rv.i == -1 ) rv.i = 0; rv.u = rv.i; if ( param->extra_widget_data ) rv.u = ((guint *)param->extra_widget_data)[rv.u]; } if ( param->type == VIK_LAYER_PARAM_STRING) { if ( param->extra_widget_data ) { /* Combobox displays labels and we want values from extra */ int pos = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) ); rv.s = ((const char **)param->extra_widget_data)[pos]; } else { /* Return raw value */ #if GTK_CHECK_VERSION (2, 24, 0) rv.s = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget)))); #else rv.s = gtk_combo_box_get_active_text ( GTK_COMBO_BOX(widget) ); #endif } g_debug("%s: %s", __FUNCTION__, rv.s); } break; case VIK_LAYER_WIDGET_RADIOGROUP: case VIK_LAYER_WIDGET_RADIOGROUP_STATIC: rv.u = vik_radio_group_get_selected(VIK_RADIO_GROUP(widget)); if ( param->extra_widget_data ) rv.u = GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, rv.u) ); break; case VIK_LAYER_WIDGET_SPINBUTTON: if ( param->type == VIK_LAYER_PARAM_UINT ) rv.u = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) ); else if ( param->type == VIK_LAYER_PARAM_INT ) rv.i = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) ); else rv.d = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(widget) ); break; case VIK_LAYER_WIDGET_ENTRY: case VIK_LAYER_WIDGET_PASSWORD: rv.s = gtk_entry_get_text ( GTK_ENTRY(widget) ); break; case VIK_LAYER_WIDGET_FILEENTRY: case VIK_LAYER_WIDGET_FOLDERENTRY: rv.s = vik_file_entry_get_filename ( VIK_FILE_ENTRY(widget) ); break; case VIK_LAYER_WIDGET_FILELIST: rv.sl = vik_file_list_get_files ( VIK_FILE_LIST(widget) ); break; case VIK_LAYER_WIDGET_HSCALE: if ( param->type == VIK_LAYER_PARAM_UINT ) rv.u = (guint32) gtk_range_get_value ( GTK_RANGE(widget) ); else if ( param->type == VIK_LAYER_PARAM_INT ) rv.i = (gint32) gtk_range_get_value ( GTK_RANGE(widget) ); else rv.d = gtk_range_get_value ( GTK_RANGE(widget) ); break; default: break; } // Perform conversion if necessary if ( param->convert_to_internal ) rv = param->convert_to_internal ( rv ); return rv; }
static void update_editor_sheet (EggToolbarEditor *editor) { gint y; GPtrArray *items; GList *to_move = NULL, *to_copy = NULL; GtkWidget *table; GtkWidget *viewport; g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor)); /* Create new table. */ table = gtk_table_new (0, 0, TRUE); editor->priv->table = table; gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 24); gtk_widget_show (table); gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL, dest_drag_types, G_N_ELEMENTS (dest_drag_types), GDK_ACTION_MOVE | GDK_ACTION_COPY); /* Build two lists of items (one for copying, one for moving). */ items = egg_toolbars_model_get_name_avail (editor->priv->model); while (items->len > 0) { GtkWidget *item; const char *name; gint flags; name = g_ptr_array_index (items, 0); g_ptr_array_remove_index_fast (items, 0); flags = egg_toolbars_model_get_name_flags (editor->priv->model, name); if ((flags & EGG_TB_MODEL_NAME_INFINITE) == 0) { item = editor_create_item_from_name (editor, name, GDK_ACTION_MOVE); if (item != NULL) to_move = g_list_insert_sorted (to_move, item, compare_items); } else { item = editor_create_item_from_name (editor, name, GDK_ACTION_COPY); if (item != NULL) to_copy = g_list_insert_sorted (to_copy, item, compare_items); } } /* Add them to the sheet. */ y = 0; y = append_table (GTK_TABLE (table), to_move, y, 4); y = append_table (GTK_TABLE (table), to_copy, y, 4); g_list_free (to_move); g_list_free (to_copy); g_ptr_array_free (items, TRUE); /* Delete old table. */ viewport = gtk_bin_get_child (GTK_BIN (editor->priv->scrolled_window)); if (viewport) { gtk_container_remove (GTK_CONTAINER (viewport), gtk_bin_get_child (GTK_BIN (viewport))); } /* Add table to window. */ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table); }
static gboolean budgie_popover_draw(GtkWidget *widget, cairo_t *cr, gboolean draw) { BudgiePopover *self = BUDGIE_POPOVER(widget); GtkStyleContext *style; GtkAllocation alloc; GtkPositionType gap_side; GdkRGBA color; gdouble x, y, tail_height, gap_width; gdouble margin, width, height, gap1, gap2; x = 0; y = 0; tail_height = 12; gap_width = 24; margin = 11; x += margin; y += margin; style = gtk_widget_get_style_context(widget); gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME); gtk_widget_get_allocation(widget, &alloc); /* Have parent class do drawing, so we gain shadows */ ((GtkWidgetClass*)budgie_popover_parent_class)->draw(widget, cr); /* Remove height of tail, and margin, from our rendered size */ width = alloc.width; height = alloc.height - tail_height; height -= margin; width -= margin*2; cairo_set_operator(cr, CAIRO_OPERATOR_OVER); gap1 = (alloc.width/2)-(gap_width/2); gap1 = self->widg_x; gap2 = gap1 + gap_width; gap2 -= margin; gap_side = self->top == TRUE ? GTK_POS_TOP : GTK_POS_BOTTOM; /* Render a gap in the bottom center for our arrow */ gtk_render_frame_gap(style, cr, x, y, width, height, gap_side, gap1, gap2); /* Fill in the background (pre-clip) */ gtk_render_background(style, cr, x, y, width, height); /* Clip to the tail, fill in the arrow background */ cairo_save(cr); if (self->top) budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top); else budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top); cairo_clip(cr); if (self->top) gtk_render_background(style, cr, x, y-tail_height, alloc.width, alloc.height); else gtk_render_background(style, cr, x, y, alloc.width, alloc.height); cairo_restore(cr); /* Draw in the border */ gtk_style_context_get_border_color(style, gtk_widget_get_state_flags(widget), &color); gdk_cairo_set_source_rgba(cr, &color); cairo_set_line_width(cr, 1); if (self->top) budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top); else budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top); cairo_stroke(cr); /* Draw children */ gtk_container_propagate_draw(GTK_CONTAINER(widget), gtk_bin_get_child(GTK_BIN(widget)), cr); return TRUE; }
void ghb_update_widget(GtkWidget *widget, const GValue *value) { GType type; gchar *str; gint ival; gdouble dval; g_debug("ghb_update_widget"); type = G_VALUE_TYPE(value); if (type == ghb_array_get_type() || type == ghb_dict_get_type()) return; if (value == NULL) return; str = ghb_value_string(value); ival = ghb_value_int(value); dval = ghb_value_double(value); type = G_OBJECT_TYPE(widget); if (type == GTK_TYPE_ENTRY) { g_debug("entry"); gtk_entry_set_text((GtkEntry*)widget, str); } else if (type == GTK_TYPE_RADIO_BUTTON) { g_debug("radio button"); if (ival) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), !!ival); } else if (type == GTK_TYPE_CHECK_BUTTON) { g_debug("check button"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival); } else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON) { g_debug("toggle button"); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), ival); } else if (type == GTK_TYPE_TOGGLE_BUTTON) { g_debug("toggle button"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival); } else if (type == GTK_TYPE_CHECK_MENU_ITEM) { g_debug("check menu item"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival); } else if (type == GTK_TYPE_COMBO_BOX) { GtkTreeModel *store; GtkTreeIter iter; gchar *shortOpt; gdouble ivalue; gboolean foundit = FALSE; g_debug("combo (%s)", str); store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); if (gtk_tree_model_get_iter_first (store, &iter)) { do { gtk_tree_model_get(store, &iter, 2, &shortOpt, -1); if (strcasecmp(shortOpt, str) == 0) { gtk_combo_box_set_active_iter ( GTK_COMBO_BOX(widget), &iter); g_free(shortOpt); foundit = TRUE; break; } g_free(shortOpt); } while (gtk_tree_model_iter_next (store, &iter)); } if (!foundit && gtk_tree_model_get_iter_first (store, &iter)) { do { gtk_tree_model_get(store, &iter, 3, &ivalue, -1); if ((gint)ivalue == ival || ivalue == dval) { gtk_combo_box_set_active_iter ( GTK_COMBO_BOX(widget), &iter); foundit = TRUE; break; } } while (gtk_tree_model_iter_next (store, &iter)); } if (!foundit) { if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget))) { GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget))); if (entry) { gtk_entry_set_text (entry, str); } else { gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0); } } else { gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0); } } } else if (type == GTK_TYPE_SPIN_BUTTON) { g_debug("spin (%s)", str); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval); } else if (type == GTK_TYPE_SCALE) { g_debug("hscale"); gtk_range_set_value(GTK_RANGE(widget), dval); } else if (type == GTK_TYPE_SCALE_BUTTON) { g_debug("scale_button"); gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), dval); } else if (type == GTK_TYPE_TEXT_VIEW) { g_debug("textview (%s)", str); GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(widget)); gtk_text_buffer_set_text (buffer, str, -1); } else if (type == GTK_TYPE_LABEL) { gtk_label_set_markup (GTK_LABEL(widget), str); } else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON) { GtkFileChooserAction act; act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget)); if (str[0] == 0) { // Do nothing ; } else if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER || act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str); } else if (act == GTK_FILE_CHOOSER_ACTION_SAVE) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str); } else { if (g_file_test(str, G_FILE_TEST_IS_DIR)) { gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(widget), str); } else if (g_file_test(str, G_FILE_TEST_EXISTS)) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str); } else { gchar *dirname; dirname = g_path_get_dirname(str); gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(widget), dirname); g_free(dirname); } } } else { g_debug("Attempt to set unknown widget type"); } g_free(str); }
void ags_desk_init(AgsDesk *desk) { GtkHBox *hbox; GtkAlignment *alignment; GtkHBox *balance_hbox; desk->name = NULL; desk->xml_type = "ags-desk"; /* create widgets */ desk->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) desk), (GtkWidget *) desk->vbox); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) desk->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); /* left pad */ desk->left_pad = ags_desk_input_pad_new(NULL); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) desk->left_pad, FALSE, FALSE, 0); /* console */ alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) alignment, FALSE, FALSE, 0); desk->console = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer *) alignment, (GtkWidget *) desk->console); balance_hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) desk->console, (GtkWidget *) balance_hbox, FALSE, FALSE, 0); desk->move_left = (GtkButton *) gtk_button_new_with_label(i18n("left")); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->move_left, FALSE, FALSE, 0); desk->balance = (GtkScale *) gtk_hscale_new_with_range(-1.0, 1.0, 0.1); gtk_widget_set_size_request((GtkWidget *) desk->balance, 200, -1); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->balance, FALSE, FALSE, 0); desk->move_right = (GtkButton *) gtk_button_new_with_label(i18n("right")); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->move_right, FALSE, FALSE, 0); /* left pad */ desk->right_pad = ags_desk_input_pad_new(NULL); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) desk->right_pad, FALSE, FALSE, 0); /* file chooser */ desk->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_set_size_request((GtkWidget *) desk->file_chooser, -1, 400); gtk_box_pack_start((GtkBox *) desk->vbox, (GtkWidget *) desk->file_chooser, FALSE, FALSE, 0); }