static void gtk_color_button_init (GtkColorButton *color_button) { GtkWidget *alignment; GtkWidget *frame; PangoLayout *layout; PangoRectangle rect; /* Create the widgets */ color_button->priv = GTK_COLOR_BUTTON_GET_PRIVATE (color_button); gtk_widget_push_composite_child (); alignment = gtk_alignment_new (0.5, 0.5, 0.5, 1.0); gtk_container_set_border_width (GTK_CONTAINER (alignment), 1); gtk_container_add (GTK_CONTAINER (color_button), alignment); gtk_widget_show (alignment); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_OUT); gtk_container_add (GTK_CONTAINER (alignment), frame); gtk_widget_show (frame); /* Just some widget we can hook to expose-event on */ color_button->priv->draw_area = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); layout = gtk_widget_create_pango_layout (GTK_WIDGET (color_button), "Black"); pango_layout_get_pixel_extents (layout, NULL, &rect); g_object_unref (layout); gtk_widget_set_size_request (color_button->priv->draw_area, rect.width - 2, rect.height - 2); g_signal_connect (color_button->priv->draw_area, "expose-event", G_CALLBACK (expose_event), color_button); gtk_container_add (GTK_CONTAINER (frame), color_button->priv->draw_area); gtk_widget_show (color_button->priv->draw_area); color_button->priv->title = g_strdup (_("Pick a Color")); /* default title */ /* Start with opaque black, alpha disabled */ color_button->priv->color.red = 0; color_button->priv->color.green = 0; color_button->priv->color.blue = 0; color_button->priv->alpha = 65535; color_button->priv->use_alpha = FALSE; gtk_drag_dest_set (GTK_WIDGET (color_button), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, 1, GDK_ACTION_COPY); gtk_drag_source_set (GTK_WIDGET(color_button), GDK_BUTTON1_MASK|GDK_BUTTON3_MASK, drop_types, 1, GDK_ACTION_COPY); g_signal_connect (color_button, "drag-begin", G_CALLBACK (gtk_color_button_drag_begin), color_button); g_signal_connect (color_button, "drag-data-received", G_CALLBACK (gtk_color_button_drag_data_received), color_button); g_signal_connect (color_button, "drag-data-get", G_CALLBACK (gtk_color_button_drag_data_get), color_button); gtk_widget_pop_composite_child (); }
static void viewer_init (Viewer *viewer) { viewer->renderers = g_ptr_array_new(); viewer->renderers_sorted = g_ptr_array_new(); viewer->renderers_sorted_with_controls = g_ptr_array_new(); viewer->event_handlers = g_ptr_array_new(); viewer->event_handlers_sorted = g_ptr_array_new(); viewer->modes = g_ptr_array_new(); viewer->prettier_flag = (getenv("DGC_VIEWER_PRETTIER") != NULL && atoi(getenv("DGC_VIEWER_PRETTIER"))>0);; printf("DGC_VIEWER_PRETTIER: %d\n", viewer->prettier_flag); viewer->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(viewer->window), "Viewer"); gtk_window_set_resizable(GTK_WINDOW(viewer->window), TRUE); gtk_window_set_default_size(GTK_WINDOW(viewer->window), 800, 540); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(viewer->window), vbox); make_menus(viewer, vbox); viewer->tips = gtk_tooltips_new (); make_toolbar(viewer, vbox); GtkWidget *hpaned = gtk_hpaned_new(); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); GtkWidget *gl_box = gtk_event_box_new(); gtk_paned_pack1(GTK_PANED(hpaned), gl_box, TRUE, TRUE); GtkWidget *controls_align = gtk_alignment_new(.5, .5, 1, 1); gtk_paned_pack2(GTK_PANED(hpaned), controls_align, FALSE, TRUE); gtk_paned_set_position(GTK_PANED(hpaned), 560); GtkWidget *controls_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(controls_align), controls_scroll); GtkWidget *controls_view = gtk_viewport_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(controls_scroll), controls_view); viewer->controls_box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(controls_view), viewer->controls_box); viewer->status_bar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), viewer->status_bar, FALSE, FALSE, 0); viewer_set_status_bar_message(viewer, "Ready"); // create the aspect area to maintain a 1:1 aspect ratio viewer->gl_area = GTKU_GL_DRAWING_AREA (gtku_gl_drawing_area_new (FALSE)); gtk_widget_set_events (GTK_WIDGET (viewer->gl_area), GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK); gtk_container_add (GTK_CONTAINER (gl_box), GTK_WIDGET (viewer->gl_area)); gtk_widget_show (GTK_WIDGET (viewer->gl_area)); g_signal_connect (G_OBJECT (viewer->gl_area), "configure-event", G_CALLBACK (on_gl_configure), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "expose-event", G_CALLBACK (on_gl_expose), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "button-press-event", G_CALLBACK (on_button_press), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "button-release-event", G_CALLBACK (on_button_release), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "motion-notify-event", G_CALLBACK (on_motion_notify), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "scroll-event", G_CALLBACK (on_scroll_notify), viewer); g_signal_connect (G_OBJECT (viewer->window), "key_press_event", G_CALLBACK (on_main_window_key_press_event), viewer); g_signal_connect (G_OBJECT (viewer->window), "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (G_OBJECT (viewer->window), "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (G_OBJECT (viewer->window), "destroy_event", G_CALLBACK(gtk_main_quit), NULL); //////////////////////////////////////////////////////////////////// // Create plugins menu // plugins will be inserted here as add_plugin is called gtk_widget_show_all(viewer->window); DefaultViewHandler *dvh = default_view_handler_new(viewer); viewer->default_view_handler = &dvh->vhandler; viewer_request_redraw(viewer); }
void idou_window_init(iDouWindow *self) { GtkWidget *window; GtkWidget *hbox, *hbox2, *hbox3, *hbox4, *hbox5; GtkWidget *vbox, *vbox2, *vbox3; GtkWidget *image; GdkPixbuf *pixbuf; window = GTK_WIDGET(self); gtk_window_set_default_size(GTK_WINDOW(window), 720, 580); gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_widget_set_name(window, "iDouWindow"); self->shadow_radius = 10; self->frame_radius = 3; //self->shadow_padding = self->shadow_radius - self->frame_radius; //GtkWidget *window_shadow = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); //gtk_alignment_set_padding(GTK_ALIGNMENT(window_shadow), self->shadow_padding, self->shadow_padding, self->shadow_padding, self->shadow_padding); //g_signal_connect(G_OBJECT(window_shadow), "draw", G_CALLBACK(on_draw_shadow), (gpointer)self); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); vbox3 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); hbox4 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); hbox5 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); GtkWidget *title_bar = idou_titlebar_new(); gtk_box_pack_start(GTK_BOX(vbox), title_bar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 2); self->music_name = gtk_label_new(NULL); self->time_label = gtk_label_new("00:00/00:00"); gtk_box_pack_start(GTK_BOX(hbox3), self->music_name, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox3), self->time_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox3), hbox3, FALSE, FALSE, 0); self->progress_adjust = gtk_adjustment_new(0, 0, 100, 1, 0, 0); GtkWidget *time_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, self->progress_adjust); gtk_scale_set_draw_value(GTK_SCALE(time_scale), FALSE); g_signal_connect(G_OBJECT(time_scale), "value-changed", G_CALLBACK(on_time_scale_change_value), NULL); gtk_box_pack_start(GTK_BOX(vbox3), time_scale, FALSE, FALSE, 0); GtkWidget *lyric_toggle = gtk_check_button_new_with_label("歌词"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lyric_toggle), TRUE); gtk_box_pack_start(GTK_BOX(hbox4), lyric_toggle, FALSE, FALSE, 0); GtkWidget *align = gtk_alignment_new(0.3, 0, 0, 0); GtkWidget *last_btn = itk_button_new(); ITK_BUTTON_SET(last_btn, RESDIR"image/button/last_normal.png", RESDIR"image/button/last_hover.png", RESDIR"image/button/last_press.png", 32, 32); GtkWidget *play_btn = itk_button_new(); ITK_BUTTON_SET(play_btn, RESDIR"image/button/play_normal.png", RESDIR"image/button/play_hover.png", RESDIR"image/button/play_press.png", 32, 32); GtkWidget *next_btn = itk_button_new(); ITK_BUTTON_SET(next_btn, RESDIR"image/button/next_normal.png", RESDIR"image/button/next_hover.png", RESDIR"image/button/next_press.png", 32, 32); g_signal_connect(G_OBJECT(play_btn), "clicked", G_CALLBACK(on_play_event), (gpointer)self); gtk_box_pack_start(GTK_BOX(hbox2), last_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox2), play_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox2), next_btn, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(align), hbox2); gtk_box_pack_start(GTK_BOX(hbox4), align, TRUE, FALSE, 0); self->volume_adjust = gtk_adjustment_new(0, 0, 100, 1, 0, 0); GtkWidget *volume_scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, self->volume_adjust); gtk_range_set_value(GTK_RANGE(volume_scale), 50); gtk_widget_set_size_request(volume_scale, 60, 10); gtk_scale_set_draw_value(GTK_SCALE(volume_scale), FALSE); gtk_box_pack_end(GTK_BOX(hbox4), volume_scale, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox3), hbox4, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), vbox3, FALSE, FALSE, 3); GtkWidget *music_manager = idou_music_manager_new(); gtk_box_pack_start(GTK_BOX(vbox2), music_manager, TRUE, TRUE, 2); GtkWidget *order_btn = itk_button_new(); ITK_BUTTON_SET(order_btn, RESDIR"image/playmode/order_normal.png", RESDIR"image/playmode/order_hover.png", RESDIR"image/playmode/order_press.png", 18, 14); GtkWidget *loop_btn = itk_button_new(); ITK_BUTTON_SET(loop_btn, RESDIR"image/playmode/loop_normal.png", RESDIR"image/playmode/loop_hover.png", RESDIR"image/playmode/loop_press.png", 18, 14); GtkWidget *random_btn = itk_button_new(); ITK_BUTTON_SET(random_btn, RESDIR"image/playmode/random_normal.png", RESDIR"image/playmode/random_hover.png", RESDIR"image/playmode/random_press.png", 18, 14); GtkWidget *single_btn = itk_button_new(); ITK_BUTTON_SET(single_btn, RESDIR"image/playmode/single_normal.png", RESDIR"image/playmode/single_hover.png", RESDIR"image/playmode/single_press.png", 18, 14); gtk_box_pack_start(GTK_BOX(hbox5), order_btn, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox5), loop_btn, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox5), random_btn, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox5), single_btn, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox2), hbox5, FALSE, FALSE, 3); GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); WebKitWebView *web_view; web_view = webkit_web_view_new(); /*webkit_web_view_load_uri(web_view, "http://www.baidu.com/");*/ webkit_web_view_load_uri(web_view, "file://"RESDIR"html/index.html"); gtk_container_add(GTK_CONTAINER(scrolled), web_view); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); g_signal_connect(G_OBJECT(title_bar), "itk-destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect_after(G_OBJECT(window), "draw", G_CALLBACK(on_draw), NULL); GtkCssProvider *provider = gtk_css_provider_new(); GdkScreen *screen = gdk_screen_get_default(); GdkVisual *visual = gdk_screen_get_rgba_visual(screen); gtk_widget_set_visual(window, visual); const gchar *css_data = "#iDouWindow {" "background-image: url('" RESDIR"image/skin/blueSky.jpg');" "background-size: 100% 100%;" "}"; gtk_css_provider_load_from_data(provider, css_data, -1, NULL); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref(provider); gtk_widget_show_all(window); }
static GtkWidget * bezierline_get_properties(Bezierline *bezierline) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *color; GtkWidget *linestyle; GtkWidget *arrow; GtkWidget *line_width; GtkWidget *align; GtkAdjustment *adj; if (bezierline_properties_dialog == NULL) { bezierline_properties_dialog = g_new(BezierlinePropertiesDialog, 1); vbox = gtk_vbox_new(FALSE, 5); bezierline_properties_dialog->vbox = vbox; hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("Line width:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); adj = (GtkAdjustment *) gtk_adjustment_new(0.1, 0.00, 10.0, 0.01, 0.0, 0.0); line_width = gtk_spin_button_new(adj, 1.0, 2); gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(line_width), TRUE); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(line_width), TRUE); bezierline_properties_dialog->line_width = GTK_SPIN_BUTTON(line_width); gtk_box_pack_start(GTK_BOX (hbox), line_width, TRUE, TRUE, 0); gtk_widget_show (line_width); gtk_widget_show(hbox); gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("Color:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); color = dia_color_selector_new(); bezierline_properties_dialog->color = DIACOLORSELECTOR(color); gtk_box_pack_start (GTK_BOX (hbox), color, TRUE, TRUE, 0); gtk_widget_show (color); gtk_widget_show(hbox); gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("Line style:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); linestyle = dia_line_style_selector_new(); bezierline_properties_dialog->line_style = DIALINESTYLESELECTOR(linestyle); gtk_box_pack_start (GTK_BOX (hbox), linestyle, TRUE, TRUE, 0); gtk_widget_show (linestyle); gtk_widget_show(hbox); gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("Start arrow:")); align = gtk_alignment_new(0.0,0.0,0.0,0.0); gtk_container_add(GTK_CONTAINER(align), label); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, TRUE, 0); gtk_widget_show (label); gtk_widget_show(align); arrow = dia_arrow_selector_new(); bezierline_properties_dialog->start_arrow = DIAARROWSELECTOR(arrow); gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, TRUE, 0); gtk_widget_show (arrow); gtk_widget_show(hbox); gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("End arrow:")); align = gtk_alignment_new(0.0,0.0,0.0,0.0); gtk_container_add(GTK_CONTAINER(align), label); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, TRUE, 0); gtk_widget_show (label); gtk_widget_show(align); arrow = dia_arrow_selector_new(); bezierline_properties_dialog->end_arrow = DIAARROWSELECTOR(arrow); gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, TRUE, 0); gtk_widget_show (arrow); gtk_widget_show(hbox); gtk_box_pack_start (GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (vbox); } bezierline_properties_dialog->bezierline = bezierline; gtk_spin_button_set_value(bezierline_properties_dialog->line_width, bezierline->line_width); dia_color_selector_set_color(bezierline_properties_dialog->color, &bezierline->line_color); dia_line_style_selector_set_linestyle(bezierline_properties_dialog->line_style, bezierline->line_style, bezierline->dashlength); dia_arrow_selector_set_arrow(bezierline_properties_dialog->start_arrow, bezierline->start_arrow); dia_arrow_selector_set_arrow(bezierline_properties_dialog->end_arrow, bezierline->end_arrow); return bezierline_properties_dialog->vbox; }
/* Add a group of options: create title and layout widgets and then add widgets for all the options in the group. */ static void xkb_options_add_group (XklConfigRegistry * config_registry, XklConfigItem * config_item, GtkBuilder * dialog) { GtkWidget *align, *vbox, *option_check; gboolean allow_multiple_selection = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (config_item), XCI_PROP_ALLOW_MULTIPLE_SELECTION)); GSList *expanders_list = g_object_get_data (G_OBJECT (dialog), EXPANDERS_PROP); gchar *utf_group_name = xci_desc_to_utf8 (config_item); gchar *titlemarkup = g_strconcat ("<span>", utf_group_name, "</span>", NULL); current_expander = gtk_expander_new (titlemarkup); gtk_expander_set_use_markup (GTK_EXPANDER (current_expander), TRUE); g_object_set_data_full (G_OBJECT (current_expander), "utfGroupName", utf_group_name, g_free); g_object_set_data_full (G_OBJECT (current_expander), "groupId", g_strdup (config_item->name), g_free); g_free (titlemarkup); align = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 6, 12, 12, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_container_add (GTK_CONTAINER (align), vbox); gtk_container_add (GTK_CONTAINER (current_expander), align); current_multi_select = (gboolean) allow_multiple_selection; current_radio_group = NULL; current1st_level_id = config_item->name; option_checks_list = NULL; xkl_config_registry_foreach_option (config_registry, config_item->name, (ConfigItemProcessFunc) xkb_options_add_option, dialog); /* sort it */ option_checks_list = g_slist_sort (option_checks_list, (GCompareFunc) xkb_option_checks_compare); while (option_checks_list) { option_check = GTK_WIDGET (option_checks_list->data); gtk_box_pack_start (GTK_BOX (vbox), option_check, TRUE, TRUE, 0); option_checks_list = option_checks_list->next; } /* free it */ g_slist_free (option_checks_list); option_checks_list = NULL; xkb_options_expander_highlight (); expanders_list = g_slist_append (expanders_list, current_expander); g_object_set_data (G_OBJECT (dialog), EXPANDERS_PROP, expanders_list); g_signal_connect (current_expander, "focus-in-event", G_CALLBACK (option_focused_cb), WID ("options_scroll")); }
GtkWidget* create_WaitWindow (void) { GtkWidget *WaitWindow; GtkWidget *fixed1; GtkWidget *CancelButton; GtkWidget *alignment1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *label2; WaitWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (WaitWindow), "Waiting for user"); fixed1 = gtk_fixed_new (); gtk_widget_show (fixed1); gtk_container_add (GTK_CONTAINER (WaitWindow), fixed1); gtk_widget_set_size_request (fixed1, 400, 40); MessageLabel = gtk_label_new ("Waiting for user to connect."); gtk_widget_show (MessageLabel); gtk_fixed_put (GTK_FIXED (fixed1), MessageLabel, 0, 0); gtk_widget_set_size_request (MessageLabel, 400, 16); CancelButton = gtk_button_new (); gtk_widget_show (CancelButton); gtk_fixed_put (GTK_FIXED (fixed1), CancelButton, 160, 16); gtk_widget_set_size_request (CancelButton, 88, 24); alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (CancelButton), alignment1); hbox1 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment1), hbox1); image1 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic ("Cancel"); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox1), label2, FALSE, FALSE, 0); g_signal_connect ((gpointer) CancelButton, "clicked", G_CALLBACK (on_CancelButton_clicked), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (WaitWindow, WaitWindow, "WaitWindow"); GLADE_HOOKUP_OBJECT (WaitWindow, fixed1, "fixed1"); GLADE_HOOKUP_OBJECT (WaitWindow, MessageLabel, "MessageLabel"); GLADE_HOOKUP_OBJECT (WaitWindow, CancelButton, "CancelButton"); GLADE_HOOKUP_OBJECT (WaitWindow, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (WaitWindow, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (WaitWindow, image1, "image1"); GLADE_HOOKUP_OBJECT (WaitWindow, label2, "label2"); gtk_timeout_add(50, connect_wait, WaitWindow); return WaitWindow; }
static GtkWidget *create_timer_list(CtkConfig *ctk_config) { GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *sw; GtkWidget *vbox; GtkWidget *label; GtkWidget *alignment; sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); ctk_config->list_store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_POINTER, /* TIMER_CONFIG_COLUMN */ G_TYPE_POINTER, /* FUNCTION_COLUMN */ G_TYPE_POINTER, /* DATA_COLUMN */ G_TYPE_UINT, /* HANDLE_COLUMN */ G_TYPE_BOOLEAN); /* OWNER_ENABLE_COLUMN */ model = GTK_TREE_MODEL(ctk_config->list_store); treeview = gtk_tree_view_new_with_model(model); g_object_unref(ctk_config->list_store); /* Enable */ renderer = gtk_cell_renderer_toggle_new(); g_signal_connect(renderer, "toggled", G_CALLBACK(timer_enable_toggled), ctk_config); column = gtk_tree_view_column_new_with_attributes("Enabled", renderer, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, enabled_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); /* Description */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, description_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); /* Time interval */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time Interval", renderer, NULL); g_signal_connect(renderer, "edited", G_CALLBACK(time_interval_edited), ctk_config); gtk_tree_view_column_set_cell_data_func(column, renderer, time_interval_renderer_func, GINT_TO_POINTER (TIMER_CONFIG_COLUMN), NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_column_set_resizable(column, FALSE); gtk_container_add(GTK_CONTAINER(sw), treeview); vbox = gtk_vbox_new(FALSE, 5); label = gtk_label_new("Active Timers:"); alignment = gtk_alignment_new(0.0, 0.0, 0, 0); gtk_container_add(GTK_CONTAINER(alignment), label); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); /* create the tooltip for the treeview (can't do it per column) */ ctk_config_set_tooltip(ctk_config, treeview, "The Active Timers describe operations that " "nvidia-settings will perform at regular " "intervals."); return vbox; } /* create_timer_list() */
static void rejilla_burn_options_build_contents (RejillaBurnOptions *object) { RejillaBurnOptionsPrivate *priv; GtkWidget *content_area; GtkWidget *selection; GtkWidget *alignment; gchar *string; priv = REJILLA_BURN_OPTIONS_PRIVATE (object); priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* Sets default flags for the session */ rejilla_burn_session_add_flag (REJILLA_BURN_SESSION (priv->session), REJILLA_BURN_FLAG_NOGRACE| REJILLA_BURN_FLAG_CHECK_SIZE); /* Create a cancel button */ gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); /* Create an upper box for sources */ priv->source_placeholder = gtk_alignment_new (0.0, 0.5, 1.0, 1.0); content_area = gtk_dialog_get_content_area (GTK_DIALOG (object)); gtk_box_pack_start (GTK_BOX (content_area), priv->source_placeholder, FALSE, TRUE, 0); /* Medium selection box */ selection = gtk_hbox_new (FALSE, 12); gtk_widget_show (selection); alignment = gtk_alignment_new (0.0, 0.5, 1.0, 1.0); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (selection), alignment, TRUE, TRUE, 0); priv->selection = rejilla_dest_selection_new (REJILLA_BURN_SESSION (priv->session)); gtk_widget_show (priv->selection); gtk_container_add (GTK_CONTAINER (alignment), priv->selection); priv->properties = rejilla_medium_properties_new (priv->session); gtk_size_group_add_widget (priv->size_group, priv->properties); gtk_widget_show (priv->properties); gtk_box_pack_start (GTK_BOX (selection), priv->properties, FALSE, FALSE, 0); /* Box to display warning messages */ priv->message_output = rejilla_notify_new (); gtk_widget_show (priv->message_output); string = g_strdup_printf ("<b>%s</b>", _("Select a disc to write to")); selection = rejilla_utils_pack_properties (string, priv->message_output, selection, NULL); g_free (string); gtk_widget_show (selection); gtk_box_pack_start (GTK_BOX (content_area), selection, FALSE, TRUE, 0); /* Create a lower box for options */ alignment = gtk_alignment_new (0.0, 0.5, 1.0, 1.0); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (content_area), alignment, FALSE, TRUE, 0); priv->options_placeholder = alignment; priv->options = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (alignment), priv->options); g_signal_connect (priv->session, "is-valid", G_CALLBACK (rejilla_burn_options_valid_cb), object); rejilla_burn_options_update_valid (object); }
RestoreAssistant::RestoreAssistant(GtkWindow *transient_parent) : AssistantBase(_("Restore"), _("restore"), transient_parent) // Restore assistant. { gtk_assistant_set_forward_page_func (GTK_ASSISTANT (assistant), GtkAssistantPageFunc (assistant_forward_function), gpointer(this), NULL); g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (on_assistant_apply_signal), gpointer(this)); g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare_signal), gpointer(this)); introduction (_("This assists you with restoring a backup")); // Configuration and initialization. extern Settings *settings; ustring project = settings->genconfig.project_get(); // Build the GUI for the task selector. vbox_select_type = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_select_type); page_number_select_type = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_select_type); gtk_container_set_border_width (GTK_CONTAINER (vbox_select_type), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_select_type, _("What would you like to restore?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_select_type, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_select_type, true); GSList *radiobutton_select_type_group = NULL; radiobutton_select_type_bible = gtk_radio_button_new_with_mnemonic (NULL, _("Bible")); gtk_widget_show (radiobutton_select_type_bible); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_bible, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible)); radiobutton_select_type_notes = gtk_radio_button_new_with_mnemonic (NULL, _("Notes")); gtk_widget_show (radiobutton_select_type_notes); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_notes, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes)); radiobutton_select_type_resource = gtk_radio_button_new_with_mnemonic (NULL, _("Resource")); gtk_widget_show (radiobutton_select_type_resource); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_resource, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource)); radiobutton_select_type_everything = gtk_radio_button_new_with_mnemonic (NULL, _("Everything")); gtk_widget_show (radiobutton_select_type_everything); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_everything, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything)); Shortcuts shortcuts_select_type (0); shortcuts_select_type.button (radiobutton_select_type_bible); shortcuts_select_type.button (radiobutton_select_type_notes); shortcuts_select_type.button (radiobutton_select_type_resource); shortcuts_select_type.button (radiobutton_select_type_everything); shortcuts_select_type.consider_assistant(); shortcuts_select_type.process(); // Confirm or change Bible. vbox_bible_name = gtk_vbox_new (FALSE, 5); gtk_widget_show (vbox_bible_name); page_number_bible_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_bible_name); gtk_container_set_border_width (GTK_CONTAINER (vbox_bible_name), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_bible_name, _("What will be the name of the Bible?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_bible_name, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_bible_name, true); entry_bible_name = gtk_entry_new (); gtk_widget_show (entry_bible_name); gtk_box_pack_start (GTK_BOX (vbox_bible_name), entry_bible_name, FALSE, FALSE, 0); label_bible_name = gtk_label_new (""); gtk_widget_show (label_bible_name); gtk_box_pack_start (GTK_BOX (vbox_bible_name), label_bible_name, FALSE, FALSE, 0); g_signal_connect_after ((gpointer) entry_bible_name, "changed", G_CALLBACK (on_entry_bible_name_changed), gpointer (this)); // Select file. vbox_file = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_file); page_number_file = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_file); gtk_container_set_border_width (GTK_CONTAINER (vbox_file), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_file, _("What is the file to restore?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_file, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_file, false); button_file = gtk_button_new (); gtk_widget_show (button_file); gtk_box_pack_start (GTK_BOX (vbox_file), button_file, FALSE, FALSE, 0); GtkWidget *alignment2; GtkWidget *hbox2; GtkWidget *image2; alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (button_file), alignment2); hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox2); gtk_container_add (GTK_CONTAINER (alignment2), hbox2); image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0); label_file = gtk_label_new_with_mnemonic (""); gtk_widget_show (label_file); gtk_box_pack_start (GTK_BOX (hbox2), label_file, FALSE, FALSE, 0); g_signal_connect ((gpointer) button_file, "clicked", G_CALLBACK (on_button_file_clicked), gpointer(this)); // Build the confirmation stuff. label_confirm = gtk_label_new (_("Restore is about to be done")); gtk_widget_show (label_confirm); page_number_confirm = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_confirm); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_confirm, _("Restore is about to be done")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_confirm, GTK_ASSISTANT_PAGE_CONFIRM); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_confirm, true); label_progress = gtk_label_new (_("Restore is in progress")); gtk_widget_show (label_progress); page_number_progress = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_progress); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_progress, ""); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_progress, GTK_ASSISTANT_PAGE_PROGRESS); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_progress, true); label_summary = gtk_label_new (""); gtk_widget_show (label_summary); summary_page_number = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_summary); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_summary, _("Ready")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_summary, GTK_ASSISTANT_PAGE_SUMMARY); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_summary, true); // Finish building assistant. gtk_widget_show_all (assistant); gtk_assistant_set_current_page (GTK_ASSISTANT (assistant), 0); }
static gboolean activate_panel (GnomeControlCenter *shell, const gchar *id, const gchar **argv, const gchar *desktop_file, const gchar *name, GIcon *gicon) { GDesktopAppInfo *appinfo; GdkAppLaunchContext *context; GdkScreen *screen; GdkDisplay *display; GError *error; appinfo = g_desktop_app_info_new_from_filename (desktop_file); screen = gtk_widget_get_screen (shell->priv->window); display = gdk_screen_get_display (screen); context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, gtk_get_current_event_time ()); error = NULL; g_app_info_launch_uris (G_APP_INFO (appinfo), NULL, (GAppLaunchContext *) context, &error); if (error) { g_printerr ("Could not launch '%s': %s\n", id, error->message); g_clear_error (&error); } g_object_unref (context); g_object_unref (appinfo); #if 0 GnomeControlCenterPrivate *priv = shell->priv; GType panel_type = G_TYPE_INVALID; GList *panels, *l; GtkWidget *box; const gchar *icon_name; /* check if there is an plugin that implements this panel */ panels = g_io_extension_point_get_extensions (priv->extension_point); if (!desktop_file) return FALSE; if (!id) return FALSE; for (l = panels; l != NULL; l = l->next) { GIOExtension *extension; const gchar *name; extension = l->data; name = g_io_extension_get_name (extension); if (!g_strcmp0 (name, id)) { panel_type = g_io_extension_get_type (extension); break; } } if (panel_type == G_TYPE_INVALID) { g_warning ("Could not find the loadable module for panel '%s'", id); return FALSE; } /* create the panel plugin */ priv->current_panel = g_object_new (panel_type, "shell", shell, "argv", argv, NULL); cc_shell_set_active_panel (CC_SHELL (shell), CC_PANEL (priv->current_panel)); gtk_widget_show (priv->current_panel); gtk_lock_button_set_permission (GTK_LOCK_BUTTON (priv->lock_button), cc_panel_get_permission (CC_PANEL (priv->current_panel))); box = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (box), 6, 6, 6, 6); gtk_container_add (GTK_CONTAINER (box), priv->current_panel); gtk_widget_set_name (box, id); notebook_add_page (priv->notebook, box); /* switch to the new panel */ gtk_widget_show (box); notebook_select_page (priv->notebook, box); /* set the title of the window */ icon_name = get_icon_name_from_g_icon (gicon); gtk_window_set_role (GTK_WINDOW (priv->window), id); gtk_window_set_title (GTK_WINDOW (priv->window), name); gtk_window_set_default_icon_name (icon_name); gtk_window_set_icon_name (GTK_WINDOW (priv->window), icon_name); priv->current_panel_box = box; #endif return TRUE; }
GtkWidget * do_stock_browser (GtkWidget *do_widget) { if (!window) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *sw; GtkWidget *treeview; GtkWidget *align; GtkTreeModel *model; GtkCellRenderer *cell_renderer; StockItemDisplay *display; GtkTreeSelection *selection; GtkTreeViewColumn *column; 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), "Stock Icons and Items"); gtk_window_set_default_size (GTK_WINDOW (window), -1, 500); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 8); hbox = gtk_hbox_new (FALSE, 8); gtk_container_add (GTK_CONTAINER (window), hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0); model = create_model (); treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (sw), treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Macro"); cell_renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell_renderer, FALSE); gtk_tree_view_column_set_attributes (column, cell_renderer, "stock_id", 1, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, cell_renderer, macro_set_func_text, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "Label", cell_renderer, label_set_func, NULL, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "Accel", cell_renderer, accel_set_func, NULL, NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), -1, "ID", cell_renderer, id_set_func, NULL, NULL); align = gtk_alignment_new (0.5, 0.0, 0.0, 0.0); gtk_box_pack_end (GTK_BOX (hbox), align, FALSE, FALSE, 0); frame = gtk_frame_new ("Selected Item"); gtk_container_add (GTK_CONTAINER (align), frame); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 4); gtk_container_add (GTK_CONTAINER (frame), vbox); display = g_new (StockItemDisplay, 1); g_object_set_data_full (G_OBJECT (treeview), "stock-display", display, g_free); /* free display with treeview */ display->type_label = gtk_label_new (NULL); display->macro_label = gtk_label_new (NULL); display->id_label = gtk_label_new (NULL); display->label_accel_label = gtk_label_new (NULL); display->icon_image = gtk_image_new_from_pixbuf (NULL); /* empty image */ gtk_box_pack_start (GTK_BOX (vbox), display->type_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->icon_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->label_accel_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->macro_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), display->id_label, FALSE, FALSE, 0); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (selection_changed), NULL); } if (!gtk_widget_get_visible (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
static void gimp_hue_saturation_tool_dialog (GimpImageMapTool *image_map_tool) { GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (image_map_tool); GimpHueSaturationConfig *config = hs_tool->config; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *abox; GtkWidget *table; GtkWidget *button; GtkWidget *frame; GtkWidget *hbox; GtkObject *data; GtkSizeGroup *label_group; GtkSizeGroup *spinner_group; GSList *group = NULL; gint i; const struct { const gchar *label; const gchar *tooltip; gint label_col; gint label_row; gint frame_col; gint frame_row; } hue_range_table[] = { { N_("M_aster"), N_("Adjust all colors"), 2, 3, 0, 0 }, { N_("_R"), N_("Red"), 2, 1, 2, 0 }, { N_("_Y"), N_("Yellow"), 1, 2, 0, 2 }, { N_("_G"), N_("Green"), 1, 4, 0, 4 }, { N_("_C"), N_("Cyan"), 2, 5, 2, 6 }, { N_("_B"), N_("Blue"), 3, 4, 4, 4 }, { N_("_M"), N_("Magenta"), 3, 2, 4, 2 } }; main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); frame = gimp_frame_new (_("Select Primary Color to Adjust")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, TRUE, TRUE, 0); gtk_widget_show (abox); /* The table containing hue ranges */ table = gtk_table_new (7, 5, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (table), 3, 4); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 5, 2); gtk_container_add (GTK_CONTAINER (abox), table); /* the radio buttons for hue ranges */ for (i = 0; i < G_N_ELEMENTS (hue_range_table); i++) { button = gtk_radio_button_new_with_mnemonic (group, gettext (hue_range_table[i].label)); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gimp_help_set_help_data (button, gettext (hue_range_table[i].tooltip), NULL); if (i == 0) { gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); hs_tool->range_radio = button; } gtk_table_attach (GTK_TABLE (table), button, hue_range_table[i].label_col, hue_range_table[i].label_col + 1, hue_range_table[i].label_row, hue_range_table[i].label_row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); if (i > 0) { GimpRGB color = { 0.0 }; frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), frame, hue_range_table[i].frame_col, hue_range_table[i].frame_col + 1, hue_range_table[i].frame_row, hue_range_table[i].frame_row + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (frame); hs_tool->hue_range_color_area[i - 1] = gimp_color_area_new (&color, GIMP_COLOR_AREA_FLAT, 0); gtk_widget_set_size_request (hs_tool->hue_range_color_area[i - 1], DA_WIDTH, DA_HEIGHT); gtk_container_add (GTK_CONTAINER (frame), hs_tool->hue_range_color_area[i - 1]); gtk_widget_show (hs_tool->hue_range_color_area[i - 1]); } g_signal_connect (button, "toggled", G_CALLBACK (hue_saturation_range_callback), hs_tool); gtk_widget_show (button); } gtk_widget_show (table); label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); spinner_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* Create the 'Overlap' option slider */ table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Overlap:"), SLIDER_WIDTH, -1, config->overlap * 100.0, 0.0, 100.0, 1.0, 15.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->overlap_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_object_unref (label_group); g_object_unref (spinner_group); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_overlap_changed), hs_tool); frame = gimp_frame_new (_("Adjust Selected Color")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* The table containing sliders */ vbox = gtk_vbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Create the hue scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Hue:"), SLIDER_WIDTH, -1, config->hue[config->range] * 180.0, -180.0, 180.0, 1.0, 15.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->hue_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_hue_changed), hs_tool); /* Create the lightness scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Lightness:"), SLIDER_WIDTH, -1, config->lightness[config->range] * 100.0, -100.0, 100.0, 1.0, 10.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->lightness_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (data, "value-changed", G_CALLBACK (hue_saturation_lightness_changed), hs_tool); /* Create the saturation scale widget */ data = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("_Saturation:"), SLIDER_WIDTH, -1, config->saturation[config->range] * 100.0, -100.0, 100.0, 1.0, 10.0, 0, TRUE, 0.0, 0.0, NULL, NULL); hs_tool->saturation_data = GTK_ADJUSTMENT (data); gtk_size_group_add_widget (label_group, GIMP_SCALE_ENTRY_LABEL (data)); gtk_size_group_add_widget (spinner_group, GIMP_SCALE_ENTRY_SPINBUTTON (data)); g_signal_connect (hs_tool->saturation_data, "value-changed", G_CALLBACK (hue_saturation_saturation_changed), hs_tool); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_with_mnemonic (_("R_eset Color")); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (hue_saturation_range_reset_callback), hs_tool); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (hs_tool->range_radio), config->range); hue_saturation_update_color_areas (hs_tool); }
/* Public GnomeTwoPasswordDialog methods */ GtkWidget * gnome_two_password_dialog_new (const char *dialog_title, const char *message, const char *username, const char *password, gboolean readonly_username) { GnomeTwoPasswordDialog *password_dialog; GtkDialog *dialog; GtkWidget *table; GtkLabel *message_label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *dialog_icon; GSList *group; password_dialog = GNOME_TWO_PASSWORD_DIALOG (gtk_widget_new (gnome_two_password_dialog_get_type (), NULL)); dialog = GTK_DIALOG (password_dialog); gtk_window_set_title (GTK_WINDOW (password_dialog), dialog_title); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (password_dialog), GTK_RESPONSE_OK); /* Setup the dialog */ gtk_dialog_set_has_separator (dialog, FALSE); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5); gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6); gtk_window_set_position (GTK_WINDOW (password_dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (password_dialog), TRUE); g_signal_connect (password_dialog, "show", G_CALLBACK (dialog_show_callback), password_dialog); g_signal_connect (password_dialog, "close", G_CALLBACK (dialog_close_callback), password_dialog); /* the radio buttons for anonymous login */ password_dialog->details->connect_with_no_userpass_button = gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously")); group = gtk_radio_button_get_group ( GTK_RADIO_BUTTON (password_dialog->details->connect_with_no_userpass_button)); password_dialog->details->connect_with_userpass_button = gtk_radio_button_new_with_mnemonic ( group, _("Connect as _user:"******"clicked", G_CALLBACK (userpass_radio_button_clicked), password_dialog); g_signal_connect (password_dialog->details->connect_with_userpass_button, "clicked", G_CALLBACK (userpass_radio_button_clicked), password_dialog); /* The table that holds the captions */ password_dialog->details->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); password_dialog->details->table = table = gtk_table_new (3, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (password_dialog->details->table_alignment), table); password_dialog->details->username_entry = gtk_entry_new (); password_dialog->details->domain_entry = gtk_entry_new (); password_dialog->details->password_entry = gtk_entry_new (); password_dialog->details->password_entry_secondary = gtk_entry_new (); /* We want to hold on to these during the table rearrangement */ #if GLIB_CHECK_VERSION (2, 10, 0) g_object_ref_sink (password_dialog->details->username_entry); g_object_ref_sink (password_dialog->details->domain_entry); g_object_ref_sink (password_dialog->details->password_entry); g_object_ref_sink (password_dialog->details->password_entry_secondary); #else g_object_ref (password_dialog->details->username_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->username_entry)); g_object_ref (password_dialog->details->domain_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->domain_entry)); g_object_ref (password_dialog->details->password_entry); gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry)); g_object_ref (password_dialog->details->password_entry_secondary); gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry_secondary)); #endif gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry_secondary), FALSE); g_signal_connect (password_dialog->details->username_entry, "activate", G_CALLBACK (username_entry_activate), password_dialog); g_signal_connect (password_dialog->details->domain_entry, "activate", G_CALLBACK (domain_entry_activate), password_dialog); g_signal_connect_swapped (password_dialog->details->password_entry, "activate", G_CALLBACK (gtk_window_activate_default), password_dialog); g_signal_connect_swapped (password_dialog->details->password_entry_secondary, "activate", G_CALLBACK (gtk_window_activate_default), password_dialog); add_table_rows (password_dialog); /* Adds some eye-candy to the dialog */ hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); dialog_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0); /* Fills the vbox */ main_vbox = gtk_vbox_new (FALSE, 18); if (message) { message_label = GTK_LABEL (gtk_label_new (message)); gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (message_label, TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0); } vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->radio_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->table_alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (password_dialog)->vbox), hbox, TRUE, /* expand */ TRUE, /* fill */ 0); /* padding */ gtk_widget_show_all (GTK_DIALOG (password_dialog)->vbox); password_dialog->details->remember_session_button = gtk_check_button_new_with_mnemonic (_("_Remember passwords for this session")); password_dialog->details->remember_forever_button = gtk_check_button_new_with_mnemonic (_("_Save passwords in keyring")); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_session_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_forever_button, FALSE, FALSE, 0); gnome_two_password_dialog_set_username (password_dialog, username); gnome_two_password_dialog_set_password (password_dialog, password); gnome_two_password_dialog_set_readonly_domain (password_dialog, readonly_username); return GTK_WIDGET (password_dialog); }
/* Public NMAVpnPasswordDialog methods */ GtkWidget * nma_vpn_password_dialog_new (const char *title, const char *message, const char *password) { GtkWidget *dialog; NMAVpnPasswordDialogPrivate *priv; GtkLabel *message_label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *dialog_icon; GtkBox *content, *action_area; dialog = gtk_widget_new (NMA_VPN_TYPE_PASSWORD_DIALOG, NULL); if (!dialog) return NULL; priv = NMA_VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog); gtk_window_set_title (GTK_WINDOW (dialog), title); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))); action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))); /* Set up the dialog */ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5); gtk_box_set_spacing (action_area, 6); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); g_signal_connect (dialog, "show", G_CALLBACK (dialog_show_callback), dialog); g_signal_connect (dialog, "close", G_CALLBACK (dialog_close_callback), dialog); /* The grid that holds the captions */ priv->grid_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (priv->grid), 12); gtk_grid_set_row_spacing (GTK_GRID (priv->grid), 6); gtk_container_add (GTK_CONTAINER (priv->grid_alignment), priv->grid); priv->password_entry = gtk_entry_new (); priv->password_entry_secondary = gtk_entry_new (); priv->password_entry_ternary = gtk_entry_new (); priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords")); /* We want to hold on to these during the grid rearrangement */ g_object_ref_sink (priv->password_entry); g_object_ref_sink (priv->password_entry_secondary); g_object_ref_sink (priv->password_entry_ternary); g_object_ref_sink (priv->show_passwords_checkbox); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_ternary), FALSE); g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect_swapped (priv->password_entry_secondary, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect_swapped (priv->password_entry_ternary, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect (priv->show_passwords_checkbox, "toggled", G_CALLBACK (show_passwords_toggled_cb), dialog); add_grid_rows (NMA_VPN_PASSWORD_DIALOG (dialog)); /* Adds some eye-candy to the dialog */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); dialog_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0); /* Fills the vbox */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); if (message) { message_label = GTK_LABEL (gtk_label_new (message)); gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (message_label, TRUE); gtk_label_set_max_width_chars (message_label, 35); gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label)); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0); gtk_size_group_add_widget (priv->group, priv->grid_alignment); } vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), priv->grid_alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_box_pack_start (content, hbox, FALSE, FALSE, 0); gtk_widget_show_all (GTK_WIDGET (content)); nma_vpn_password_dialog_set_password (NMA_VPN_PASSWORD_DIALOG (dialog), password); return GTK_WIDGET (dialog); }
static GtkWidget* preview_collection (int font_size, const PangoFontDescription *base_desc) { GtkWidget *box; GtkWidget *sw; GdkRGBA desktop_color; int i; GtkWidget *eventbox; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_spacing (GTK_BOX (box), 20); gtk_container_set_border_width (GTK_CONTAINER (box), 20); eventbox = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (eventbox), box); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox); desktop_color.red = 0.32; desktop_color.green = 0.46; desktop_color.blue = 0.65; desktop_color.alpha = 1.0; gtk_widget_override_background_color (eventbox, 0, &desktop_color); i = 0; while (i < META_FRAME_TYPE_LAST) { const char *title = NULL; GtkWidget *contents; GtkWidget *align; double xalign, yalign; GtkWidget *eventbox2; GtkWidget *preview; PangoFontDescription *font_desc; double scale; eventbox2 = gtk_event_box_new (); preview = meta_preview_new (); gtk_container_add (GTK_CONTAINER (eventbox2), preview); meta_preview_set_frame_type (META_PREVIEW (preview), i); meta_preview_set_frame_flags (META_PREVIEW (preview), get_window_flags (i)); meta_preview_set_theme (META_PREVIEW (preview), global_theme); contents = get_window_contents (i, &title); meta_preview_set_title (META_PREVIEW (preview), title); gtk_container_add (GTK_CONTAINER (preview), contents); if (i == META_FRAME_TYPE_MENU) { xalign = 0.0; yalign = 0.0; } else { xalign = 0.5; yalign = 0.5; } align = gtk_alignment_new (0.0, 0.0, xalign, yalign); gtk_container_add (GTK_CONTAINER (align), eventbox2); gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0); switch (font_size) { case FONT_SIZE_SMALL: scale = PANGO_SCALE_XX_SMALL; break; case FONT_SIZE_LARGE: scale = PANGO_SCALE_XX_LARGE; break; default: scale = 1.0; break; } if (scale != 1.0) { font_desc = pango_font_description_new (); pango_font_description_set_size (font_desc, MAX (pango_font_description_get_size (base_desc) * scale, 1)); gtk_widget_modify_font (preview, font_desc); pango_font_description_free (font_desc); } previews[font_size*META_FRAME_TYPE_LAST + i] = preview; ++i; } return sw; }
static void edit_preset (const char *name_in, dt_lib_module_info_t *minfo) { gchar *name = NULL; if(name_in == NULL) { name = get_active_preset_name(minfo); if(name == NULL) return; } else name = g_strdup(name_in); GtkWidget *dialog; /* Create the widgets */ char title[1024]; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); snprintf(title, sizeof(title), _("edit `%s'"), name); dialog = gtk_dialog_new_with_buttons (title, GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area (GTK_DIALOG (dialog))); GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 5, 5, 5); gtk_container_add (content_area, alignment); GtkBox *box = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_container_add (GTK_CONTAINER(alignment), GTK_WIDGET(box)); dt_lib_presets_edit_dialog_t *g = (dt_lib_presets_edit_dialog_t *)g_malloc0(sizeof(dt_lib_presets_edit_dialog_t)); g->old_id = -1; g_strlcpy(g->plugin_name, minfo->plugin_name, sizeof(g->plugin_name)); g->version = minfo->version; g->params_size = minfo->params_size; g->params = minfo->params; g->name = GTK_ENTRY(gtk_entry_new()); g->module = minfo->module; g->original_name = name; gtk_entry_set_text(g->name, name); gtk_box_pack_start(box, GTK_WIDGET(g->name), FALSE, FALSE, 0); g_object_set(G_OBJECT(g->name), "tooltip-text", _("name of the preset"), (char *)NULL); g->description = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(g->description), FALSE, FALSE, 0); g_object_set(G_OBJECT(g->description), "tooltip-text", _("description or further information"), (char *)NULL); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select rowid, description from presets where name = ?1 and operation = ?2 and op_version = ?3", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, minfo->plugin_name, strlen(minfo->plugin_name), SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, minfo->version); if(sqlite3_step(stmt) == SQLITE_ROW) { g->old_id = sqlite3_column_int(stmt, 0); gtk_entry_set_text(g->description, (const char *)sqlite3_column_text(stmt, 1)); } sqlite3_finalize(stmt); g_signal_connect (dialog, "response", G_CALLBACK (edit_preset_response), g); gtk_widget_show_all (dialog); }
static GtkWidget* previews_of_button_layouts (void) { static gboolean initted = FALSE; GtkWidget *box; GtkWidget *sw; GdkRGBA desktop_color; int i; GtkWidget *eventbox; if (!initted) { init_layouts (); initted = TRUE; } sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_spacing (GTK_BOX (box), 20); gtk_container_set_border_width (GTK_CONTAINER (box), 20); eventbox = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (eventbox), box); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), eventbox); desktop_color.red = 0.32; desktop_color.green = 0.46; desktop_color.blue = 0.65; desktop_color.alpha = 1.0; gtk_widget_override_background_color (eventbox, 0, &desktop_color); i = 0; while (i < BUTTON_LAYOUT_COMBINATIONS) { GtkWidget *align; double xalign, yalign; GtkWidget *eventbox2; GtkWidget *preview; char *title; eventbox2 = gtk_event_box_new (); preview = meta_preview_new (); gtk_container_add (GTK_CONTAINER (eventbox2), preview); meta_preview_set_theme (META_PREVIEW (preview), global_theme); title = g_strdup_printf (_("Button layout test %d"), i+1); meta_preview_set_title (META_PREVIEW (preview), title); g_free (title); meta_preview_set_button_layout (META_PREVIEW (preview), &different_layouts[i]); xalign = 0.5; yalign = 0.5; align = gtk_alignment_new (0.0, 0.0, xalign, yalign); gtk_container_add (GTK_CONTAINER (align), eventbox2); gtk_box_pack_start (GTK_BOX (box), align, TRUE, TRUE, 0); previews[META_FRAME_TYPE_LAST*FONT_SIZE_LAST + i] = preview; ++i; } return sw; }
GtkWidget * dt_lib_gui_get_expander (dt_lib_module_t *module) { /* check if module is expandable */ if(!module->expandable()) { module->expander = NULL; return NULL; } int bs = 12; GtkWidget *expander = gtk_vbox_new(FALSE, 3); GtkWidget *header_evb = gtk_event_box_new(); GtkWidget *header = gtk_hbox_new(FALSE, 0); GtkWidget *pluginui_frame = gtk_frame_new(NULL); GtkWidget *pluginui = gtk_event_box_new(); /* setup the header box */ gtk_container_add(GTK_CONTAINER(header_evb), header); g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press), module); /* setup plugin content frame */ gtk_frame_set_shadow_type(GTK_FRAME(pluginui_frame),GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(pluginui_frame),pluginui); /* layout the main expander widget */ gtk_box_pack_start(GTK_BOX(expander), header_evb, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(expander), pluginui_frame, TRUE, FALSE,0); /* * initialize the header widgets */ int idx=0; GtkWidget *hw[5]= {NULL,NULL,NULL,NULL,NULL}; /* add the expand indicator icon */ hw[idx] = dtgtk_icon_new(dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]),bs,bs); /* add module label */ char label[128]; g_snprintf(label,sizeof(label),"<span size=\"larger\">%s</span>",module->name()); hw[idx] = gtk_label_new(""); gtk_widget_set_name(hw[idx], "panel_label"); gtk_label_set_markup(GTK_LABEL(hw[idx++]),label); /* add reset button if module has implementation */ if (module->gui_reset) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); module->reset_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("reset parameters"), (char *)NULL); g_signal_connect (G_OBJECT (hw[idx]), "clicked", G_CALLBACK (dt_lib_gui_reset_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]),bs,bs); /* add preset button if module has implementation */ if (module->get_params) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_presets,CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); module->presets_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("presets"), (char *)NULL); g_signal_connect (G_OBJECT (hw[idx]), "clicked", G_CALLBACK (popup_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]),bs,bs); /* add a spacer to align buttons with iop buttons (enabled button) */ hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]),bs,bs); /* lets order header elements depending on left/right side panel placement */ int c = module->container(); if ( (c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) || (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM) ) { for(int i=0; i<=4; i++) if (hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i],i==1?TRUE:FALSE,i==1?TRUE:FALSE,2); gtk_misc_set_alignment(GTK_MISC(hw[1]),0.0,0.5); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_RIGHT); } else { for(int i=4; i>=0; i--) if (hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i],i==1?TRUE:FALSE,i==1?TRUE:FALSE,2); gtk_misc_set_alignment(GTK_MISC(hw[1]),1.0,0.5); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); } /* add module widget into an alignment */ GtkWidget *al = gtk_alignment_new(1.0, 1.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(al), 8, 8, 8, 8); gtk_container_add(GTK_CONTAINER(pluginui), al); gtk_container_add(GTK_CONTAINER(al), module->widget); gtk_widget_show_all(module->widget); module->expander = expander; return module->expander; }
GtkWidget* ctk_config_new(ConfigProperties *conf, CtrlSystem *pCtrlSystem) { gint i; GObject *object; CtkConfig *ctk_config; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *banner; GtkWidget *label; GtkWidget *hseparator; GtkWidget *check_button; GtkWidget *alignment; gboolean b; struct { const char *label; unsigned int mask; GCallback toggled_callback; const char *help_text; } config_check_button_entries[] = { #ifndef CTK_GTK3 { "Enable ToolTips", CONFIG_PROPERTIES_TOOLTIPS, G_CALLBACK(tooltips_toggled), __tooltip_help }, #endif { "Display Status Bar", CONFIG_PROPERTIES_DISPLAY_STATUS_BAR, G_CALLBACK(display_status_bar_toggled), __status_bar_help }, { "Slider Text Entries", CONFIG_PROPERTIES_SLIDER_TEXT_ENTRIES, G_CALLBACK(slider_text_entries_toggled), __slider_text_entries_help }, { "Include X Display Names in the Config File", CONFIG_PROPERTIES_INCLUDE_DISPLAY_NAME_IN_CONFIG_FILE, G_CALLBACK(display_name_toggled), __x_display_names_help }, { "Show \"Really Quit?\" Dialog", CONFIG_PROPERTIES_SHOW_QUIT_DIALOG, G_CALLBACK(show_quit_dialog_toggled), __show_quit_dialog_help }, { "Update Rules when an Application Profile Name changes", CONFIG_PROPERTIES_UPDATE_RULES_ON_PROFILE_NAME_CHANGE, G_CALLBACK(update_rules_on_profile_name_change_toggled), __update_rules_on_profile_name_change_help }, }; object = g_object_new(CTK_TYPE_CONFIG, NULL); ctk_config = CTK_CONFIG(object); ctk_config->conf = conf; ctk_config->pCtrlSystem = pCtrlSystem; gtk_box_set_spacing(GTK_BOX(ctk_config), 10); /* initialize the statusbar widget */ ctk_statusbar_init(&ctk_config->status_bar); #ifndef CTK_GTK3 /* initialize the tooltips widget */ ctk_config->tooltips.object = gtk_tooltips_new(); #endif /* banner */ banner = ctk_banner_image_new(BANNER_ARTWORK_CONFIG); gtk_box_pack_start(GTK_BOX(ctk_config), banner, FALSE, FALSE, 0); /* "nvidia-settings Configuration" */ hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start(GTK_BOX(ctk_config), hbox, FALSE, FALSE, 0); label = gtk_label_new("nvidia-settings Configuration"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 0); /* check buttons: Enable tooltips, Display statusbar, and Display slider text entries */ vbox = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(ctk_config), vbox, FALSE, FALSE, 0); ctk_config->help_data = NULL; for (i = 0; i < ARRAY_LEN(config_check_button_entries); i++) { label = gtk_label_new(config_check_button_entries[i].label); check_button = gtk_check_button_new(); gtk_container_add(GTK_CONTAINER(check_button), label); b = !!(ctk_config->conf->booleans & config_check_button_entries[i].mask); #ifndef CTK_GTK3 if (config_check_button_entries[i].mask == CONFIG_PROPERTIES_TOOLTIPS) { if (b) { gtk_tooltips_enable(ctk_config->tooltips.object); } else { gtk_tooltips_disable(ctk_config->tooltips.object); } } #endif gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), b); gtk_box_pack_start(GTK_BOX(vbox), check_button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(check_button), "toggled", config_check_button_entries[i].toggled_callback, ctk_config); ctk_config_set_tooltip_and_add_help_data(ctk_config, check_button, &ctk_config->help_data, config_check_button_entries[i].label, config_check_button_entries[i].help_text, NULL); } ctk_config->help_data = g_list_reverse(ctk_config->help_data); /* timer list */ ctk_config->timer_list_box = gtk_hbox_new(FALSE, 0); ctk_config->timer_list = create_timer_list(ctk_config); g_object_ref(ctk_config->timer_list); ctk_config->timer_list_visible = FALSE; gtk_box_pack_start(GTK_BOX(ctk_config), ctk_config->timer_list_box, TRUE, TRUE, 0); /* "Save Current Configuration" button */ label = gtk_label_new("Save Current Configuration"); hbox = gtk_hbox_new(FALSE, 0); ctk_config->button_save_rc = gtk_button_new(); alignment = gtk_alignment_new(1, 1, 0, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15); gtk_container_add(GTK_CONTAINER(ctk_config->button_save_rc), hbox); gtk_container_add(GTK_CONTAINER(alignment), ctk_config->button_save_rc); gtk_box_pack_start(GTK_BOX(ctk_config), alignment, TRUE, TRUE, 0); /* Create the file selector for rc file */ g_signal_connect(G_OBJECT(ctk_config->button_save_rc), "clicked", G_CALLBACK(save_rc_clicked), (gpointer) ctk_config); ctk_config_set_tooltip(ctk_config, ctk_config->button_save_rc, __save_current_config_help); ctk_config->rc_filename = NULL; gtk_widget_show_all(GTK_WIDGET(ctk_config)); return GTK_WIDGET(ctk_config); }
GtkWidget* create_Calculator (void) { GtkWidget *Calculator; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *framebox; GtkWidget *alignment1; GtkWidget *table2; GtkWidget *hbox5; GtkWidget *heading; GtkWidget *labelDOO; GtkWidget *labelDuration; GtkWidget *hbox14; GtkWidget *label2; GtkWidget *hbox16; GtkWidget *label16; GtkWidget *entryCustom; GtkWidget *hbox21; GtkWidget *label14; GtkWidget *hbox18; GtkWidget *optionmenu2; GtkWidget *menu2; GtkWidget *avi1; GtkWidget *ogm1; GtkWidget *mpeg1; GtkWidget *hbox17; GtkWidget *optionmenu1; GtkWidget *menu1; GtkWidget *_1x80_cd1; GtkWidget *_2x80_cd1; GtkWidget *_1x74_cd1; GtkWidget *_2x74_cd1; GtkWidget *dvd1; GtkWidget *custom1; GtkWidget *hbox11; GtkWidget *hbox12; GtkWidget *hbox13; GtkWidget *label6; GtkWidget *entry3; GtkWidget *label7; GtkWidget *entry4; GtkWidget *hbox20; GtkWidget *table3; GtkWidget *label9; GtkWidget *labelAudio; GtkWidget *label11; GtkWidget *labelVideo; GtkWidget *label17; GtkWidget *labelTotal; GtkWidget *table4; GtkWidget *label12; GtkWidget *label15; GtkWidget *labelBitrate; GtkWidget *labelBPP; GtkWidget *dialog_action_area1; GtkWidget *doit; GtkWidget *button1; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); Calculator = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (Calculator), 6); gtk_window_set_title (GTK_WINDOW (Calculator), QT_TR_NOOP("Calculator")); gtk_window_set_resizable (GTK_WINDOW (Calculator), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (Calculator), FALSE); dialog_vbox1 = GTK_DIALOG (Calculator)->vbox; gtk_box_set_spacing (GTK_BOX(dialog_vbox1), 12); gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 6); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); heading = gtk_label_new (QT_TR_NOOP("<b>Target</b>")); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_widget_show (heading); table2 = gtk_table_new (3, 4, FALSE); gtk_widget_show (table2); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), table2); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_table_attach (GTK_TABLE (table2), hbox5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); labelDOO = gtk_label_new (QT_TR_NOOP("Duration:")); gtk_widget_show (labelDOO); gtk_box_pack_start (GTK_BOX (hbox5), labelDOO, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (labelDOO), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDOO), 0, 0.5); labelDuration = gtk_label_new (QT_TR_NOOP("00:00:00")); gtk_widget_show (labelDuration); gtk_table_attach (GTK_TABLE (table2), labelDuration, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelDuration), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDuration), 0, 0.5); hbox14 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox14); gtk_table_attach (GTK_TABLE (table2), hbox14, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Medium:")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox14), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hbox16 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox16); gtk_table_attach (GTK_TABLE (table2), hbox16, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label16 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Format:")); gtk_widget_show (label16); gtk_box_pack_start (GTK_BOX (hbox16), label16, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label16), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); entryCustom = gtk_entry_new (); gtk_widget_show (entryCustom); gtk_table_attach (GTK_TABLE (table2), entryCustom, 3, 4, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, entryCustom, QT_TR_NOOP("Total size (custom)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entryCustom), 10); gtk_entry_set_width_chars (GTK_ENTRY (entryCustom), 6); hbox21 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox21); gtk_table_attach (GTK_TABLE (table2), hbox21, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label14 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Custom size (MB):")); gtk_widget_show (label14); gtk_box_pack_start (GTK_BOX (hbox21), label14, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_LEFT); hbox18 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox18); gtk_table_attach (GTK_TABLE (table2), hbox18, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu2 = gtk_option_menu_new (); gtk_widget_show (optionmenu2); gtk_box_pack_start (GTK_BOX (hbox18), optionmenu2, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu2, QT_TR_NOOP("Output container format"), NULL); menu2 = gtk_menu_new (); avi1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("AVI")); gtk_widget_show (avi1); gtk_container_add (GTK_CONTAINER (menu2), avi1); ogm1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("OGM")); gtk_widget_show (ogm1); gtk_container_add (GTK_CONTAINER (menu2), ogm1); mpeg1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("MPEG")); gtk_widget_show (mpeg1); gtk_container_add (GTK_CONTAINER (menu2), mpeg1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu2), menu2); hbox17 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox17); gtk_table_attach (GTK_TABLE (table2), hbox17, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX (hbox17), optionmenu1, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu1, QT_TR_NOOP("Total size"), NULL); menu1 = gtk_menu_new (); _1x80_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1x 80 min. CD")); gtk_widget_show (_1x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x80_cd1); gtk_tooltips_set_tip (tooltips, _1x80_cd1, QT_TR_NOOP("Total size (custom)"), NULL); _2x80_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("2x 80 min. CD")); gtk_widget_show (_2x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x80_cd1); _1x74_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1x 74 min. CD")); gtk_widget_show (_1x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x74_cd1); _2x74_cd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("2x 74 min. CD")); gtk_widget_show (_2x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x74_cd1); dvd1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("DVD5")); gtk_widget_show (dvd1); gtk_container_add (GTK_CONTAINER (menu1), dvd1); custom1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Custom")); gtk_widget_show (custom1); gtk_container_add (GTK_CONTAINER (menu1), custom1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu1); hbox11 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox11); hbox12 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox11), hbox12, TRUE, TRUE, 0); gtk_widget_show (hbox12); label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Track _1:")); gtk_widget_show (label6); gtk_box_pack_start (GTK_BOX (hbox12), label6, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); entry3 = gtk_entry_new (); gtk_widget_show (entry3); gtk_box_pack_start (GTK_BOX (hbox12), entry3, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry3, QT_TR_NOOP("Audio bitrate in kb/s for track 1 (0 for no audio)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry3), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry3), 6); hbox13 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox11), hbox13, TRUE, TRUE, 0); gtk_widget_show (hbox13); label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Track _2: ")); gtk_widget_show (label7); gtk_box_pack_start (GTK_BOX (hbox13), label7, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); entry4 = gtk_entry_new (); gtk_widget_show (entry4); gtk_box_pack_start (GTK_BOX (hbox13), entry4, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry4, QT_TR_NOOP("Audio bitrate in kb/s for track 2 (optional)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry4), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry4), 6); heading = gtk_label_new (QT_TR_NOOP("<b>Audio Bitrate</b>")); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_widget_show (heading); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), hbox11); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); hbox20 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox20); table3 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (hbox20), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 12); label9 = gtk_label_new (QT_TR_NOOP("Audio size (MB):")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); labelAudio = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelAudio); gtk_table_attach (GTK_TABLE (table3), labelAudio, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelAudio), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelAudio), 0, 0.5); label11 = gtk_label_new (QT_TR_NOOP("Video size (MB):")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); labelVideo = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelVideo); gtk_table_attach (GTK_TABLE (table3), labelVideo, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelVideo), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelVideo), 0, 0.5); label17 = gtk_label_new (QT_TR_NOOP("Total size (MB):")); gtk_widget_show (label17); gtk_table_attach (GTK_TABLE (table3), label17, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label17), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label17), 0, 0.5); labelTotal = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelTotal); gtk_table_attach (GTK_TABLE (table3), labelTotal, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelTotal), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelTotal), 0, 0.5); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (hbox20), table4, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table4), 6); gtk_table_set_col_spacings (GTK_TABLE (table4), 6); label12 = gtk_label_new (QT_TR_NOOP("Video bitrate:")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table4), label12, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); label15 = gtk_label_new (QT_TR_NOOP("Bits per pixel:")); gtk_widget_show (label15); gtk_table_attach (GTK_TABLE (table4), label15, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label15), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5); labelBitrate = gtk_label_new (QT_TR_NOOP("0")); gtk_widget_show (labelBitrate); gtk_table_attach (GTK_TABLE (table4), labelBitrate, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBitrate), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBitrate), 0, 0.5); labelBPP = gtk_label_new (QT_TR_NOOP("0.0")); gtk_widget_show (labelBPP); gtk_table_attach (GTK_TABLE (table4), labelBPP, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBPP), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBPP), 0, 0.5); heading = gtk_label_new (QT_TR_NOOP("<b>Result</b>")); gtk_misc_set_alignment (GTK_MISC (heading), 0, 1); gtk_label_set_use_markup (GTK_LABEL (heading), TRUE); gtk_widget_show (heading); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); gtk_container_add (GTK_CONTAINER (alignment1), hbox20); framebox = gtk_vbox_new (0, 0); gtk_box_pack_start (GTK_BOX(vbox1), framebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), heading, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(framebox), alignment1, FALSE, FALSE, 0); gtk_widget_show(framebox); dialog_action_area1 = GTK_DIALOG (Calculator)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); doit = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (doit); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), doit, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (doit, GTK_CAN_DEFAULT); button1 = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (button1); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), button1, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), optionmenu1); gtk_label_set_mnemonic_widget (GTK_LABEL (label16), optionmenu2); gtk_label_set_mnemonic_widget (GTK_LABEL (label14), entryCustom); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry3); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry4); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (Calculator, Calculator, "Calculator"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (Calculator, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (Calculator, framebox, "framebox"); GLADE_HOOKUP_OBJECT (Calculator, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (Calculator, table2, "table2"); GLADE_HOOKUP_OBJECT (Calculator, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (Calculator, heading, "heading"); GLADE_HOOKUP_OBJECT (Calculator, labelDOO, "labelDOO"); GLADE_HOOKUP_OBJECT (Calculator, labelDuration, "labelDuration"); GLADE_HOOKUP_OBJECT (Calculator, hbox14, "hbox14"); GLADE_HOOKUP_OBJECT (Calculator, label2, "label2"); GLADE_HOOKUP_OBJECT (Calculator, hbox16, "hbox16"); GLADE_HOOKUP_OBJECT (Calculator, label16, "label16"); GLADE_HOOKUP_OBJECT (Calculator, entryCustom, "entryCustom"); GLADE_HOOKUP_OBJECT (Calculator, hbox21, "hbox21"); GLADE_HOOKUP_OBJECT (Calculator, label14, "label14"); GLADE_HOOKUP_OBJECT (Calculator, hbox18, "hbox18"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu2, "optionmenu2"); GLADE_HOOKUP_OBJECT (Calculator, menu2, "menu2"); GLADE_HOOKUP_OBJECT (Calculator, avi1, "avi1"); GLADE_HOOKUP_OBJECT (Calculator, ogm1, "ogm1"); GLADE_HOOKUP_OBJECT (Calculator, mpeg1, "mpeg1"); GLADE_HOOKUP_OBJECT (Calculator, hbox17, "hbox17"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (Calculator, menu1, "menu1"); GLADE_HOOKUP_OBJECT (Calculator, _1x80_cd1, "_1x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x80_cd1, "_2x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _1x74_cd1, "_1x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x74_cd1, "_2x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, dvd1, "dvd1"); GLADE_HOOKUP_OBJECT (Calculator, custom1, "custom1"); GLADE_HOOKUP_OBJECT (Calculator, hbox11, "hbox11"); GLADE_HOOKUP_OBJECT (Calculator, hbox12, "hbox12"); GLADE_HOOKUP_OBJECT (Calculator, hbox13, "hbox13"); GLADE_HOOKUP_OBJECT (Calculator, label6, "label6"); GLADE_HOOKUP_OBJECT (Calculator, entry3, "entry3"); GLADE_HOOKUP_OBJECT (Calculator, label7, "label7"); GLADE_HOOKUP_OBJECT (Calculator, entry4, "entry4"); GLADE_HOOKUP_OBJECT (Calculator, hbox20, "hbox20"); GLADE_HOOKUP_OBJECT (Calculator, table3, "table3"); GLADE_HOOKUP_OBJECT (Calculator, label9, "label9"); GLADE_HOOKUP_OBJECT (Calculator, labelAudio, "labelAudio"); GLADE_HOOKUP_OBJECT (Calculator, label11, "label11"); GLADE_HOOKUP_OBJECT (Calculator, labelVideo, "labelVideo"); GLADE_HOOKUP_OBJECT (Calculator, label17, "label17"); GLADE_HOOKUP_OBJECT (Calculator, labelTotal, "labelTotal"); GLADE_HOOKUP_OBJECT (Calculator, table4, "table4"); GLADE_HOOKUP_OBJECT (Calculator, label12, "label12"); GLADE_HOOKUP_OBJECT (Calculator, label15, "label15"); GLADE_HOOKUP_OBJECT (Calculator, labelBitrate, "labelBitrate"); GLADE_HOOKUP_OBJECT (Calculator, labelBPP, "labelBPP"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (Calculator, doit, "doit"); GLADE_HOOKUP_OBJECT (Calculator, button1, "button1"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, tooltips, "tooltips"); gtk_widget_grab_focus (entry3); return Calculator; }
MetaTabPopup* meta_ui_tab_popup_new (const MetaTabEntry *entries, int screen_number, int entry_count, int width, gboolean outline) { MetaTabPopup *popup; int i, left, right, top, bottom; int height; GtkWidget *table; GtkWidget *vbox; GtkWidget *align; GList *tmp; GtkWidget *frame; int max_label_width; /* the actual max width of the labels we create */ AtkObject *obj; GdkScreen *screen; int screen_width; popup = g_new (MetaTabPopup, 1); popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP); screen = gdk_display_get_screen (gdk_display_get_default (), screen_number); gtk_window_set_screen (GTK_WINDOW (popup->outline_window), screen); gtk_widget_set_app_paintable (popup->outline_window, TRUE); gtk_widget_realize (popup->outline_window); g_signal_connect (G_OBJECT (popup->outline_window), "expose_event", G_CALLBACK (outline_window_expose), popup); popup->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (popup->window), screen); gtk_window_set_position (GTK_WINDOW (popup->window), GTK_WIN_POS_CENTER_ALWAYS); /* enable resizing, to get never-shrink behavior */ gtk_window_set_resizable (GTK_WINDOW (popup->window), TRUE); popup->current = NULL; popup->entries = NULL; popup->current_selected_entry = NULL; popup->outline = outline; screen_width = gdk_screen_get_width (screen); for (i = 0; i < entry_count; ++i) { TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline); popup->entries = g_list_prepend (popup->entries, new_entry); } popup->entries = g_list_reverse (popup->entries); g_assert (width > 0); height = i / width; if (i % width) height += 1; table = gtk_table_new (height, width, FALSE); vbox = gtk_vbox_new (FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_set_border_width (GTK_CONTAINER (table), 1); gtk_container_add (GTK_CONTAINER (popup->window), frame); gtk_container_add (GTK_CONTAINER (frame), vbox); align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (align), table); popup->label = gtk_label_new (""); /* Set the accessible role of the label to a status bar so it * will emit name changed events that can be used by screen * readers. */ obj = gtk_widget_get_accessible (popup->label); atk_object_set_role (obj, ATK_ROLE_STATUSBAR); gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3); gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0); max_label_width = 0; top = 0; bottom = 1; tmp = popup->entries; while (tmp && top < height) { left = 0; right = 1; while (tmp && left < width) { GtkWidget *image; GtkRequisition req; TabEntry *te; te = tmp->data; if (te->blank) { /* just stick a widget here to avoid special cases */ image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); } else if (outline) { if (te->dimmed_icon) { image = selectable_image_new (te->dimmed_icon); } else { image = selectable_image_new (te->icon); } gtk_misc_set_padding (GTK_MISC (image), INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1, INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5); } else { image = selectable_workspace_new ((MetaWorkspace *) te->key); } te->widget = image; gtk_table_attach (GTK_TABLE (table), te->widget, left, right, top, bottom, 0, 0, 0, 0); /* Efficiency rules! */ gtk_label_set_markup (GTK_LABEL (popup->label), te->title); gtk_widget_size_request (popup->label, &req); max_label_width = MAX (max_label_width, req.width); tmp = tmp->next; ++left; ++right; } ++top; ++bottom; } /* remove all the temporary text */ gtk_label_set_text (GTK_LABEL (popup->label), ""); /* Make it so that we ellipsize if the text is too long */ gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END); /* Limit the window size to no bigger than screen_width/4 */ if (max_label_width>(screen_width/4)) { max_label_width = screen_width/4; } max_label_width += 20; /* add random padding */ gtk_window_set_default_size (GTK_WINDOW (popup->window), max_label_width, -1); return popup; }
static void create_effects_frame (GtkWidget *outer_vbox, const gchar *frame_title) { GtkWidget *main_vbox, *vbox, *hbox; GtkWidget *align; GtkWidget *label; GtkWidget *check; GtkWidget *combo; gchar *title; main_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); effects_vbox = main_vbox; title = g_strconcat ("<b>", frame_title, "</b>", NULL); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (title); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); gtk_widget_show (align); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (align), vbox); gtk_widget_show (vbox); /** Include pointer **/ check = gtk_check_button_new_with_mnemonic (_("Include _pointer")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), include_pointer); g_signal_connect (check, "toggled", G_CALLBACK (include_pointer_toggled_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0); gtk_widget_show (check); /** Include window border **/ check = gtk_check_button_new_with_mnemonic (_("Include the window _border")); gtk_widget_set_sensitive (check, take_window_shot); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), include_border); g_signal_connect (check, "toggled", G_CALLBACK (include_border_toggled_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0); gtk_widget_show (check); border_check = check; /** Effects **/ hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Apply _effect:")); gtk_widget_set_sensitive (label, take_window_shot); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); effect_label = label; combo = create_effects_combo (); gtk_widget_set_sensitive (combo, take_window_shot); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_widget_show (combo); effect_combo = combo; }
static GtkWidget *create_window(void) { GtkWidget *startwin; GtkWidget *hlayout; GtkWidget *banner; GtkWidget *vlayout; GtkWidget *tabs; GtkWidget *configvlayout; GtkWidget *configlayout; GtkWidget *vmode3dlabel; GtkWidget *vmode3dcombo; GtkWidget *fullscreencheck; GtkWidget *alwaysshowcheck; GtkWidget *configtab; GtkWidget *messagesscroll; GtkWidget *messagestext; GtkWidget *messagestab; GtkWidget *buttons; GtkWidget *cancelbutton; GtkWidget *cancelbuttonalign; GtkWidget *cancelbuttonlayout; GtkWidget *cancelbuttonicon; GtkWidget *cancelbuttonlabel; GtkWidget *startbutton; GtkWidget *startbuttonalign; GtkWidget *startbuttonlayout; GtkWidget *startbuttonicon; GtkWidget *startbuttonlabel; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); // Basic window startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE); gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls hlayout = gtk_hbox_new (FALSE, 0); gtk_widget_show (hlayout); gtk_container_add (GTK_CONTAINER (startwin), hlayout); // Banner { GdkPixbuf *pixbuf = load_banner(); banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_widget_show (banner); gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons vlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (vlayout); gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0); // Tab control tabs = gtk_notebook_new (); gtk_widget_show (tabs); gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tabs), 4); // Vertical layout of config page main body configvlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (configvlayout); gtk_container_add (GTK_CONTAINER (tabs), configvlayout); // Fixed-position layout of config page controls configlayout = gtk_fixed_new (); gtk_widget_show (configlayout); gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6); // 3D video mode label vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:"); gtk_widget_show (vmode3dlabel); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0); gtk_widget_set_size_request (vmode3dlabel, 88, 29); gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL); } gtk_widget_show (vmode3dcombo); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0); gtk_widget_set_size_request (vmode3dcombo, 150, 29); gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group, GDK_V, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Fullscreen checkbox fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen"); gtk_widget_show (fullscreencheck); gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0); gtk_widget_set_size_request (fullscreencheck, 85, 29); gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group, GDK_F, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Always show config checkbox alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start"); gtk_widget_show (alwaysshowcheck); gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0); gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Configuration tab configtab = gtk_label_new ("Configuration"); gtk_widget_show (configtab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab); // Messages scrollable area messagesscroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (messagesscroll); gtk_container_add (GTK_CONTAINER (tabs), messagesscroll); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area messagestext = gtk_text_view_new (); gtk_widget_show (messagestext); gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext); gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2); // Messages tab messagestab = gtk_label_new ("Messages"); gtk_widget_show (messagestab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), messagestab); // Dialogue box buttons layout buttons = gtk_hbutton_box_new (); gtk_widget_show (buttons); gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (buttons), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END); // Cancel button cancelbutton = gtk_button_new (); gtk_widget_show (cancelbutton); gtk_container_add (GTK_CONTAINER (buttons), cancelbutton); GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group, GDK_C, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (cancelbuttonalign); gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign); cancelbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (cancelbuttonlayout); gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout); cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (cancelbuttonicon); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0); cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel"); gtk_widget_show (cancelbuttonlabel); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0); // Start button startbutton = gtk_button_new (); gtk_widget_show (startbutton); gtk_container_add (GTK_CONTAINER (buttons), startbutton); GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group, GDK_S, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (startbutton, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (startbuttonalign); gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign); startbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (startbuttonlayout); gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout); startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_widget_show (startbuttonicon); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0); startbuttonlabel = gtk_label_new_with_mnemonic ("_Start"); gtk_widget_show (startbuttonlabel); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect ((gpointer) startwin, "delete_event", G_CALLBACK (on_startwin_delete_event), NULL); g_signal_connect ((gpointer) vmode3dcombo, "changed", G_CALLBACK (on_vmode3dcombo_changed), NULL); g_signal_connect ((gpointer) fullscreencheck, "toggled", G_CALLBACK (on_fullscreencheck_toggled), NULL); g_signal_connect ((gpointer) alwaysshowcheck, "toggled", G_CALLBACK (on_alwaysshowcheck_toggled), NULL); g_signal_connect ((gpointer) cancelbutton, "clicked", G_CALLBACK (on_cancelbutton_clicked), NULL); g_signal_connect ((gpointer) startbutton, "clicked", G_CALLBACK (on_startbutton_clicked), NULL); // Associate labels with their controls gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin"); GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout"); GLADE_HOOKUP_OBJECT (startwin, banner, "banner"); GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout"); GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs"); GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout"); GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout"); GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel"); GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo"); GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck"); GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck"); GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab"); GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll"); GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext"); GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab"); GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons"); GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel"); GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton"); GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel"); gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group); return startwin; }
static void create_screenshot_frame (GtkWidget *outer_vbox, const gchar *frame_title) { GtkWidget *main_vbox, *vbox, *hbox; GtkWidget *align; GtkWidget *radio; GtkWidget *image; GtkWidget *spin; GtkWidget *label; GtkAdjustment *adjust; GSList *group; gchar *title; main_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); title = g_strconcat ("<b>", frame_title, "</b>", NULL); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (title); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_widget_set_size_request (align, 48, -1); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); gtk_widget_show (align); image = gtk_image_new_from_stock (SCREENSHOOTER_ICON, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (align), image); gtk_widget_show (image); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /** Grab whole desktop **/ group = NULL; radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the whole _desktop")); if (take_window_shot || take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), FALSE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_DESKTOP)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab current window **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the current _window")); if (take_window_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_WINDOW)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab area of the desktop **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Select _area to grab")); if (take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_AREA)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); gtk_widget_show (radio); /** Grab after delay **/ delay_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), delay_hbox, FALSE, FALSE, 0); gtk_widget_show (delay_hbox); /* translators: this is the first part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new_with_mnemonic (_("Grab _after a delay of")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); adjust = GTK_ADJUSTMENT (gtk_adjustment_new ((gdouble) delay, 0.0, 99.0, 1.0, 1.0, 0.0)); spin = gtk_spin_button_new (adjust, 1.0, 0); g_signal_connect (spin, "value-changed", G_CALLBACK (delay_spin_value_changed_cb), NULL); gtk_box_pack_start (GTK_BOX (delay_hbox), spin, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin); gtk_widget_show (spin); /* translators: this is the last part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new (_("seconds")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_end (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox2; GtkWidget *drawingarea1; GtkWidget *entry1; GtkWidget *table1; GtkWidget *buttonNext; GtkWidget *buttonPrev; GtkWidget *buttonEmptyPrev; GtkWidget *alignment2; GtkWidget *hbox4; GtkWidget *image2; GtkWidget *label2; GtkWidget *buttonNextEmpty; GtkWidget *alignment3; GtkWidget *hbox5; GtkWidget *image3; GtkWidget *label3; GtkWidget *buttonDelete; GtkWidget *buttonSave; GtkWidget *buttonSearch; GtkWidget *buttonRewind; GtkWidget *dialog_action_area1; GtkWidget *closebutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("dialog1")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox2, TRUE, TRUE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox2), drawingarea1, TRUE, TRUE, 0); entry1 = gtk_entry_new (); gtk_widget_show (entry1); gtk_box_pack_start (GTK_BOX (vbox2), entry1, FALSE, FALSE, 0); table1 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0); buttonNext = gtk_button_new_from_stock ("gtk-media-next"); gtk_widget_show (buttonNext); gtk_table_attach (GTK_TABLE (table1), buttonNext, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK), 0, 0); buttonPrev = gtk_button_new_from_stock ("gtk-media-previous"); gtk_widget_show (buttonPrev); gtk_table_attach (GTK_TABLE (table1), buttonPrev, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0); buttonEmptyPrev = gtk_button_new (); gtk_widget_show (buttonEmptyPrev); gtk_table_attach (GTK_TABLE (table1), buttonEmptyPrev, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK), 0, 0); alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (buttonEmptyPrev), alignment2); hbox4 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox4); gtk_container_add (GTK_CONTAINER (alignment2), hbox4); image2 = gtk_image_new_from_stock ("gtk-media-previous", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox4), image2, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Prev. Empty")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox4), label2, FALSE, FALSE, 0); buttonNextEmpty = gtk_button_new (); gtk_widget_show (buttonNextEmpty); gtk_table_attach (GTK_TABLE (table1), buttonNextEmpty, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK), 0, 0); alignment3 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment3); gtk_container_add (GTK_CONTAINER (buttonNextEmpty), alignment3); hbox5 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox5); gtk_container_add (GTK_CONTAINER (alignment3), hbox5); image3 = gtk_image_new_from_stock ("gtk-media-next", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image3); gtk_box_pack_start (GTK_BOX (hbox5), image3, FALSE, FALSE, 0); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Next Empty")); gtk_widget_show (label3); gtk_box_pack_start (GTK_BOX (hbox5), label3, FALSE, FALSE, 0); buttonDelete = gtk_button_new_from_stock ("gtk-delete"); gtk_widget_show (buttonDelete); gtk_table_attach (GTK_TABLE (table1), buttonDelete, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); buttonSave = gtk_button_new_from_stock ("gtk-save"); gtk_widget_show (buttonSave); gtk_table_attach (GTK_TABLE (table1), buttonSave, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); buttonSearch = gtk_button_new_from_stock ("gtk-find"); gtk_widget_show (buttonSearch); gtk_table_attach (GTK_TABLE (table1), buttonSearch, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); buttonRewind = gtk_button_new_from_stock ("gtk-home"); gtk_widget_show (buttonRewind); gtk_table_attach (GTK_TABLE (table1), buttonRewind, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); closebutton1 = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (closebutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), closebutton1, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (closebutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT (dialog1, entry1, "entry1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, buttonNext, "buttonNext"); GLADE_HOOKUP_OBJECT (dialog1, buttonPrev, "buttonPrev"); GLADE_HOOKUP_OBJECT (dialog1, buttonEmptyPrev, "buttonEmptyPrev"); GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2"); GLADE_HOOKUP_OBJECT (dialog1, hbox4, "hbox4"); GLADE_HOOKUP_OBJECT (dialog1, image2, "image2"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, buttonNextEmpty, "buttonNextEmpty"); GLADE_HOOKUP_OBJECT (dialog1, alignment3, "alignment3"); GLADE_HOOKUP_OBJECT (dialog1, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (dialog1, image3, "image3"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, buttonDelete, "buttonDelete"); GLADE_HOOKUP_OBJECT (dialog1, buttonSave, "buttonSave"); GLADE_HOOKUP_OBJECT (dialog1, buttonSearch, "buttonSearch"); GLADE_HOOKUP_OBJECT (dialog1, buttonRewind, "buttonRewind"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, closebutton1, "closebutton1"); return dialog1; }
void ags_desk_init(AgsDesk *desk) { GtkHBox *hbox; GtkAlignment *alignment; GtkHBox *balance_hbox; desk->name = NULL; desk->xml_type = "ags-desk"; /* create widgets */ desk->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) desk), (GtkWidget *) desk->vbox); hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) desk->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0); /* left pad */ desk->left_pad = ags_desk_input_pad_new(NULL); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) desk->left_pad, FALSE, FALSE, 0); /* console */ alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) alignment, FALSE, FALSE, 0); desk->console = (GtkVBox *) gtk_vbox_new(FALSE, 0); gtk_container_add((GtkContainer *) alignment, (GtkWidget *) desk->console); balance_hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0); gtk_box_pack_start((GtkBox *) desk->console, (GtkWidget *) balance_hbox, FALSE, FALSE, 0); desk->move_left = (GtkButton *) gtk_button_new_with_label(i18n("left")); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->move_left, FALSE, FALSE, 0); desk->balance = (GtkScale *) gtk_hscale_new_with_range(-1.0, 1.0, 0.1); gtk_widget_set_size_request((GtkWidget *) desk->balance, 200, -1); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->balance, FALSE, FALSE, 0); desk->move_right = (GtkButton *) gtk_button_new_with_label(i18n("right")); gtk_box_pack_start((GtkBox *) balance_hbox, (GtkWidget *) desk->move_right, FALSE, FALSE, 0); /* left pad */ desk->right_pad = ags_desk_input_pad_new(NULL); gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) desk->right_pad, FALSE, FALSE, 0); /* file chooser */ desk->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_set_size_request((GtkWidget *) desk->file_chooser, -1, 400); gtk_box_pack_start((GtkBox *) desk->vbox, (GtkWidget *) desk->file_chooser, FALSE, FALSE, 0); }
static void ol_scroll_window_init (OlScrollWindow *self) { /*basic*/ self->percentage = 0.0; self->whole_lyrics = NULL; self->current_lyric_id = -1; /*privat data*/ OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (self); priv->line_count = DEFAULT_LINE_COUNT; priv->active_color = DEFAULT_ACTIVE_COLOR; priv->inactive_color = DEFAULT_INACTIVE_COLOR; priv->bg_color = DEFAULT_BG_COLOR; priv->font_name = g_strdup (DEFAULT_FONT_NAME); priv->line_margin = DEFAULT_LINE_MARGIN; priv->padding_x = DEFAULT_PADDING_X; priv->padding_y = DEFAULT_PADDING_Y; priv->corner_radius = DEFAULT_CORNER_RADIUS; priv->bg_opacity = DEFAULT_BG_OPACITY; priv->frame_width = DEFAULT_FRAME_WIDTH; priv->text = NULL; priv->scroll_mode = OL_SCROLL_WINDOW_ALWAYS; priv->can_seek = FALSE; priv->seeking = FALSE; /*set allocation*/ gtk_window_resize(GTK_WINDOW(self), DEFAULT_WIDTH, DEFAULT_HEIGHT); gtk_widget_add_events (GTK_WIDGET (self), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_DESTROY); /* Set RGBA Colormap */ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (self)); GdkColormap* colormap = gdk_screen_get_rgba_colormap (screen); if (colormap == NULL) colormap = gdk_screen_get_rgb_colormap (screen); gtk_widget_set_colormap (GTK_WIDGET (self), colormap); gtk_window_set_decorated (GTK_WINDOW(self), FALSE); gtk_widget_set_app_paintable (GTK_WIDGET (self), TRUE); /* We need an additional widget to paint on */ priv->window_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_widget_set_redraw_on_allocate(priv->window_container, TRUE); gtk_container_add (GTK_CONTAINER (self), priv->window_container); /* Set toolbar container */ priv->toolbar_container = GTK_CONTAINER (gtk_alignment_new (1.0, 0.0, 0.0, 0.0)); gtk_alignment_set_padding (GTK_ALIGNMENT (priv->toolbar_container), priv->padding_x, priv->padding_x, priv->padding_x, priv->padding_x); gtk_container_add (GTK_CONTAINER (priv->window_container), GTK_WIDGET (priv->toolbar_container)); gtk_widget_show_all (priv->window_container); /* Set tooltips */ ol_scroll_window_update_tooltip (self); /* Connect signals */ g_signal_connect (G_OBJECT (priv->window_container), "expose-event", G_CALLBACK (ol_scroll_window_expose), self); g_signal_connect (G_OBJECT (self), "button-press-event", G_CALLBACK (ol_scroll_window_button_press), self); g_signal_connect (G_OBJECT (self), "button-release-event", G_CALLBACK (ol_scroll_window_button_release), self); g_signal_connect (G_OBJECT (self), "motion-notify-event", G_CALLBACK (ol_scroll_window_motion_notify), self); }
void diaElemHex::setMe(void *dialog, void *opaque,uint32_t line) { GtkWidget *hexTable; GtkWidget *buttonP, *alignment1, *hbox1, *image1, *label1; GtkWidget *buttonN, *alignment2, *hbox2, *image2, *label2; uint8_t *tail=data+dataSize; hexTable=gtk_table_new(1,HEX_NB_LINE,0); gtk_widget_show(hexTable); gtk_table_attach (GTK_TABLE (opaque), hexTable, 0, 2, line, line+1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); hexStruct *s=new hexStruct; s->grid=hexTable; s->data=data; s->size=dataSize; s->curOffset=0; for(int i=0;i<HEX_NB_LINE;i++) { s->entry[i]=gtk_label_new(""); gtk_label_set_selectable(GTK_LABEL(s->entry[i]), TRUE); gtk_misc_set_alignment (GTK_MISC (s->entry[i]), 0, 1); gtk_widget_show(s->entry[i]); gtk_table_attach (GTK_TABLE (hexTable), s->entry[i], 0, 1, i, i+1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); } myWidget=(void *)s; //************************* buttonP = gtk_button_new_with_mnemonic (QT_TR_NOOP("_Previous")); gtk_widget_show (buttonP); gtk_table_attach (GTK_TABLE (opaque), buttonP, 0, 1, line+1, line+2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(GTK_OBJECT(buttonP), "clicked", GTK_SIGNAL_FUNC(prev), s); buttonN = gtk_button_new_with_mnemonic (QT_TR_NOOP("_Next")); gtk_widget_show (buttonN); gtk_table_attach (GTK_TABLE (opaque), buttonN, 1, 2, line+1, line+2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(GTK_OBJECT(buttonN), "clicked", GTK_SIGNAL_FUNC(next), s); #if 0 alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); hbox1 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment1), hbox1); GTK_WIDGET_SET_FLAGS (buttonP, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (hbox1), buttonP, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (buttonP), alignment1); image1 = gtk_image_new_from_stock ("gtk-go-back", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0); label1 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Previous")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0); gtk_table_attach (GTK_TABLE (opaque), hbox1, 0, 1, line+1, line+2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(GTK_OBJECT(buttonP), "clicked", GTK_SIGNAL_FUNC(prev), s); alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (buttonN), alignment2); hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox2); gtk_container_add (GTK_CONTAINER (alignment2), hbox2); buttonN = gtk_button_new (); gtk_widget_show (buttonN); gtk_box_pack_start (GTK_BOX (hbox2), buttonN, FALSE, FALSE, 0); GTK_WIDGET_SET_FLAGS (buttonN, GTK_CAN_DEFAULT); image2 = gtk_image_new_from_stock ("gtk-go-forward", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Next")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox2), label2, FALSE, FALSE, 0); gtk_table_attach (GTK_TABLE (opaque), hbox2, 0, 1, line+2, line+3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(GTK_OBJECT(buttonN), "clicked", GTK_SIGNAL_FUNC(next), s); #endif update(s); }
GtkWidget* create_dialog1 (const char *msg) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *label1; GtkWidget *dialog_action_area1; GtkWidget *button2; GtkWidget *alignment1; GtkWidget *hbox2; GtkWidget *image2; GtkWidget *label2; GtkWidget *button1; GtkWidget *alignment2; GtkWidget *hbox3; GtkWidget *image3; GtkWidget *label3; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Filesystem full / quota exceeded")); gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); hbox1 = gtk_hbox_new (FALSE, 12); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 12); image1 = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 0); label1 = gtk_label_new (msg); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, TRUE, FALSE, 0); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); button2 = gtk_button_new (); gtk_widget_show (button2); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button2, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT); alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (button2), alignment1); hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox2); gtk_container_add (GTK_CONTAINER (alignment1), hbox2); image2 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Ignore")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox2), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); button1 = gtk_button_new (); gtk_widget_show (button1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (button1), alignment2); hbox3 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox3); gtk_container_add (GTK_CONTAINER (alignment2), hbox3); image3 = gtk_image_new_from_stock ("gtk-redo", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image3); gtk_box_pack_start (GTK_BOX (hbox3), image3, FALSE, FALSE, 0); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Retry")); gtk_widget_show (label3); gtk_box_pack_start (GTK_BOX (hbox3), label3, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, image1, "image1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, button2, "button2"); GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT (dialog1, image2, "image2"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, button1, "button1"); GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2"); GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT (dialog1, image3, "image3"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); gtk_widget_grab_focus (button1); gtk_widget_grab_default (button1); return dialog1; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect((gpointer) sel, "changed", G_CALLBACK(on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }