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;
}
