static void
ephy_title_box_add_address_bar (EphyTitleBox *title_box)
{
title_box->entry = ephy_location_entry_new ();
gtk_widget_show (title_box->entry);
gtk_stack_add_named (GTK_STACK (title_box), title_box->entry, "address-bar");
}
static void
ekiga_window_init_dialpad (EkigaWindow *mw)
{
GtkWidget *dialpad = NULL;
GtkWidget *grid = NULL;
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 18);
gtk_container_set_border_width (GTK_CONTAINER (grid), 18);
dialpad = ekiga_dialpad_new (mw->priv->accel);
gtk_widget_set_hexpand (dialpad, FALSE);
gtk_widget_set_vexpand (dialpad, FALSE);
gtk_widget_set_halign (dialpad, GTK_ALIGN_CENTER);
gtk_widget_set_valign (dialpad, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), dialpad, 0, 0, 1, 1);
g_signal_connect (dialpad, "button-clicked",
G_CALLBACK (dialpad_button_clicked_cb), mw);
mw->priv->entry = ekiga_window_uri_entry_new (mw);
gtk_widget_set_hexpand (dialpad, TRUE);
gtk_widget_set_vexpand (dialpad, TRUE);
gtk_widget_set_halign (mw->priv->entry, GTK_ALIGN_FILL);
gtk_widget_set_valign (mw->priv->entry, GTK_ALIGN_END);
gtk_grid_attach_next_to (GTK_GRID (grid), mw->priv->entry, dialpad,
GTK_POS_BOTTOM, 1, 1);
gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), grid, "dialpad");
gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
grid,
"icon-name", "input-dialpad-symbolic", NULL);
g_signal_connect (mw, "key-press-event",
G_CALLBACK (key_press_event_cb), mw);
}
void
bjb_window_base_switch_to_item (BjbWindowBase *bwb, BijiItem *item)
{
BjbWindowBasePriv *priv = bwb->priv;
GtkWidget *w = GTK_WIDGET (bwb);
bjb_search_toolbar_disconnect (priv->search_bar);
bjb_search_toolbar_fade_out (priv->search_bar);
destroy_note_if_needed (bwb);
if (BIJI_IS_NOTE_OBJ (item))
{
BijiNoteObj *note = BIJI_NOTE_OBJ (item);
priv->note = note;
priv->note_view = bjb_note_view_new (w, note);
gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->note_view), "note-view");
g_object_add_weak_pointer (G_OBJECT (priv->note_view),
(gpointer *) &priv->note_view);
bjb_window_base_switch_to (bwb, BJB_WINDOW_BASE_NOTE_VIEW);
gtk_widget_show (w);
bjb_note_view_grab_focus (priv->note_view);
}
}
void
ev_sidebar_add_page (EvSidebar *ev_sidebar,
GtkWidget *widget,
const gchar *name,
const gchar *title,
const gchar *icon_name)
{
EvSidebarPrivate *priv;
GtkTreeIter iter;
g_return_if_fail (EV_IS_SIDEBAR (ev_sidebar));
g_return_if_fail (GTK_IS_WIDGET (widget));
priv = GET_PRIVATE (ev_sidebar);
ev_sidebar_page_set_model (EV_SIDEBAR_PAGE (widget), priv->model);
gtk_stack_add_named (GTK_STACK (priv->stack), widget, name);
gtk_container_child_set (GTK_CONTAINER (priv->stack), widget,
"icon-name", icon_name,
"title", title,
NULL);
/* Insert and move to end */
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->page_model),
&iter, 0,
PAGE_COLUMN_NAME, name,
PAGE_COLUMN_MAIN_WIDGET, widget,
PAGE_COLUMN_TITLE, title,
PAGE_COLUMN_ICON_NAME, icon_name,
-1);
gtk_list_store_move_before (GTK_LIST_STORE (priv->page_model),
&iter, NULL);
}
static void
gtk_inspector_window_init (GtkInspectorWindow *iw)
{
GIOExtensionPoint *extension_point;
GList *l, *extensions;
gtk_widget_init_template (GTK_WIDGET (iw));
gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw));
extension_point = g_io_extension_point_lookup ("gtk-inspector-page");
extensions = g_io_extension_point_get_extensions (extension_point);
for (l = extensions; l != NULL; l = l->next)
{
GIOExtension *extension = l->data;
GType type;
GtkWidget *widget;
const char *name;
char *title;
GtkWidget *button;
gboolean use_picker;
type = g_io_extension_get_type (extension);
widget = g_object_new (type, NULL);
iw->extra_pages = g_list_prepend (iw->extra_pages, widget);
name = g_io_extension_get_name (extension);
g_object_get (widget, "title", &title, NULL);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (widget), "use-picker"))
g_object_get (widget, "use-picker", &use_picker, NULL);
else
use_picker = FALSE;
if (use_picker)
{
button = gtk_button_new_from_icon_name ("find-location-symbolic",
GTK_ICON_SIZE_MENU);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_halign (button, GTK_ALIGN_START);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
g_signal_connect (button, "clicked",
G_CALLBACK (gtk_inspector_on_inspect), iw);
}
else
button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_stack_add_titled (GTK_STACK (iw->top_stack), widget, name, title);
gtk_stack_add_named (GTK_STACK (iw->button_stack), button, name);
gtk_widget_show (widget);
gtk_widget_show (button);
g_free (title);
}
}
static void
show_account_creation(RingMainWindow *win)
{
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
gtk_stack_add_named(GTK_STACK(priv->stack_main_view),
priv->account_creation_1,
CREATE_ACCOUNT_1_VIEW_NAME);
gtk_stack_add_named(GTK_STACK(priv->stack_main_view),
priv->account_creation_2,
CREATE_ACCOUNT_2_VIEW_NAME);
/* hide settings button until account creation is complete */
gtk_widget_hide(priv->ring_settings);
/* set ring logo */
GError *error = NULL;
GdkPixbuf* logo_ring = gdk_pixbuf_new_from_resource_at_scale("/cx/ring/RingGnome/ring-logo-blue",
-1, 75, TRUE, &error);
if (logo_ring == NULL) {
g_debug("Could not load logo: %s", error->message);
g_clear_error(&error);
} else
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->image_ring_logo), logo_ring);
/* style of alias and hash entry; give them a larger font */
gtk_widget_override_font(priv->entry_alias, pango_font_description_from_string("15"));
gtk_widget_override_font(priv->entry_hash, pango_font_description_from_string("monospace 15"));
gtk_entry_set_text(GTK_ENTRY(priv->entry_alias), g_get_real_name());
/* connect signals */
g_signal_connect(priv->entry_alias, "changed", G_CALLBACK(alias_entry_changed), win);
g_signal_connect(priv->button_account_creation_next, "clicked", G_CALLBACK(account_creation_next_clicked), win);
g_signal_connect(priv->button_account_creation_done, "clicked", G_CALLBACK(account_creation_done_clicked), win);
g_signal_connect(priv->entry_alias, "activate", G_CALLBACK(entry_alias_activated), win);
g_signal_connect_swapped(priv->entry_hash, "activate", G_CALLBACK(gtk_button_clicked), priv->button_account_creation_done);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CREATE_ACCOUNT_1_VIEW_NAME);
}
static void
nemo_context_menu_menu_item_init (NemoContextMenuMenuItem *item)
{
item->on_toggle = FALSE;
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *stack = gtk_stack_new ();
item->stack = stack;
GtkWidget *label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.98, 0.5);
gtk_stack_add_named (GTK_STACK (stack), label, "toggle");
item->toggle_label_widget = label;
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_stack_add_named (GTK_STACK (stack), label, "action");
item->label_widget = label;
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE, 0);
GtkWidget *toggle = gtk_image_new ();
gtk_box_pack_end (GTK_BOX (box), toggle, FALSE, FALSE, 0);
item->toggle_widget = toggle;
gtk_widget_show_all (box);
gtk_container_add (GTK_CONTAINER (item), box);
update_toggle_state (item, FALSE, FALSE);
item->settings_monitor_id = g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_CONTEXT_MENUS_SHOW_ALL_ACTIONS,
G_CALLBACK (update_toggle_state),
item);
}
static void
ekiga_window_init_contact_list (EkigaWindow *mw)
{
mw->priv->roster_view = roster_view_gtk_new (mw->priv->presence_core,
mw->priv->account_core);
gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), mw->priv->roster_view, "contacts");
gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
mw->priv->roster_view,
"icon-name", "avatar-default-symbolic", NULL);
g_object_ref (mw->priv->roster_view);
g_signal_connect (mw->priv->roster_view, "actions-changed",
G_CALLBACK (actions_changed_cb), mw);
}
static void
add_stack_page (CcBluetoothPanel *self,
const char *message,
const char *explanation,
const char *name)
{
GtkWidget *label, *image, *box;
char *str;
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_set (G_OBJECT (box), "margin-top", 64, "margin-bottom", 64, NULL);
if (g_str_equal (name, BLUETOOTH_AIRPLANE_PAGE) ||
g_str_equal (name, BLUETOOTH_HW_AIRPLANE_PAGE)) {
image = gtk_image_new_from_icon_name ("airplane-mode-symbolic",
GTK_ICON_SIZE_DIALOG);
} else {
image = gtk_image_new_from_icon_name ("bluetooth-active-symbolic",
GTK_ICON_SIZE_DIALOG);
}
gtk_image_set_pixel_size (GTK_IMAGE (image), 192);
gtk_style_context_add_class (gtk_widget_get_style_context (image), "dim-label");
gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 24);
str = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>", message);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
label = gtk_label_new (explanation);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
if (g_str_equal (name, BLUETOOTH_AIRPLANE_PAGE)) {
GtkWidget *button, *alignment;
button = gtk_button_new_with_label (_("Turn Off Airplane Mode"));
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (alignment), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (on_airplane_mode_off_clicked), self);
gtk_box_pack_start (GTK_BOX (box), alignment, FALSE, FALSE, 24);
}
gtk_stack_add_named (GTK_STACK (self->priv->stack), box, name);
gtk_widget_show_all (box);
}
static void
ekiga_window_init_history (EkigaWindow *mw)
{
boost::shared_ptr<History::Source> history_source = mw->priv->history_source.lock ();
if (history_source) {
boost::shared_ptr<History::Book> history_book = history_source->get_book ();
mw->priv->call_history_view = call_history_view_gtk_new (history_book,
mw->priv->call_core,
mw->priv->contact_core);
gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), mw->priv->call_history_view, "call-history");
gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
mw->priv->call_history_view,
"icon-name", "document-open-recent-symbolic", NULL);
g_signal_connect (mw->priv->call_history_view, "actions-changed",
G_CALLBACK (actions_changed_cb), mw);
}
}
static void
ephy_title_box_add_title_bar (EphyTitleBox *title_box)
{
GtkStyleContext *context;
GtkWidget *box;
GtkWidget *hbox;
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_valign (box, GTK_ALIGN_CENTER);
gtk_widget_show (box);
gtk_stack_add_named (GTK_STACK (title_box), box, "title-bar");
title_box->title = gtk_label_new (NULL);
gtk_widget_show (title_box->title);
context = gtk_widget_get_style_context (title_box->title);
gtk_style_context_add_class (context, "title");
gtk_label_set_line_wrap (GTK_LABEL (title_box->title), FALSE);
gtk_label_set_single_line_mode (GTK_LABEL (title_box->title), TRUE);
gtk_label_set_ellipsize (GTK_LABEL (title_box->title), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (box), title_box->title, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
context = gtk_widget_get_style_context (hbox);
gtk_style_context_add_class (context, "subtitle");
gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
gtk_widget_set_valign (hbox, GTK_ALIGN_BASELINE);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);
title_box->lock_image = gtk_image_new_from_icon_name ("channel-secure-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_valign (title_box->lock_image, GTK_ALIGN_BASELINE);
gtk_box_pack_start (GTK_BOX (hbox), title_box->lock_image, FALSE, FALSE, 0);
title_box->subtitle = gtk_label_new (NULL);
gtk_widget_set_valign (title_box->subtitle, GTK_ALIGN_BASELINE);
gtk_widget_show (title_box->subtitle);
gtk_label_set_line_wrap (GTK_LABEL (title_box->subtitle), FALSE);
gtk_label_set_single_line_mode (GTK_LABEL (title_box->subtitle), TRUE);
gtk_label_set_ellipsize (GTK_LABEL (title_box->subtitle), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (hbox), title_box->subtitle, FALSE, FALSE, 0);
}
int
main (int argc, char *argv[])
{
ClutterTimeline *timeline;
ClutterActor *stage;
GtkWidget *window, *stack, *clutter;
GtkWidget *label, *button, *vbox;
GdkPixbuf *pixbuf;
SuperOH *oh;
gint i;
GError *error;
error = NULL;
if (gtk_clutter_init_with_args (&argc, &argv,
NULL,
NULL,
NULL,
&error) != CLUTTER_INIT_SUCCESS)
{
if (error)
{
g_critical ("Unable to initialize Clutter-GTK: %s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
else
g_error ("Unable to initialize Clutter-GTK");
}
/* calling gtk_clutter_init* multiple times should be safe */
g_assert (gtk_clutter_init (NULL, NULL) == CLUTTER_INIT_SUCCESS);
pixbuf = gdk_pixbuf_new_from_file (EXAMPLES_DATADIR G_DIR_SEPARATOR_S "redhand.png", NULL);
if (!pixbuf)
g_error("pixbuf load failed");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), WINWIDTH, WINHEIGHT);
gtk_window_set_title (GTK_WINDOW (window), "Clutter Embedding");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
vbox = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (vbox), GTK_ORIENTATION_VERTICAL);
gtk_widget_set_hexpand (vbox, TRUE);
gtk_widget_set_vexpand (vbox, TRUE);
gtk_container_add (GTK_CONTAINER (window), vbox);
stack = gtk_stack_new ();
gtk_container_add (GTK_CONTAINER (vbox), stack);
label = gtk_label_new ("This is a label in a stack");
gtk_stack_add_named (GTK_STACK (stack), label, "label");
clutter = gtk_clutter_embed_new ();
gtk_stack_add_named (GTK_STACK (stack), clutter, "clutter");
gtk_widget_realize (clutter);
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter));
clutter_actor_set_background_color (stage, CLUTTER_COLOR_LightSkyBlue);
label = gtk_label_new ("This is a label");
gtk_container_add (GTK_CONTAINER (vbox), label);
gtk_widget_set_hexpand (label, TRUE);
button = gtk_button_new_with_label ("This is a button...clicky");
g_signal_connect (button, "clicked", G_CALLBACK (clickity), stack);
gtk_container_add (GTK_CONTAINER (vbox), button);
gtk_widget_set_hexpand (button, TRUE);
button = gtk_button_new_with_mnemonic ("_Fullscreen");
g_signal_connect (button, "clicked",
G_CALLBACK (on_fullscreen),
window);
gtk_container_add (GTK_CONTAINER (vbox), button);
gtk_widget_set_hexpand (button, TRUE);
button = gtk_button_new_with_mnemonic ("_Quit");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_container_add (GTK_CONTAINER (vbox), button);
gtk_widget_set_hexpand (button, TRUE);
oh = g_new (SuperOH, 1);
oh->stage = stage;
oh->group = clutter_actor_new ();
clutter_actor_set_pivot_point (oh->group, 0.5, 0.5);
for (i = 0; i < NHANDS; i++)
{
gint x, y, w, h;
/* Create a texture from pixbuf, then clone in to same resources */
if (i == 0)
{
oh->hand[i] = gtk_clutter_texture_new ();
gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE (oh->hand[i]), pixbuf, NULL);
}
else
oh->hand[i] = clutter_clone_new (oh->hand[0]);
/* Place around a circle */
w = clutter_actor_get_width (oh->hand[0]);
h = clutter_actor_get_height (oh->hand[0]);
x = WINWIDTH / 2 + RADIUS * cos (i * M_PI / (NHANDS / 2)) - w / 2;
y = WINHEIGHT / 2 + RADIUS * sin (i * M_PI / (NHANDS / 2)) - h / 2;
clutter_actor_set_position (oh->hand[i], x, y);
clutter_actor_set_pivot_point (oh->hand[i], 0.5, 0.5);
/* Add to our group group */
clutter_actor_add_child (oh->group, oh->hand[i]);
}
/* Add the group to the stage */
clutter_actor_add_child (stage, oh->group);
clutter_actor_add_constraint (oh->group, clutter_align_constraint_new (oh->stage, CLUTTER_ALIGN_BOTH, 0.5));
g_signal_connect (stage, "button-press-event",
G_CALLBACK (input_cb),
oh);
g_signal_connect (stage, "key-release-event",
G_CALLBACK (input_cb),
oh);
gtk_widget_show_all (window);
/* Create a timeline to manage animation */
timeline = clutter_timeline_new (6000);
clutter_timeline_set_repeat_count (timeline, -1);
/* fire a callback for frame change */
g_signal_connect (timeline, "new-frame", G_CALLBACK (frame_cb), oh);
/* and start it */
clutter_timeline_start (timeline);
gtk_main ();
return 0;
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t));
dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data;
dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params;
dt_pthread_mutex_init(&c->lock, NULL);
dt_pthread_mutex_lock(&c->lock);
c->auto_levels[0] = NAN;
c->auto_levels[1] = NAN;
c->auto_levels[2] = NAN;
dt_pthread_mutex_unlock(&c->lock);
c->modes = NULL;
c->mouse_x = c->mouse_y = -1.0;
c->dragging = 0;
c->activeToggleButton = NULL;
c->current_pick = NONE;
c->last_picked_color = -1;
for(int i = 0; i < 3; i++)
for(int j = 0; j < 2; j++) c->pick_xy_positions[i][j] = -1;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
c->mode = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(c->mode, NULL, _("mode"));
dt_bauhaus_combobox_add(c->mode, C_("mode", "manual"));
c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_MANUAL));
dt_bauhaus_combobox_add(c->mode, _("automatic"));
c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_AUTOMATIC));
dt_bauhaus_combobox_set_default(c->mode, LEVELS_MODE_MANUAL);
dt_bauhaus_combobox_set(c->mode, g_list_index(c->modes, GUINT_TO_POINTER(p->mode)));
gtk_box_pack_start(GTK_BOX(self->widget), c->mode, TRUE, TRUE, 0);
c->mode_stack = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(c->mode_stack),FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), c->mode_stack, TRUE, TRUE, 0);
c->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(9.0 / 16.0));
GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(c->area), TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(c->area),_("drag handles to set black, gray, and white points. "
"operates on L channel."));
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_LEAVE_NOTIFY_MASK | GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(c->area), "draw", G_CALLBACK(dt_iop_levels_area_draw), self);
g_signal_connect(G_OBJECT(c->area), "button-press-event", G_CALLBACK(dt_iop_levels_button_press), self);
g_signal_connect(G_OBJECT(c->area), "button-release-event", G_CALLBACK(dt_iop_levels_button_release), self);
g_signal_connect(G_OBJECT(c->area), "motion-notify-event", G_CALLBACK(dt_iop_levels_motion_notify), self);
g_signal_connect(G_OBJECT(c->area), "leave-notify-event", G_CALLBACK(dt_iop_levels_leave_notify), self);
g_signal_connect(G_OBJECT(c->area), "scroll-event", G_CALLBACK(dt_iop_levels_scroll), self);
GtkWidget *autobutton = gtk_button_new_with_label(_("auto"));
gtk_widget_set_tooltip_text(autobutton, _("apply auto levels"));
gtk_widget_set_size_request(autobutton, -1, DT_PIXEL_APPLY_DPI(24));
GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(blackpick, _("pick black point from image"));
GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(greypick, _("pick medium gray point from image"));
GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
gtk_widget_set_tooltip_text(whitepick, _("pick white point from image"));
GdkRGBA color = { 0 };
color.alpha = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(blackpick), &color);
color.red = color.green = color.blue = 0.5;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(greypick), &color);
color.red = color.green = color.blue = 1.0;
dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(whitepick), &color);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_manual), box, TRUE, TRUE, 0);
gtk_widget_show_all(vbox_manual);
gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_manual, "manual");
c->percentile_black = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[0], 3);
gtk_widget_set_tooltip_text(c->percentile_black, _("black percentile"));
dt_bauhaus_slider_set_format(c->percentile_black, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_black, NULL, _("black"));
c->percentile_grey = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[1], 3);
gtk_widget_set_tooltip_text(c->percentile_grey, _("gray percentile"));
dt_bauhaus_slider_set_format(c->percentile_grey, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_grey, NULL, _("gray"));
c->percentile_white = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[2], 3);
gtk_widget_set_tooltip_text(c->percentile_white, _("white percentile"));
dt_bauhaus_slider_set_format(c->percentile_white, "%.1f%%");
dt_bauhaus_widget_set_label(c->percentile_white, NULL, _("white"));
GtkWidget *vbox_automatic = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_black), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_grey), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_white), FALSE, FALSE, 0);
gtk_widget_show_all(vbox_automatic);
gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_automatic, "automatic");
switch(p->mode)
{
case LEVELS_MODE_AUTOMATIC:
gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "automatic");
break;
case LEVELS_MODE_MANUAL:
default:
gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "manual");
break;
}
g_signal_connect(G_OBJECT(c->mode), "value-changed", G_CALLBACK(dt_iop_levels_mode_callback), self);
g_signal_connect(G_OBJECT(c->percentile_black), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(c->percentile_grey), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(c->percentile_white), "value-changed",
G_CALLBACK(dt_iop_levels_percentiles_callback), self);
g_signal_connect(G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback),
(gpointer)self);
g_signal_connect(G_OBJECT(blackpick), "toggled", G_CALLBACK(dt_iop_levels_pick_black_callback), self);
g_signal_connect(G_OBJECT(greypick), "toggled", G_CALLBACK(dt_iop_levels_pick_grey_callback), self);
g_signal_connect(G_OBJECT(whitepick), "toggled", G_CALLBACK(dt_iop_levels_pick_white_callback), self);
}
static void
photos_view_container_constructed (GObject *object)
{
PhotosViewContainer *self = PHOTOS_VIEW_CONTAINER (object);
PhotosViewContainerPrivate *priv = self->priv;
AtkObject *accessible;
GAction *action;
GApplication *app;
GtkWidget *generic_view;
GtkWidget *grid;
PhotosSearchContextState *state;
gboolean status;
gint size;
G_OBJECT_CLASS (photos_view_container_parent_class)->constructed (object);
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
accessible = gtk_widget_get_accessible (GTK_WIDGET (self));
if (accessible != NULL)
atk_object_set_name (accessible, priv->name);
priv->model = photos_view_model_new (priv->mode);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gtk_stack_add_named (GTK_STACK (self), grid, "view");
priv->no_results = photos_empty_results_box_new (priv->mode);
gtk_stack_add_named (GTK_STACK (self), priv->no_results, "no-results");
priv->error_box = photos_error_box_new ();
gtk_stack_add_named (GTK_STACK (self), priv->error_box, "error");
priv->view = gd_main_view_new (GD_MAIN_VIEW_ICON);
generic_view = gd_main_view_get_generic_view (priv->view);
size = photos_utils_get_icon_size_unscaled ();
gtk_icon_view_set_item_width (GTK_ICON_VIEW (generic_view), size + 24);
gtk_container_add (GTK_CONTAINER (grid), GTK_WIDGET (priv->view));
gtk_widget_show_all (GTK_WIDGET (self));
gtk_stack_set_visible_child_full (GTK_STACK (self), "view", GTK_STACK_TRANSITION_TYPE_NONE);
g_signal_connect_swapped (priv->view, "item-activated", G_CALLBACK (photos_view_container_item_activated), self);
g_signal_connect_swapped (priv->view,
"selection-mode-request",
G_CALLBACK (photos_view_container_selection_mode_request),
self);
g_signal_connect_swapped (priv->view,
"view-selection-changed",
G_CALLBACK (photos_view_container_view_selection_changed),
self);
priv->item_mngr = g_object_ref (state->item_mngr);
priv->sel_cntrlr = photos_selection_controller_dup_singleton ();
g_signal_connect_object (priv->sel_cntrlr,
"selection-mode-changed",
G_CALLBACK (photos_view_container_selection_mode_changed),
self,
G_CONNECT_SWAPPED);
photos_view_container_selection_mode_changed (self,
photos_selection_controller_get_selection_mode (priv->sel_cntrlr));
priv->mode_cntrlr = g_object_ref (state->mode_cntrlr);
g_signal_connect_object (priv->mode_cntrlr,
"window-mode-changed",
G_CALLBACK (photos_view_container_window_mode_changed),
self,
G_CONNECT_SWAPPED);
priv->remote_mngr = photos_remote_display_manager_dup_singleton ();
switch (priv->mode)
{
case PHOTOS_WINDOW_MODE_COLLECTIONS:
priv->trk_cntrlr = photos_tracker_collections_controller_dup_singleton ();
priv->offset_cntrlr = photos_offset_collections_controller_dup_singleton ();
break;
case PHOTOS_WINDOW_MODE_FAVORITES:
priv->trk_cntrlr = photos_tracker_favorites_controller_dup_singleton ();
priv->offset_cntrlr = photos_offset_favorites_controller_dup_singleton ();
break;
case PHOTOS_WINDOW_MODE_OVERVIEW:
priv->trk_cntrlr = photos_tracker_overview_controller_dup_singleton ();
priv->offset_cntrlr = photos_offset_overview_controller_dup_singleton ();
break;
case PHOTOS_WINDOW_MODE_SEARCH:
priv->trk_cntrlr = photos_tracker_search_controller_dup_singleton ();
priv->offset_cntrlr = photos_offset_search_controller_dup_singleton ();
break;
case PHOTOS_WINDOW_MODE_NONE:
case PHOTOS_WINDOW_MODE_EDIT:
case PHOTOS_WINDOW_MODE_PREVIEW:
default:
g_assert_not_reached ();
break;
}
action = g_action_map_lookup_action (G_ACTION_MAP (app), "select-all");
g_signal_connect_object (action,
"activate",
G_CALLBACK (photos_view_container_select_all),
self,
G_CONNECT_SWAPPED);
action = g_action_map_lookup_action (G_ACTION_MAP (app), "select-none");
g_signal_connect_object (action,
"activate",
G_CALLBACK (gd_main_view_unselect_all),
priv->view,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->offset_cntrlr,
"count-changed",
G_CALLBACK (photos_view_container_count_changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->trk_cntrlr,
"query-error",
G_CALLBACK (photos_view_container_query_error),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->trk_cntrlr,
"query-status-changed",
G_CALLBACK (photos_view_container_query_status_changed),
self,
G_CONNECT_SWAPPED);
photos_tracker_controller_start (priv->trk_cntrlr);
status = photos_tracker_controller_get_query_status (priv->trk_cntrlr);
photos_view_container_query_status_changed (self, status);
}
GtkWidget *
dsn_config_new (void)
{
DsnConfigPrivate *priv;
GtkWidget *dsn;
GtkWidget *label;
GtkWidget *sw;
gchar *title;
GdaDataModel *model;
priv = g_new0 (DsnConfigPrivate, 1);
dsn = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (dsn);
gtk_container_set_border_width (GTK_CONTAINER (dsn), 6);
g_object_set_data_full (G_OBJECT (dsn), DSN_CONFIG_DATA, priv,
(GDestroyNotify) free_private_data);
/* title */
title = g_strdup_printf ("<b>%s</b>\n%s", _("Data Sources"),
_("Data sources are the means by which database "
"connections are identified: all "
"the information needed to open a connection to "
"a specific database using a 'provider' is referenced using "
"a unique name."));
priv->title = gdaui_bar_new (title);
g_free (title);
gdaui_bar_set_icon_from_resource (GDAUI_BAR (priv->title), "/images/gdaui-generic.png");
gtk_box_pack_start (GTK_BOX (dsn), priv->title, FALSE, FALSE, 0);
gtk_widget_show (priv->title);
/* horizontal box for the provider list and its properties */
GtkWidget *hbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (dsn), hbox, TRUE, TRUE, 0);
/* left part */
GtkWidget *vbox;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_size_request (vbox, 150, -1);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
/* create the data source list */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
model = gda_config_list_dsn ();
priv->dsn_list = gdaui_raw_grid_new (model);
gtk_tree_view_move_column_after (GTK_TREE_VIEW (priv->dsn_list),
gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 1),
gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 2));
g_object_unref (model);
g_object_set_data (G_OBJECT (dsn), "grid", priv->dsn_list);
gdaui_data_proxy_column_set_editable (GDAUI_DATA_PROXY (priv->dsn_list), 0, FALSE);
gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), -1, FALSE);
gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), 0, TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->dsn_list), FALSE);
g_object_set (priv->dsn_list, "info-cell-visible", FALSE, NULL);
gtk_container_add (GTK_CONTAINER (sw), priv->dsn_list);
g_signal_connect (priv->dsn_list, "selection-changed",
G_CALLBACK (list_selection_changed_cb), dsn);
g_signal_connect (priv->dsn_list, "populate-popup",
G_CALLBACK (list_popup_cb), dsn);
/* add/delete buttons */
GtkWidget *toolbar;
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_style_context_add_class (gtk_widget_get_style_context (toolbar), "inline-toolbar");
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
GtkToolItem *titem;
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-add-symbolic");
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceNew");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-remove-symbolic");
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceDelete");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
/* create the data source's properties */
GtkWidget *stack;
stack = gtk_stack_new ();
priv->stack = stack;
gtk_box_pack_start (GTK_BOX (hbox), stack, TRUE, TRUE, 10);
label = gtk_label_new (_("No data source selected."));
gtk_stack_add_named (GTK_STACK (stack), label, ST_NOPROP);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_stack_add_named (GTK_STACK (stack), vbox, ST_PROP);
GtkWidget *form;
form = gdaui_dsn_editor_new ();
priv->dsn_editor = GDAUI_DSN_EDITOR (form);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
g_signal_connect (priv->dsn_editor, "changed",
G_CALLBACK (dsn_editor_changed_cb), dsn);
/* action buttons */
GtkWidget *hbox2;
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6);
GtkWidget *bbox;
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_hexpand (bbox, TRUE);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (hbox2), bbox, FALSE, FALSE, 6);
GtkWidget *button;
button = gtk_toggle_button_new_with_label (_("Definition"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_DEFINITION] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_toggle_button_new_with_label (_("Parameters"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_PARAMS] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_toggle_button_new_with_label (_("Authentication"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
priv->commit_button = button;
gtk_widget_set_sensitive (button, FALSE);
gtk_widget_set_tooltip_text (button, _("Write changes made to the DSN"));
g_signal_connect (button, "clicked",
G_CALLBACK (save_cb), dsn);
gtk_widget_show_all (hbox);
return dsn;
}
GtkWidget *
do_sidebar (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *sidebar;
GtkWidget *stack;
GtkWidget *box;
GtkWidget *widget;
GtkWidget *header;
const gchar* pages[] = {
"Welcome to GTK+",
"GtkStackSidebar Widget",
"Automatic navigation",
"Consistent appearance",
"Scrolling",
"Page 6",
"Page 7",
"Page 8",
"Page 9",
NULL
};
const gchar *c = NULL;
guint i;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_widget_set_size_request (window, 500, 350);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW(window), header);
gtk_window_set_title (GTK_WINDOW(window), "Stack Sidebar");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
/* Separator between sidebar and stack */
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE);
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE);
for (i=0; (c = *(pages+i)) != NULL; i++ )
{
if (i == 0)
{
widget = gtk_image_new_from_icon_name ("help-about", GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (GTK_IMAGE (widget), 256);
}
else
{
widget = gtk_label_new (c);
}
gtk_stack_add_named (GTK_STACK (stack), widget, c);
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", c, NULL);
}
gtk_container_add (GTK_CONTAINER (window), box);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
void
Restore_side(GtkWidget *widget, GtkWidget *stack){
//TODO create GUI
widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
static FZ_Restore field;
// widget = gtk_label_new ("Este assistente ira ajuda-lo a\nRestaurar um Backup de um Banco de Dados.");
GtkWidget *container_label,
*container_entry,
*label_all
;
/* Label's */
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(widget), container_label);
/* File */
label_all = gtk_label_new("Arquivo: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Password */
label_all = gtk_label_new("Senha Mestre: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* New DB */
label_all = gtk_label_new("Nova Base de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* File */
field.chooser = gtk_file_chooser_button_new (_("Select a file"), GTK_FILE_CHOOSER_ACTION_OPEN);
field.filter = gtk_file_filter_new ();
gtk_file_filter_set_name (field.filter, _("SQL/Dump"));
gtk_file_filter_add_mime_type(field.filter, "application/sql");
//gtk_file_filter_add_mime_type(field.filter, "application/octet-stream");
gtk_file_filter_add_pattern (field.filter, "*.dump");
//gtk_file_filter_add_pattern (field.filter, "*.sql");
g_object_ref_sink (field.filter);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (field.chooser), FALSE);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(field.chooser), field.filter);
gtk_box_pack_start(GTK_BOX(container_entry), field.chooser, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.new_dbname=gtk_entry_new();
gtk_widget_set_tooltip_text(field.new_dbname, "Digite o nome do Novo banco de dados.");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.new_dbname), "Nome da Nova Base");
gtk_box_pack_start(GTK_BOX(container_entry), field.new_dbname, FALSE, FALSE, 0);
//TODO to continue...
gtk_stack_add_named (GTK_STACK (stack), widget, "Restaurar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Restaurar", NULL);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_exposure_gui_data_t));
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
g->modes = NULL;
g->deflicker_histogram_sources = NULL;
g->deflicker_histogram = NULL;
dt_pthread_mutex_init(&g->lock, NULL);
/* register hooks with current dev so that histogram
can interact with this module.
*/
darktable.develop->proxy.exposure.module = self;
darktable.develop->proxy.exposure.set_white = dt_iop_exposure_set_white;
darktable.develop->proxy.exposure.get_white = dt_iop_exposure_get_white;
darktable.develop->proxy.exposure.set_black = dt_iop_exposure_set_black;
darktable.develop->proxy.exposure.get_black = dt_iop_exposure_get_black;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->mode = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->mode, NULL, _("mode"));
dt_bauhaus_combobox_add(g->mode, C_("mode", "manual"));
g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_MANUAL));
dt_bauhaus_combobox_add(g->mode, _("automatic"));
g->modes = g_list_append(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_DEFLICKER));
dt_bauhaus_combobox_set_default(g->mode, 0);
dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(p->mode)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->mode), TRUE, TRUE, 0);
g->black = dt_bauhaus_slider_new_with_range(self, -0.1, 0.1, .001, p->black, 4);
g_object_set(G_OBJECT(g->black), "tooltip-text", _("adjust the black level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->black, "%.4f");
dt_bauhaus_widget_set_label(g->black, NULL, _("black"));
dt_bauhaus_slider_enable_soft_boundaries(g->black, -1.0, 1.0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->black), TRUE, TRUE, 0);
g->mode_stack = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(g->mode_stack),FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), g->mode_stack, TRUE, TRUE, 0);
GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->exposure = dt_bauhaus_slider_new_with_range(self, -3.0, 3.0, .02, p->exposure, 3);
g_object_set(G_OBJECT(g->exposure), "tooltip-text", _("adjust the exposure correction"), (char *)NULL);
dt_bauhaus_slider_set_format(g->exposure, "%.2fEV");
dt_bauhaus_widget_set_label(g->exposure, NULL, _("exposure"));
dt_bauhaus_slider_enable_soft_boundaries(g->exposure, -18.0, 18.0);
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(g->exposure), TRUE, TRUE, 0);
GtkBox *hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
g->autoexp = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto")));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexp), FALSE, TRUE, 0);
g->autoexpp = dt_bauhaus_slider_new_with_range(self, 0.0, 0.2, .001, 0.01, 3);
g_object_set(G_OBJECT(g->autoexpp), "tooltip-text", _("percentage of bright values clipped out"),
(char *)NULL);
gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->autoexpp), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_widget_show_all(vbox_manual);
gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_manual, "manual");
GtkWidget *vbox_deflicker = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE));
g->deflicker_percentile = dt_bauhaus_slider_new_with_range(self, 0, 100, .01, p->deflicker_percentile, 3);
// FIXME: this needs a better tooltip!
g_object_set(G_OBJECT(g->deflicker_percentile), "tooltip-text", _("percentile"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_percentile, "%.2f%%");
dt_bauhaus_widget_set_label(g->deflicker_percentile, NULL, _("percentile"));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_percentile), TRUE, TRUE, 0);
g->deflicker_target_level
= dt_bauhaus_slider_new_with_range(self, -18.0, 18.0, .01, p->deflicker_target_level, 3);
g_object_set(G_OBJECT(g->deflicker_target_level), "tooltip-text", _("target level"), (char *)NULL);
dt_bauhaus_slider_set_format(g->deflicker_target_level, "%.2fEV");
dt_bauhaus_widget_set_label(g->deflicker_target_level, NULL, _("target level"));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_target_level), TRUE, TRUE, 0);
g->deflicker_histogram_source = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->deflicker_histogram_source, NULL, _("histogram of"));
dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("pre-processed image"));
g->deflicker_histogram_sources
= g_list_append(g->deflicker_histogram_sources, GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL));
dt_bauhaus_combobox_add(g->deflicker_histogram_source, _("source raw data"));
g->deflicker_histogram_sources = g_list_append(g->deflicker_histogram_sources,
GUINT_TO_POINTER(DEFLICKER_HISTOGRAM_SOURCE_SOURCEFILE));
dt_bauhaus_combobox_set_default(g->deflicker_histogram_source, DEFLICKER_HISTOGRAM_SOURCE_THUMBNAIL);
dt_bauhaus_combobox_set(g->deflicker_histogram_source,
g_list_index(g->modes, GUINT_TO_POINTER(p->deflicker_histogram_source)));
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(g->deflicker_histogram_source), TRUE, TRUE, 0);
GtkBox *hbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
GtkLabel *label = GTK_LABEL(gtk_label_new(_("computed EC: ")));
gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(label), FALSE, FALSE, 0);
g->deflicker_used_EC = GTK_LABEL(gtk_label_new("")); // This gets filled in by process
g_object_set(G_OBJECT(g->deflicker_used_EC), "tooltip-text",
_("what exposure correction have actually been used"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(hbox1), GTK_WIDGET(g->deflicker_used_EC), FALSE, FALSE, 0);
dt_pthread_mutex_lock(&g->lock);
g->deflicker_computed_exposure = NAN;
dt_pthread_mutex_unlock(&g->lock);
gtk_box_pack_start(GTK_BOX(vbox_deflicker), GTK_WIDGET(hbox1), FALSE, FALSE, 0);
gtk_widget_show_all(vbox_deflicker);
gtk_stack_add_named(GTK_STACK(g->mode_stack), vbox_deflicker, "deflicker");
g_signal_connect(G_OBJECT(g->mode), "value-changed", G_CALLBACK(mode_callback), self);
g_signal_connect(G_OBJECT(g->black), "value-changed", G_CALLBACK(black_callback), self);
g_signal_connect(G_OBJECT(g->exposure), "value-changed", G_CALLBACK(exposure_callback), self);
g_signal_connect(G_OBJECT(g->autoexpp), "value-changed", G_CALLBACK(autoexpp_callback), self);
g_signal_connect(G_OBJECT(g->autoexp), "toggled", G_CALLBACK(autoexp_callback), self);
g_signal_connect(G_OBJECT(g->deflicker_percentile), "value-changed", G_CALLBACK(deflicker_params_callback),
self);
g_signal_connect(G_OBJECT(g->deflicker_target_level), "value-changed",
G_CALLBACK(deflicker_params_callback), self);
g_signal_connect(G_OBJECT(g->deflicker_histogram_source), "value-changed",
G_CALLBACK(deflicker_histogram_source_callback), self);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
}
void
Advanced_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
static FZ_Advanced field;
// widget = gtk_label_new ("Isto ira configurar as info de conexão.");
GtkWidget *container_label,
*container_entry,
*label_all,
*button_refresh,
*container_all
;
GtkAdjustment *adjustment;
/* Create an adjustment representing an adjustable bounded value */
//adjustment = gtk_adjustment_new (5432, 0, G_MAXDOUBLE, 1, 0, 0);
adjustment = gtk_adjustment_new (5432, 0, 100000, 1, 0, 0);
container_all = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_all);
//
// Label's
//
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(container_all), container_label);
/* Host Server IP */
label_all = gtk_label_new("IP: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server Port */
label_all = gtk_label_new("Porta: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server User */
label_all = gtk_label_new("Usuario: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Host Server PassWord */
label_all = gtk_label_new("Senha: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
//
// Entry's
//
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(container_all), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* Host Server IP */
field.Host = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.Host, "IP do Servidor do banco de dados...\nEX:localhost");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Host), "EX: localhost");
gtk_box_pack_start(GTK_BOX(container_entry), field.Host, FALSE, FALSE, 0);
/* Host Server Porta */
//field.Port = gtk_entry_new ();
field.Port = gtk_spin_button_new (adjustment, 1, 0);
gtk_widget_set_tooltip_text(field.Port, "Porta do Servidor do banco de dados...\nEX: 5432");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Port), "EX: 5432");
gtk_box_pack_start(GTK_BOX(container_entry), field.Port, FALSE, FALSE, 0);
/* Host Server User */
field.Login = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.Login, "Usuario do banco de dados...");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.Login), "Usuario");
gtk_box_pack_start(GTK_BOX(container_entry), field.Login, FALSE, FALSE, 0);
/* Host Server PassWord */
field.PassWord = gtk_entry_new ();
gtk_widget_set_tooltip_text(field.PassWord, "Senha do Usuario do banco de dados...");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.PassWord), "Senha");
gtk_entry_set_visibility(GTK_ENTRY(field.PassWord), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.PassWord, FALSE, FALSE, 0);
/* Buttons */
//container_button_all = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
//gtk_container_add(GTK_CONTAINER(container_all), container_button_all);
field.button_load = gtk_button_new_with_label("Ler");
gtk_box_pack_start(GTK_BOX(widget), field.button_load, FALSE, FALSE, 0);
field.button_save = gtk_button_new_with_label("Salvar");
gtk_box_pack_start(GTK_BOX(widget), field.button_save, FALSE, FALSE, 0);
gtk_stack_add_named (GTK_STACK (stack), widget, "Avançado");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Avançado", NULL);
/* Sinais */
g_signal_connect (GTK_BUTTON (field.button_load),
"clicked",
G_CALLBACK (button_load_conf_clicked),
(gpointer) &field);
g_signal_connect (GTK_BUTTON (field.button_save),
"clicked",
G_CALLBACK (button_save_conf_clicked),
(gpointer) &field);
}
static void
gtk_shortcuts_window_init (GtkShortcutsWindow *self)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkToggleButton *search_button;
GtkBox *menu_box;
GtkBox *box;
GtkArrow *arrow;
GtkWidget *scroller;
GtkWidget *label;
GtkWidget *empty;
PangoAttrList *attributes;
gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (self), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect (self, "key-press-event",
G_CALLBACK (window_key_press_event_cb), NULL);
priv->keywords = g_hash_table_new_full (NULL, NULL, NULL, g_free);
priv->search_items_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->search_text_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->search_image_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->header_bar = g_object_new (GTK_TYPE_HEADER_BAR,
"show-close-button", TRUE,
"visible", TRUE,
NULL);
gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->header_bar));
search_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON,
"child", g_object_new (GTK_TYPE_IMAGE,
"visible", TRUE,
"icon-name", "edit-find-symbolic",
NULL),
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->header_bar), GTK_WIDGET (search_button));
priv->main_box = g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
GTK_CONTAINER_CLASS (gtk_shortcuts_window_parent_class)->add (GTK_CONTAINER (self), GTK_WIDGET (priv->main_box));
priv->search_bar = g_object_new (GTK_TYPE_SEARCH_BAR,
"visible", TRUE,
NULL);
g_object_bind_property (priv->search_bar, "search-mode-enabled",
search_button, "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->search_bar));
priv->stack = g_object_new (GTK_TYPE_STACK,
"expand", TRUE,
"homogeneous", TRUE,
"transition-type", GTK_STACK_TRANSITION_TYPE_CROSSFADE,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->stack));
priv->title_stack = g_object_new (GTK_TYPE_STACK,
"visible", TRUE,
NULL);
gtk_header_bar_set_custom_title (priv->header_bar, GTK_WIDGET (priv->title_stack));
label = gtk_label_new (_("Shortcuts"));
gtk_widget_show (label);
gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE);
gtk_stack_add_named (priv->title_stack, label, "title");
label = gtk_label_new (_("Search Results"));
gtk_widget_show (label);
gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE);
gtk_stack_add_named (priv->title_stack, label, "search");
priv->menu_button = g_object_new (GTK_TYPE_MENU_BUTTON,
"focus-on-click", FALSE,
"visible", TRUE,
"relief", GTK_RELIEF_NONE,
NULL);
gtk_stack_add_named (priv->title_stack, GTK_WIDGET (priv->menu_button), "sections");
menu_box = g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_HORIZONTAL,
"spacing", 6,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->menu_button), GTK_WIDGET (menu_box));
priv->menu_label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (priv->menu_label));
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
arrow = g_object_new (GTK_TYPE_ARROW,
"arrow-type", GTK_ARROW_DOWN,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (arrow));
G_GNUC_END_IGNORE_DEPRECATIONS;
priv->popover = g_object_new (GTK_TYPE_POPOVER,
"border-width", 6,
"relative-to", priv->menu_button,
"position", GTK_POS_BOTTOM,
NULL);
gtk_menu_button_set_popover (priv->menu_button, GTK_WIDGET (priv->popover));
priv->list_box = g_object_new (GTK_TYPE_LIST_BOX,
"selection-mode", GTK_SELECTION_NONE,
"visible", TRUE,
NULL);
g_signal_connect_object (priv->list_box,
"row-activated",
G_CALLBACK (gtk_shortcuts_window__list_box__row_activated),
self,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (priv->popover), GTK_WIDGET (priv->list_box));
priv->search_entry = GTK_SEARCH_ENTRY (gtk_search_entry_new ());
gtk_widget_show (GTK_WIDGET (priv->search_entry));
gtk_container_add (GTK_CONTAINER (priv->search_bar), GTK_WIDGET (priv->search_entry));
g_object_set (priv->search_entry,
"placeholder-text", _("Search Shortcuts"),
"width-chars", 40,
NULL);
g_signal_connect_object (priv->search_entry,
"search-changed",
G_CALLBACK (gtk_shortcuts_window__entry__changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->search_bar,
"notify::search-mode-enabled",
G_CALLBACK (gtk_shortcuts_window__search_mode__changed),
self,
G_CONNECT_SWAPPED);
scroller = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"visible", TRUE,
NULL);
box = g_object_new (GTK_TYPE_BOX,
"border-width", 24,
"halign", GTK_ALIGN_CENTER,
"spacing", 24,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (box));
gtk_stack_add_named (priv->stack, scroller, "internal-search");
priv->search_shortcuts = g_object_new (GTK_TYPE_BOX,
"halign", GTK_ALIGN_CENTER,
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_shortcuts));
priv->search_gestures = g_object_new (GTK_TYPE_BOX,
"halign", GTK_ALIGN_CENTER,
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_gestures));
empty = g_object_new (GTK_TYPE_GRID,
"visible", TRUE,
"row-spacing", 12,
"margin", 12,
"hexpand", TRUE,
"vexpand", TRUE,
"halign", GTK_ALIGN_CENTER,
"valign", GTK_ALIGN_CENTER,
NULL);
gtk_style_context_add_class (gtk_widget_get_style_context (empty), GTK_STYLE_CLASS_DIM_LABEL);
gtk_grid_attach (GTK_GRID (empty),
g_object_new (GTK_TYPE_IMAGE,
"visible", TRUE,
"icon-name", "edit-find-symbolic",
"pixel-size", 72,
NULL),
0, 0, 1, 1);
attributes = pango_attr_list_new ();
pango_attr_list_insert (attributes, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attributes, pango_attr_scale_new (1.44));
label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", _("No Results Found"),
"attributes", attributes,
NULL);
pango_attr_list_unref (attributes);
gtk_grid_attach (GTK_GRID (empty), label, 0, 1, 1, 1);
label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", _("Try a different search"),
NULL);
gtk_grid_attach (GTK_GRID (empty), label, 0, 2, 1, 1);
gtk_stack_add_named (priv->stack, empty, "no-search-results");
g_signal_connect_object (priv->stack, "notify::visible-child",
G_CALLBACK (update_title_stack), self, G_CONNECT_SWAPPED);
}
void
Welcome_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_label_new ("Este assistente ira ajuda-lo a Gerenciar um Banco de Dados Mais Rapido e melhor.");
gtk_stack_add_named (GTK_STACK (stack), widget, "Bem-vindos");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Bem-vindos", NULL);
}
void
Create_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
//widget = gtk_label_new ("Este assistente ira ajuda-lo a Criar um Banco de Dados.");
static FZ_Create field;// caso não for static da pau
GtkWidget *container_all,
*container_label,
*container_entry,
*label_all
;
// Container all
container_all = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_all);
// Label's
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(container_all), container_label);
/* nome do DB */
label_all = gtk_label_new ("Novo Banco de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Code Builder or password SuperUser */
label_all = gtk_label_new ("Senha Master: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* ROOT Password */
label_all = gtk_label_new ("Senha do Administrador: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
label_all = gtk_label_new ("Confirme a Senha do Administrador: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(container_all), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* nome do DB */
field.entry_db=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_db, "Digite o Novo Nome do Banco de Dados.");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_db), "Banco de Dados");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_db, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* ROOT Password */
field.rootpwd = gtk_entry_new();
gtk_widget_set_tooltip_text(field.rootpwd, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin).");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd), "Senha do Administrador");
gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd, FALSE, FALSE, 0);
/* ROOT Password Reply */
field.rootpwd_reply = gtk_entry_new();
gtk_widget_set_tooltip_text(field.rootpwd_reply, "Digite a senha de Adimistrador do Novo Banco de Dados (login:admin).");
gtk_entry_set_placeholder_text(GTK_ENTRY(field.rootpwd_reply), "Confirme a Senha");
gtk_entry_set_visibility(GTK_ENTRY(field.rootpwd_reply), FALSE);
gtk_box_pack_start(GTK_BOX(container_entry), field.rootpwd_reply, FALSE, FALSE, 0);
/* Demo info preload */
field.demo = gtk_check_button_new_with_label("Demostração?");
gtk_widget_set_halign(field.demo, GTK_ALIGN_CENTER);
gtk_widget_set_tooltip_text(field.demo, "Se na criação as informações de Demostração serão instaladas.");
gtk_container_add(GTK_CONTAINER(widget), field.demo);
/* Botão de Criar */
field.button = gtk_button_new_with_label ("Criar");
gtk_widget_set_tooltip_text(field.button, "Sera ativado quando as Informações estiverem corretas.");
gtk_widget_set_sensitive (field.button, FALSE);// disable button
g_signal_connect (GTK_BUTTON (field.button),
"clicked",
G_CALLBACK (button_create_clicked),
(gpointer) &field);
gtk_container_add( GTK_CONTAINER(widget) ,field.button );
gtk_stack_add_named (GTK_STACK (stack), widget, "Criar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Criar", NULL);
/* Validate Focus */
g_signal_connect (GTK_ENTRY (field.entry_db),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.entry_pwd),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.rootpwd),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
g_signal_connect (GTK_ENTRY (field.rootpwd_reply),
"focus-out-event",
G_CALLBACK (validate_create_focus),
(gpointer) &field);
}
/* Gobj */
static void
bjb_window_base_constructed (GObject *obj)
{
BjbWindowBase *self = BJB_WINDOW_BASE (obj);
BjbWindowBasePriv *priv;
gboolean maximized;
const gint32 *position;
const gint32 *size;
gsize n_elements;
GVariant *variant;
G_OBJECT_CLASS (bjb_window_base_parent_class)->constructed (obj);
priv = self->priv;
priv->settings = bjb_app_get_settings ((gpointer) g_application_get_default ());
gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (self), _(BIJIBEN_MAIN_WIN_TITLE));
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-size");
size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]);
g_variant_unref (variant);
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-position");
position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_move (GTK_WINDOW (self), position[0], position[1]);
g_variant_unref (variant);
maximized = g_settings_get_boolean (G_SETTINGS (priv->settings), "window-maximized");
if (maximized)
gtk_window_maximize (GTK_WINDOW (self));
/* We probably want to offer a no entry window at first (startup) */
priv->entry = NULL ;
priv->controller = bjb_controller_new
(bijiben_get_manager (BIJIBEN_APPLICATION(g_application_get_default())),
GTK_WINDOW (obj),
priv->entry );
/* Shared toolbar */
priv->view = bjb_main_view_new (GTK_WIDGET (obj), priv->controller);
priv->main_toolbar = bjb_main_toolbar_new (priv->view, priv->controller);
gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->main_toolbar));
/* Search entry toolbar */
priv->search_bar = bjb_search_toolbar_new (GTK_WIDGET (obj), priv->controller);
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->search_bar), FALSE, FALSE, 0);
/* UI : stack for different views */
priv->stack = GTK_STACK (gtk_stack_new ());
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->stack), TRUE, TRUE, 0);
priv->spinner = gtk_spinner_new ();
gtk_stack_add_named (priv->stack, priv->spinner, "spinner");
gtk_stack_set_visible_child_name (priv->stack, "spinner");
gtk_widget_show (priv->spinner);
gtk_spinner_start (GTK_SPINNER (priv->spinner));
priv->no_note = bjb_empty_results_box_new ();
gtk_stack_add_named (priv->stack, priv->no_note, "empty");
gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->view), "main-view");
gtk_widget_show (GTK_WIDGET (priv->stack));
/* Connection to window signals */
g_signal_connect (GTK_WIDGET (self),
"destroy",
G_CALLBACK (bjb_window_base_destroy),
self);
g_signal_connect (self,
"window-state-event",
G_CALLBACK (bjb_application_window_state_changed),
priv->settings);
g_signal_connect (self,
"configure-event",
G_CALLBACK (bjb_application_window_configured),
self);
/* Keys */
g_signal_connect (GTK_WIDGET (self),
"key-press-event",
G_CALLBACK(on_key_pressed_cb),
self);
/* If a note is requested at creation, show it
* This is a specific type of window not associated with any view */
if (priv->note == NULL)
{
bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW);
}
else
{
priv->detached = TRUE;
bjb_window_base_switch_to_item (self, BIJI_ITEM (priv->note));
}
/* For some reason, do not gtk_widget_show _self_
* or gtk_application_get_menu_bar will run,
* fire a warning, while app menu will not show up
* you have been warned!
*
* This is probably due to the fact that,
* at startup, we still are
* inside... drums... gapplication startup () */
gtk_widget_show (priv->vbox);
}
void
Delete_side(GtkWidget *widget, GtkWidget *stack){
widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
static FZ_Delete field;
// widget = gtk_label_new ("Este assistente ira ajuda-lo a\nDeletar um Banco de Dados.");
GtkWidget *container_label,
*container_entry,
*label_all,
*button_refresh
;
/* Label's */
container_label = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_halign(container_label, GTK_ALIGN_END);
gtk_container_add(GTK_CONTAINER(widget), container_label);
/* Banco de Dados */
label_all = gtk_label_new("Banco de Dados: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Senha Mestre */
label_all = gtk_label_new("Senha Master: ");
gtk_widget_set_halign(label_all, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(container_label), label_all, FALSE, FALSE, 5);
/* Button Refresh */
button_refresh = gtk_button_new_with_label("Atualizar");
gtk_box_pack_start(GTK_BOX(container_label), button_refresh, FALSE, FALSE, 0);
// Entry's
container_entry = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(widget), container_entry);
gtk_widget_set_hexpand(container_entry, TRUE);
/* Banco de Dados */
field.combo_db = gtk_combo_box_text_new ();
gtk_widget_set_tooltip_text(field.combo_db, "Banco de Dados.");
gtk_box_pack_start(GTK_BOX(container_entry), field.combo_db, FALSE, FALSE, 0);
/* Code Builder or password SuperUser */
field.entry_pwd=gtk_entry_new();
gtk_widget_set_tooltip_text(field.entry_pwd, "Digite a senha de Super Usuario.");
gtk_entry_set_visibility(GTK_ENTRY(field.entry_pwd), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(field.entry_pwd), "Senha Mestre");
gtk_box_pack_start(GTK_BOX(container_entry), field.entry_pwd, FALSE, FALSE, 0);
/* Button Refresh */
field.button = gtk_button_new_with_label("Deletar");
gtk_box_pack_start(GTK_BOX(container_entry), field.button, FALSE, FALSE, 0);
gtk_stack_add_named (GTK_STACK (stack), widget, "Deletar");
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", "Deletar", NULL);
//TODO Criar os sinais refresh e delete.
g_signal_connect (GTK_BUTTON (button_refresh),
"clicked",
G_CALLBACK (button_refresh_delete_clicked),
(gpointer) &field);
}
static void
cc_bluetooth_panel_init (CcBluetoothPanel *self)
{
GError *error = NULL;
self->priv = BLUETOOTH_PANEL_PRIVATE (self);
g_resources_register (cc_bluetooth_get_resource ());
self->priv->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (self->priv->builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (self->priv->builder,
"/org/gnome/control-center/bluetooth/bluetooth.ui",
&error);
if (error != NULL) {
g_warning ("Could not load ui: %s", error->message);
g_error_free (error);
return;
}
self->priv->cancellable = g_cancellable_new ();
/* RFKill */
self->priv->rfkill = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.gnome.SettingsDaemon.Rfkill",
"/org/gnome/SettingsDaemon/Rfkill",
"org.gnome.SettingsDaemon.Rfkill",
NULL, NULL);
self->priv->properties = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.gnome.SettingsDaemon.Rfkill",
"/org/gnome/SettingsDaemon/Rfkill",
"org.freedesktop.DBus.Properties",
NULL, NULL);
self->priv->stack = gtk_stack_new ();
gtk_stack_set_homogeneous (GTK_STACK (self->priv->stack), TRUE);
add_stack_page (self, _("No Bluetooth Found"), _("Plug in a dongle to use Bluetooth."), BLUETOOTH_NO_DEVICES_PAGE);
add_stack_page (self, _("Bluetooth Turned Off"), _("Turn on to connect devices and receive file transfers."), BLUETOOTH_DISABLED_PAGE);
add_stack_page (self, _("Airplane Mode is on"), _("Bluetooth is disabled when airplane mode is on."), BLUETOOTH_AIRPLANE_PAGE);
add_stack_page (self, _("Hardware Airplane Mode is on"), _("Turn off the Airplane mode switch to enable Bluetooth."), BLUETOOTH_HW_AIRPLANE_PAGE);
self->priv->widget = bluetooth_settings_widget_new ();
g_signal_connect (G_OBJECT (self->priv->widget), "panel-changed",
G_CALLBACK (panel_changed), self);
gtk_stack_add_named (GTK_STACK (self->priv->stack),
self->priv->widget, BLUETOOTH_WORKING_PAGE);
gtk_widget_show (self->priv->widget);
gtk_widget_show (self->priv->stack);
gtk_container_add (GTK_CONTAINER (self), self->priv->stack);
airplane_mode_changed (NULL, NULL, NULL, self);
g_signal_connect (self->priv->rfkill, "g-properties-changed",
G_CALLBACK (airplane_mode_changed), self);
g_signal_connect_swapped (G_OBJECT (self->priv->widget), "adapter-status-changed",
G_CALLBACK (cc_bluetooth_panel_update_power), self);
g_signal_connect (G_OBJECT (WID ("switch_bluetooth")), "notify::active",
G_CALLBACK (power_callback), self);
}
static void
gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *exp;
gchar *str;
g_return_if_fail (GDAUI_IS_DSN_EDITOR (config));
gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL);
/* allocate private structure */
config->priv = g_new0 (GdauiDsnEditorPrivate, 1);
config->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
config->priv->no_change_signal = TRUE;
/* data source's name and icon */
GtkWidget *hbox_header;
hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6);
config->priv->icon = gtk_image_new ();
gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE);
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0);
config->priv->wname = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10);
GtkWidget *menu_button;
menu_button = gtk_menu_button_new ();
gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0);
GtkWidget *menu_icon;
menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon);
GMenu *smenu;
smenu = g_menu_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu));
GMenuItem *mitem;
mitem = g_menu_item_new ("Test data source", "win.DSNTest");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy");
g_menu_insert_item (smenu, -1, mitem);
GtkWindow *win;
win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config);
/* stack in a scrolled window */
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6);
/* Stack */
config->priv->stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_container_add (GTK_CONTAINER (sw), config->priv->stack);
/* set up widgets */
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_widget_show (grid);
label = gtk_label_new_with_mnemonic (_("_System wide data source:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
config->priv->is_system = gtk_check_button_new ();
gtk_widget_show (config->priv->is_system);
g_signal_connect (G_OBJECT (config->priv->is_system), "toggled",
G_CALLBACK (field_toggled_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1);
str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:"));
label = gtk_label_new ("");
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
config->priv->wprovider = gdaui_provider_selector_new ();
gtk_widget_set_hexpand (config->priv->wprovider, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider);
gtk_widget_show (config->priv->wprovider);
g_signal_connect (G_OBJECT (config->priv->wprovider), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1);
label = gtk_label_new_with_mnemonic (_("_Description:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
config->priv->wdesc = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc);
gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE);
gtk_widget_set_vexpand (config->priv->wdesc, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc);
g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1);
config->priv->warning = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (config->priv->warning),
_("<span foreground='red'>The database provider used by this data source is not available,\n"
"editing the data source's attributes is disabled</span>"));
gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (config->priv->warning, TRUE);
g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL);
gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE);
gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1);
gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION);
/* connection's spec */
config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_spec);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS);
/* connection's authentication */
config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_auth);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH);
config->priv->no_change_signal = FALSE;
}
static void
ring_main_window_init(RingMainWindow *win)
{
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
gtk_widget_init_template(GTK_WIDGET(win));
/* set window icon */
GError *error = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/cx/ring/RingGnome/ring-symbol-blue", &error);
if (icon == NULL) {
g_debug("Could not load icon: %s", error->message);
g_clear_error(&error);
} else
gtk_window_set_icon(GTK_WINDOW(win), icon);
/* set menu icon */
GdkPixbuf* image_ring = gdk_pixbuf_new_from_resource_at_scale("/cx/ring/RingGnome/ring-symbol-blue",
-1, 24, TRUE, &error);
if (image_ring == NULL) {
g_debug("Could not load icon: %s", error->message);
g_clear_error(&error);
} else
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->image_ring), image_ring);
/* ring menu */
GtkBuilder *builder = gtk_builder_new_from_resource("/cx/ring/RingGnome/ringgearsmenu.ui");
GMenuModel *menu = G_MENU_MODEL(gtk_builder_get_object(builder, "menu"));
gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(priv->ring_menu), menu);
g_object_unref(builder);
/* settings icon */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-system-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
/* connect settings button signal */
g_signal_connect(priv->ring_settings, "clicked", G_CALLBACK(settings_clicked), win);
/* add the call view to the main stack */
gtk_stack_add_named(GTK_STACK(priv->stack_main_view),
priv->vbox_call_view,
CALL_VIEW_NAME);
if (has_ring_account()) {
/* user has ring account, so show the call view right away */
gtk_stack_set_visible_child(GTK_STACK(priv->stack_main_view), priv->vbox_call_view);
} else {
/* user has to create the ring account */
show_account_creation(win);
}
/* init the settings views */
priv->account_settings_view = account_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->account_settings_view, ACCOUNT_SETTINGS_VIEW_NAME);
priv->media_settings_view = media_settings_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->media_settings_view, MEDIA_SETTINGS_VIEW_NAME);
priv->general_settings_view = general_settings_view_new();
gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->general_settings_view, GENERAL_SETTINGS_VIEW_NAME);
/* make the setting we will show first the active one */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->radiobutton_general_settings), TRUE);
priv->last_settings_view = priv->general_settings_view;
/* connect the settings button signals to switch settings views */
g_signal_connect(priv->radiobutton_media_settings, "toggled", G_CALLBACK(show_media_settings), win);
g_signal_connect(priv->radiobutton_account_settings, "toggled", G_CALLBACK(show_account_settings), win);
g_signal_connect(priv->radiobutton_general_settings, "toggled", G_CALLBACK(show_general_settings), win);
/* populate the notebook */
auto smart_view = recent_contacts_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_smartview), smart_view);
auto contacts_view = contacts_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_contacts), contacts_view);
auto history_view = history_view_new();
gtk_container_add(GTK_CONTAINER(priv->scrolled_window_history), history_view);
/* welcome/default view */
priv->welcome_view = ring_welcome_view_new();
g_object_ref(priv->welcome_view);
// gtk_stack_add_named(GTK_STACK(priv->stack_call_view), welcome_view, DEFAULT_VIEW_NAME);
gtk_container_add(GTK_CONTAINER(priv->frame_call), priv->welcome_view);
gtk_widget_show(priv->welcome_view);
/* call/chat selection */
QObject::connect(
RecentModel::instance().selectionModel(),
&QItemSelectionModel::currentChanged,
[win](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) {
if (auto call = RecentModel::instance().getActiveCall(current)) {
/* if the call is on hold, we want to put it off hold automatically
* when switching to it */
if (call->state() == Call::State::HOLD)
call << Call::Action::HOLD;
}
selection_changed(current, win);
}
);
/* connect to dataChanged of the RecentModel to see if we need to change the view */
QObject::connect(
&RecentModel::instance(),
&RecentModel::dataChanged,
[win](const QModelIndex & topLeft, G_GNUC_UNUSED const QModelIndex & bottomRight, G_GNUC_UNUSED const QVector<int> & roles) {
/* it is possible for dataChanged to be emitted inside of a dataChanged handler or
* some other signal; since the connection is via a lambda, Qt would cause the
* handler to be called directly. This is not behaviour we usually want, so we call our
* function via g_idle so that it gets called after the initial handler is done.
*/
if (topLeft == RecentModel::instance().selectionModel()->currentIndex())
g_idle_add((GSourceFunc)selected_item_changed, win);
}
);
g_signal_connect(priv->button_placecall, "clicked", G_CALLBACK(search_entry_placecall), win);
g_signal_connect(priv->search_entry, "activate", G_CALLBACK(search_entry_placecall), win);
/* autocompletion */
priv->q_completion_model = new NumberCompletionModel();
/* autocompletion renderers */
GtkCellArea *completion_area = gtk_cell_area_box_new();
/* photo renderer */
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_photo_render,
NULL, NULL);
/* name renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_name_render,
NULL, NULL);
/* number renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_number_render,
NULL, NULL);
/* account renderer */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area),
renderer,
TRUE, /* expand */
TRUE, /* align */
TRUE); /* fixed size */
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area),
renderer,
(GtkCellLayoutDataFunc)autocompletion_account_render,
NULL, NULL);
GtkEntryCompletion *entry_completion = gtk_entry_completion_new_with_area(completion_area);
GtkQTreeModel *completion_model = gtk_q_tree_model_new(
(QAbstractItemModel *)priv->q_completion_model,
1,
Qt::DisplayRole, G_TYPE_STRING);
gtk_entry_completion_set_model(entry_completion, GTK_TREE_MODEL(completion_model));
gtk_entry_set_completion(GTK_ENTRY(priv->search_entry), entry_completion);
gtk_entry_completion_set_match_func(
entry_completion,
(GtkEntryCompletionMatchFunc) completion_match_func,
NULL,
NULL);
/* connect signal to when text is entered in the entry */
g_signal_connect(priv->search_entry, "changed", G_CALLBACK(search_entry_text_changed), win);
g_signal_connect(entry_completion, "match-selected", G_CALLBACK(select_autocompletion), win);
/* connect to incoming call and focus */
QObject::connect(
&CallModel::instance(),
&CallModel::incomingCall,
[=](Call* call) {
CallModel::instance().selectionModel()->setCurrentIndex(
CallModel::instance().getIndex(call), QItemSelectionModel::ClearAndSelect);
}
);
/* react to digit key press events */
g_signal_connect(win, "key-press-event", G_CALLBACK(dtmf_pressed), NULL);
/* set the search entry placeholder text */
gtk_entry_set_placeholder_text(GTK_ENTRY(priv->search_entry),
C_("Please try to make the translation 50 chars or less so that it fits into the layout", "Search contacts or enter number"));
}
static void
nemo_toolbar_constructed (GObject *obj)
{
NemoToolbar *self = NEMO_TOOLBAR (obj);
GtkWidget *toolbar;
GtkWidget *hbox;
GtkToolItem *tool_box;
GtkWidget *box;
GtkStyleContext *context;
G_OBJECT_CLASS (nemo_toolbar_parent_class)->constructed (obj);
gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)),
GTK_JUNCTION_BOTTOM);
self->priv->show_location_entry = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_LOCATION_ENTRY);
/* add the UI */
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0);
toolbar = gtk_toolbar_new ();
self->priv->toolbar = toolbar;
gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0);
context = gtk_widget_get_style_context (GTK_WIDGET(toolbar));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
/* Back/Forward/Up */
self->priv->navigation_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->previous_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_BACK);
gtk_container_add (GTK_CONTAINER (box), self->priv->previous_button);
self->priv->next_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_FORWARD);
gtk_container_add (GTK_CONTAINER (box), self->priv->next_button);
self->priv->up_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_UP);
gtk_container_add (GTK_CONTAINER (box), self->priv->up_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->navigation_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->navigation_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->navigation_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->navigation_box), 6);
/* Refresh */
self->priv->refresh_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->refresh_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_RELOAD);
gtk_container_add (GTK_CONTAINER (box), self->priv->refresh_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_container_add (GTK_CONTAINER (self->priv->refresh_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->refresh_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->refresh_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->refresh_box), 6);
/* Home/Computer */
self->priv->location_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->home_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_HOME);
gtk_container_add (GTK_CONTAINER (box), self->priv->home_button);
self->priv->computer_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_COMPUTER);
gtk_container_add (GTK_CONTAINER (box), self->priv->computer_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->location_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->location_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->location_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->location_box), 6);
/* Container to hold the location and pathbars */
self->priv->stack = gtk_stack_new();
gtk_stack_set_transition_type (GTK_STACK (self->priv->stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_stack_set_transition_duration (GTK_STACK (self->priv->stack), 150);
/* Regular Path Bar */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->stack), TRUE, TRUE, 0);
self->priv->path_bar = g_object_new (NEMO_TYPE_PATH_BAR, NULL);
gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->path_bar), "path_bar");
/* Entry-Like Location Bar */
self->priv->location_bar = nemo_location_bar_new ();
gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->location_bar), "location_bar");
gtk_widget_show_all (hbox);
tool_box = gtk_tool_item_new ();
gtk_tool_item_set_expand (tool_box, TRUE);
gtk_container_add (GTK_CONTAINER (tool_box), hbox);
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (tool_box));
gtk_widget_show (GTK_WIDGET (tool_box));
/* Search/Open in Terminal/New Folder/Toggle Location */
self->priv->tools_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->toggle_location_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_TOGGLE_LOCATION);
gtk_container_add (GTK_CONTAINER (box), self->priv->toggle_location_button);
self->priv->open_terminal_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_OPEN_IN_TERMINAL);
gtk_container_add (GTK_CONTAINER (box), self->priv->open_terminal_button);
self->priv->new_folder_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_NEW_FOLDER);
gtk_container_add (GTK_CONTAINER (box), self->priv->new_folder_button);
self->priv->search_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_SEARCH);
gtk_container_add (GTK_CONTAINER (box), self->priv->search_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->tools_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->tools_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->tools_box));
gtk_widget_set_margin_left (GTK_WIDGET (self->priv->tools_box), 6);
setup_root_info_bar (self);
/* View Select */
self->priv->view_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->icon_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_ICON_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->icon_view_button);
self->priv->list_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_LIST_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->list_view_button);
self->priv->compact_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_COMPACT_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->compact_view_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->view_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->view_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->view_box));
gtk_widget_set_margin_left (GTK_WIDGET (self->priv->view_box), 6);
/* nemo patch */
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_PREVIOUS_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_NEXT_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_UP_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_EDIT_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_RELOAD_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_HOME_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_COMPUTER_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_SEARCH_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_NEW_FOLDER_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_OPEN_IN_TERMINAL_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_ICON_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_LIST_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_COMPACT_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
toolbar_update_appearance (self);
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_live_view_t));
// Setup lib data
dt_lib_live_view_t *lib = self->data;
lib->splitline_x = lib->splitline_y = 0.5;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
dt_gui_add_help_link(self->widget, "live_view.html#live_view");
GtkWidget *box;
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->live_view_zoom = dtgtk_button_new(
dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); // TODO: see _zoom_live_view_clicked
lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
lib->flip = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->live_view_zoom, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->flip, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->live_view, _("toggle live view"));
gtk_widget_set_tooltip_text(lib->live_view_zoom, _("zoom live view"));
gtk_widget_set_tooltip_text(lib->rotate_ccw, _("rotate 90 degrees ccw"));
gtk_widget_set_tooltip_text(lib->rotate_cw, _("rotate 90 degrees cw"));
gtk_widget_set_tooltip_text(lib->flip, _("flip live view horizontally"));
g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->live_view_zoom), "clicked", G_CALLBACK(_zoom_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib);
g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib);
g_signal_connect(G_OBJECT(lib->flip), "clicked", G_CALLBACK(_toggle_flip_clicked), lib);
// focus buttons
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL);
lib->focus_in_small
= dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_LEFT, NULL); // TODO icon not centered
lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_RIGHT, NULL); // TODO same here
lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->focus_in_big, _("move focus point in (big steps)"));
gtk_widget_set_tooltip_text(lib->focus_in_small, _("move focus point in (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_small, _("move focus point out (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_big, _("move focus point out (big steps)"));
// Near 3
g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(2));
// Near 1
g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(0));
// Far 1
g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(4));
// Far 3
g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(6));
// Guides
lib->guide_selector = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->guide_selector, NULL, _("guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->guide_selector, TRUE, TRUE, 0);
lib->guides_widgets = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(lib->guides_widgets), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), lib->guides_widgets, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(lib->guide_selector, _("none"));
int i = 0;
for(GList *iter = darktable.guides; iter; iter = g_list_next(iter), i++)
{
GtkWidget *widget = NULL;
dt_guides_t *guide = (dt_guides_t *)iter->data;
dt_bauhaus_combobox_add(lib->guide_selector, _(guide->name));
if(guide->widget)
{
// generate some unique name so that we can have the same name several times
char name[5];
snprintf(name, sizeof(name), "%d", i);
widget = guide->widget(NULL, guide->user_data);
gtk_widget_show_all(widget);
gtk_stack_add_named(GTK_STACK(lib->guides_widgets), widget, name);
}
lib->guides_widgets_list = g_list_append(lib->guides_widgets_list, widget);
}
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_set_tooltip_text(lib->guide_selector, _("display guide lines to help compose your photograph"));
g_signal_connect(G_OBJECT(lib->guide_selector), "value-changed", G_CALLBACK(guides_presets_changed), lib);
lib->flip_guides = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->flip_guides, NULL, _("flip"));
dt_bauhaus_combobox_add(lib->flip_guides, _("none"));
dt_bauhaus_combobox_add(lib->flip_guides, _("horizontally"));
dt_bauhaus_combobox_add(lib->flip_guides, _("vertically"));
dt_bauhaus_combobox_add(lib->flip_guides, _("both"));
gtk_widget_set_tooltip_text(lib->flip_guides, _("flip guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->flip_guides, TRUE, TRUE, 0);
lib->overlay = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay, NULL, _("overlay"));
dt_bauhaus_combobox_add(lib->overlay, _("none"));
dt_bauhaus_combobox_add(lib->overlay, _("selected image"));
dt_bauhaus_combobox_add(lib->overlay, _("id"));
gtk_widget_set_tooltip_text(lib->overlay, _("overlay another image over the live view"));
g_signal_connect(G_OBJECT(lib->overlay), "value-changed", G_CALLBACK(overlay_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay, TRUE, TRUE, 0);
lib->overlay_id_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *label = gtk_label_new(_("image id"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->overlay_id = gtk_spin_button_new_with_range(0, 1000000000, 1);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lib->overlay_id), 0);
gtk_widget_set_tooltip_text(lib->overlay_id, _("enter image id of the overlay manually"));
g_signal_connect(G_OBJECT(lib->overlay_id), "value-changed", G_CALLBACK(_overlay_id_changed), lib);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lib->overlay_id),
dt_conf_get_int("plugins/lighttable/live_view/overlay_imgid"));
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), lib->overlay_id, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_id_box, TRUE, TRUE, 0);
gtk_widget_show(lib->overlay_id);
gtk_widget_show(label);
lib->overlay_mode = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_mode, NULL, _("overlay mode"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "normal"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "xor"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "add"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "saturate"));
#if(CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 10, 0))
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "multiply"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "screen"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "overlay"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "darken"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "lighten"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color dodge"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color burn"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "hard light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "soft light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "difference"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "exclusion"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL hue"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL saturation"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL color"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL luminosity"));
#endif
gtk_widget_set_tooltip_text(lib->overlay_mode, _("mode of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_mode, dt_conf_get_int("plugins/lighttable/live_view/overlay_mode"));
g_signal_connect(G_OBJECT(lib->overlay_mode), "value-changed", G_CALLBACK(_overlay_mode_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_mode, TRUE, TRUE, 0);
lib->overlay_splitline = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_splitline, NULL, _("split line"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("off"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("on"));
gtk_widget_set_tooltip_text(lib->overlay_splitline, _("only draw part of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_splitline, dt_conf_get_int("plugins/lighttable/live_view/splitline"));
g_signal_connect(G_OBJECT(lib->overlay_splitline), "value-changed", G_CALLBACK(_overlay_splitline_changed),
lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_splitline, TRUE, TRUE, 0);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_mode), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_id_box), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_splitline), FALSE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_mode), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_id_box), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_splitline), TRUE);
guides_presets_set_visibility(lib, 0);
}
