void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_import_t *d = (dt_lib_import_t *)g_malloc0(sizeof(dt_lib_import_t));
self->data = (void *)d;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
/* add import single image buttons */
GtkWidget *widget = gtk_button_new_with_label(_("image"));
d->import_file = GTK_BUTTON(widget);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(widget)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(widget, _("select one or more images to import"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_lib_import_single_image_callback), self);
/* adding the import folder button */
widget = gtk_button_new_with_label(_("folder"));
d->import_directory = GTK_BUTTON(widget);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(widget)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(widget, _("select a folder to import as film roll"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_lib_import_folder_callback), self);
#ifdef HAVE_GPHOTO2
/* add the rescan button */
GtkButton *scan = GTK_BUTTON(gtk_button_new_with_label(_("scan for devices")));
d->scan_devices = scan;
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(scan)), GTK_ALIGN_START);
gtk_widget_set_tooltip_text(GTK_WIDGET(scan), _("scan for newly attached devices"));
g_signal_connect(G_OBJECT(scan), "clicked", G_CALLBACK(_lib_import_scan_devices_callback), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scan), TRUE, TRUE, 0);
/* add devices container for cameras */
d->devices = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->devices), FALSE, FALSE, 0);
_lib_import_ui_devices_update(self);
/* initialize camctl listener and update devices */
d->camctl_listener.data = self;
d->camctl_listener.control_status = _camctl_camera_control_status_callback;
d->camctl_listener.camera_disconnected = _camctl_camera_disconnected_callback;
dt_camctl_register_listener(darktable.camctl, &d->camctl_listener);
dt_control_signal_connect(darktable.signals, DT_SIGNAL_CAMERA_DETECTED, G_CALLBACK(_camera_detected),
self);
#endif
#ifdef USE_LUA
/* initialize the lua area and make sure it survives its parent's destruction*/
d->extra_lua_widgets = gtk_box_new(GTK_ORIENTATION_VERTICAL,5);
g_object_ref_sink(d->extra_lua_widgets);
#endif
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_import_t *d = (dt_lib_import_t *)g_malloc(sizeof(dt_lib_import_t));
memset(d,0,sizeof(dt_lib_import_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 5);
/* add import singel image buttons */
GtkWidget *widget = gtk_button_new_with_label(_("image"));
d->import_file = GTK_BUTTON(widget);
gtk_button_set_alignment(GTK_BUTTON(widget), 0.05, 5);
gtk_widget_set_tooltip_text(widget, _("select one or more images to import"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (widget), "clicked",
G_CALLBACK (_lib_import_single_image_callback),
self);
/* adding the import folder button */
widget = gtk_button_new_with_label(_("folder"));
d->import_directory = GTK_BUTTON(widget);
gtk_button_set_alignment(GTK_BUTTON(widget), 0.05, 5);
gtk_widget_set_tooltip_text(widget,
_("select a folder to import as film roll"));
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_receives_default(widget, TRUE);
gtk_box_pack_start(GTK_BOX(self->widget), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "clicked",
G_CALLBACK (_lib_import_folder_callback),
self);
#ifdef HAVE_GPHOTO2
/* add devices container for cameras */
d->devices = GTK_BOX(gtk_vbox_new(FALSE,5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->devices), FALSE, FALSE, 0);
/* initialize camctl listener and update devices */
d->camctl_listener.data = self;
d->camctl_listener.control_status = _camctl_camera_control_status_callback;
d->camctl_listener.camera_disconnected = _camctl_camera_disconnected_callback;
dt_camctl_register_listener(darktable.camctl, &d->camctl_listener );
_lib_import_ui_devices_update(self);
#endif
}
static void gtk_sys_menu_init (GtkSysMenu *menu)
{
menu->priv = GTK_SYS_MENU_GET_PRIVATE (menu);
gtk_widget_set_can_focus (GTK_WIDGET(menu), TRUE);
gtk_widget_set_receives_default (GTK_WIDGET(menu), TRUE);
gtk_widget_set_has_window (GTK_WIDGET(menu), FALSE);
menu->priv->start = 0;
menu->priv->end = 0;
menu->priv->amount = 0;
menu->priv->hover = -1;
menu->priv->exceed = FALSE;
menu->priv->children = NULL;
menu->priv->selected = -1;
}
static void
gtk_button_init (GtkButton *button)
{
GtkButtonPrivate *priv;
button->priv = gtk_button_get_instance_private (button);
priv = button->priv;
gtk_widget_set_can_focus (GTK_WIDGET (button), TRUE);
gtk_widget_set_receives_default (GTK_WIDGET (button), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
priv->in_button = FALSE;
priv->button_down = FALSE;
priv->use_underline = FALSE;
priv->child_type = WIDGET_CHILD;
priv->gesture = gtk_gesture_multi_press_new (GTK_WIDGET (button));
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->gesture), FALSE);
gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->gesture), TRUE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->gesture), GDK_BUTTON_PRIMARY);
g_signal_connect (priv->gesture, "pressed", G_CALLBACK (multipress_pressed_cb), button);
g_signal_connect (priv->gesture, "released", G_CALLBACK (multipress_released_cb), button);
g_signal_connect (priv->gesture, "update", G_CALLBACK (multipress_gesture_update_cb), button);
g_signal_connect (priv->gesture, "cancel", G_CALLBACK (multipress_gesture_cancel_cb), button);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->gesture), GTK_PHASE_BUBBLE);
priv->gadget = gtk_css_custom_gadget_new_for_node (gtk_widget_get_css_node (GTK_WIDGET (button)),
GTK_WIDGET (button),
gtk_button_measure,
gtk_button_allocate,
gtk_button_render,
NULL,
NULL);
}
static GtkWidget*
create_new_window (GtkApplication *application,
GVariantDict *options)
{
dg_lmem gchar* command = NULL;
dg_lmem gchar* title = NULL;
gboolean opt_show_title;
gboolean opt_update_title;
gboolean opt_no_headerbar;
g_object_get (dwt_settings_get_instance (),
"show-title", &opt_show_title,
"update-title", &opt_update_title,
"no-header-bar", &opt_no_headerbar,
"command", &command,
"title", &title,
NULL);
const gchar *opt_command = command;
const gchar *opt_title = title;
const gchar *opt_workdir = NULL;
if (options) {
gboolean opt_no_auto_title = FALSE;
g_variant_dict_lookup (options, "title-on-maximize", "b", &opt_show_title);
g_variant_dict_lookup (options, "no-header-bar", "b", &opt_no_headerbar);
g_variant_dict_lookup (options, "no-auto-title", "b", &opt_no_auto_title);
g_variant_dict_lookup (options, "workdir", "&s", &opt_workdir);
g_variant_dict_lookup (options, "command", "&s", &opt_command);
g_variant_dict_lookup (options, "title", "&s", &opt_title);
if (opt_no_auto_title)
opt_update_title = FALSE;
}
if (!opt_workdir) opt_workdir = g_get_home_dir ();
if (!opt_command) opt_command = guess_shell ();
/*
* Title either comes from the default value of the "title" setting,
* or from the command line flag, but should never be NULL at this
* point.
*/
g_assert (opt_title);
dg_lerr GError *gerror = NULL;
gint command_argv_len = 0;
gchar **command_argv = NULL;
if (!g_shell_parse_argv (opt_command,
&command_argv_len,
&command_argv,
&gerror))
{
g_printerr ("%s: coult not parse command: %s\n",
__func__, gerror->message);
return NULL;
}
GtkWidget *window = gtk_application_window_new (application);
gtk_widget_set_visual (window,
gdk_screen_get_system_visual (gtk_widget_get_screen (window)));
gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (window),
FALSE);
gtk_window_set_title (GTK_WINDOW (window), opt_title);
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window),
!opt_show_title);
g_action_map_add_action_entries (G_ACTION_MAP (window), win_actions,
G_N_ELEMENTS (win_actions), window);
VteTerminal *vtterm = VTE_TERMINAL (vte_terminal_new ());
configure_term_widget (vtterm, options);
term_char_size_changed (vtterm,
vte_terminal_get_char_width (vtterm),
vte_terminal_get_char_height (vtterm),
window);
g_signal_connect (G_OBJECT (window), "notify::has-toplevel-focus",
G_CALLBACK (window_has_toplevel_focus_notified),
vtterm);
g_signal_connect (G_OBJECT (vtterm), "char-size-changed",
G_CALLBACK (term_char_size_changed), window);
g_signal_connect (G_OBJECT (vtterm), "child-exited",
G_CALLBACK (term_child_exited), window);
g_signal_connect (G_OBJECT (vtterm), "bell",
G_CALLBACK (term_beeped), window);
g_signal_connect (G_OBJECT (vtterm), "button-release-event",
G_CALLBACK (term_mouse_button_released),
setup_popover (vtterm));
/*
* Propagate title changes to the window.
*/
if (opt_update_title)
g_object_bind_property (G_OBJECT (vtterm), "window-title",
G_OBJECT (window), "title",
G_BINDING_DEFAULT);
if (!opt_no_headerbar)
setup_header_bar (window, vtterm, opt_show_title);
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (vtterm));
gtk_widget_set_receives_default (GTK_WIDGET (vtterm), TRUE);
/* We need to realize and show the window for it to have a valid XID */
gtk_widget_show_all (window);
gchar **command_env = g_get_environ ();
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_SCREEN (gtk_widget_get_screen (window))) {
GdkWindow *gdk_window = gtk_widget_get_window (window);
if (gdk_window) {
gchar window_id[NDIGITS10(unsigned long)];
snprintf (window_id,
sizeof (window_id),
"%lu",
GDK_WINDOW_XID (gdk_window));
command_env = g_environ_setenv (command_env,
"WINDOWID",
window_id,
TRUE);
} else {
g_printerr ("No window, cannot set $WINDOWID!\n");
}
}
static void
set_up (EmpathyGroupsWidget *self)
{
EmpathyGroupsWidgetPriv *priv;
GtkWidget *label, *alignment;
GtkBox *vbox, *hbox;
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
GtkScrolledWindow *scrolled_window;
gchar *markup;
priv = GET_PRIV (self);
/* Set up ourself */
gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (self), 6);
/* Create our child widgets */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
markup = g_strdup_printf ("<b>%s</b>", _("Groups"));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_box_pack_start (GTK_BOX (self), label, FALSE, FALSE, 0);
gtk_widget_show (label);
alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
label = gtk_label_new (_("Select the groups you want this contact to appear "
"in. Note that you can select more than one group or no groups."));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (vbox, label, FALSE, FALSE, 0);
gtk_widget_show (label);
hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12));
priv->add_group_entry = gtk_entry_new ();
g_signal_connect (priv->add_group_entry, "changed",
(GCallback) add_group_entry_changed_cb, self);
g_signal_connect (priv->add_group_entry, "activate",
(GCallback) add_group_entry_activate_cb, self);
gtk_box_pack_start (hbox, priv->add_group_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->add_group_entry);
priv->add_group_button = gtk_button_new_with_mnemonic (_("_Add Group"));
gtk_widget_set_sensitive (priv->add_group_button, FALSE);
gtk_widget_set_receives_default (priv->add_group_button, TRUE);
g_signal_connect (priv->add_group_button, "clicked",
(GCallback) add_group_button_clicked_cb, self);
gtk_box_pack_start (hbox, priv->add_group_button, FALSE, FALSE, 0);
gtk_widget_show (priv->add_group_button);
gtk_box_pack_start (vbox, GTK_WIDGET (hbox), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (hbox));
scrolled_window = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (scrolled_window, GTK_SHADOW_IN);
gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
priv->group_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, /* name */
G_TYPE_BOOLEAN, /* enabled */
G_TYPE_BOOLEAN); /* editable */
tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (
GTK_TREE_MODEL (priv->group_store)));
gtk_tree_view_set_headers_visible (tree_view, FALSE);
gtk_tree_view_set_enable_search (tree_view, FALSE);
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled", (GCallback) cell_toggled_cb, self);
column = gtk_tree_view_column_new_with_attributes (
C_("verb in a column header displaying group names", "Select"), renderer,
"active", COL_ENABLED,
NULL);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (column, 50);
gtk_tree_view_append_column (tree_view, column);
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (tree_view,
-1, _("Group"),
renderer,
"text", COL_NAME,
/* "editable", COL_EDITABLE, */
NULL);
column = gtk_tree_view_get_column (tree_view, col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->group_store),
COL_NAME, GTK_SORT_ASCENDING);
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
gtk_widget_show (GTK_WIDGET (tree_view));
gtk_box_pack_start (vbox, GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (scrolled_window));
gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
gtk_widget_show (GTK_WIDGET (vbox));
gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0);
gtk_widget_show (alignment);
}
static void
mosaic_search_box_init (MosaicSearchBox *box)
{
gtk_widget_set_can_focus (GTK_WIDGET (box), FALSE);
gtk_widget_set_receives_default (GTK_WIDGET (box), FALSE);
}
