bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); } g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(tool->m_item, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(tool->m_item, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); if ( tool->IsStretchable() ) { gtk_separator_tool_item_set_draw ( GTK_SEPARATOR_TOOL_ITEM(tool->m_item), FALSE ); gtk_tool_item_set_expand(tool->m_item, TRUE); } gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (control->m_widget->parent == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } // Inserted items "slide" into place using an animated effect that // causes multiple size events on the item. Must set size request // to keep item size from getting permanently set too small by the // first of these size events. const wxSize size = control->GetSize(); gtk_widget_set_size_request(control->m_widget, size.x, size.y); break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
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_ALT_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_ALT_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; }
static void _camera_import_dialog_new(_camera_import_dialog_t *data) { data->dialog = gtk_dialog_new_with_buttons(_("import images from camera"), NULL, GTK_DIALOG_MODAL, _("cancel"), GTK_RESPONSE_NONE, C_("camera import", "import"), GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size(GTK_WINDOW(data->dialog), 100, 600); gtk_window_set_transient_for(GTK_WINDOW(data->dialog), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui))); GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog)); // List - setup store data->store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING); // IMPORT PAGE data->import.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(data->import.page), 5); // Top info data->import.info = gtk_label_new(_("please wait while prefetching thumbnails of images from camera...")); gtk_label_set_single_line_mode(GTK_LABEL(data->import.info), FALSE); gtk_widget_set_halign(data->import.info, GTK_ALIGN_START); gtk_box_pack_start(GTK_BOX(data->import.page), data->import.info, FALSE, FALSE, 0); // jobcode data->import.jobname = _camera_import_gconf_widget(data, _("jobcode"), "plugins/capture/camera/import/jobcode"); gtk_box_pack_start(GTK_BOX(data->import.page), GTK_WIDGET(data->import.jobname->widget), FALSE, FALSE, 0); // Create the treview with list model data store data->import.treeview = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new()); GtkTreeView *treeview = GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))); GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new(); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(_("thumbnail"), renderer, "pixbuf", 0, (char *)NULL); gtk_tree_view_append_column(treeview, column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("storage file"), renderer, "text", 1, (char *)NULL); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_expand(column, TRUE); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(data->store)); gtk_tree_view_set_headers_visible(treeview, FALSE); gtk_box_pack_start(GTK_BOX(data->import.page), data->import.treeview, TRUE, TRUE, 0); // SETTINGS PAGE data->settings.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width(GTK_CONTAINER(data->settings.page), 5); // general settings gtk_box_pack_start(GTK_BOX(data->settings.page), gtk_label_new(_("general")), FALSE, FALSE, 0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. data->settings.general.ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files")); gtk_widget_set_tooltip_text(data->settings.general.ignore_jpeg, _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are " "raw+JPEG in a directory.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->settings.general.ignore_jpeg), "clicked", G_CALLBACK(_check_button_callback), data); GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); data->settings.general.date_override = gtk_check_button_new_with_label(_("override today's date")); gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_override, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(data->settings.general.date_override, _("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), " "$(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)")); data->settings.general.date_entry = gtk_entry_new(); gtk_widget_set_sensitive(data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( data->settings.general.date_override))); gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_entry, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(data->settings.general.date_override), "clicked", G_CALLBACK(_check_button_callback), data); gtk_box_pack_start(GTK_BOX(data->settings.page), hbox, FALSE, FALSE, 0); // THE NOTEBOOK data->notebook = gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->import.page, gtk_label_new(_("images"))); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->settings.page, gtk_label_new(_("settings"))); // end gtk_box_pack_start(GTK_BOX(content), data->notebook, TRUE, TRUE, 0); // gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400)); }
static void zoom_options_init (ZoomOptions *self) { ZoomOptionsPrivate *priv; GtkWidget *w; PangoAttrList *pango_attrs; PangoAttribute *attr; GError *err = NULL; priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, ZOOM_TYPE_OPTIONS, ZoomOptionsPrivate); priv->builder = gtk_builder_new (); gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE); gtk_builder_add_from_file (priv->builder, SAGARMATHACC_UI_DIR "/zoom-options.ui", &err); if (err) { g_warning ("Could not load interface file: %s", err->message); g_error_free (err); g_object_unref (priv->builder); priv->builder = NULL; return; } priv->settings = g_settings_new ("org.sagarmatha.desktop.a11y.magnifier"); priv->application_settings = g_settings_new ("org.sagarmatha.desktop.a11y.applications"); pango_attrs = pango_attr_list_new (); attr = pango_attr_scale_new (FONT_SCALE); pango_attr_list_insert (pango_attrs, attr); /* Zoom switch */ g_settings_bind (priv->application_settings, "screen-magnifier-enabled", WID ("seeing_zoom_switch"), "active", G_SETTINGS_BIND_DEFAULT); /* Magnification factor */ w = WID ("magFactorSpinButton"); g_settings_bind (priv->settings, "mag-factor", gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w)), "value", G_SETTINGS_BIND_DEFAULT); /* Screen position combo */ w = WID ("screen_position_combo_box"); screen_position_notify_cb (priv->settings, "screen-position", self); g_signal_connect (G_OBJECT (priv->settings), "changed::screen-position", G_CALLBACK (screen_position_notify_cb), self); g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (screen_position_combo_changed_cb), self); /* Screen part section */ init_screen_part_section (priv, pango_attrs); /* Cross hairs: show/hide ... */ w = WID ("xhairsEnabledSwitch"); g_settings_bind (priv->settings, "show-cross-hairs", w, "active", G_SETTINGS_BIND_DEFAULT); /* ... Cross hairs: color and opacity */ w = WID ("xHairsPicker"); init_xhairs_color_opacity (GTK_COLOR_BUTTON (w), priv->settings); g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-color", G_CALLBACK (xhairs_color_notify_cb), w); g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-opacity", G_CALLBACK (xhairs_opacity_notify_cb), w); g_signal_connect (G_OBJECT (w), "color-set", G_CALLBACK (xhairs_color_opacity_changed), priv); /* ... Cross hairs: thickness ... */ w = WID ("xHairsThicknessSlider"); g_settings_bind (priv->settings, "cross-hairs-thickness", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* ... Cross hairs: clip ... */ w = WID ("xHairsClipCheckbox"); scale_label (GTK_BIN(w), pango_attrs); g_settings_bind (priv->settings, "cross-hairs-clip", w, "active", G_SETTINGS_BIND_INVERT_BOOLEAN); /* ... Cross hairs: length ... */ w = WID ("xHairsLengthSlider"); xhairs_length_add_marks (GTK_SCALE (w)); g_settings_bind (priv->settings, "cross-hairs-length", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* ... Color effects ... */ w = WID ("inverseEnabledSwitch"); g_settings_bind (priv->settings, "invert-lightness", w, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("brightnessSlider"); priv->brightness_slider = w; init_effects_slider (GTK_RANGE(w), priv, brightness_keys, G_CALLBACK (brightness_slider_notify_cb)); w = WID ("contrastSlider"); priv->contrast_slider = w; init_effects_slider (GTK_RANGE(w), priv, contrast_keys, G_CALLBACK (contrast_slider_notify_cb)); w = WID ("grayscale_slider"); g_settings_bind (priv->settings, "color-saturation", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); gtk_scale_add_mark (GTK_SCALE(w), 1.0, GTK_POS_BOTTOM, NULL); /* ... Window itself ... */ priv->dialog = WID ("magPrefsDialog"); w = WID ("closeButton"); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (zoom_option_close_dialog_cb), priv); g_signal_connect (G_OBJECT (priv->dialog), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); pango_attr_list_unref (pango_attrs); }
void uim_cand_win_horizontal_gtk_set_index(UIMCandWinHorizontalGtk *horizontal_cwin, gint index) { gint new_page, prev_index; UIMCandWinGtk *cwin; g_return_if_fail(UIM_IS_CAND_WIN_HORIZONTAL_GTK(horizontal_cwin)); cwin = UIM_CAND_WIN_GTK(horizontal_cwin); prev_index = cwin->candidate_index; if (index >= (gint) cwin->nr_candidates) cwin->candidate_index = 0; else cwin->candidate_index = index; if (cwin->candidate_index >= 0 && cwin->display_limit) new_page = cwin->candidate_index / cwin->display_limit; else new_page = cwin->page_index; if (cwin->page_index != new_page) uim_cand_win_gtk_set_page(cwin, new_page); if (cwin->candidate_index >= 0) { gint pos; struct index_button *idxbutton, *prev_selected; GtkWidget *label; if (cwin->display_limit) pos = cwin->candidate_index % cwin->display_limit; else pos = cwin->candidate_index; idxbutton = g_ptr_array_index(horizontal_cwin->buttons, pos); prev_selected = (gpointer)horizontal_cwin->selected; if (prev_selected && prev_index != cwin->candidate_index) { label = gtk_bin_get_child(GTK_BIN(prev_selected->button)); gtk_widget_queue_draw(label); } label = gtk_bin_get_child(GTK_BIN(idxbutton->button)); gtk_widget_queue_draw(label); horizontal_cwin->selected = idxbutton; /* show subwin */ if (cwin->stores->pdata[new_page]) { char *annotation = NULL; GtkTreeModel *model = GTK_TREE_MODEL(cwin->stores->pdata[new_page]); GtkTreeIter iter; gtk_tree_model_iter_nth_child(model, &iter, NULL, pos); gtk_tree_model_get(model, &iter, COLUMN_ANNOTATION, &annotation, -1); if (annotation && *annotation) { if (!cwin->sub_window.window) uim_cand_win_gtk_create_sub_window(cwin); gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(cwin->sub_window.text_view)), annotation, -1); uim_cand_win_gtk_layout_sub_window(cwin); gtk_widget_show(cwin->sub_window.window); cwin->sub_window.active = TRUE; } else { if (cwin->sub_window.window) { gtk_widget_hide(cwin->sub_window.window); cwin->sub_window.active = FALSE; } } free(annotation); } } else { horizontal_cwin->selected = NULL; if (cwin->sub_window.window) { gtk_widget_hide(cwin->sub_window.window); cwin->sub_window.active = FALSE; } } uim_cand_win_gtk_update_label(cwin); }
void wxButton::DoApplyWidgetStyle(GtkRcStyle *style) { gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(GTK_BIN(m_widget)->child, style); }
GtkEditable *wxComboBox::GetEditable() const { return GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(m_widget))); }
void set_string_combo(SettingItem * item, gchar * s) { gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(item->widget))),s); }
void wxChoice::DoApplyWidgetStyle(GtkRcStyle *style) { GTKApplyStyle(m_widget, style); GTKApplyStyle(gtk_bin_get_child(GTK_BIN(m_widget)), style); }
/*! *\brief Create the matcher dialog */ static void prefs_filtering_action_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *confirm_area; GtkWidget *vbox1; GtkWidget *frame; GtkWidget *table; GtkWidget *hbox1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *action_combo; GtkWidget *account_combo; GtkWidget *header_combo; GtkWidget *header_entry; #ifndef USE_NEW_ADDRBOOK GtkWidget *addressbook_btn; #endif GtkWidget *dest_entry; GtkWidget *dest_btn; GtkWidget *score_entry; GtkWidget *tags_combo; GtkWidget *reg_hbox; GtkWidget *btn_hbox; GtkWidget *arrow; GtkWidget *reg_btn; GtkWidget *subst_btn; GtkWidget *del_btn; GtkWidget *action_hbox; GtkWidget *action_scrolledwin; GtkWidget *action_list_view; GtkWidget *btn_vbox; GtkWidget *up_btn; GtkWidget *down_btn; GtkWidget *exec_btn; #if !GTK_CHECK_VERSION(3, 0, 0) GtkWidget *color_optmenu; #endif static GdkGeometry geometry; GList * accounts; GSList *tmp, *tags; GtkSizeGroup *size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); GtkSizeGroup *size_action = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); GtkTreeModel *model; GtkCellRenderer *renderer; debug_print("Creating matcher configuration window...\n"); window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_filtering_action"); gtk_container_set_border_width(GTK_CONTAINER(window), VBOX_BORDER); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); vbox = gtk_vbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(window), vbox); gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL, &ok_btn, GTK_STOCK_OK, NULL, NULL); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); gtk_window_set_title(GTK_WINDOW(window), _("Action configuration")); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(prefs_filtering_action_deleted), NULL); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(prefs_filtering_action_size_allocate_cb), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_filtering_action_key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window); g_signal_connect(G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_filtering_action_ok), NULL); g_signal_connect(G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_filtering_action_cancel), NULL); vbox1 = gtk_vbox_new(FALSE, VSPACING); gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER (vbox1), 2); frame = gtk_frame_new(_("Rule")); gtk_frame_set_label_align(GTK_FRAME(frame), 0.01, 0.5); gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, FALSE, 0); gtk_widget_set_size_request(frame, -1, 110); table = gtk_table_new(3, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), VSPACING_NARROW_2); gtk_table_set_col_spacings (GTK_TABLE (table), HSPACING_NARROW); gtk_container_add(GTK_CONTAINER(frame), table); /* first row labels */ label1 = gtk_label_new (_("Action")); gtk_widget_set_size_request(label1, LABELS_WIDTH, -1); gtk_size_group_add_widget(size_group, label1); gtk_misc_set_alignment (GTK_MISC (label1), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); label2 = gtk_label_new (""); gtk_size_group_add_widget(size_group, label2); gtk_misc_set_alignment (GTK_MISC (label2), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2, GTK_FILL, GTK_SHRINK, 0, 0); label3 = gtk_label_new (""); gtk_size_group_add_widget(size_group, label3); gtk_misc_set_alignment (GTK_MISC (label3), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label3, 0, 1, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0); /* action combo */ hbox1 = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); model = prefs_filtering_action_create_model(); action_combo = gtk_combo_box_new_with_model(model); gtk_size_group_add_widget(size_action, action_combo); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(action_combo), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(action_combo), renderer, "text", ACTION_COMBO_TEXT, "sensitive", ACTION_COMBO_SENS, NULL); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(action_combo), renderer, cell_is_sensitive, NULL, NULL); combobox_select_by_data(GTK_COMBO_BOX(action_combo), ACTION_MOVE); g_signal_connect(G_OBJECT(action_combo), "changed", G_CALLBACK(prefs_filtering_action_type_selection_changed), NULL); gtk_box_pack_start(GTK_BOX(hbox1), action_combo, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox1), gtk_label_new(""), TRUE, TRUE, 0); /* accounts */ hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); #if !GTK_CHECK_VERSION(2, 24, 0) account_combo = gtk_combo_box_new_text (); #else account_combo = gtk_combo_box_text_new (); #endif gtk_size_group_add_widget(size_action, account_combo); for (accounts = account_get_list() ; accounts != NULL; accounts = accounts->next) { PrefsAccount *ac = (PrefsAccount *)accounts->data; gchar *name = g_strdup(ac->account_name); #if !GTK_CHECK_VERSION(2, 24, 0) gtk_combo_box_append_text(GTK_COMBO_BOX(account_combo), (gpointer) name); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(account_combo), (gpointer) name); #endif g_free(name); } prefs_filtering_action_check_widget_width(account_combo); gtk_combo_box_set_active(GTK_COMBO_BOX(account_combo), 0); gtk_box_pack_start (GTK_BOX (hbox1), account_combo, FALSE, FALSE, 0); /* header */ header_combo = combobox_text_new(TRUE, "From", "To", "Cc", "Reply-To", "Sender", NULL); gtk_size_group_add_widget(size_action, header_combo); gtk_box_pack_start (GTK_BOX (hbox1), header_combo, FALSE, FALSE, 0); header_entry = gtk_bin_get_child(GTK_BIN((header_combo))); /* destination */ hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); dest_entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox1), dest_entry, TRUE, TRUE, 0); score_entry = gtk_spin_button_new_with_range(-1000, 1000, 1); gtk_box_pack_start(GTK_BOX(hbox1), score_entry, FALSE, FALSE, 0); #if !GTK_CHECK_VERSION(3, 0, 0) color_optmenu = gtk_cmoption_menu_new(); gtk_size_group_add_widget(size_action, color_optmenu); gtk_cmoption_menu_set_menu(GTK_CMOPTION_MENU(color_optmenu), colorlabel_create_color_menu()); prefs_filtering_action_check_widget_width(color_optmenu); gtk_box_pack_start(GTK_BOX(hbox1), color_optmenu, FALSE, FALSE, 0); #endif #if !GTK_CHECK_VERSION(2, 24, 0) tags_combo = gtk_combo_box_new_text (); #else tags_combo = gtk_combo_box_text_new (); #endif gtk_size_group_add_widget(size_action, tags_combo); for (tmp = tags = tags_get_list() ; tmp != NULL; tmp = tmp->next) { gchar *name = g_strdup(tags_get_tag(GPOINTER_TO_INT(tmp->data))); #if !GTK_CHECK_VERSION(2, 24, 0) gtk_combo_box_append_text(GTK_COMBO_BOX(tags_combo), (gpointer) name); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tags_combo), (gpointer) name); #endif g_free(name); } g_slist_free(tags); prefs_filtering_action_check_widget_width(tags_combo); gtk_combo_box_set_active(GTK_COMBO_BOX(tags_combo), 0); gtk_box_pack_start (GTK_BOX (hbox1), tags_combo, FALSE, FALSE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 2, 3, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0); dest_btn = gtk_button_new_with_label (_("Select...")); gtk_box_pack_start (GTK_BOX (hbox1), dest_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (dest_btn), "clicked", G_CALLBACK(prefs_filtering_action_select_dest), NULL); #ifndef USE_NEW_ADDRBOOK addressbook_btn = gtk_button_new_with_label (_("Select...")); gtk_box_pack_start (GTK_BOX (hbox1), addressbook_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (addressbook_btn), "clicked", G_CALLBACK(prefs_filtering_action_select_addressbook), NULL); #endif exec_btn = gtk_button_new_from_stock(GTK_STOCK_INFO); gtk_box_pack_start (GTK_BOX (hbox1), exec_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (exec_btn), "clicked", G_CALLBACK(prefs_filtering_action_exec_info), window); /* register / substitute / delete */ reg_hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox1), reg_hbox, FALSE, FALSE, 0); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_box_pack_start(GTK_BOX(reg_hbox), arrow, FALSE, FALSE, 0); gtk_widget_set_size_request(arrow, -1, 16); btn_hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start(GTK_BOX(reg_hbox), btn_hbox, FALSE, FALSE, 0); reg_btn = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(btn_hbox), reg_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(reg_btn), "clicked", G_CALLBACK(prefs_filtering_action_register_cb), NULL); subst_btn = gtkut_get_replace_btn(_("_Replace")); gtk_box_pack_start(GTK_BOX(btn_hbox), subst_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(subst_btn), "clicked", G_CALLBACK(prefs_filtering_action_substitute_cb), NULL); del_btn = gtk_button_new_with_mnemonic (_("Re_move")); gtk_button_set_image(GTK_BUTTON(del_btn), gtk_image_new_from_stock(GTK_STOCK_REMOVE,GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(btn_hbox), del_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(del_btn), "clicked", G_CALLBACK(prefs_filtering_action_delete_cb), NULL); action_hbox = gtk_hbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(vbox1), action_hbox, TRUE, TRUE, 0); action_scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(action_scrolledwin, -1, 150); gtk_box_pack_start(GTK_BOX(action_hbox), action_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(action_scrolledwin), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(action_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); action_list_view = prefs_filtering_action_list_view_create(); gtk_container_add(GTK_CONTAINER(action_scrolledwin), action_list_view); btn_vbox = gtk_vbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(action_hbox), btn_vbox, FALSE, FALSE, 0); up_btn = gtk_button_new_from_stock(GTK_STOCK_GO_UP); gtk_box_pack_start(GTK_BOX(btn_vbox), up_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(up_btn), "clicked", G_CALLBACK(prefs_filtering_action_up), NULL); down_btn = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN); gtk_box_pack_start(GTK_BOX(btn_vbox), down_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(down_btn), "clicked", G_CALLBACK(prefs_filtering_action_down), NULL); if (!geometry.min_height) { geometry.min_width = 490; geometry.min_height = 348; } gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry, GDK_HINT_MIN_SIZE); gtk_widget_set_size_request(window, prefs_common.filteringactionwin_width, prefs_common.filteringactionwin_height); gtk_widget_show_all(window); filtering_action.window = window; filtering_action.label1 = label1; filtering_action.label2 = label2; filtering_action.label3 = label3; filtering_action.action_combo = action_combo; filtering_action.account_combo = account_combo; filtering_action.tags_combo = tags_combo; filtering_action.dest_entry = dest_entry; filtering_action.dest_btn = dest_btn; filtering_action.exec_btn = exec_btn; #if !GTK_CHECK_VERSION(3, 0, 0) filtering_action.color_optmenu = color_optmenu; #endif filtering_action.score_entry = score_entry; filtering_action.header_combo = header_combo; filtering_action.header_entry = header_entry; #ifndef USE_NEW_ADDRBOOK filtering_action.addressbook_btn = addressbook_btn; #endif filtering_action.ok_btn = ok_btn; filtering_action.action_list_view = action_list_view; prefs_filtering_action_type_selection_changed(NULL, NULL); }
SettingItem * register_setting(GtkWidget * widget, SettingType type, gchar * section, gchar * key) { SettingItem * item; item = malloc(sizeof(SettingItem)); item->type = type; item->key = g_strdup(key); item->section = g_strdup(section); item->widget = widget; item->fvalue = g_strdup(""); SettingList = g_slist_append(SettingList,item); switch(item->type) { case ST_BOOL: case ST_SFILE_BOOL: g_signal_connect(widget,"toggled", G_CALLBACK(cb_apply_setting), item); break; case ST_INT: case ST_SFILE_INT: g_signal_connect(widget,"value-changed", G_CALLBACK(cb_apply_setting), item); break; case ST_FLOAT: g_signal_connect(widget,"value-changed", G_CALLBACK(cb_apply_setting), item); break; case ST_COLOR: g_signal_connect(widget,"color-set", G_CALLBACK(cb_apply_setting), item); break; case ST_FONT: g_signal_connect(widget,"font-set", G_CALLBACK(cb_apply_setting), item); break; case ST_IMG_FILE: g_signal_connect(widget,"selection-changed", G_CALLBACK(cb_apply_setting), item); break; case ST_STRING_COMBO: g_signal_connect(gtk_bin_get_child(GTK_BIN(widget)),"changed", G_CALLBACK(cb_apply_setting), item); break; case ST_SFILE_INT_COMBO: g_signal_connect(widget,"changed", G_CALLBACK(cb_apply_setting), item); break; case ST_ENGINE_COMBO: g_signal_connect(widget,"changed", G_CALLBACK(cb_apply_setting), item); default: break; //unconnected types } return item; }
/*! \brief sets up and populates the MS2-Extra combo for output choice \param widget is the pointer to the combo to initialize */ G_MODULE_EXPORT void ms2_output_combo_setup(GtkWidget *widget) { guint i = 0; GtkWidget *parent = NULL; gchar * lower = NULL; gchar * upper = NULL; gfloat * multiplier = NULL; gfloat * adder = NULL; gfloat * testmult = NULL; gchar * range = NULL; gint bitval = 0; gint width = 0; DataSize size = MTX_U08; gint precision = 0; gconstpointer * object = NULL; gint raw_lower = 0; gint raw_upper = 0; gboolean temp_dep = FALSE; gchar *raw_lower_str = NULL; gchar *raw_upper_str = NULL; gchar *tempc_range = NULL; gchar *tempf_range = NULL; gchar *tempk_range = NULL; gfloat real_lower = 0.0; gfloat real_upper = 0.0; gfloat tmpf = 0.0; gchar * name = NULL; gchar *internal_names = NULL; GtkWidget *entry = NULL; GtkEntryCompletion *completion = NULL; GtkListStore *store = NULL; GtkTreeIter iter; ENTER(); Rtv_Map *rtv_map = NULL; rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map"); if (!rtv_map) { EXIT(); return; } /* Create the store for the combo, with severla hidden values */ store = gtk_list_store_new(UO_COMBO_COLS, G_TYPE_STRING, /* Choice */ G_TYPE_UCHAR, /* BITval */ G_TYPE_POINTER, /* FromECU Multiplier (gfloat *) */ G_TYPE_POINTER, /* FromECU Adder (gfloat *) */ G_TYPE_STRING, /* Raw Lower clamp limit */ G_TYPE_STRING, /* Raw Upper clamp limit */ G_TYPE_STRING, /* Range widget string (non temp ctrls) */ G_TYPE_STRING, /* Range widget string (Celsius) */ G_TYPE_STRING, /* Range widget string (Fahrenheit) */ G_TYPE_STRING, /* Range widget string (Kelvin) */ G_TYPE_INT, /* Size enumeration (_U08_, _U16_, etc.) */ G_TYPE_UCHAR, /* Precision (floating point precision) */ G_TYPE_BOOLEAN);/* Temp dependent flag */ /* Iterate across valid variables */ for (i=0;i<rtv_map->rtv_list->len;i++) { object = NULL; name = NULL; object = (gconstpointer *)g_ptr_array_index(rtv_map->rtv_list,i); if (!object) continue; name = (gchar *) DATA_GET(object,"dlog_gui_name"); if (!name) continue; if (DATA_GET(object,"fromecu_complex")) continue; if (DATA_GET(object,"special")) continue; internal_names = (gchar *) DATA_GET(object,"internal_names"); if (!find_in_list(rtv_map->raw_list,internal_names)) continue; temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep"); size = (DataSize)(GINT)DATA_GET(object,"size"); multiplier = (gfloat *)DATA_GET(object,"fromecu_mult"); adder = (gfloat *)DATA_GET(object,"fromecu_add"); precision = (GINT) DATA_GET(object,"precision"); bitval = (GINT) DATA_GET(object,"offset"); if (DATA_GET(object,"real_lower")) { lower = (gchar *)DATA_GET(object,"real_lower"); real_lower = g_strtod(lower,NULL); raw_lower = calc_value_f(real_lower,multiplier,adder,TOECU); } else raw_lower = get_extreme_from_size_f(size,LOWER); if (DATA_GET(object,"real_upper")) { upper = (gchar *)DATA_GET(object,"real_upper"); real_upper = g_strtod(upper,NULL); raw_upper = calc_value_f(real_upper,multiplier,adder,TOECU); } else raw_upper = get_extreme_from_size_f(size,UPPER); range = g_strdup_printf("Valid Range: %.1f <-> %.1f",real_lower,real_upper); if (temp_dep) { tempc_range = g_strdup_printf("Valid Range: %.1f\302\260C <-> %.1f\302\260C",f_to_c_f(real_lower),f_to_c_f(real_upper)); tempf_range = g_strdup_printf("Valid Range: %.1f\302\260F <-> %.1f\302\260F",real_lower,real_upper); tempk_range = g_strdup_printf("Valid Range: %.1f\302\260K <-> %.1f\302\260K",f_to_k_f(real_lower),f_to_k_f(real_upper)); } else { tempc_range = g_strdup(range); tempf_range = g_strdup(range); tempk_range = g_strdup(range); } raw_lower_str = g_strdup_printf("%i",raw_lower); raw_upper_str = g_strdup_printf("%i",raw_upper); gtk_list_store_append(store,&iter); gtk_list_store_set(store,&iter, UO_CHOICE_COL,name, UO_BITVAL_COL,bitval, UO_FROMECU_MULT_COL,multiplier, UO_FROMECU_ADD_COL,adder, UO_RAW_LOWER_COL,raw_lower_str, UO_RAW_UPPER_COL,raw_upper_str, UO_RANGE_COL,range, UO_RANGE_TEMPC_COL,tempc_range, UO_RANGE_TEMPF_COL,tempf_range, UO_RANGE_TEMPK_COL,tempk_range, UO_SIZE_COL,size, UO_PRECISION_COL,precision, UO_TEMP_DEP_COL,temp_dep, -1); g_free(raw_lower_str); g_free(raw_upper_str); g_free(range); g_free(tempc_range); g_free(tempf_range); g_free(tempk_range); } if (GTK_IS_COMBO_BOX_ENTRY(widget)) { gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(widget),UO_CHOICE_COL); gtk_combo_box_set_model(GTK_COMBO_BOX(widget),GTK_TREE_MODEL(store)); g_object_unref(store); entry = gtk_bin_get_child(GTK_BIN(widget)); /* Nasty hack, but otherwise the entry is an obnoxious size.. */ if ((width = (GINT)OBJ_GET((GtkWidget *)widget,"max_chars")) > 0) gtk_entry_set_width_chars(GTK_ENTRY(entry),width); else gtk_entry_set_width_chars(GTK_ENTRY(entry),12); gtk_widget_set_size_request(GTK_WIDGET(widget),-1,(3*(GINT)DATA_GET(global_data,"font_size"))); // gtk_container_remove (GTK_CONTAINER (widget), gtk_bin_get_child(GTK_BIN(widget))); // gtk_container_add (GTK_CONTAINER (widget), entry); completion = gtk_entry_completion_new(); gtk_entry_set_completion(GTK_ENTRY(entry),completion); g_object_unref(completion); gtk_entry_completion_set_model(completion,GTK_TREE_MODEL(store)); gtk_entry_completion_set_text_column(completion,UO_CHOICE_COL); gtk_entry_completion_set_inline_completion(completion,TRUE); gtk_entry_completion_set_inline_selection(completion,TRUE); gtk_entry_completion_set_popup_single_match(completion,FALSE); OBJ_SET(widget,"arrow-size",GINT_TO_POINTER(1)); } EXIT(); return; }
nsresult EmbedPrompter::Create(PromptType aType, GtkWindow* aParentWindow) { mWindow = gtk_dialog_new_with_buttons(mTitle.get(), aParentWindow, (GtkDialogFlags)0, NULL); // only add the dialog to the window group if the parent already has a window group, // so as not to break app's expectations about modal dialogs. if (aParentWindow && aParentWindow->group) { gtk_window_group_add_window (aParentWindow->group, GTK_WINDOW (mWindow)); } // gtk will resize this for us as necessary gtk_window_set_default_size(GTK_WINDOW(mWindow), 100, 50); // this HBox will contain the icon, and a vbox which contains the // dialog text and other widgets. GtkWidget* dialogHBox = gtk_hbox_new(FALSE, 12); // Set up dialog properties according to the GNOME HIG // (http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows) gtk_container_set_border_width(GTK_CONTAINER(mWindow), 6); gtk_dialog_set_has_separator(GTK_DIALOG(mWindow), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(mWindow)->vbox), 12); gtk_container_set_border_width(GTK_CONTAINER(dialogHBox), 6); // This is the VBox which will contain the label and other controls. GtkWidget* contentsVBox = gtk_vbox_new(FALSE, 12); // get the stock icon for this dialog and put it in the box const gchar* iconDesc = DialogTable[aType].icon; GtkWidget* icon = gtk_image_new_from_stock(iconDesc, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(dialogHBox), icon, FALSE, FALSE, 0); // now pack the label into the vbox GtkWidget* label = gtk_label_new(mMessageText.get()); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), label, FALSE, FALSE, 0); int widgetFlags = DialogTable[aType].flags; if (widgetFlags & (INCLUDE_USERNAME | INCLUDE_PASSWORD)) { // If we're creating a username and/or password field, make an hbox // which will contain two vboxes, one for the labels and one for the // text fields. This will let us line up the textfields. GtkWidget* userPassHBox = gtk_hbox_new(FALSE, 12); GtkWidget* userPassLabels = gtk_vbox_new(TRUE, 6); GtkWidget* userPassFields = gtk_vbox_new(TRUE, 6); if (widgetFlags & INCLUDE_USERNAME) { GtkWidget* userLabel = gtk_label_new("User Name:"); gtk_box_pack_start(GTK_BOX(userPassLabels), userLabel, FALSE, FALSE, 0); mUserField = gtk_entry_new(); if (!mUser.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get()); gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE); gtk_box_pack_start(GTK_BOX(userPassFields), mUserField, FALSE, FALSE, 0); } if (widgetFlags & INCLUDE_PASSWORD) { GtkWidget* passLabel = gtk_label_new("Password:"); gtk_box_pack_start(GTK_BOX(userPassLabels), passLabel, FALSE, FALSE, 0); mPassField = gtk_entry_new(); if (!mPass.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get()); gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE); gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE); gtk_box_pack_start(GTK_BOX(userPassFields), mPassField, FALSE, FALSE, 0); } gtk_box_pack_start(GTK_BOX(userPassHBox), userPassLabels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(userPassHBox), userPassFields, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(contentsVBox), userPassHBox, FALSE, FALSE, 0); } if (aType == TYPE_PROMPT) { mTextField = gtk_entry_new(); if (!mTextValue.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get()); gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0); } // Add a checkbox if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) { mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox), mCheckValue); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0); } // Add a dropdown menu if (aType == TYPE_SELECT) { // Build up a GtkMenu containing the items GtkWidget* menu = gtk_menu_new(); for (PRUint32 i = 0; i < mItemCount; ++i) { GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get()); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); } // Now create an OptionMenu and set this as the menu mOptionMenu = gtk_option_menu_new(); gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu); gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0); } if (aType == TYPE_UNIVERSAL) { // Create buttons based on the flags passed in. for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) { if (!mButtonLabels[i].IsEmpty()) gtk_dialog_add_button(GTK_DIALOG(mWindow), mButtonLabels[i].get(), i); } gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0); } else { // Create standard ok and cancel buttons if (widgetFlags & INCLUDE_CANCEL) gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); gtk_widget_grab_default(okButton); } // Pack the contentsVBox into the dialogHBox and the dialog. gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(mWindow)->vbox), dialogHBox, FALSE, FALSE, 0); return NS_OK; }
static void update_editor_sheet (EggToolbarEditor *editor) { GList *l; GList *to_drag; int x, y, height, width; GtkWidget *table; GtkWidget *viewport; GtkWidget *item; GtkWidget *icon; g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor)); viewport = GTK_BIN (editor->priv->scrolled_window)->child; if (viewport) { table = GTK_BIN (viewport)->child; gtk_container_remove (GTK_CONTAINER (viewport), table); } table = gtk_table_new (0, 0, TRUE); editor->priv->table = table; gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_widget_show (table); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table); gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL, dest_drag_types, n_dest_drag_types, GDK_ACTION_MOVE); g_signal_connect (table, "drag_data_received", G_CALLBACK (editor_drag_data_received_cb), editor); to_drag = editor->priv->actions_list; x = y = 0; width = 4; height = (g_list_length (to_drag)) / width + 1; gtk_table_resize (GTK_TABLE (editor->priv->table), height, width); for (l = to_drag; l != NULL; l = l->next) { GtkAction *action = (l->data); const char *stock_id, *short_label; GValue value = { 0, }; g_value_init (&value, G_TYPE_STRING); g_object_get_property (G_OBJECT (action), "stock_id", &value); stock_id = g_value_get_string (&value); icon = gtk_image_new_from_stock (stock_id ? stock_id : GTK_STOCK_DND, GTK_ICON_SIZE_LARGE_TOOLBAR); g_value_unset (&value); g_value_init (&value, G_TYPE_STRING); g_object_get_property (G_OBJECT (action), "short_label", &value); short_label = g_value_get_string (&value); item = editor_create_item (editor, GTK_IMAGE (icon), short_label, GDK_ACTION_MOVE); g_value_unset (&value); g_object_set_data (G_OBJECT (item), "egg-action", action); gtk_table_attach_defaults (GTK_TABLE (editor->priv->table), item, x, x + 1, y, y + 1); x++; if (x >= width) { x = 0; y++; } } icon = _egg_editable_toolbar_new_separator_image (); item = editor_create_item (editor, GTK_IMAGE (icon), _("Separator"), GDK_ACTION_COPY); gtk_table_attach_defaults (GTK_TABLE (editor->priv->table), item, x, x + 1, y, y + 1); }
RendererFuncs *renderer_clutter_new(PixbufRenderer *pr) { RendererClutter *rc = g_new0(RendererClutter, 1); rc->pr = pr; rc->f.area_changed = rc_area_changed; rc->f.update_pixbuf = rc_update_pixbuf; rc->f.free = rc_free; rc->f.update_zoom = rc_update_zoom; rc->f.invalidate_region = rc_invalidate_region; rc->f.scroll = rc_scroll; rc->f.update_viewport = rc_update_viewport; rc->f.overlay_add = rc_overlay_add; rc->f.overlay_set = rc_overlay_set; rc->f.overlay_get = rc_overlay_get; rc->f.stereo_set = rc_stereo_set; rc->stereo_mode = 0; rc->stereo_off_x = 0; rc->stereo_off_y = 0; rc->idle_update = 0; rc->pending_updates = NULL; rc->widget = gtk_bin_get_child(GTK_BIN(rc->pr)); if (rc->widget) { if (!GTK_CLUTTER_IS_EMBED(rc->widget)) { g_free(rc); DEBUG_3("pixbuf renderer has a child of other type than gtk_clutter_embed"); return NULL; } } else { rc->widget = gtk_clutter_embed_new(); gtk_container_add(GTK_CONTAINER(rc->pr), rc->widget); } gtk_event_box_set_above_child (GTK_EVENT_BOX(rc->pr), TRUE); rc->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (rc->widget)); rc->group = clutter_group_new(); clutter_container_add_actor(CLUTTER_CONTAINER(rc->stage), rc->group); clutter_actor_set_clip_to_allocation(CLUTTER_ACTOR(rc->group), TRUE); rc->texture = clutter_texture_new (); clutter_container_add_actor(CLUTTER_CONTAINER(rc->group), rc->texture); renderer_clutter_init_checker_shader(rc); g_object_ref(G_OBJECT(rc->widget)); gtk_widget_show(rc->widget); return (RendererFuncs *) rc; }
static void _lib_backgroundjobs_set_cancellable(dt_lib_module_t *self, const guint *key, struct dt_job_t *job) { if(!darktable.control->running) return; gboolean i_own_lock = dt_control_gdk_lock(); dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data; dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key); if (j) { GtkWidget *w=j->widget; GtkBox *hbox = GTK_BOX (g_list_nth_data (gtk_container_get_children (GTK_CONTAINER ( gtk_bin_get_child (GTK_BIN (w) ) ) ), 0)); GtkWidget *button = dtgtk_button_new(dtgtk_cairo_paint_cancel,CPF_STYLE_FLAT); gtk_widget_set_size_request(button,17,17); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (_lib_backgroundjobs_cancel_callback), (gpointer)job); gtk_box_pack_start (hbox, GTK_WIDGET(button), FALSE, FALSE, 0); gtk_widget_show_all(button); } if(i_own_lock) dt_control_gdk_unlock(); }
void dates_details_time_lminute_cb (GtkButton *source, DatesData *d) { dates_details_time_entry_alt (GTK_ARROW (gtk_bin_get_child ( GTK_BIN (source))), d->lminute_entry, d, 5); }
static void update_frame_params(GtkComboBox *widget, changeformat_settings settings) { increase_dialog_height(0); format_type selected_format = (format_type)gtk_combo_box_get_active(widget); if (selected_format == FORMAT_GIF) { inner_widget = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8); check_interlace = gtk_check_button_new_with_label(_("Interlaced")); if (selected_format == settings->format) { format_params_gif settings_gif = (format_params_gif)(settings->params); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_interlace), settings_gif->interlace); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_interlace), FALSE); } gtk_box_pack_start(GTK_BOX(inner_widget), check_interlace, FALSE, FALSE, 0); } else if (selected_format == FORMAT_JPEG) { GtkWidget *hbox_quality, *hbox_smoothing, *hbox_checks, *hbox_comment, *hbox_markers, *hbox_subsampling, *hbox_dct; GtkWidget *vbox_advanced, *label_quality, *label_smoothing, *label_markers, *label_comment, *label_subsampling, *label_dct, *text_comment; inner_widget = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8); hbox_quality = gtk_hbox_new(FALSE, 5); label_quality = gtk_label_new(_("Quality")); gtk_widget_set_size_request (label_quality, 100, LABEL_H); gtk_misc_set_alignment(GTK_MISC(label_quality), 0.5, 0.8); scale_quality = gtk_hscale_new_with_range(0, 100, 1); gtk_widget_set_size_request (scale_quality, 160, SCALE_H); expander_advanced = gtk_expander_new(_("Advanced params")); vbox_advanced = gtk_vbox_new(FALSE, 5); hbox_smoothing = gtk_hbox_new(FALSE, 5); label_smoothing = gtk_label_new(_("Smoothing")); gtk_widget_set_size_request (label_smoothing, 100, LABEL_H); gtk_misc_set_alignment(GTK_MISC(label_smoothing), 0.5, 0.8); scale_smoothing = gtk_hscale_new_with_range(0, 1, 0.01); gtk_widget_set_size_request (scale_smoothing, 160, SCALE_H); hbox_checks = gtk_hbox_new(FALSE, 5); check_entrophy = gtk_check_button_new_with_label(_("Optimize")); check_progressive = gtk_check_button_new_with_label(_("Progressive")); check_baseline = gtk_check_button_new_with_label(_("Save baseline")); hbox_comment = gtk_hbox_new(FALSE, 5); label_comment = gtk_label_new(g_strconcat(_("Comment"), ": ", NULL)); gtk_widget_set_size_request (label_comment, 100, LABEL_H); text_comment = gtk_text_view_new(); buffer_comment = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_comment)); gtk_widget_set_size_request (text_comment, 160, TEXT_H); hbox_markers = gtk_hbox_new(FALSE, 5); label_markers = gtk_label_new(g_strconcat(_("Markers rows"), ": ", NULL)); gtk_widget_set_size_request (label_markers, 100, LABEL_H); spin_markers = gtk_spin_button_new(NULL, 1, 0); hbox_subsampling = gtk_hbox_new(FALSE, 5); label_subsampling = gtk_label_new(g_strconcat(_("Subsampling"), ": ", NULL)); gtk_widget_set_size_request (label_subsampling, 100, LABEL_H); combo_subsampling = gtk_combo_box_new_text(); gtk_widget_set_size_request (combo_subsampling, 180, COMBO_H); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_subsampling), g_strconcat("2x2, 1x1, 1x1 (", _("Small size"), ")", NULL)); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_subsampling), "2x1, 1x1, 1x1 (4:2:2)"); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_subsampling), g_strconcat("1x1, 1x1, 1x1 (", _("Quality"), ")", NULL)); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_subsampling), "1x2, 1x1, 1x1"); hbox_dct = gtk_hbox_new(FALSE, 5); label_dct = gtk_label_new(g_strconcat(_("DCT algorithm"), ": ", NULL)); gtk_widget_set_size_request (label_dct, 100, LABEL_H); combo_dct = gtk_combo_box_new_text(); gtk_widget_set_size_request (combo_dct, 150, COMBO_H); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_dct), _("Integer")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_dct), _("Fast integer")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_dct), _("Float")); if (selected_format == settings->format) { format_params_jpeg settings_jpeg = (format_params_jpeg)(settings->params); gtk_range_set_value(GTK_RANGE(scale_quality), settings_jpeg->quality); gtk_range_set_value(GTK_RANGE(scale_smoothing), settings_jpeg->smoothing); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_entrophy), settings_jpeg->entropy); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_progressive), settings_jpeg->progressive); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_baseline), settings_jpeg->baseline); gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_markers), GTK_ADJUSTMENT(gtk_adjustment_new (settings_jpeg->markers, 0, 64, 1, 1, 0)), 0, 0); buffer_comment = gtk_text_view_get_buffer(GTK_TEXT_VIEW (text_comment)); gtk_text_buffer_set_text (buffer_comment, settings_jpeg->comment, -1); gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_comment), buffer_comment); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_subsampling), settings_jpeg->subsampling); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_dct), settings_jpeg->dct); } else { gtk_range_set_value(GTK_RANGE(scale_quality), 85.0); gtk_range_set_value(GTK_RANGE(scale_smoothing), 0.0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_entrophy), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_progressive), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_baseline), FALSE); gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_markers), GTK_ADJUSTMENT(gtk_adjustment_new (0, 0, 64, 1, 1, 0)), 0, 0); gtk_text_buffer_set_text (buffer_comment, "", -1); gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_comment), buffer_comment); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_subsampling), 2); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_dct), 1); } gtk_box_pack_start(GTK_BOX(hbox_quality), label_quality, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_quality), scale_quality, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), hbox_quality, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), expander_advanced, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_smoothing), label_smoothing, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_smoothing), scale_smoothing, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_smoothing, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_checks), check_entrophy, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_checks), check_progressive, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_checks), check_baseline, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_checks, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_comment), label_comment, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_comment), text_comment, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_comment, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_markers), label_markers, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_markers), spin_markers, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_markers, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_subsampling), label_subsampling, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_subsampling), combo_subsampling, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_subsampling, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_dct), label_dct, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_dct), combo_dct, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), hbox_dct, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(expander_advanced), vbox_advanced); g_signal_connect(G_OBJECT(expander_advanced), "activate", G_CALLBACK(adv_expanded), combo_format); } else if (selected_format == FORMAT_PNG) { GtkWidget *hbox_compression, *label_compression; GtkWidget *vbox_advanced; inner_widget = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8); check_interlace = gtk_check_button_new_with_label(_("Interlace (Adam7)")); hbox_compression = gtk_hbox_new(FALSE, 5); label_compression = gtk_label_new(_("Compression")); gtk_widget_set_size_request (label_compression, 100, LABEL_H); gtk_misc_set_alignment(GTK_MISC(label_compression), 0.5, 0.8); scale_compression = gtk_hscale_new_with_range(0, 9, 1); gtk_widget_set_size_request (scale_compression, 100, SCALE_H); expander_advanced = gtk_expander_new(_("Advanced params")); vbox_advanced = gtk_vbox_new(FALSE, 5); check_savebgc = gtk_check_button_new_with_label(_("Save background color")); check_savegamma = gtk_check_button_new_with_label(_("Save gamma")); check_saveoff = gtk_check_button_new_with_label(_("Save layer offset")); check_savephys = gtk_check_button_new_with_label(_("Save resolution")); check_savetime = gtk_check_button_new_with_label(_("Save creation date")); check_savecomm = gtk_check_button_new_with_label(_("Save comments")); check_savetrans = gtk_check_button_new_with_label(_("Save color from transparent pixels")); if (selected_format == settings->format) { format_params_png settings_png = (format_params_png)(settings->params); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_interlace), settings_png->interlace); gtk_range_set_value(GTK_RANGE(scale_compression), settings_png->compression); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savebgc), settings_png->savebgc); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savegamma), settings_png->savegamma); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_saveoff), settings_png->saveoff); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savephys), settings_png->savephys); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetime), settings_png->savetime); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savecomm), settings_png->savecomm); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetrans), settings_png->savetrans); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_interlace), FALSE); gtk_range_set_value(GTK_RANGE(scale_compression), 9); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savebgc), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savegamma), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_saveoff), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savephys), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetime), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savecomm), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetrans), TRUE); } gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savebgc, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savegamma, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_saveoff, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savephys, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savetime, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savecomm, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savetrans, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), check_interlace, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_compression), label_compression, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_compression), scale_compression, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), hbox_compression, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), expander_advanced, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(expander_advanced), vbox_advanced); g_signal_connect(G_OBJECT(expander_advanced), "activate", G_CALLBACK(adv_expanded), combo_format); } else if (selected_format == FORMAT_TGA) { GtkWidget *hbox_origin, *label_origin; inner_widget = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8); check_rle = gtk_check_button_new_with_label(_("RLE compression")); hbox_origin = gtk_hbox_new(FALSE, 5); label_origin = gtk_label_new(g_strconcat(_("Image origin"), ": ", NULL)); gtk_widget_set_size_request (label_origin, 100, LABEL_H); combo_origin = gtk_combo_box_new_text(); gtk_widget_set_size_request (combo_origin, 100, COMBO_H); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_origin), _("Top-left")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_origin), _("Bottom-left")); if (selected_format == settings->format) { format_params_tga settings_tga = (format_params_tga)(settings->params); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rle), settings_tga->rle); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_origin), settings_tga->origin); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rle), FALSE); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_origin), 0); } gtk_box_pack_start(GTK_BOX(hbox_origin), label_origin, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_origin), combo_origin, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), check_rle, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), hbox_origin, FALSE, FALSE, 0); } else if (selected_format == FORMAT_TIFF) { GtkWidget *hbox_compression, *label_compression; inner_widget = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8); hbox_compression = gtk_hbox_new(FALSE, 5); label_compression = gtk_label_new(_("Compression")); gtk_widget_set_size_request (label_compression, 80, LABEL_H); gtk_misc_set_alignment(GTK_MISC(label_compression), 0.5, 0.5); combo_compression = gtk_combo_box_new_text(); gtk_widget_set_size_request (combo_compression, 130, COMBO_H); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("None")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("LZW")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("Pack bits")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("Deflate")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("JPEG")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("CCITT G3 Fax")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("CCITT G4 Fax")); if (selected_format == settings->format) { format_params_tiff settings_tiff = (format_params_tiff)(settings->params); gtk_combo_box_set_active(GTK_COMBO_BOX(combo_compression), settings_tiff->compression); } else { gtk_combo_box_set_active(GTK_COMBO_BOX(combo_compression), 0); } gtk_box_pack_start(GTK_BOX(hbox_compression), label_compression, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_compression), combo_compression, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_widget), hbox_compression, FALSE, FALSE, 0); } else { inner_widget = gtk_label_new(_("This format has no params")); } if (gtk_bin_get_child(GTK_BIN(frame_params)) != NULL) { gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(frame_params))); } gtk_container_add(GTK_CONTAINER(frame_params), inner_widget); gtk_widget_show_all(frame_params); }
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); }
void set_combo_box_default_text (GtkComboBox *box, const char *s) { GtkWidget *entry = gtk_bin_get_child(GTK_BIN(box)); gtk_entry_set_text(GTK_ENTRY(entry), s); }
/** * na_gtk_utils_set_editable: * @widget: the #GtkWdiget. * @editable: whether the @widget is editable or not. * * Try to set a visual indication of whether the @widget is editable or not. * * Having a GtkWidget should be enough, but we also deal with a GtkTreeViewColumn. * So the most-bottom common ancestor is just GObject (since GtkObject having been * deprecated in Gtk+-3.0) * * Note that using 'sensitivity' property is just a work-around because the * two things have distinct semantics: * - editable: whether we are allowed to modify the value (is not read-only) * - sensitive: whether the value is relevant (has a sense in this context) */ void na_gtk_utils_set_editable( GObject *widget, gboolean editable ) { GList *renderers, *irender; /* GtkComboBoxEntry is deprecated from Gtk+3 * see. http://git.gnome.org/browse/gtk+/commit/?id=9612c648176378bf237ad0e1a8c6c995b0ca7c61 * while 'has_entry' property exists since 2.24 */ #if GTK_CHECK_VERSION( 2,24,0 ) if( GTK_IS_COMBO_BOX( widget ) && gtk_combo_box_get_has_entry( GTK_COMBO_BOX( widget ))){ #else if( GTK_IS_COMBO_BOX_ENTRY( widget )){ #endif /* idem as GtkEntry */ gtk_editable_set_editable( GTK_EDITABLE( gtk_bin_get_child( GTK_BIN( widget ))), editable ); g_object_set( G_OBJECT( gtk_bin_get_child( GTK_BIN( widget ))), "can-focus", editable, NULL ); /* disable the listbox button itself */ gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF ); } else if( GTK_IS_COMBO_BOX( widget )){ /* disable the listbox button itself */ gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF ); } else if( GTK_IS_ENTRY( widget )){ gtk_editable_set_editable( GTK_EDITABLE( widget ), editable ); /* removing the frame leads to a disturbing modification of the * height of the control */ /*g_object_set( G_OBJECT( widget ), "has-frame", editable, NULL );*/ /* this prevents the caret to be displayed when we click in the entry */ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); } else if( GTK_IS_TEXT_VIEW( widget )){ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); gtk_text_view_set_editable( GTK_TEXT_VIEW( widget ), editable ); } else if( GTK_IS_TOGGLE_BUTTON( widget )){ /* transforms to a quasi standard GtkButton */ /*g_object_set( G_OBJECT( widget ), "draw-indicator", editable, NULL );*/ /* this at least prevent the keyboard focus to go to the button * (which is better than nothing) */ g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL ); } else if( GTK_IS_TREE_VIEW_COLUMN( widget )){ renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( GTK_TREE_VIEW_COLUMN( widget ))); for( irender = renderers ; irender ; irender = irender->next ){ if( GTK_IS_CELL_RENDERER_TEXT( irender->data )){ g_object_set( G_OBJECT( irender->data ), "editable", editable, "editable-set", TRUE, NULL ); } } g_list_free( renderers ); } else if( GTK_IS_BUTTON( widget )){ gtk_widget_set_sensitive( GTK_WIDGET( widget ), editable ); } } /** * na_gtk_utils_radio_set_initial_state: * @button: the #GtkRadioButton button which is initially active. * @handler: the corresponding "toggled" handler. * @user_data: the user data associated to the handler. * @editable: whether this radio button group is editable. * @sensitive: whether this radio button group is sensitive. * * This function should be called for the button which is initially active * inside of a radio button group when the radio group may happen to not be * editable. * This function should be called only once for the radio button group. * * It does the following operations: * - set the button as active * - set other buttons of the radio button group as icactive * - set all buttons of radio button group as @editable * * The initially active @button, along with its @handler, are recorded * as properties of the radio button group (actually as properties of each * radio button of the group), so that they can later be used to reset the * initial state. */ void na_gtk_utils_radio_set_initial_state( GtkRadioButton *button, GCallback handler, void *user_data, gboolean editable, gboolean sensitive ) { GSList *group, *ig; GtkRadioButton *other; group = gtk_radio_button_get_group( button ); for( ig = group ; ig ; ig = ig->next ){ other = GTK_RADIO_BUTTON( ig->data ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_BUTTON, button ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_HANDLER, handler ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_USER_DATA, user_data ); g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_EDITABLE, GUINT_TO_POINTER( editable )); na_gtk_utils_set_editable( G_OBJECT( other ), editable ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( other ), FALSE ); gtk_widget_set_sensitive( GTK_WIDGET( other ), sensitive ); } gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( button ), TRUE ); }
/** * fix_popover_menu_icons: * @window: a #GtkPopover * * Hackish code that inspects the popover's children, * retrieve the hidden GtkImage buried under lots of * widgets, and make it visible again. * * Hopefully, we'll find a better way to do this in * the long run. * */ void fix_popover_menu_icons (GtkPopover *popover) { GtkWidget *popover_stack; GtkWidget *menu_section; GtkWidget *menu_section_box; GList *stack_children; GList *menu_section_children; GList *menu_section_box_children, *aux; popover_stack = gtk_bin_get_child (GTK_BIN (popover)); stack_children = gtk_container_get_children (GTK_CONTAINER (popover_stack)); /** * At the moment, the popover stack surely contains only * one child of type GtkMenuSectionBox, which contains * a single GtkBox. */ menu_section = stack_children->data; menu_section_children = gtk_container_get_children (GTK_CONTAINER (menu_section)); /** * Get the unique box's children. */ menu_section_box = menu_section_children->data; menu_section_box_children = gtk_container_get_children (GTK_CONTAINER (menu_section_box)); /** * Iterate through the GtkModelButtons inside the menu section box. */ for (aux = menu_section_box_children; aux != NULL; aux = aux->next) { GtkWidget *button_box; GList *button_box_children, *aux2; button_box = gtk_bin_get_child (GTK_BIN (aux->data)); button_box_children = gtk_container_get_children (GTK_CONTAINER (button_box)); /** * Since there is no guarantee that the first child is * the GtkImage we're looking for, we have to iterate * through the children and check if the types match. */ for (aux2 = button_box_children; aux2 != NULL; aux2 = aux2->next) { GtkWidget *button_box_child; button_box_child = aux2->data; if (g_type_is_a (G_OBJECT_TYPE (button_box_child), GTK_TYPE_IMAGE)) { gtk_widget_show (button_box_child); break; } } g_list_free (button_box_children); } g_list_free (stack_children); g_list_free (menu_section_children); g_list_free (menu_section_box_children); }
static void button_clicked (GtkButton *button, GNCSearchAccount *fi) { GNCSearchAccountPrivate *priv; GtkDialog *dialog; GtkWidget *account_tree; GtkWidget *accounts_scroller; GtkWidget *label; char *desc; GtkTreeSelection *selection; /* Create the account tree */ account_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(account_tree), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_tree)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); /* Select the currently-selected accounts */ priv = _PRIVATE(fi); if (priv->selected_accounts) gnc_tree_view_account_set_selected_accounts (GNC_TREE_VIEW_ACCOUNT(account_tree), priv->selected_accounts, FALSE); /* Create the account scroller and put the tree in it */ accounts_scroller = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(accounts_scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(accounts_scroller), account_tree); gtk_widget_set_size_request(GTK_WIDGET(accounts_scroller), 300, 300); /* Create the label */ label = gtk_label_new (_("Select Accounts to Match")); /* Create the dialog */ dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Select the Accounts to Compare"), NULL, 0, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_OK"), GTK_RESPONSE_OK, NULL)); /* Put the dialog together */ gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), label, FALSE, FALSE, 3); gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), accounts_scroller, TRUE, TRUE, 3); gtk_widget_show_all (GTK_WIDGET (dialog)); /* Now run the dialog */ if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK) { if (priv->selected_accounts) g_list_free (priv->selected_accounts); priv->selected_accounts = gnc_tree_view_account_get_selected_accounts (GNC_TREE_VIEW_ACCOUNT (account_tree)); desc = describe_button (fi); gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), desc); } gtk_widget_destroy (GTK_WIDGET (dialog)); }
void ephy_push_scroller_start (EphyPushScroller *scroller, EphyEmbed *embed, gdouble x, gdouble y) { EphyPushScrollerPrivate *priv = scroller->priv; GtkWidget *widget, *child; guint32 timestamp; g_return_if_fail (embed != NULL); LOG ("Start [%p]", scroller); if (priv->active) return; if (gdk_pointer_is_grabbed ()) return; priv->active = TRUE; /* FIXME is this good enough? */ timestamp = gtk_get_current_event_time (); g_object_ref (scroller); priv->embed = embed; g_object_ref (priv->window); /* set positions */ priv->start_x = x; priv->start_y = y; g_signal_connect (priv->window, "motion-notify-event", G_CALLBACK (ephy_push_scroller_motion_cb), scroller); g_signal_connect (priv->window, "button-press-event", G_CALLBACK (ephy_push_scroller_mouse_press_cb), scroller); g_signal_connect (priv->window, "button-release-event", G_CALLBACK (ephy_push_scroller_mouse_release_cb), scroller); g_signal_connect (priv->window, "key-press-event", G_CALLBACK (ephy_push_scroller_key_press_cb), scroller); g_signal_connect (priv->window, "unmap-event", G_CALLBACK (ephy_push_scroller_unmap_event_cb), scroller); g_signal_connect (priv->window, "grab-broken-event", G_CALLBACK (ephy_push_scroller_grab_broken_event_cb), scroller); /* FIXME: this signal only seems to be emitted on the container children of GtkWindow, * not on GtkWindow itself... is there a better way to get notified of new grabs? */ child = gtk_bin_get_child (GTK_BIN (priv->window)); g_signal_connect_object (child, "grab-notify", G_CALLBACK (ephy_push_scroller_grab_notify_cb), scroller, 0); /* grab the pointer */ widget = GTK_WIDGET (priv->window); gtk_grab_add (widget); if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK, NULL, priv->cursor, timestamp) != GDK_GRAB_SUCCESS) { ephy_push_scroller_stop (scroller, timestamp); return; } if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE, timestamp) != GDK_GRAB_SUCCESS) { ephy_push_scroller_stop (scroller, timestamp); return; } }
static void update_table_button(UIMCandWinHorizontalGtk *horizontal_cwin, guint new_page) { UIMCandWinGtk *cwin; GtkTreeModel *model; GPtrArray *buttons; GtkTreeIter ti; gboolean has_next; gint display_limit, len, cand_index = 0; cwin = UIM_CAND_WIN_GTK(horizontal_cwin); if (!cwin->stores->pdata[new_page]) { return; } model = GTK_TREE_MODEL(cwin->stores->pdata[new_page]); buttons = horizontal_cwin->buttons; display_limit = cwin->display_limit; len = buttons->len; clear_all_buttons(buttons); has_next = gtk_tree_model_get_iter_first(model, &ti); while (has_next) { gchar *heading; gchar *cand_str; GtkEventBox *button = NULL; gtk_tree_model_get(model, &ti, COLUMN_HEADING, &heading, COLUMN_CANDIDATE, &cand_str, TERMINATOR); if (cand_str != NULL) { button = assign_cellbutton(horizontal_cwin, cand_index, display_limit); if (button != NULL) { GtkWidget *label; label = gtk_bin_get_child(GTK_BIN(button)); if (heading && heading[0] != '\0') { gchar *text = g_strdup_printf("%s: %s", heading, cand_str); gtk_label_set_text(GTK_LABEL(label), text); g_free(text); } else { gtk_label_set_text(GTK_LABEL(label), cand_str); } scale_label(button, PANGO_SCALE_LARGE); } } g_free(cand_str); g_free(heading); cand_index++; has_next = gtk_tree_model_iter_next(model, &ti); } if (cand_index < len) { gint i; for (i = len - 1; i >= cand_index; i--) { struct index_button *idxbutton; idxbutton = g_ptr_array_index(buttons, i); if (idxbutton == horizontal_cwin->selected) horizontal_cwin->selected = NULL; gtk_widget_destroy(GTK_WIDGET(idxbutton->button)); g_free(idxbutton); g_ptr_array_remove_index(buttons, i); } #if !GTK_CHECK_VERSION(3, 4, 0) gtk_table_resize(GTK_TABLE(cwin->view), 1, cand_index); #endif } }
static void show_auth_dialog(WebKitAuthData* authData, const char* login, const char* password) { GtkWidget* toplevel; GtkWidget* widget; GtkDialog* dialog; GtkWindow* window; GtkWidget* entryContainer; GtkWidget* hbox; GtkWidget* mainVBox; GtkWidget* vbox; GtkWidget* icon; GtkWidget* table; GtkWidget* serverMessageDescriptionLabel; GtkWidget* serverMessageLabel; GtkWidget* descriptionLabel; char* description; const char* realm; gboolean hasRealm; SoupURI* uri; GtkWidget* rememberBox; GtkWidget* checkButton; /* From GTK+ gtkmountoperation.c, modified and simplified. LGPL 2 license */ widget = gtk_dialog_new(); window = GTK_WINDOW(widget); dialog = GTK_DIALOG(widget); gtk_dialog_add_buttons(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* Set the dialog up with HIG properties */ gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(dialog)), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_action_area(dialog)), 5); gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_action_area(dialog)), 6); gtk_window_set_resizable(window, FALSE); gtk_window_set_title(window, ""); gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); /* Get the current toplevel */ g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel); if (toplevel) gtk_window_set_transient_for(window, GTK_WINDOW(toplevel)); /* Build contents */ hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(dialog)), hbox, TRUE, TRUE, 0); icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0); mainVBox = gtk_vbox_new(FALSE, 18); gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0); uri = soup_message_get_uri(authData->msg); description = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host); descriptionLabel = gtk_label_new(description); g_free(description); gtk_misc_set_alignment(GTK_MISC(descriptionLabel), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(descriptionLabel), TRUE); gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(descriptionLabel), FALSE, FALSE, 0); vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0); /* The table that holds the entries */ entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer), 0, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), entryContainer, FALSE, FALSE, 0); realm = soup_auth_get_realm(authData->auth); // Checking that realm is not an empty string hasRealm = (realm && (strlen(realm) > 0)); table = gtk_table_new(hasRealm ? 3 : 2, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_table_set_row_spacings(GTK_TABLE(table), 6); gtk_container_add(GTK_CONTAINER(entryContainer), table); if (hasRealm) { serverMessageDescriptionLabel = gtk_label_new(_("Server message:")); serverMessageLabel = gtk_label_new(realm); gtk_misc_set_alignment(GTK_MISC(serverMessageDescriptionLabel), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(serverMessageDescriptionLabel), TRUE); gtk_misc_set_alignment(GTK_MISC(serverMessageLabel), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(serverMessageLabel), TRUE); gtk_table_attach_defaults(GTK_TABLE(table), serverMessageDescriptionLabel, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), serverMessageLabel, 1, 2, 0, 1); } authData->loginEntry = table_add_entry(table, hasRealm ? 1 : 0, _("Username:"******"Password:"******"_Remember password")); if (login && password) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE); gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0); authData->checkButton = checkButton; } g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData); gtk_widget_show_all(widget); }
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 dt_lib_presets_popup_menu_show(dt_lib_module_info_t *minfo) { GtkMenu *menu = darktable.gui->presets_popup_menu; if(menu) gtk_widget_destroy(GTK_WIDGET(menu)); darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new()); menu = darktable.gui->presets_popup_menu; GtkWidget *mi; int active_preset = -1, cnt = 0, writeprotect = 0; sqlite3_stmt *stmt; // order: get shipped defaults first DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, description from presets where operation=?1 and op_version=?2 order by writeprotect desc, rowid", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, minfo->plugin_name, strlen(minfo->plugin_name), SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, minfo->version); // collect all presets for op from db int found = 0; while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); const char *name = (char *)sqlite3_column_text(stmt, 0); if (darktable.gui->last_preset && strcmp(darktable.gui->last_preset, name)==0) found = 1; // selected in bold: // printf("comparing %d bytes to %d\n", op_params_size, minfo->params_size); // for(int k=0;k<op_params_size && !memcmp(minfo->params, op_params, k);k++) printf("compare [%c %c] %d: %d\n", // ((const char*)(minfo->params))[k], // ((const char*)(op_params))[k], // k, memcmp(minfo->params, op_params, k)); if(op_params_size == minfo->params_size && !memcmp(minfo->params, op_params, op_params_size)) { active_preset = cnt; writeprotect = sqlite3_column_int(stmt, 2); char *markup; mi = gtk_menu_item_new_with_label(""); markup = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>", name); gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup); g_free (markup); } else { mi = gtk_menu_item_new_with_label((const char *)name); } g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), minfo); g_object_set(G_OBJECT(mi), "tooltip-text", sqlite3_column_text(stmt, 3), (char *)NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); cnt ++; } sqlite3_finalize(stmt); if(cnt > 0) gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); // FIXME: this doesn't seem to work. if(active_preset >= 0) { if(!writeprotect) { mi = gtk_menu_item_new_with_label(_("edit this preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); mi = gtk_menu_item_new_with_label(_("delete this preset")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); } } else { mi = gtk_menu_item_new_with_label(_("store new preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); if (darktable.gui->last_preset && found) { char label[60]; strcpy (label, _("update preset")); strcat (label, " <span weight=\"bold\">%s</span>"); char *markup = g_markup_printf_escaped (label, darktable.gui->last_preset); mi = gtk_menu_item_new_with_label(""); gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); g_free (markup); } } }
static void _camera_import_dialog_run(_camera_import_dialog_t *data) { gtk_widget_show_all(data->dialog); // Populate store // Setup a listener for previews of all files on camera // then initiate fetch of all previews from camera if(data->params->camera != NULL) { /* setup a camctl listener */ dt_camctl_listener_t listener = { 0 }; listener.data = data; listener.control_status = _control_status; listener.camera_storage_image_filename = _camera_storage_image_filename; dt_job_t *job = dt_camera_get_previews_job_create(data->params->camera, &listener, CAMCTL_IMAGE_PREVIEW_DATA, data); if(job) { dt_control_job_set_state_callback(job, _preview_job_state_changed); dt_control_add_job(darktable.control, DT_JOB_QUEUE_SYSTEM_FG, job); } } else return; // Lets run dialog gtk_label_set_text(GTK_LABEL(data->import.info), _("select the images from the list below that you want to import into a new filmroll")); gboolean all_good = FALSE; g_signal_connect(G_OBJECT(data->dialog), "delete-event", G_CALLBACK(_dialog_close), data); while(!all_good) { gint result = gtk_dialog_run(GTK_DIALOG(data->dialog)); if(result == GTK_RESPONSE_ACCEPT) { GtkTreeIter iter; all_good = TRUE; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)))); // Now build up result from store into GList **result g_list_free(data->params->result); data->params->result = NULL; GtkTreeModel *model = GTK_TREE_MODEL(data->store); GList *sp = gtk_tree_selection_get_selected_rows(selection, &model); if(sp) { do { GValue value = { 0, }; gtk_tree_model_get_iter(GTK_TREE_MODEL(data->store), &iter, (GtkTreePath *)sp->data); gtk_tree_model_get_value(GTK_TREE_MODEL(data->store), &iter, 1, &value); if(G_VALUE_HOLDS_STRING(&value)) data->params->result = g_list_append(data->params->result, g_strdup(g_value_get_string(&value))); g_value_unset(&value); } while((sp = g_list_next(sp))); } /* get jobcode from import dialog */ data->params->jobcode = data->import.jobname->value; /* get time override if used */ data->params->time_override = 0; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))) data->params->time_override = parse_date_time(gtk_entry_get_text(GTK_ENTRY(data->settings.general.date_entry))); if(data->params->jobcode == NULL || data->params->jobcode[0] == '\0') { g_free(data->params->jobcode); // might just be a string of length 0 data->params->jobcode = dt_conf_get_string("plugins/capture/camera/import/jobcode"); } else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)) && data->params->time_override == 0) { GtkWidget *dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("please use YYYY-MM-DD format for date override")); g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog); gtk_dialog_run(GTK_DIALOG(dialog)); all_good = FALSE; } } else { data->params->result = NULL; all_good = TRUE; } } // Destroy and quit gtk_widget_destroy(data->dialog); }
static int gtkListMapMethod(Ihandle* ih) { GtkScrolledWindow* scrolled_window = NULL; GtkListStore *store; store = gtk_list_store_new(1, G_TYPE_STRING); if (ih->data->is_dropdown) { GtkCellRenderer *renderer = NULL; if (ih->data->has_editbox) ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0); else ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL); if (ih->data->has_editbox) { GtkWidget *entry; #if GTK_CHECK_VERSION(2, 12, 0) GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle)); renderer = list->data; g_list_free(list); #endif entry = gtk_bin_get_child(GTK_BIN(ih->handle)); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; } else { /* had to add an event box just to get get/killfocus,enter/leave events */ GtkWidget *box = gtk_event_box_new(); gtk_container_add((GtkContainer*)box, ih->handle); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL); g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; else GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS; } g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih); g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih); if (renderer) { renderer->xpad = 0; renderer->ypad = 0; iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); } } else { GtkCellRenderer *renderer; GtkTreeSelection* selection; GtkTreeViewColumn *column; GtkPolicyType scrollbar_policy; ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL); if (ih->data->has_editbox) { GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0); GtkWidget *entry = gtk_entry_new(); gtk_widget_show(entry); gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); gtk_widget_show((GtkWidget*)vbox); gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox); iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window); GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */ if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih); g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); } else { iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); } column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL); iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); g_object_set(G_OBJECT(renderer), "xpad", 0, NULL); g_object_set(G_OBJECT(renderer), "ypad", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE); gtk_container_add((GtkContainer*)scrolled_window, ih->handle); gtk_widget_show((GtkWidget*)scrolled_window); gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); if (ih->data->sb) { if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE"))) scrollbar_policy = GTK_POLICY_AUTOMATIC; else scrollbar_policy = GTK_POLICY_ALWAYS; } else scrollbar_policy = GTK_POLICY_NEVER; gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle)); if (!ih->data->has_editbox && ih->data->is_multiple) { gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE); #endif } else gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih); g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih); g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih); } /* add to the parent, all GTK controls must call this. */ iupgtkBaseAddToParent(ih); if (scrolled_window) gtk_widget_realize((GtkWidget*)scrolled_window); gtk_widget_realize(ih->handle); /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); iupListSetInitialItems(ih); return IUP_NOERROR; }