static void process_single_field(
GtkWidget * container,
int row_index,
const char * label,
const char * value,
int is_password) {
GtkWidget * label_widget = gtk_label_new(label);
gtk_widget_set_halign(GTK_WIDGET(label_widget), GTK_ALIGN_END);
gtk_widget_set_margin_end(GTK_WIDGET(label_widget), 5);
GtkWidget * value_widget = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(value_widget), value);
gtk_widget_set_hexpand(GTK_WIDGET(value_widget), TRUE);
g_object_set(G_OBJECT(value_widget),
"editable", FALSE,
NULL
);
GtkWidget * copy_button = NULL, *reveal_button = NULL;
if(is_password) {
gtk_entry_set_visibility(GTK_ENTRY(value_widget), FALSE);
copy_button = gtk_button_new_with_mnemonic("_Copy");
g_signal_connect(G_OBJECT(copy_button), "clicked",
G_CALLBACK(handle_copy_button), value_widget);
reveal_button = gtk_button_new_with_mnemonic("_Reveal");
g_signal_connect(G_OBJECT(reveal_button), "clicked",
G_CALLBACK(handle_reveal_button), value_widget);
}
gtk_grid_attach(GTK_GRID(container), label_widget, 0, row_index, 1, 1);
gtk_grid_attach(GTK_GRID(container), value_widget, 1, row_index, copy_button == NULL ? 3 : 1, 1);
if(copy_button) {
gtk_grid_attach(GTK_GRID(container), copy_button, 2, row_index, 1, 1);
gtk_grid_attach(GTK_GRID(container), reveal_button, 3, row_index, 1, 1);
}
}
void gui_init(dt_lib_module_t *self)
{
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
self->data = calloc(1, sizeof(dt_lib_session_t));
// Setup lib data
dt_lib_session_t *lib = self->data;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox, *vbox1, *vbox2;
// Session settings
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
vbox1 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
vbox2 = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
lib->gui.label1 = GTK_LABEL(gtk_label_new(_("jobcode")));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_box_pack_start(vbox1, GTK_WIDGET(lib->gui.label1), TRUE, TRUE, 0);
lib->gui.entry1 = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.entry1), 0);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(lib->gui.entry1));
gtk_box_pack_start(vbox2, GTK_WIDGET(lib->gui.entry1), TRUE, TRUE, 0);
lib->gui.button1 = GTK_BUTTON(gtk_button_new_with_label(_("create")));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(lib->gui.button1), TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(create_callback), self);
gchar *str = dt_conf_get_string("plugins/session/jobcode");
gtk_entry_set_text(lib->gui.entry1, str);
g_free(str);
}
static void agreement_app_window_init(AgreementAppWindow *win)
{
gtk_window_set_title(GTK_WINDOW(win), "Agreement");
gtk_window_set_default_size(GTK_WINDOW(win), 800, 500);
GtkWidget* grid;
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(win), grid);
GtkWidget *view;
view = gtk_text_view_new();
gtk_widget_set_hexpand(view, true);
gtk_widget_set_vexpand(view, true);
gtk_grid_attach(GTK_GRID(grid), view, 0, 0, 1, 1);
agreement_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
gtk_text_buffer_set_text(agreement_text_buffer, "No file loaded", -1);
GtkWidget *flow_box;
flow_box = gtk_flow_box_new();
gtk_flow_box_set_min_children_per_line(GTK_FLOW_BOX(flow_box), 2);
gtk_widget_set_halign(flow_box, GTK_ALIGN_CENTER);
gtk_grid_attach(GTK_GRID(grid), flow_box, 0, 1, 1, 1);
GtkWidget *no_button;
no_button = gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON);
gtk_button_set_always_show_image(GTK_BUTTON(no_button), true);
gtk_button_set_label(GTK_BUTTON(no_button), "No, I do not agree");
gtk_container_add(GTK_CONTAINER(flow_box), no_button);
GtkWidget *yes_button;
yes_button = gtk_button_new_from_icon_name("go-next", GTK_ICON_SIZE_BUTTON);
gtk_button_set_always_show_image(GTK_BUTTON(yes_button), true);
gtk_button_set_label(GTK_BUTTON(yes_button), "Yes, I agree");
gtk_container_add(GTK_CONTAINER(flow_box), yes_button);
gtk_widget_show_all(GTK_WIDGET(win));
}
static GtkWidget *
nimf_settings_page_build_label (NimfSettingsPage *page, const gchar *schema_id)
{
GString *string;
gchar *str;
GtkWidget *tab_label;
gchar *p;
str = g_settings_get_string (page->gsettings, "hidden-schema-name");
string = g_string_new (str);
for (p = (gchar *) schema_id; *p != 0; p++)
if (*p == '.')
g_string_prepend (string, " ");
tab_label = gtk_label_new (string->str);
gtk_widget_set_halign (tab_label, GTK_ALIGN_START);
g_free (str);
g_string_free (string, TRUE);
return tab_label;
}
// Close button
GtkWidget* close_button_new()
{
auto* self = GTK_WIDGET(g_object_new(close_button_get_type(), nullptr));
gtk_button_set_relief(GTK_BUTTON(self), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(self), FALSE);
gtk_widget_set_can_focus(self, FALSE);
gtk_widget_set_halign(self, GTK_ALIGN_START);
auto const& file = decoration::Style::Get()->ThemedFilePath(CLOSE_BUTTON_INACTIVE_FILE, {PKGDATADIR"/"});
auto* img = gtk_image_new_from_file(file.c_str());
gtk_container_add(GTK_CONTAINER(self), img);
CLOSE_BUTTON(self)->priv->img = GTK_IMAGE(img);
glib::Object<GtkCssProvider> style(gtk_css_provider_new());
gtk_css_provider_load_from_data(style, R"(
* {padding: 0px 0px 0px 0px; border: 0px; }
)", -1, nullptr);
auto* style_ctx = gtk_widget_get_style_context(self);
gtk_style_context_add_provider(style_ctx, glib::object_cast<GtkStyleProvider>(style), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
return self;
}
static GtkWidget*
menu_contents (void)
{
GtkWidget *vbox;
GtkWidget *mi;
int i;
GtkWidget *frame;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame),
GTK_SHADOW_OUT);
vbox = gtk_vbox_new (FALSE, 0);
i = 0;
while (i < 10)
{
char *str = g_strdup_printf (_("Fake menu item %d\n"), i + 1);
mi = gtk_label_new (str);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_halign (image, GTK_ALIGN_START);
gtk_widget_set_valign (image, GTK_ALIGN_CENTER);
#else
gtk_misc_set_alignment (GTK_MISC (mi), 0.0, 0.5);
#endif
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), mi, FALSE, FALSE, 0);
++i;
}
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show_all (frame);
return frame;
}
static void
set_table_row (GtkTable *table,
GtkWidget *label, GtkWidget *widget,
gpointer user_data)
{
static guint row = 0;
guint col = 0;
g_return_if_fail (GTK_IS_TABLE (table));
g_return_if_fail (GTK_IS_WIDGET (widget));
if (label) {
gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label,
0, ++col, row, row + 1,
GTK_FILL, 0, 0, 0);
}
if (GTK_IS_EDITABLE (widget)) {
g_signal_connect_swapped (widget, "changed",
G_CALLBACK (verify_input), user_data);
g_signal_connect_swapped (widget, "activate",
G_CALLBACK (cycle_focus), user_data);
}
gtk_widget_show (widget);
gtk_table_attach (GTK_TABLE (table), widget,
col, 2, row, row + 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
static GtkWidget *_lib_viewswitcher_create_label(dt_view_t *v)
{
GtkWidget *eb = gtk_event_box_new();
GtkWidget *b = gtk_label_new(v->name(v));
gtk_container_add(GTK_CONTAINER(eb), b);
/*setup label*/
gtk_widget_set_halign(b, GTK_ALIGN_START);
g_object_set_data(G_OBJECT(b), "view-label", (gchar *)v->name(v));
g_object_set_data(G_OBJECT(eb), "view-label", (gchar *)v->name(v));
gtk_widget_set_name(b, "view_label");
gtk_widget_set_state_flags(b, GTK_STATE_FLAG_NORMAL, TRUE);
/* connect button press handler */
g_signal_connect(G_OBJECT(eb), "button-press-event", G_CALLBACK(_lib_viewswitcher_button_press_callback),
GINT_TO_POINTER(v->view(v)));
/* set enter/leave notify events and connect signals */
gtk_widget_add_events(GTK_WIDGET(eb), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect(G_OBJECT(eb), "enter-notify-event", G_CALLBACK(_lib_viewswitcher_enter_notify_callback), b);
g_signal_connect(G_OBJECT(eb), "leave-notify-event", G_CALLBACK(_lib_viewswitcher_leave_notify_callback), b);
return eb;
}
static void
open_valigned_label_window (void)
{
GtkWidget *window, *box, *label, *frame;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (test_window, "delete-event",
G_CALLBACK (gtk_main_quit), test_window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (window), box);
label = gtk_label_new ("Both labels expand");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
label = gtk_label_new ("Some wrapping text with width-chars = 15 and max-width-chars = 35");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_width_chars (GTK_LABEL (label), 15);
gtk_label_set_max_width_chars (GTK_LABEL (label), 35);
gtk_widget_show (label);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0);
gtk_window_present (GTK_WINDOW (window));
}
static void
photos_empty_results_box_constructed (GObject *object)
{
PhotosEmptyResultsBox *self = PHOTOS_EMPTY_RESULTS_BOX (object);
GtkStyleContext *context;
g_autofree gchar *label = NULL;
G_OBJECT_CLASS (photos_empty_results_box_parent_class)->constructed (object);
gtk_widget_set_halign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
gtk_widget_set_valign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (self), 12);
context = gtk_widget_get_style_context (GTK_WIDGET (self));
gtk_style_context_add_class (context, "dim-label");
photos_empty_results_box_add_image (self);
photos_empty_results_box_add_primary_label (self);
photos_empty_results_box_add_secondary_label (self);
gtk_widget_show_all (GTK_WIDGET (self));
}
GtkWidget *gtk_text_qr_new(void)
{
GtkWidget *gtk_text_button_clear = gtk_button_new_with_label("Clear and reset");
GtkWidget *gtk_text_label = gtk_label_new(NULL);
gtk_text_entry = gtk_entry_new();
GtkWidget *gtk_text_scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *gtk_text_vertical = gtk_box_new(GTK_ORIENTATION_VERTICAL, 15);
GtkWidget *gtk_text_horizontal_buttons = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
gtk_label_set_markup(GTK_LABEL(gtk_text_label), "<span size=\"xx-large\">Generate from text or URL</span>");
gtk_widget_set_halign(gtk_text_label, GTK_ALIGN_START);
gtk_entry_set_placeholder_text(GTK_ENTRY(gtk_text_entry), "Text or URL");
gtk_container_set_border_width(GTK_CONTAINER(gtk_text_vertical), 15);
gtk_box_pack_end(GTK_BOX(gtk_text_horizontal_buttons), gtk_text_button_clear, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gtk_text_vertical), gtk_text_horizontal_buttons, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(gtk_text_scrolled), gtk_text_vertical);
g_signal_connect(G_OBJECT(gtk_text_button_clear), "clicked", G_CALLBACK(cb_clicked_text_clear), NULL);
return gtk_text_scrolled;
}
static WidgetInfo *
create_menu_button (void)
{
GtkWidget *widget;
GtkWidget *image;
GtkWidget *menu;
GtkWidget *vbox;
widget = gtk_menu_button_new ();
image = gtk_image_new ();
gtk_image_set_from_icon_name (GTK_IMAGE (image), "emblem-system-symbolic");
gtk_container_add (GTK_CONTAINER (widget), image);
menu = gtk_menu_new ();
gtk_menu_button_set_popup (GTK_MENU_BUTTON (widget), menu);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add (GTK_CONTAINER (vbox), widget);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), gtk_label_new ("Menu Button"));
return new_widget_info ("menu-button", vbox, SMALL);
}
/** \brief Create HVSC STIL widget
*
* \return GtkGrid
*/
GtkWidget *hvsc_stil_widget_create(void)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *scroll;
grid = vice_gtk3_grid_new_spaced(VICE_GTK3_DEFAULT, VICE_GTK3_DEFAULT);
/* add title label */
label = gtk_label_new(NULL);
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_label_set_markup(GTK_LABEL(label), "<b>STIL entry:</b>");
g_object_set(G_OBJECT(label), "margin-bottom", 16, NULL);
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1);
/* add view */
stil_view = create_view();
hvsc_stil_widget_create_tags();
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_vexpand(scroll, TRUE);
gtk_widget_set_size_request(scroll, 400, 500);
gtk_widget_set_hexpand(scroll, TRUE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scroll), stil_view);
gtk_grid_attach(GTK_GRID(grid), scroll, 0, 1, 1, 1);
gtk_widget_set_vexpand(grid, TRUE);
gtk_widget_show_all(grid);
return grid;
}
GtkWidget *
do_images (GtkWidget *do_widget)
{
GtkWidget *video;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *base_vbox;
GtkWidget *image;
GtkWidget *picture;
GtkWidget *label;
GtkWidget *button;
GdkPaintable *paintable;
GIcon *gicon;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Images");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
g_signal_connect (window, "destroy",
G_CALLBACK (cleanup_callback), NULL);
base_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
g_object_set (base_vbox, "margin", 16, NULL);
gtk_container_add (GTK_CONTAINER (window), base_vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16);
gtk_container_add (GTK_CONTAINER (base_vbox), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
image = gtk_image_new_from_icon_name ("gtk3-demo");
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Animation */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif");
gtk_container_add (GTK_CONTAINER (frame), picture);
/* Symbolic icon */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Symbolic themed icon</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
image = gtk_image_new_from_gicon (gicon);
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Progressive */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
/* Create an empty image for now; the progressive loader
* will create the pixbuf and fill it in.
*/
picture = gtk_picture_new ();
gtk_container_add (GTK_CONTAINER (frame), picture);
start_progressive_loading (picture);
/* Video */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Displaying video</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
video = gtk_video_new_for_resource ("/images/gtk-logo.webm");
gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE);
gtk_container_add (GTK_CONTAINER (frame), video);
/* Widget paintables */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>GtkWidgetPaintable</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
paintable = gtk_widget_paintable_new (do_widget);
picture = gtk_picture_new_for_paintable (paintable);
gtk_widget_set_size_request (picture, 100, 100);
gtk_widget_set_valign (picture, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (vbox), picture);
/* Sensitivity control */
button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
gtk_container_add (GTK_CONTAINER (base_vbox), button);
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_sensitivity_callback),
base_vbox);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
/*
* attach v4l2 controls tab widget
* args:
* parent - tab parent widget
*
* asserts:
* parent is not null
*
* returns: error code (0 -OK)
*/
int gui_attach_gtk3_v4l2ctrls(GtkWidget *parent)
{
/*assertions*/
assert(parent != NULL);
if(debug_level > 1)
printf("GUVCVIEW: attaching v4l2 controls\n");
GtkWidget *img_controls_grid = gtk_grid_new();
gtk_widget_show (img_controls_grid);
gtk_grid_set_column_homogeneous (GTK_GRID(img_controls_grid), FALSE);
gtk_widget_set_hexpand (img_controls_grid, TRUE);
gtk_widget_set_halign (img_controls_grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID(img_controls_grid), 4);
gtk_grid_set_column_spacing (GTK_GRID (img_controls_grid), 4);
gtk_container_set_border_width (GTK_CONTAINER (img_controls_grid), 2);
int i = 0;
int n = 0;
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next, ++n)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (attach gtk3 controls) empty control in list\n");
break;
}
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
++n; /*add a virtual software autofocus control*/
}
widget_list_size = n + 1;
control_widgets_list = realloc(control_widgets_list, sizeof(control_widgets_t) * widget_list_size);
if(control_widgets_list == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
/*label*/
char *tmp;
tmp = g_strdup_printf ("%s:", current->name);
control_widgets_list[widget_list_size - 1].label = gtk_label_new (tmp);
g_free(tmp);
gtk_widget_show (control_widgets_list[widget_list_size - 1].label);
#if GTK_VER_AT_LEAST(3,15)
gtk_label_set_xalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 1);
gtk_label_set_yalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (control_widgets_list[widget_list_size - 1].label), 1, 0.5);
#endif
control_widgets_list[widget_list_size - 1].id = current->control.id;
control_widgets_list[widget_list_size - 1].widget = NULL;
control_widgets_list[widget_list_size - 1].widget2 = NULL; /*usually a spin button*/
switch (current->control.type)
{
case V4L2_CTRL_TYPE_INTEGER:
switch (current->control.id)
{
//special cases
case V4L2_CID_PAN_RELATIVE:
case V4L2_CID_TILT_RELATIVE:
{
control_widgets_list[n].widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
GtkWidget *PanTilt1 = NULL;
GtkWidget *PanTilt2 = NULL;
if(current->control.id == V4L2_CID_PAN_RELATIVE)
{
PanTilt1 = gtk_button_new_with_label(_("Left"));
PanTilt2 = gtk_button_new_with_label(_("Right"));
}
else
{
PanTilt1 = gtk_button_new_with_label(_("Down"));
PanTilt2 = gtk_button_new_with_label(_("Up"));
}
gtk_widget_show (PanTilt1);
gtk_widget_show (PanTilt2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt1,TRUE,TRUE,2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt2,TRUE,TRUE,2);
g_object_set_data (G_OBJECT (PanTilt1), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (PanTilt2), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signals*/
g_signal_connect (GTK_BUTTON(PanTilt1), "clicked",
G_CALLBACK (button_PanTilt1_clicked), NULL);
g_signal_connect (GTK_BUTTON(PanTilt2), "clicked",
G_CALLBACK (button_PanTilt2_clicked), NULL);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2 = gtk_spin_button_new_with_range(-256, 256, 64);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2), TRUE);
if(current->control.id == V4L2_CID_PAN_RELATIVE)
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2), v4l2core_get_pan_step());
else
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2),v4l2core_get_tilt_step());
/*connect signal*/
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (pan_tilt_step_changed), NULL);
gtk_widget_show (control_widgets_list[n].widget2);
break;
}
case V4L2_CID_PAN_RESET:
case V4L2_CID_TILT_RESET:
{
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
};
case V4L2_CID_LED1_MODE_LOGITECH:
{
char* LEDMenu[4] = {_("Off"),_("On"),_("Blinking"),_("Auto")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(4+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (4+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'N'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'O';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = 'B';
current->menu[3].id = current->control.id;
current->menu[3].index = 3;
current->menu[3].name[0] = 'A';
current->menu[4].id = current->control.id;
current->menu[4].index = current->control.maximum+1;
current->menu[4].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) LEDMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH:
{
/*turn it into a menu control*/
char* BITSMenu[2] = {_("8 bit"),_("12 bit")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(2+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (2+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'o'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'd';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
//if (debug_level > 0)
// printf("GUVCVIEW: adding menu entry %d: %d, %s\n",j, current->menu[j].index, current->menu[j].name);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) BITSMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_FOCUS_LOGITECH:
case V4L2_CID_FOCUS_ABSOLUTE:
if(!is_control_panel)
{
/*add a virtual control for software autofocus*/
control_widgets_list[n-1].widget = gtk_check_button_new_with_label (_("Auto Focus (continuous)"));
control_widgets_list[n-1].widget2 = gtk_button_new_with_label (_("set Focus"));
gtk_widget_show (control_widgets_list[n-1].widget);
gtk_widget_show (control_widgets_list[n-1].widget2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n-1].widget), FALSE);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget), "toggled",
G_CALLBACK (autofocus_changed), NULL);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget2), "clicked",
G_CALLBACK (setfocus_clicked), NULL);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n-1].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n-1].widget, TRUE);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget2, 2, i, 1 , 1);
i++;
}
default: /*standard case - hscale + spin*/
{
/* check for valid range */
if((current->control.maximum > current->control.minimum) && (current->control.step != 0))
{
GtkAdjustment *adjustment = gtk_adjustment_new (
current->value,
current->control.minimum,
current->control.maximum,
current->control.step,
current->control.step*10,
0);
control_widgets_list[n].widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_draw_value (GTK_SCALE (control_widgets_list[n].widget), FALSE);
gtk_scale_set_digits(GTK_SCALE(control_widgets_list[n].widget), 0);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2= gtk_spin_button_new(adjustment, current->control.step, 0);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2),TRUE);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control_entry",
control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control2_entry",
control_widgets_list[n].widget2);
}
/*connect signals*/
g_signal_connect (GTK_SCALE(control_widgets_list[n].widget), "value-changed",
G_CALLBACK (slider_changed), NULL);
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (spin_changed), NULL);
}
else
fprintf(stderr, "GUVCVIEW: (Invalid range) [MAX <= MIN] for control id: 0x%08x \n", current->control.id);
break;
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (int64_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
control_widgets_list[n].widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2= gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (string_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
control_widgets_list[n].widget = gtk_entry_new();
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (bitmask_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
if(current->menu)
{
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->control.type == V4L2_CTRL_TYPE_MENU)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) current->menu_entry[j]);
}
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
else
{
char buffer[30]="0";
snprintf(buffer, "%" PRIu64 "", 29, current->menu[j].value);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget), buffer);
}
#endif
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
}
break;
case V4L2_CTRL_TYPE_BUTTON:
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
if(current->control.id ==V4L2_CID_DISABLE_PROCESSING_LOGITECH)
{
control_widgets_list[n].widget2 = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GBGB... | RGRG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GRGR... | BGBG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"BGBG... | GRGR...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"RGRG... | GBGB...");
v4l2core_set_bayer_pix_order(0);
gtk_combo_box_set_active(GTK_COMBO_BOX(control_widgets_list[n].widget2), v4l2core_get_bayer_pix_order());
gtk_widget_show (control_widgets_list[n].widget2);
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget2), "changed",
G_CALLBACK (bayer_pix_ord_changed), NULL);
uint8_t isbayer = (current->value ? TRUE : FALSE);
v4l2core_set_isbayer(isbayer);
}
control_widgets_list[n].widget = gtk_check_button_new();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n].widget),
current->value ? TRUE : FALSE);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_TOGGLE_BUTTON(control_widgets_list[n].widget), "toggled",
G_CALLBACK (check_changed), NULL);
break;
default:
printf("control[%d]:(unknown - 0x%x) 0x%x '%s'\n",i ,current->control.type,
current->control.id, current->control.name);
break;
}
/*attach widgets to grid*/
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].label, 0, i, 1 , 1);
if(control_widgets_list[n].widget)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n].widget, TRUE);
}
if(control_widgets_list[n].widget2)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget2, 2, i, 1 , 1);
}
i++;
}
/*add control grid to parent container*/
gtk_container_add(GTK_CONTAINER(parent), img_controls_grid);
gui_gtk3_update_controls_state();
return 0;
}
/**************************************************************************
Creates a new dialog. It will be a tab or a window depending on the
current user setting of 'gui_gtk3_enable_tabs'.
Sets pdlg to point to the dialog once it is create, Zeroes pdlg on
dialog destruction.
user_data will be passed through response function
check_top indicates if the layout deision should depend on the parent.
**************************************************************************/
void gui_dialog_new(struct gui_dialog **pdlg, GtkNotebook *notebook,
gpointer user_data, bool check_top)
{
struct gui_dialog *dlg;
GtkWidget *vbox, *action_area;
static int dialog_id_counter;
dlg = fc_malloc(sizeof(*dlg));
dialog_list = g_list_prepend(dialog_list, dlg);
dlg->source = pdlg;
*pdlg = dlg;
dlg->user_data = user_data;
dlg->title = NULL;
dlg->default_width = 200;
dlg->default_height = 300;
if (gui_gtk3_enable_tabs) {
dlg->type = GUI_DIALOG_TAB;
} else {
dlg->type = GUI_DIALOG_WINDOW;
}
if (!gui_action) {
gui_action = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL);
}
dlg->gui_button = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
vbox = gtk_grid_new();
action_area = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(action_area), 4);
gtk_grid_set_column_spacing(GTK_GRID(action_area), 4);
if (gui_gtk3_enable_tabs &&
(check_top && notebook != GTK_NOTEBOOK(top_notebook))
&& !gui_gtk3_small_display_layout) {
/* We expect this to be short (as opposed to tall); maximise usable
* height by putting buttons down the right hand side */
gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area),
GTK_ORIENTATION_VERTICAL);
} else {
/* We expect this to be reasonably tall; maximise usable width by
* putting buttons along the bottom */
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox),
GTK_ORIENTATION_VERTICAL);
}
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(vbox), action_area);
gtk_widget_show(action_area);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
gtk_container_set_border_width(GTK_CONTAINER(action_area), 2);
switch (dlg->type) {
case GUI_DIALOG_WINDOW:
{
GtkWidget *window;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(window, "Freeciv");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
setup_dialog(window, toplevel);
gtk_container_add(GTK_CONTAINER(window), vbox);
dlg->v.window = window;
g_signal_connect(window, "delete_event",
G_CALLBACK(gui_dialog_delete_handler), dlg);
}
break;
case GUI_DIALOG_TAB:
{
GtkWidget *hbox, *label, *image, *button, *event_box;
gint w, h;
gchar *buf;
gtk_icon_size_lookup_for_settings(
gtk_settings_get_for_screen(gtk_widget_get_screen(vbox)),
GTK_ICON_SIZE_MENU, &w, &h);
hbox = gtk_grid_new();
label = gtk_label_new(NULL);
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_widget_set_valign(label, GTK_ALIGN_CENTER);
gtk_widget_set_margin_left(label, 4);
gtk_widget_set_margin_right(label, 4);
gtk_widget_set_margin_top(label, 0);
gtk_widget_set_margin_bottom(label, 0);
gtk_container_add(GTK_CONTAINER(hbox), label);
button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(gui_dialog_delete_tab_handler), dlg);
buf = g_strdup_printf(_("Close Tab:\n%s"), _("Ctrl+W"));
gtk_widget_set_tooltip_text(button, buf);
g_free(buf);
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_set_margin_left(image, 0);
gtk_widget_set_margin_right(image, 0);
gtk_widget_set_margin_top(image, 0);
gtk_widget_set_margin_bottom(image, 0);
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_show_all(hbox);
event_box = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_container_add(GTK_CONTAINER(event_box), hbox);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, event_box);
dlg->v.tab.handler_id =
g_signal_connect(notebook, "switch-page",
G_CALLBACK(gui_dialog_switch_page_handler), dlg);
dlg->v.tab.child = vbox;
dlg->v.tab.label = label;
dlg->v.tab.notebook = GTK_WIDGET(notebook);
gtk_widget_add_events(event_box, GDK_BUTTON2_MOTION_MASK);
g_signal_connect(event_box, "button-press-event",
G_CALLBACK(click_on_tab_callback), dlg);
}
break;
}
dlg->vbox = vbox;
dlg->action_area = action_area;
dlg->response_callback = gui_dialog_destroyed;
dlg->id = dialog_id_counter;
dialog_id_counter++;
dlg->return_dialog_id = -1;
g_signal_connect(vbox, "destroy",
G_CALLBACK(gui_dialog_destroy_handler), dlg);
g_signal_connect(vbox, "key_press_event",
G_CALLBACK(gui_dialog_key_press_handler), dlg);
g_object_set_data(G_OBJECT(vbox), "gui-dialog-data", dlg);
}
int
main (int argc,
char *argv[])
{
GtkWidget *win, *vbox, *frame, *group_box;
GtkSizeGroup *label_group;
GOptionContext *context;
gchar *cwd;
context = g_option_context_new ("- test GtkFileChooserButton widget");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
gtk_init ();
/* to test rtl layout, use "--right-to-left" */
if (rtl)
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
cwd = g_get_current_dir();
gtk_src_dir = g_path_get_dirname (cwd);
g_free (cwd);
win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0,
"_Quit", GTK_RESPONSE_CLOSE, NULL);
g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
g_object_set (vbox, "margin", 6, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);
frame = gtk_frame_new ("<b>GtkFileChooserButton</b>");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), frame);
gtk_widget_set_halign (frame, GTK_ALIGN_FILL);
gtk_widget_set_valign (frame, GTK_ALIGN_FILL);
g_object_set (frame, "margin-top", 6, "margin-start", 12, NULL);
label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), group_box);
/* OPEN */
add_new_filechooser_button ("_Open:", "Select A File",
GTK_FILE_CHOOSER_ACTION_OPEN,
group_box, label_group);
/* SELECT_FOLDER */
add_new_filechooser_button ("Select _Folder:", "Select A Folder",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
group_box, label_group);
g_object_unref (label_group);
gtk_widget_show (win);
gtk_window_present (GTK_WINDOW (win));
gtk_main ();
return 0;
}
static gboolean
set_tooltip_widget_from_marks (GtkSourceView *view,
GtkTooltip *tooltip,
GSList *marks)
{
GtkGrid *grid = NULL;
gint row_num = 0;
gint icon_size;
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, NULL, &icon_size);
for (; marks; marks = g_slist_next (marks))
{
const gchar *category;
GtkSourceMark *mark;
GtkSourceMarkAttributes *attrs;
gchar *text;
gboolean ismarkup = FALSE;
GtkWidget *label;
const GdkPixbuf *pixbuf;
mark = marks->data;
category = gtk_source_mark_get_category (mark);
attrs = gtk_source_view_get_mark_attributes (view, category, NULL);
if (attrs == NULL)
{
continue;
}
text = gtk_source_mark_attributes_get_tooltip_markup (attrs, mark);
if (text == NULL)
{
text = gtk_source_mark_attributes_get_tooltip_text (attrs, mark);
}
else
{
ismarkup = TRUE;
}
if (text == NULL)
{
continue;
}
if (grid == NULL)
{
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_column_spacing (grid, 4);
gtk_widget_show (GTK_WIDGET (grid));
}
label = gtk_label_new (NULL);
if (ismarkup)
{
gtk_label_set_markup (GTK_LABEL (label), text);
}
else
{
gtk_label_set_text (GTK_LABEL (label), text);
}
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_START);
gtk_widget_show (label);
pixbuf = gtk_source_mark_attributes_render_icon (attrs,
GTK_WIDGET (view),
icon_size);
if (pixbuf == NULL)
{
gtk_grid_attach (grid, label, 0, row_num, 2, 1);
}
else
{
GtkWidget *image;
GdkPixbuf *copy;
/* FIXME why a copy is needed? */
copy = gdk_pixbuf_copy (pixbuf);
image = gtk_image_new_from_pixbuf (copy);
g_object_unref (copy);
gtk_widget_set_halign (image, GTK_ALIGN_START);
gtk_widget_set_valign (image, GTK_ALIGN_START);
gtk_widget_show (image);
gtk_grid_attach (grid, image, 0, row_num, 1, 1);
gtk_grid_attach (grid, label, 1, row_num, 1, 1);
}
row_num++;
if (marks->next != NULL)
{
GtkWidget *separator;
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (separator);
gtk_grid_attach (grid, separator, 0, row_num, 2, 1);
row_num++;
}
g_free (text);
}
if (grid == NULL)
{
return FALSE;
}
gtk_tooltip_set_custom (tooltip, GTK_WIDGET (grid));
return TRUE;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
MidiogreApp *midiogre_app_init(void)
{
MidiogreApp *app;
GtkWidget *header;
GtkWidget *separator;
GtkWidget *scrolled;
GtkWidget *label,*frame;
GtkWidget *button;
GtkBox *box;
gint i;
GError *err;
/* Allocate app */
app = calloc(1, sizeof(MidiogreApp));
/* Setup window */
app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));
/* Setup header bar */
header = gtk_header_bar_new();
gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
gtk_window_set_titlebar(app->window, header);
/* Setup close button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);
/* Add seperator */
separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);
/* Setup folder button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);
/* Global horizontal box */
app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));
/* Scroll container for sidepanel */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);
/* Sidepanel box */
app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);
/* Frame with favorit info */
frame = gtk_frame_new("Favorite");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));
/* Current favorite */
app->fav_title_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_title_label, 20);
gtk_label_set_width_chars(app->fav_title_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
gtk_label_set_max_width_chars(app->fav_artist_label, 20);
gtk_label_set_width_chars(app->fav_artist_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
app->fav_album_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_album_label, 20);
gtk_label_set_width_chars(app->fav_album_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);
/* Frame with search criteria widgets */
frame = gtk_frame_new("Search");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));
/* Title entry */
frame = gtk_frame_new("Title");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);
/* Artist entry */
frame = gtk_frame_new("Artist");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->artist_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);
/* Album entry */
frame = gtk_frame_new("Album");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->album_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);
/* Instrument class buttons */
frame = gtk_frame_new("Instrument Classes");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
app->instr_grid = GTK_GRID(gtk_grid_new());
#if GTK_MINOR_VERSION >= 12
gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));
for (i = 0; i < INSTR_CLASSES; i++) {
label = gtk_label_new(instrument_classes[i]);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);
app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
}
/* Result spinbutton */
frame = gtk_frame_new("Max result");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
gtk_spin_button_set_value(app->result_spinbutton, 25);
gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);
/* Search button */
app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);
/* Songboxes notebook (Tabsview) */
app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);
/* Add song boxes */
app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match");
app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity");
app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest");
/* Show all widgets */
gtk_widget_show_all(GTK_WIDGET(app->window));
/* Allocate song queue */
app->songs[SONGBOX_ALPHA] = g_queue_new();
app->songs[SONGBOX_FPRNT] = g_queue_new();
app->songs[SONGBOX_BEST] = g_queue_new();
app->songs[SONGBOX_POP] = g_queue_new();
app->songs[SONGBOX_NEW] = g_queue_new();
return app;
}
GtkWidget*
_gtk_error_dialog_new (GtkWindow *parent,
GtkDialogFlags flags,
GList *row_output,
const char *primary_text,
const char *secondary_text,
...)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *image;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *text_view;
GtkWidget *scrolled = NULL;
GtkWidget *expander;
GtkWidget *content_area;
GtkWidget *action_area;
GtkTextBuffer *text_buf;
GtkTextIter iter;
GList *scan;
char *escaped_message, *markup_text;
va_list args;
gboolean view_output = (row_output != NULL);
dialog = gtk_dialog_new_with_buttons ("",
parent,
flags,
"gtk-ok", GTK_RESPONSE_OK,
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog));
/* Add label and image */
image = gtk_image_new_from_icon_name ("dialog-error", GTK_ICON_SIZE_DIALOG);
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
label = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.0);
escaped_message = g_markup_escape_text (primary_text, -1);
if (secondary_text != NULL) {
char *secondary_message;
char *escaped_secondary_message;
va_start (args, secondary_text);
secondary_message = g_strdup_vprintf (secondary_text, args);
va_end (args);
escaped_secondary_message = g_markup_escape_text (secondary_message, -1);
markup_text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s",
escaped_message,
escaped_secondary_message);
g_free (escaped_secondary_message);
g_free (secondary_message);
}
else
markup_text = g_strdup (escaped_message);
gtk_label_set_markup (GTK_LABEL (label), markup_text);
g_free (markup_text);
g_free (escaped_message);
if (view_output) {
gtk_widget_set_size_request (dialog, 500, -1);
/* Expander */
expander = gtk_expander_new_with_mnemonic (_("Command _Line Output"));
gtk_expander_set_expanded (GTK_EXPANDER (expander), secondary_text == NULL);
/* Add text */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
gtk_widget_set_size_request (scrolled, -1, 200);
text_buf = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text_buf, "monospace",
"family", "monospace", NULL);
gtk_text_buffer_get_iter_at_offset (text_buf, &iter, 0);
for (scan = row_output; scan; scan = scan->next) {
char *line = scan->data;
char *utf8_line;
gsize bytes_written;
utf8_line = g_locale_to_utf8 (line, -1, NULL, &bytes_written, NULL);
gtk_text_buffer_insert_with_tags_by_name (text_buf,
&iter,
utf8_line,
bytes_written,
"monospace", NULL);
g_free (utf8_line);
gtk_text_buffer_insert (text_buf, &iter, "\n", 1);
}
text_view = gtk_text_view_new_with_buffer (text_buf);
g_object_unref (text_buf);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
if (view_output) {
gtk_container_add (GTK_CONTAINER (scrolled), text_view);
gtk_container_add (GTK_CONTAINER (expander), scrolled);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
}
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 14); /* 14 + 2 * 5 = 24 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (GTK_BOX (action_area), 6);
gtk_widget_show_all (vbox);
return dialog;
}
BalsaMimeWidget *
balsa_mime_widget_new_vcalendar(BalsaMessage * bm,
LibBalsaMessageBody * mime_body,
const gchar * content_type, gpointer data)
{
LibBalsaVCal *vcal_obj;
BalsaMimeWidget *mw;
GtkWidget *label;
gchar *text;
GList *l;
LibBalsaMessage *lbm = bm->message;
gboolean may_reply = FALSE;
InternetAddress *sender = NULL;;
g_return_val_if_fail(mime_body != NULL, NULL);
g_return_val_if_fail(content_type != NULL, NULL);
g_return_val_if_fail(lbm != NULL, NULL);
vcal_obj = libbalsa_vcal_new_from_body(mime_body);
if (!vcal_obj)
return NULL;
mw = g_object_new(BALSA_TYPE_MIME_WIDGET, NULL);
mw->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);
text = g_strdup_printf(_("This is an iTIP calendar “%s” message."),
libbalsa_vcal_method_to_str(vcal_obj->method));
label = gtk_label_new(text);
g_free(text);
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_widget_set_valign(label, GTK_ALIGN_START);
gtk_container_add(GTK_CONTAINER(mw->widget), label);
/* a reply may be created only for unread requests */
if ((vcal_obj->method == ITIP_REQUEST) &&
LIBBALSA_MESSAGE_IS_UNREAD(lbm)) {
may_reply = TRUE;
if (lbm->headers) {
if (lbm->headers->reply_to)
sender =
internet_address_list_get_address(lbm->headers->
reply_to, 0);
else if (lbm->headers && lbm->headers->from)
sender =
internet_address_list_get_address(lbm->headers->from,
0);
} else if (lbm->sender)
sender = internet_address_list_get_address(lbm->sender, 0);
}
/* add events */
for (l = vcal_obj->vevent; l; l = g_list_next(l)) {
GtkWidget *event =
balsa_vevent_widget((LibBalsaVEvent *) l->data, may_reply,
sender);
gtk_container_add(GTK_CONTAINER(mw->widget), event);
}
g_object_unref(vcal_obj);
return mw;
}
static void
mail_config_sendmail_backend_insert_widgets (EMailConfigServiceBackend *backend,
GtkBox *parent)
{
CamelSettings *settings;
GtkLabel *label;
GtkWidget *widget;
GtkWidget *container;
GtkWidget *use_custom_binary_check;
GtkWidget *custom_binary_entry;
GtkWidget *use_custom_args_check;
GtkWidget *custom_args_entry;
GtkWidget *send_in_offline;
gchar *markup;
PangoAttribute *attr;
PangoAttrList *attr_list;
settings = e_mail_config_service_backend_get_settings (backend);
markup = g_markup_printf_escaped ("<b>%s</b>", _("Configuration"));
widget = gtk_label_new (markup);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
g_free (markup);
widget = gtk_grid_new ();
gtk_widget_set_margin_left (widget, 12);
gtk_grid_set_row_spacing (GTK_GRID (widget), 6);
gtk_grid_set_column_spacing (GTK_GRID (widget), 6);
gtk_box_pack_start (GTK_BOX (parent), widget, FALSE, FALSE, 0);
container = widget;
widget = gtk_check_button_new_with_mnemonic (_("_Use custom binary, instead of 'sendmail'"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 2, 1);
use_custom_binary_check = widget;
widget = gtk_label_new_with_mnemonic (_("_Custom binary:"));
gtk_widget_set_margin_left (widget, 12);
gtk_grid_attach (GTK_GRID (container), widget, 0, 1, 1, 1);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_label_set_mnemonic_widget (label, widget);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 1, 1, 1);
custom_binary_entry = widget;
e_binding_bind_property (
use_custom_binary_check, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
widget = gtk_check_button_new_with_mnemonic (_("U_se custom arguments"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 2, 2, 1);
use_custom_args_check = widget;
widget = gtk_label_new_with_mnemonic (_("Cus_tom arguments:"));
gtk_widget_set_margin_left (widget, 12);
gtk_grid_attach (GTK_GRID (container), widget, 0, 3, 1, 1);
label = GTK_LABEL (widget);
widget = gtk_entry_new ();
gtk_label_set_mnemonic_widget (label, widget);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 3, 1, 1);
custom_args_entry = widget;
e_binding_bind_property (
use_custom_args_check, "active",
label, "sensitive",
G_BINDING_SYNC_CREATE);
widget = gtk_label_new (_(
"Default arguments are '-i -f %F -- %R', where\n"
" %F - stands for the From address\n"
" %R - stands for the recipient addresses"));
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
gtk_grid_attach (GTK_GRID (container), widget, 1, 4, 1, 1);
attr_list = pango_attr_list_new ();
attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
pango_attr_list_insert (attr_list, attr);
gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
pango_attr_list_unref (attr_list);
widget = gtk_check_button_new_with_mnemonic (_("Send mail also when in offline _mode"));
gtk_grid_attach (GTK_GRID (container), widget, 0, 5, 2, 1);
send_in_offline = widget;
e_binding_bind_property (
use_custom_binary_check, "active",
custom_binary_entry, "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "use-custom-binary",
use_custom_binary_check, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_object_text_property (
settings, "custom-binary",
custom_binary_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
use_custom_args_check, "active",
custom_args_entry, "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "use-custom-args",
use_custom_args_check, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_object_text_property (
settings, "custom-args",
custom_args_entry, "text",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
settings, "send-in-offline",
send_in_offline, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
gtk_widget_show_all (container);
}
static void
add_row (NetDeviceEthernet *device, NMConnection *connection)
{
GtkWidget *row;
GtkWidget *widget;
GtkWidget *box;
GtkWidget *details;
NMDevice *nmdev;
NMActiveConnection *aconn;
gboolean active;
GtkWidget *image;
active = FALSE;
nmdev = net_device_get_nm_device (NET_DEVICE (device));
aconn = nm_device_get_active_connection (nmdev);
if (aconn) {
const gchar *path1, *path2;
path1 = nm_active_connection_get_connection (aconn);
path2 = nm_connection_get_path (connection);
active = g_strcmp0 (path1, path2) == 0;
}
row = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (row), box, FALSE, TRUE, 0);
widget = gtk_label_new (nm_connection_get_id (connection));
gtk_widget_set_margin_left (widget, 12);
gtk_widget_set_margin_right (widget, 12);
gtk_widget_set_margin_top (widget, 12);
gtk_widget_set_margin_bottom (widget, 12);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0);
if (active) {
widget = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0);
details = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (details), 10);
gtk_grid_set_column_spacing (GTK_GRID (details), 10);
gtk_box_pack_start (GTK_BOX (row), details, FALSE, TRUE, 0);
add_details (details, nmdev, connection);
}
/* filler */
widget = gtk_label_new ("");
gtk_widget_set_hexpand (widget, TRUE);
gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 0);
image = gtk_image_new_from_icon_name ("emblem-system-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
widget = gtk_button_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (widget), "image-button");
gtk_widget_set_margin_left (widget, 12);
gtk_widget_set_margin_right (widget, 12);
gtk_widget_set_margin_top (widget, 12);
gtk_widget_set_margin_bottom (widget, 12);
gtk_widget_show (widget);
gtk_container_add (GTK_CONTAINER (widget), image);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
atk_object_set_name (gtk_widget_get_accessible (widget), _("Options…"));
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0);
g_object_set_data (G_OBJECT (row), "edit", widget);
g_object_set_data (G_OBJECT (widget), "row", row);
g_signal_connect (widget, "clicked",
G_CALLBACK (show_details_for_row), device);
gtk_widget_show_all (row);
g_object_set_data (G_OBJECT (row), "connection", connection);
gtk_container_add (GTK_CONTAINER (device->list), row);
}
/**
* @brief
* @param ui The GstSwitchUI instance.
* @memberof GstSwitchUI
*/
static void
gst_switch_ui_init (GstSwitchUI * ui)
{
GtkWidget *main_box, *right_box;
GtkWidget *scrollwin;
GtkWidget *overlay;
GtkStyleContext *style;
GdkDisplay *display;
GdkScreen *screen;
GError *error = NULL;
g_mutex_init (&ui->audio_lock);
g_mutex_init (&ui->compose_lock);
g_mutex_init (&ui->select_lock);
g_mutex_init (&ui->faces_lock);
g_mutex_init (&ui->tracking_lock);
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
ui->css = gtk_css_provider_new ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (ui->css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
ui->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (ui->window), 640, 480);
gtk_window_set_title (GTK_WINDOW (ui->window), "GstSwitch");
g_signal_connect (G_OBJECT (ui->window), "key-press-event",
G_CALLBACK (gst_switch_ui_key_event), ui);
main_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
right_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
//gtk_widget_set_hexpand (right_box, TRUE);
//gtk_widget_set_vexpand (right_box, TRUE);
ui->preview_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_name (ui->preview_box, "previews");
gtk_widget_set_size_request (ui->preview_box, 120, -1);
gtk_widget_set_vexpand (ui->preview_box, TRUE);
overlay = gtk_overlay_new ();
gtk_widget_set_hexpand (overlay, TRUE);
gtk_widget_set_vexpand (overlay, TRUE);
ui->compose_view = gtk_drawing_area_new ();
gtk_widget_set_name (ui->compose_view, "compose");
gtk_widget_set_double_buffered (ui->compose_view, FALSE);
gtk_widget_set_hexpand (ui->compose_view, TRUE);
gtk_widget_set_vexpand (ui->compose_view, TRUE);
gtk_widget_set_events (ui->compose_view, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
/*
g_signal_connect (ui->compose_view, "draw",
G_CALLBACK (gst_switch_ui_compose_draw), ui);
*/
g_signal_connect (ui->compose_view, "key-press-event",
G_CALLBACK (gst_switch_ui_compose_key_event), ui);
g_signal_connect (ui->compose_view, "motion-notify-event",
G_CALLBACK (gst_switch_ui_compose_view_motion), ui);
g_signal_connect (ui->compose_view, "button-press-event",
G_CALLBACK (gst_switch_ui_compose_view_press), ui);
ui->compose_overlay = gtk_fixed_new ();
style = gtk_widget_get_style_context (ui->compose_overlay);
gtk_style_context_add_class (style, "compose");
gtk_widget_set_halign (ui->compose_overlay, GTK_ALIGN_START);
gtk_widget_set_valign (ui->compose_overlay, GTK_ALIGN_START);
//gtk_fixed_put (GTK_FIXED (ui->compose_overlay), w, 5, 5);
ui->status = gtk_label_new (NULL);
gtk_widget_set_hexpand (ui->status, TRUE);
gtk_misc_set_alignment (GTK_MISC (ui->status), 1.0, 0);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrollwin, 130, -1);
gtk_widget_set_vexpand (scrollwin, TRUE);
gtk_container_add (GTK_CONTAINER (scrollwin), ui->preview_box);
gtk_container_add (GTK_CONTAINER (overlay), ui->compose_view);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), ui->compose_overlay);
gtk_box_pack_start (GTK_BOX (right_box), overlay, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (right_box), ui->status, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_box), scrollwin, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_box), right_box, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (ui->window), main_box);
gtk_container_set_border_width (GTK_CONTAINER (ui->window), 5);
g_signal_connect (G_OBJECT (ui->window), "delete-event",
G_CALLBACK (gst_switch_ui_window_closed), ui);
gtk_css_provider_load_from_data (ui->css, gst_switch_ui_css, -1, &error);
g_assert_no_error (error);
/*
gtk_widget_show_all (ui->window);
gtk_widget_realize (ui->window);
*/
}
static GtkWidget *
create_window (void)
{
GtkWidget *window, *hbox, *vbox, *flowbox_cntl, *items_cntl;
GtkWidget *flowbox, *widget, *expander, *swindow;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_widget_show (vbox);
gtk_widget_show (hbox);
gtk_container_add (GTK_CONTAINER (window), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
flowbox = gtk_flow_box_new ();
gtk_widget_set_halign (flowbox, GTK_ALIGN_END);
the_flowbox = (GtkFlowBox *)flowbox;
gtk_widget_set_halign (flowbox, INITIAL_HALIGN);
gtk_widget_set_valign (flowbox, INITIAL_VALIGN);
gtk_flow_box_set_column_spacing (GTK_FLOW_BOX (flowbox), INITIAL_CSPACING);
gtk_flow_box_set_row_spacing (GTK_FLOW_BOX (flowbox), INITIAL_RSPACING);
gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MINIMUM_LENGTH);
gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (flowbox);
gtk_container_add (GTK_CONTAINER (swindow), flowbox);
gtk_flow_box_set_hadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swindow)));
gtk_flow_box_set_vadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swindow)));
g_signal_connect (flowbox, "child-activated", G_CALLBACK (on_child_activated), NULL);
g_signal_connect (flowbox, "selected-children-changed", G_CALLBACK (on_selected_children_changed), NULL);
/* Add Flowbox test control frame */
expander = gtk_expander_new ("Flow Box controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
flowbox_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (flowbox_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), flowbox_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label ("Homogeneous");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether the items should be displayed at the same size");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (homogeneous_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Activate on single click");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
g_object_bind_property (widget, "active",
flowbox, "activate-on-single-click",
G_BINDING_SYNC_CREATE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
/* Add alignment controls */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (horizontal_alignment_changed), flowbox);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_VALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (vertical_alignment_changed), flowbox);
/* Add Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the flowbox orientation");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), flowbox);
/* Add selection mode control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "None");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Single");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Browse");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Multiple");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the selection mode");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (selection_mode_changed), flowbox);
/* Add minimum line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (line_length_changed), flowbox);
/* Add natural line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the natural amount of items per line ");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (max_line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (max_line_length_changed), flowbox);
/* Add horizontal/vertical spacing controls */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("H Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_CSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("V Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_RSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
/* filtering and sorting */
widget = gtk_check_button_new_with_label ("Filter");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether some items should be filtered out");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (filter_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Sort");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether items should be sorted");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (sort_toggled), flowbox);
/* Add test items control frame */
expander = gtk_expander_new ("Test item controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
items_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (items_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), items_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
/* Add Items control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Simple");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Focus");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Wrappy");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Stock");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Images");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item set to use");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (items_changed), flowbox);
/* Add Text Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (text_orientation_changed), flowbox);
populate_items (GTK_FLOW_BOX (flowbox));
/* This line was added only for the convenience of reproducing
* a height-for-width inside GtkScrolledWindow bug (bug 629778).
* -Tristan
*/
gtk_window_set_default_size (GTK_WINDOW (window), 390, -1);
return window;
}
static void
cc_wacom_page_init (CcWacomPage *self)
{
CcWacomPagePrivate *priv;
GError *error = NULL;
GtkComboBox *combo;
GtkWidget *box;
GtkSwitch *sw;
char *objects[] = {
"main-grid",
"liststore-tabletmode",
"liststore-buttons",
"adjustment-tip-feel",
"adjustment-eraser-feel",
NULL
};
priv = self->priv = WACOM_PAGE_PRIVATE (self);
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (priv->builder,
"/org/sagarmatha/control-center/wacom/sagarmatha-wacom-properties.ui",
objects,
&error);
if (error != NULL) {
g_warning ("Error loading UI file: %s", error->message);
g_object_unref (priv->builder);
g_error_free (error);
return;
}
box = WID ("main-grid");
gtk_container_add (GTK_CONTAINER (self), box);
gtk_widget_set_vexpand (GTK_WIDGET (box), TRUE);
self->priv->notebook = WID ("stylus-notebook");
g_signal_connect (WID ("button-calibrate"), "clicked",
G_CALLBACK (calibrate_button_clicked_cb), self);
g_signal_connect (WID ("map-buttons-button"), "clicked",
G_CALLBACK (map_buttons_button_clicked_cb), self);
combo = GTK_COMBO_BOX (WID ("combo-tabletmode"));
combobox_text_cellrenderer (combo, MODELABEL_COLUMN);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (tabletmode_changed_cb), self);
sw = GTK_SWITCH (WID ("switch-left-handed"));
g_signal_connect (G_OBJECT (sw), "notify::active",
G_CALLBACK (left_handed_toggled_cb), self);
g_signal_connect (G_OBJECT (WID ("display-link")), "activate-link",
G_CALLBACK (display_clicked_cb), self);
g_signal_connect (G_OBJECT (WID ("display-mapping-button")), "clicked",
G_CALLBACK (display_mapping_button_clicked_cb), self);
priv->nav = cc_wacom_nav_button_new ();
gtk_widget_set_halign (priv->nav, GTK_ALIGN_END);
gtk_widget_set_margin_left (priv->nav, 10);
gtk_grid_attach (GTK_GRID (box), priv->nav, 1, 0, 1, 1);
}
GtkWidget *
do_images (GtkWidget *do_widget)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *button;
GIcon *gicon;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Images");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
g_signal_connect (window, "destroy",
G_CALLBACK (cleanup_callback), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
image = gtk_image_new_from_icon_name ("gtk3-demo", GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Animation */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
image = gtk_image_new_from_resource ("/images/floppybuddy.gif");
gtk_container_add (GTK_CONTAINER (frame), image);
/* Symbolic icon */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Symbolic themed icon</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Progressive */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* Create an empty image for now; the progressive loader
* will create the pixbuf and fill it in.
*/
image = gtk_image_new_from_pixbuf (NULL);
gtk_container_add (GTK_CONTAINER (frame), image);
start_progressive_loading (image);
/* Sensitivity control */
button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_sensitivity_callback),
vbox);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static void
properties_activated_cb (GtkMenuItem *mitem, QueryFavoriteSelector *tsel)
{
if (! tsel->priv->popup_properties) {
GtkWidget *pcont, *vbox, *hbox, *label, *entry, *text, *grid;
gchar *str;
pcont = popup_container_new (GTK_WIDGET (mitem));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (pcont), vbox);
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("Favorite's properties"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); /* HIG */
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
grid = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (hbox), grid, TRUE, TRUE, 0);
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("Name"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("SQL Code"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("Is action"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_tooltip_text (label, _("Check this option to make this favorite an action\n"
"which can be proposed for execution from grids\n"
"containing data. The parameters required to execute\n"
"the query will be defined from the row selected in the grid"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
entry = gtk_entry_new ();
gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1);
tsel->priv->properties_name = entry;
g_signal_connect (entry, "changed",
G_CALLBACK (property_changed_cb), tsel);
text = query_editor_new ();
query_editor_show_tooltip (QUERY_EDITOR (text), FALSE);
gtk_widget_set_size_request (GTK_WIDGET (text), 400, 300);
gtk_grid_attach (GTK_GRID (grid), text, 1, 1, 1, 1);
tsel->priv->properties_text = text;
g_signal_connect (text, "changed",
G_CALLBACK (property_changed_cb), tsel);
entry = gtk_check_button_new ();
gtk_grid_attach (GTK_GRID (grid), entry, 1, 2, 1, 1);
tsel->priv->properties_action = entry;
g_signal_connect (entry, "toggled",
G_CALLBACK (property_changed_cb), tsel);
tsel->priv->popup_properties = pcont;
gtk_widget_show_all (vbox);
}
/* adjust contents */
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tsel->priv->treeview));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gchar *name, *contents;
gtk_tree_model_get (model, &iter,
COLUMN_ID, &(tsel->priv->properties_id),
COLUMN_POSITION, &(tsel->priv->properties_position),
COLUMN_NAME, &name,
COLUMN_CONTENTS, &contents, -1);
g_signal_handlers_block_by_func (tsel->priv->properties_name,
G_CALLBACK (property_changed_cb), tsel);
gtk_entry_set_text (GTK_ENTRY (tsel->priv->properties_name), name);
g_signal_handlers_unblock_by_func (tsel->priv->properties_name,
G_CALLBACK (property_changed_cb), tsel);
g_free (name);
g_signal_handlers_block_by_func (tsel->priv->properties_text,
G_CALLBACK (property_changed_cb), tsel);
query_editor_set_text (QUERY_EDITOR (tsel->priv->properties_text), contents);
g_signal_handlers_unblock_by_func (tsel->priv->properties_text,
G_CALLBACK (property_changed_cb), tsel);
g_free (contents);
/* action, if any */
g_signal_handlers_block_by_func (tsel->priv->properties_action,
G_CALLBACK (property_changed_cb), tsel);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tsel->priv->properties_action), FALSE);
if (tsel->priv->properties_id >= 0) {
gint id;
gchar *tmp;
TFavorites *bfav;
TFavoritesAttributes fav;
bfav = t_connection_get_favorites (tsel->priv->tcnc);
tmp = g_strdup_printf ("QUERY%d", tsel->priv->properties_id);
id = t_favorites_find (bfav, 0, tmp, &fav, NULL);
if (id >= 0) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tsel->priv->properties_action),
TRUE);
/*g_print ("ACTION_USED %d: %s\n", fav.id, tmp);*/
}
g_free (tmp);
}
g_signal_handlers_unblock_by_func (tsel->priv->properties_action,
G_CALLBACK (property_changed_cb), tsel);
gtk_widget_show (tsel->priv->popup_properties);
}
}
char *
_gtk_request_dialog_run (GtkWindow *parent,
GtkDialogFlags flags,
const char *title,
const char *message,
const char *default_value,
int max_length,
const gchar *no_button_text,
const gchar *yes_button_text)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *image;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *button;
GtkWidget *content_area;
char *result;
dialog = gtk_dialog_new_with_buttons (title, parent, flags, NULL, NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
/* Add label and image */
image = gtk_image_new_from_icon_name ("dialog-question", GTK_ICON_SIZE_DIALOG);
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
label = gtk_label_new_with_mnemonic (message);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), FALSE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.0);
entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (entry), 50);
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_entry_set_max_length (GTK_ENTRY (entry), max_length);
gtk_entry_set_text (GTK_ENTRY (entry), default_value);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 14); /* 14 + 2 * 5 = 24 */
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_box_set_spacing (GTK_BOX (vbox), 6);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
/* Add buttons */
button = create_button ("gtk-cancel", no_button_text);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_CANCEL);
button = create_button ("gtk-ok", yes_button_text);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_YES);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
/* Run dialog */
gtk_widget_grab_focus (entry);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_YES)
result = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
else
result = NULL;
gtk_widget_destroy (dialog);
return result;
}
