static void search_box_init (SearchBox *search_box) { search_box->priv = GET_PRIVATE(search_box); GList* focus_chain = NULL; /* Button images */ GtkWidget* close = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); /* Searching */ search_box->priv->search_entry = gtk_entry_new(); gtk_widget_set_tooltip_text (search_box->priv->search_entry, _("Use the context menu of the \"Find\" icon for more search options")); g_signal_connect_swapped (G_OBJECT (search_box->priv->search_entry), "activate", G_CALLBACK (search_box_forward_search), search_box); g_signal_connect (G_OBJECT (search_box), "key-press-event", G_CALLBACK (on_search_box_key_pressed), search_box); g_signal_connect (G_OBJECT (search_box->priv->search_entry), "changed", G_CALLBACK (on_search_box_entry_changed), search_box); g_signal_connect (G_OBJECT (search_box->priv->search_entry), "focus-out-event", G_CALLBACK (on_search_focus_out), search_box); g_signal_connect (G_OBJECT (search_box->priv->search_entry), "icon-press", G_CALLBACK (on_search_entry_icon_pressed), search_box); g_signal_connect (G_OBJECT (search_box->priv->search_entry), "popup-menu", G_CALLBACK (on_search_entry_popup_menu), search_box); search_box->priv->close_button = gtk_button_new(); gtk_button_set_image (GTK_BUTTON (search_box->priv->close_button), close); gtk_button_set_relief (GTK_BUTTON (search_box->priv->close_button), GTK_RELIEF_NONE); g_signal_connect (G_OBJECT (search_box->priv->close_button), "clicked", G_CALLBACK (on_search_box_hide), search_box); /* Previous, Next Navigation */ search_box->priv->next_button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (search_box->priv->next_button), gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief (GTK_BUTTON (search_box->priv->next_button), GTK_RELIEF_NONE); g_signal_connect_swapped (G_OBJECT(search_box->priv->next_button), "clicked", G_CALLBACK (search_box_forward_search), search_box); search_box->priv->previous_button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (search_box->priv->previous_button), gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief (GTK_BUTTON (search_box->priv->previous_button), GTK_RELIEF_NONE); g_signal_connect (G_OBJECT(search_box->priv->previous_button), "clicked", G_CALLBACK (on_search_box_backward_search), search_box); /* Goto line */ search_box->priv->goto_entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (search_box->priv->goto_entry), LINE_ENTRY_WIDTH); gtk_entry_set_icon_from_stock (GTK_ENTRY (search_box->priv->goto_entry), GTK_ENTRY_ICON_SECONDARY, ANJUTA_STOCK_GOTO_LINE); g_signal_connect (G_OBJECT (search_box->priv->goto_entry), "activate", G_CALLBACK (on_goto_activated), search_box); g_signal_connect (G_OBJECT (search_box->priv->goto_entry), "key-press-event", G_CALLBACK (on_goto_key_pressed), search_box); /* Replace */ search_box->priv->replace_entry = gtk_entry_new(); g_signal_connect (G_OBJECT (search_box->priv->replace_entry), "activate", G_CALLBACK (on_replace_activated), search_box); search_box->priv->replace_button = gtk_button_new_with_label(_("Replace")); gtk_button_set_relief (GTK_BUTTON (search_box->priv->replace_button), GTK_RELIEF_NONE); g_signal_connect (G_OBJECT(search_box->priv->replace_button), "clicked", G_CALLBACK (on_replace_activated), search_box); search_box->priv->replace_all_button = gtk_button_new_with_label(_("Replace all")); gtk_button_set_relief (GTK_BUTTON (search_box->priv->replace_all_button), GTK_RELIEF_NONE); g_signal_connect (G_OBJECT(search_box->priv->replace_all_button), "clicked", G_CALLBACK (on_replace_all_activated), search_box); /* Popup Menu Options */ search_box->priv->regex_mode = FALSE; search_box->priv->highlight_all = FALSE; search_box->priv->case_sensitive = FALSE; /* Highlight iterator */ search_box->priv->start_highlight = NULL; search_box->priv->end_highlight = NULL; search_box->priv->idle_id = 0; /* Initialize search_box grid */ search_box->priv->grid = gtk_grid_new(); gtk_orientable_set_orientation (GTK_ORIENTABLE (search_box->priv->grid), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing (GTK_GRID (search_box->priv->grid), 5); /* Attach search elements to grid */ gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->goto_entry, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->search_entry, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->previous_button, 2, 0, 1, 1); gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->next_button, 3, 0, 1, 1); gtk_grid_attach_next_to (GTK_GRID (search_box->priv->grid), search_box->priv->close_button, search_box->priv->next_button, GTK_POS_RIGHT, 1, 1); gtk_widget_set_hexpand(search_box->priv->close_button, TRUE); gtk_widget_set_halign(search_box->priv->close_button, GTK_ALIGN_END); /* Add Replace elements to search box on 2nd level */ gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->replace_entry, 1, 1, 1, 1); gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->replace_button, 2, 1, 1, 1); gtk_grid_attach (GTK_GRID (search_box->priv->grid), search_box->priv->replace_all_button, 3, 1, 1, 1); /* Expand search entries (a bit) */ gtk_entry_set_width_chars (GTK_ENTRY (search_box->priv->search_entry), SEARCH_ENTRY_WIDTH); gtk_entry_set_width_chars (GTK_ENTRY (search_box->priv->replace_entry), SEARCH_ENTRY_WIDTH); /* Set nice icons */ gtk_entry_set_icon_from_stock (GTK_ENTRY (search_box->priv->search_entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND); gtk_entry_set_icon_from_stock (GTK_ENTRY (search_box->priv->replace_entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND_AND_REPLACE); /* Pack grid into search box */ gtk_box_pack_start (GTK_BOX(search_box), search_box->priv->grid, TRUE, TRUE, 0); /* Set focus chain */ focus_chain = g_list_prepend (focus_chain, search_box->priv->search_entry); focus_chain = g_list_prepend (focus_chain, search_box->priv->replace_entry); focus_chain = g_list_prepend (focus_chain, search_box->priv->next_button); focus_chain = g_list_prepend (focus_chain, search_box->priv->previous_button); focus_chain = g_list_prepend (focus_chain, search_box->priv->replace_button); focus_chain = g_list_prepend (focus_chain, search_box->priv->replace_all_button); focus_chain = g_list_prepend (focus_chain, search_box->priv->goto_entry); focus_chain = g_list_prepend (focus_chain, search_box->priv->close_button); focus_chain = g_list_prepend (focus_chain, search_box->priv->search_entry); focus_chain = g_list_reverse (focus_chain); gtk_container_set_focus_chain (GTK_CONTAINER (search_box->priv->grid), focus_chain); g_list_free (focus_chain); /* Show all children but keep the top box hidden. */ gtk_widget_show_all (GTK_WIDGET (search_box)); gtk_widget_hide (GTK_WIDGET (search_box)); }
void pidgin_icon_theme_edit(PurplePluginAction *unused) { GtkWidget *dialog; GtkWidget *box, *vbox; GtkWidget *notebook; GtkSizeGroup *sizegroup; int s, i, j; dialog = pidgin_create_dialog(_("Pidgin Icon Theme Editor"), 0, "theme-editor-icon", FALSE); box = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog), FALSE, PIDGIN_HIG_BOX_SPACE); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, PIDGIN_HIG_BOX_SPACE); sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); for (s = 0; sections[s].heading; s++) { const char *heading = sections[s].heading; box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), box, gtk_label_new(heading)); vbox = pidgin_make_frame(box, heading); g_object_set_data(G_OBJECT(dialog), heading, vbox); for (i = 0; sections[s].options[i].stockid; i++) { const char *id = sections[s].options[i].stockid; const char *text = _(sections[s].options[i].text); GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_CAT_SPACE); GtkWidget *label = gtk_label_new(text); GtkWidget *image = gtk_image_new_from_stock(id, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); GtkWidget *ebox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(ebox), image); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); g_signal_connect(G_OBJECT(ebox), "button-press-event", G_CALLBACK(change_stock_image), image); g_object_set_data(G_OBJECT(image), "property-name", (gpointer)id); g_object_set_data(G_OBJECT(image), "localized-name", (gpointer)text); gtk_size_group_add_widget(sizegroup, label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), ebox, FALSE, FALSE, 0); for (j = 0; stocksizes[j]; j++) { GtkWidget *sh; if (!(sections[s].flags & (1 << j))) continue; sh = gtk_image_new_from_stock(id, gtk_icon_size_from_name(stocksizes[j])); gtk_box_pack_start(GTK_BOX(hbox), sh, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(image), stocksizes[j], sh); } gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(vbox), id, image); } } #ifdef NOT_SADRUL pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, G_CALLBACK(save_icon_theme), dialog); #endif pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_APPLY, G_CALLBACK(use_icon_theme), dialog); pidgin_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, G_CALLBACK(close_icon_theme), dialog); gtk_widget_show_all(dialog); g_object_unref(sizegroup); }
/* returns a parent widget to pack the contents of the page into */ GtkWidget *gtkui_page_new(char *title, void (*callback)(void), void (*detacher)(GtkWidget *)) { GtkWidget *parent, *label; GtkWidget *hbox, *button, *image; /* a container to hold the close button and tab label */ hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); /* the label for the tab title */ label = gtk_label_new(title); gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* the close button */ button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_set_size_request(button, 20, 20); gtk_widget_show(button); /* an image for the button */ image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_container_add(GTK_CONTAINER (button), image); gtk_widget_show(image); /* a parent to pack the contents into */ parent = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(parent), GTK_SHADOW_NONE); gtk_widget_show(parent); if(!notebook && notebook_frame) { gtk_container_remove(GTK_CONTAINER (notebook_frame), gtk_bin_get_child(GTK_BIN (notebook_frame))); notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_notebook_set_scrollable(GTK_NOTEBOOK (notebook), TRUE); gtk_container_add(GTK_CONTAINER (notebook_frame), notebook); gtk_widget_show(notebook); #if GTK_MINOR_VERSION == 2 g_signal_connect(G_OBJECT (notebook), "switch-page", G_CALLBACK(gtkui_page_defocus_tabs), NULL); #endif gtkui_create_tab_menu(); } gtk_notebook_append_page(GTK_NOTEBOOK(notebook), parent, hbox); /* attach callback to destroy the tab/page */ g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(gtkui_page_close), parent); /* attach callback to do specific clean-up */ if(callback) g_object_set_data(G_OBJECT (parent), "destroy", callback); if(detacher) g_object_set_data(G_OBJECT (parent), "detach", detacher); gtkui_page_present(parent); return(parent); }
GtkWidget* remmina_chat_window_new(GtkWindow* parent, const gchar* chat_with) { RemminaChatWindow* window; gchar buf[100]; GtkWidget* table; GtkWidget* scrolledwindow; GtkWidget* widget; GtkWidget* image; GtkTextBuffer* buffer; window = REMMINA_CHAT_WINDOW(g_object_new(REMMINA_TYPE_CHAT_WINDOW, NULL)); if (parent) { gtk_window_set_transient_for(GTK_WINDOW(window), parent); } /* Title */ g_snprintf(buf, sizeof(buf), _("Chat with %s"), chat_with); gtk_window_set_title(GTK_WINDOW(window), buf); gtk_window_set_default_size(GTK_WINDOW(window), 450, 300); /* Main container */ table = gtk_table_new(3, 2, FALSE); gtk_widget_show(table); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 4); gtk_container_set_border_width(GTK_CONTAINER(table), 8); gtk_container_add(GTK_CONTAINER(window), table); /* Chat history */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_table_attach_defaults(GTK_TABLE(table), scrolledwindow, 0, 2, 0, 1); widget = gtk_text_view_new(); gtk_widget_show(widget); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_create_tag(buffer, "sender-foreground", "foreground", "blue", NULL); gtk_text_buffer_create_tag(buffer, "receiver-foreground", "foreground", "red", NULL); window->history_text = widget; /* Chat message to be sent */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_table_attach(GTK_TABLE(table), scrolledwindow, 0, 1, 1, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); widget = gtk_text_view_new(); gtk_widget_show(widget); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(remmina_chat_window_send_text_on_key), window); window->send_text = widget; /* Send button */ image = gtk_image_new_from_icon_name("document-send", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); widget = gtk_button_new_with_mnemonic(_("_Send")); gtk_widget_show(widget); gtk_button_set_image(GTK_BUTTON(widget), image); gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 1, 2, 0, 0, 0, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_send), window); /* Clear button */ image = gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); widget = gtk_button_new_with_mnemonic(_("_Clear")); gtk_widget_show(widget); gtk_button_set_image(GTK_BUTTON(widget), image); gtk_table_attach(GTK_TABLE(table), widget, 1, 2, 2, 3, 0, 0, 0, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_clear_send_text), window); gtk_widget_grab_focus(window->send_text); return GTK_WIDGET(window); }
static void caja_file_conflict_dialog_init (CajaFileConflictDialog *fcd) { #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget *hbox, *vbox, *vbox2; #else GtkWidget *hbox, *vbox, *vbox2, *alignment; #endif GtkWidget *widget, *dialog_area; CajaFileConflictDialogDetails *details; GtkDialog *dialog; details = fcd->details = CAJA_FILE_CONFLICT_DIALOG_GET_PRIVATE (fcd); dialog = GTK_DIALOG (fcd); /* Setup the main hbox */ hbox = gtk_hbox_new (FALSE, 12); dialog_area = gtk_dialog_get_content_area (dialog); gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); /* Setup the dialog image */ widget = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (widget, GTK_ALIGN_START); #else gtk_misc_set_alignment (GTK_MISC (widget), 0.5, 0.0); #endif /* Setup the vbox containing the dialog body */ vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); /* Setup the vbox for the dialog labels */ widget = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); details->titles_vbox = widget; /* Setup the hboxes to pack file infos into */ #if GTK_CHECK_VERSION (3, 0, 0) vbox2 = gtk_vbox_new (FALSE, 12); gtk_widget_set_halign (vbox2, GTK_ALIGN_START); gtk_widget_set_valign (vbox2, GTK_ALIGN_START); gtk_widget_set_margin_start (vbox2, 12); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); #else alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); g_object_set (alignment, "left-padding", 12, NULL); vbox2 = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (alignment), vbox2); gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0); #endif hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); details->first_hbox = hbox; hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); details->second_hbox = hbox; /* Setup the expander for the rename action */ details->expander = gtk_expander_new_with_mnemonic (_("Select a new name for the _destination")); gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0); g_signal_connect (details->expander, "activate", G_CALLBACK (expander_activated_cb), dialog); hbox = gtk_hbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (details->expander), hbox); widget = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 6); details->entry = widget; g_signal_connect (widget, "changed", G_CALLBACK (entry_text_changed_cb), dialog); widget = gtk_button_new_with_label (_("Reset")); gtk_button_set_image (GTK_BUTTON (widget), gtk_image_new_from_stock (GTK_STOCK_UNDO, GTK_ICON_SIZE_MENU)); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); g_signal_connect (widget, "clicked", G_CALLBACK (reset_button_clicked_cb), dialog); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_show_all (vbox2); #else gtk_widget_show_all (alignment); #endif /* Setup the diff button for text files */ details->diff_button = gtk_button_new_with_label (_("Differences...")); gtk_button_set_image (GTK_BUTTON (details->diff_button), gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU)); gtk_box_pack_start (GTK_BOX (vbox), details->diff_button, FALSE, FALSE, 6); g_signal_connect (details->diff_button, "clicked", G_CALLBACK (diff_button_clicked_cb), dialog); gtk_widget_hide (details->diff_button); /* Setup the checkbox to apply the action to all files */ widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files")); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); details->checkbox = widget; g_signal_connect (widget, "toggled", G_CALLBACK (checkbox_toggled_cb), dialog); /* Add buttons */ gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Skip"), CONFLICT_RESPONSE_SKIP, NULL); details->rename_button = gtk_dialog_add_button (dialog, _("Re_name"), CONFLICT_RESPONSE_RENAME); gtk_widget_hide (details->rename_button); details->replace_button = gtk_dialog_add_button (dialog, _("Replace"), CONFLICT_RESPONSE_REPLACE); gtk_widget_grab_focus (details->replace_button); /* Setup HIG properties */ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 14); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_widget_show_all (dialog_area); }
GtkWidget *gui_create_display_informtion_dialog(void) { GtkWidget *dialog_vbox23; GtkWidget *hbox; GtkWidget *dialog_action_area23; GtkWidget *hbuttonbox2; GtkWidget *button_close; GtkWidget *image; dialog_display_info = gtk_dialog_new(); gtk_container_set_border_width(GTK_CONTAINER(dialog_display_info), 6); g_object_set_data(G_OBJECT(dialog_display_info), "dialog_display_info", dialog_display_info); gtk_window_set_title(GTK_WINDOW(dialog_display_info), " "); //GTK_WINDOW(dialog_display_info)->type = GTK_WINDOW_TOPLEVEL; gtk_window_set_default_size(GTK_WINDOW(dialog_display_info), 350, 200); gtk_window_set_resizable(GTK_WINDOW(dialog_display_info), TRUE); #ifndef USE_GTK_3 gtk_dialog_set_has_separator(GTK_DIALOG(dialog_display_info), FALSE); #endif dialog_vbox23 = gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info)); //GTK_DIALOG(dialog_display_info)->vbox; g_object_set_data(G_OBJECT(dialog_display_info), "dialog_vbox23", dialog_vbox23); gtk_widget_show(dialog_vbox23); UI_HBOX(hbox, FALSE, 12); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(dialog_vbox23), hbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), 6); image = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("dialog-information", GTK_ICON_SIZE_DIALOG); #else gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); #endif gtk_widget_show(image); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, TRUE, 0); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0); #endif html_widget = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, 30)); //gtk_html_new(); gtk_widget_show(html_widget); gtk_box_pack_start(GTK_BOX(hbox), html_widget, TRUE, TRUE, 0); //gtk_container_add(GTK_CONTAINER(scrolledwindow70), html_widget); dialog_action_area23 = #ifdef HAVE_GTK_312 gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info)); #else gtk_dialog_get_action_area(GTK_DIALOG(dialog_display_info)); #endif g_object_set_data(G_OBJECT(dialog_display_info), "dialog_action_area23", dialog_action_area23); gtk_widget_show(dialog_action_area23); gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area23), 10); #ifdef USE_GTK_3 hbuttonbox2 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbuttonbox2 = gtk_hbutton_box_new(); #endif gtk_widget_show(hbuttonbox2); gtk_box_pack_start(GTK_BOX(dialog_action_area23), hbuttonbox2, TRUE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox2), GTK_BUTTONBOX_END); button_close = #ifdef HAVE_GTK_310 gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON); #else gtk_button_new_from_stock(GTK_STOCK_CLOSE); #endif gtk_widget_show(button_close); gtk_container_add(GTK_CONTAINER(hbuttonbox2), button_close); gtk_widget_set_can_default(button_close, 1); g_signal_connect(G_OBJECT(button_close), "clicked", G_CALLBACK(button_close_clicked), NULL); g_signal_connect(G_OBJECT(dialog_display_info), "destroy", G_CALLBACK(on_dlgInformation_destroy), NULL); gtk_widget_show(dialog_display_info); gsI_isrunning = TRUE; return dialog_display_info; }
static void rejilla_song_control_init (RejillaSongControl *object) { RejillaSongControlPrivate *priv; GtkWidget *alignment; GtkWidget *volume; gint volume_value; GtkWidget *image; GtkWidget *vbox; GtkWidget *hbox; gpointer value; GstBus *bus; priv = REJILLA_SONG_CONTROL_PRIVATE (object); /* Pipeline */ priv->pipe = gst_element_factory_make ("playbin2", NULL); if (priv->pipe) { GstElement *audio_sink; audio_sink = gst_element_factory_make ("mateconfaudiosink", NULL); if (audio_sink) g_object_set (G_OBJECT (priv->pipe), "audio-sink", audio_sink, NULL); } else g_warning ("Pipe creation error : can't create pipe.\n"); bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipe)); gst_bus_add_watch (bus, (GstBusFunc) rejilla_song_control_bus_messages, object); gst_object_unref (bus); /* Widget itself */ vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_container_add (GTK_CONTAINER (object), vbox); /* first line title */ hbox = gtk_hbox_new (FALSE, 12); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); priv->header = gtk_label_new (_("No file")); gtk_widget_show (priv->header); gtk_label_set_use_markup (GTK_LABEL (priv->header), TRUE); gtk_label_set_justify (GTK_LABEL (priv->header), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (priv->header), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), priv->header, TRUE, TRUE, 0); priv->size = gtk_label_new (NULL); gtk_widget_show (priv->size); gtk_label_set_justify (GTK_LABEL (priv->size), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (priv->size), 0.0, 0.0); gtk_box_pack_end (GTK_BOX (hbox), priv->size, FALSE, FALSE, 0); /* second line : play, progress, volume button */ hbox = gtk_hbox_new (FALSE, 12); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_widget_show (alignment); priv->button = gtk_toggle_button_new (); gtk_widget_show (priv->button); gtk_widget_set_tooltip_text (priv->button, _("Start and stop playing")); gtk_container_add (GTK_CONTAINER (alignment), priv->button); gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON); gtk_widget_show (image); gtk_container_add (GTK_CONTAINER (priv->button), image); g_signal_connect (G_OBJECT (priv->button), "clicked", G_CALLBACK (rejilla_song_control_button_clicked_cb), object); priv->progress = gtk_hscale_new_with_range (0, 1, 500000000); gtk_widget_show (priv->progress); gtk_scale_set_digits (GTK_SCALE (priv->progress), 0); gtk_scale_set_draw_value (GTK_SCALE (priv->progress), FALSE); gtk_widget_set_size_request (priv->progress, 80, -1); gtk_range_set_update_policy (GTK_RANGE (priv->progress), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (hbox), priv->progress, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (priv->progress), "button-press-event", G_CALLBACK (rejilla_song_control_range_button_pressed_cb), object); g_signal_connect (G_OBJECT (priv->progress), "button-release-event", G_CALLBACK (rejilla_song_control_range_button_released_cb), object); g_signal_connect (G_OBJECT (priv->progress), "value-changed", G_CALLBACK (rejilla_song_control_range_value_changed), object); /* Set saved volume */ rejilla_setting_get_value (rejilla_setting_get_default (), REJILLA_SETTING_PLAYER_VOLUME, &value); volume_value = GPOINTER_TO_INT (value); volume_value = CLAMP (volume_value, 0, 100); g_object_set (priv->pipe, "volume", (gdouble) volume_value / 100.0, NULL); volume = gtk_volume_button_new (); gtk_widget_show (volume); gtk_box_pack_start (GTK_BOX (hbox), volume, FALSE, FALSE, 0); gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume), (gdouble) volume_value / 100.0); g_signal_connect (volume, "value-changed", G_CALLBACK (rejilla_song_control_volume_changed_cb), object); gtk_alignment_set_padding (GTK_ALIGNMENT (object), 12, 0, 0, 0); }
static GtkWidget * build_searchbar (void) { GtkWidget *button; GtkWidget *image; GtkWidget *entry; GtkWidget *hbox; GtkWidget *label; hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new (_("Find:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (hbox), "entry", entry); g_signal_connect (entry, "changed", G_CALLBACK (search_entry_changed), NULL); g_signal_connect (entry, "key-press-event", G_CALLBACK (search_entry_key_press), NULL); button = gtk_button_new_with_mnemonic (C_("search", "_Previous")); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (search_prev_clicked), entry); button = gtk_button_new_with_mnemonic (C_("search", "_Next")); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (search_next_clicked), entry); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); g_object_get (button, "image", &image, NULL); g_object_set (image, "icon-size", GTK_ICON_SIZE_MENU, NULL); g_object_unref (image); gtk_widget_show (button); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (search_close_clicked), NULL); return hbox; }
static GtkWidget *tab_widget_new(PASSAGE_TAB_INFO *tbinf, const gchar *label_text) { GtkWidget *box; #ifdef USE_GTK_3 // GdkRGBA color; #else GdkColor color; #endif g_return_val_if_fail(label_text != NULL, NULL); #ifdef HAVE_GTK_310 tbinf->button_close = gtk_button_new_from_icon_name("window-close-symbolic", GTK_ICON_SIZE_MENU); #else GtkWidget *tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); tbinf->button_close = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(tbinf->button_close), tmp_toolbar_icon); gtk_button_set_relief(GTK_BUTTON(tbinf->button_close), GTK_RELIEF_NONE); #endif #ifndef USE_GTK_3 gtk_rc_parse_string("style \"tab-button-style\"\n" "{\n" " GtkWidget::focus-padding = 0\n" " GtkWidget::focus-line-width = 0\n" " xthickness = 0\n" " ythickness = 0\n" " GtkButton::internal-border = {0, 0, 0, 0}\n" " GtkButton::default-border = {0, 0, 0, 0}\n" " GtkButton::default-outside-border = {0, 0, 0, 0}\n" "}\n" "widget \"*.button-close\" style \"tab-button-style\""); gtk_widget_set_name(GTK_WIDGET(tbinf->button_close), "button-close"); #else gtk_widget_set_size_request(tbinf->button_close, 18, 16); #endif #ifndef USE_GTK_3 GtkRequisition r; gtk_widget_size_request(tbinf->button_close, &r); #endif gtk_widget_set_sensitive(tbinf->button_close, FALSE); gtk_widget_show(tbinf->button_close); tbinf->tab_label = GTK_LABEL(gtk_label_new(label_text)); gtk_widget_show(GTK_WIDGET(tbinf->tab_label)); #ifdef USE_GTK_3 #else color.red = 0; color.green = 0; color.blue = 0; gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_INSENSITIVE, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_ACTIVE, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_PRELIGHT, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_SELECTED, &color); #endif UI_HBOX(box, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(tbinf->tab_label), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), tbinf->button_close, FALSE, FALSE, 0); gtk_widget_show(box); g_signal_connect(G_OBJECT(tbinf->button_close), "clicked", G_CALLBACK(on_notebook_main_close_page), tbinf); return box; }
static GtkWidget * _preferences_window_applets(Panel * panel) { GtkSizeGroup * group; GtkWidget * vbox; GtkWidget * vbox2; GtkWidget * vbox3; GtkWidget * hbox; GtkWidget * frame; GtkWidget * widget; size_t i; /* FIXME this needs a restart to apply */ group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); vbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); hbox = gtk_hbox_new(FALSE, 4); /* plug-ins */ frame = gtk_frame_new(_("Applets:")); widget = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(widget), 4); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_store = _preferences_window_applets_model(); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(panel->pr_store), 2, GTK_SORT_ASCENDING); panel->pr_view = _preferences_window_applets_view(panel->pr_store, FALSE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_view); gtk_container_add(GTK_CONTAINER(frame), widget); gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 0); /* controls */ vbox2 = gtk_vbox_new(FALSE, 4); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_add), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #ifndef EMBEDDED widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_up), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_down), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #endif widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_top_remove), panel); gtk_box_pack_start(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_label_new(NULL); gtk_box_pack_end(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_remove), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #ifndef EMBEDDED widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_down), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_up), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); #endif widget = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock( GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); g_signal_connect_swapped(widget, "clicked", G_CALLBACK( _preferences_on_bottom_add), panel); gtk_box_pack_end(GTK_BOX(vbox2), widget, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 4); /* top plug-ins */ frame = gtk_frame_new(_("Top panel:")); vbox3 = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); #if GTK_CHECK_VERSION(3, 0, 0) panel->pr_top_size = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_top_size), NULL, _("Default")); #else panel->pr_top_size = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size), _("Default")); #endif for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++) #if GTK_CHECK_VERSION(3, 0, 0) gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT( panel->pr_top_size), NULL, _(_panel_sizes[i].alias)); #else gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_top_size), _(_panel_sizes[i].alias)); #endif gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_top_size, FALSE, TRUE, 0); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_top_store = _preferences_window_applets_model(); panel->pr_top_view = _preferences_window_applets_view( panel->pr_top_store, TRUE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_top_view); gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox3); gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0); /* bottom plug-ins */ frame = gtk_frame_new(_("Bottom panel:")); vbox3 = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); #if GTK_CHECK_VERSION(3, 0, 0) panel->pr_bottom_size = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(panel->pr_bottom_size), NULL, _("Default")); #else panel->pr_bottom_size = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size), _("Default")); #endif for(i = 0; i < sizeof(_panel_sizes) / sizeof(*_panel_sizes); i++) #if GTK_CHECK_VERSION(3, 0, 0) gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT( panel->pr_bottom_size), NULL, _(_panel_sizes[i].alias)); #else gtk_combo_box_append_text(GTK_COMBO_BOX(panel->pr_bottom_size), _(_panel_sizes[i].alias)); #endif gtk_box_pack_start(GTK_BOX(vbox3), panel->pr_bottom_size, FALSE, TRUE, 0); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(widget), GTK_SHADOW_ETCHED_IN); panel->pr_bottom_store = _preferences_window_applets_model(); panel->pr_bottom_view = _preferences_window_applets_view( panel->pr_bottom_store, TRUE); gtk_container_add(GTK_CONTAINER(widget), panel->pr_bottom_view); gtk_box_pack_start(GTK_BOX(vbox3), widget, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox3); gtk_box_pack_start(GTK_BOX(vbox2), frame, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); return vbox; }
static void set_message_area_text_and_icon (GtkInfoBar *message_area, const gchar *icon_stock_id, const gchar *primary_text, const gchar *secondary_text) { GtkWidget *hbox_content; GtkWidget *image; GtkWidget *vbox; gchar *primary_markup; gchar *secondary_markup; GtkWidget *primary_label; GtkWidget *secondary_label; hbox_content = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox_content); image = gtk_image_new_from_stock (icon_stock_id, GTK_ICON_SIZE_DIALOG); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (hbox_content), vbox, TRUE, TRUE, 0); primary_markup = g_strdup_printf ("<b>%s</b>", primary_text); primary_label = gtk_label_new (primary_markup); g_free (primary_markup); gtk_widget_show (primary_label); gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0); gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE); gtk_label_set_line_wrap (GTK_LABEL (primary_label), FALSE); gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5); gtk_widget_set_can_focus (primary_label, TRUE); gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE); if (secondary_text != NULL) { secondary_markup = g_strdup_printf ("<small>%s</small>", secondary_text); secondary_label = gtk_label_new (secondary_markup); g_free (secondary_markup); gtk_widget_show (secondary_label); gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0); gtk_widget_set_can_focus (secondary_label, TRUE); gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE); gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE); gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE); gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5); } gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (message_area))), hbox_content, TRUE, TRUE, 0); }
void _showInGtkWindow (SEXP xx, SEXP caption) { int nx, ny, nz, width, height; udata *dat; SEXP dim; GdkPixbuf * pxbuf; GtkWidget *evBox, *winWG, *vboxWG, *tbarWG, *scrollWG, *btnZoomInWG, *btnZoomOutWG, *btnZoomOneWG, *btnNextWG, *btnPrevWG; GtkObject *hAdjustment; GtkIconSize iSize; if ( !GTK_OK ) error ( "failed to initialize GTK+, use 'read.image' instead" ); dim = GET_DIM (xx); nx = INTEGER (dim)[0]; ny = INTEGER (dim)[1]; nz = getNumberOfFrames(xx,1); dat=g_new(udata,1); dat->nx=nx; dat->ny=ny; dat->nz=nz; dat->x=0; dat->y=0; dat->zoom=1.0; dat->index=0; dat->hSlider=NULL; dat->xx=xx; // xx is preserved from garbage collection til the windows is closed R_PreserveObject(xx); /* create pixbuf from image data */ pxbuf=newPixbufFromSEXP(xx,0); if ( pxbuf == NULL ) error ( "cannot copy image data to display window" ); /* create imae display */ dat->imgWG = gtk_image_new_from_pixbuf (pxbuf); g_object_unref (pxbuf); /* create main window */ winWG = gtk_window_new (GTK_WINDOW_TOPLEVEL); if ( caption != R_NilValue ) gtk_window_set_title ( GTK_WINDOW(winWG), CHAR( asChar(caption) ) ); else gtk_window_set_title ( GTK_WINDOW(winWG), "R image display" ); /* set destroy event handler for the window */ g_signal_connect ( G_OBJECT(winWG), "delete-event", G_CALLBACK(onWinDestroy), dat); /* create controls and set event handlers */ /* create general horizontal lyout with a toolbar and add it to the window */ vboxWG = gtk_vbox_new (FALSE, 0); gtk_container_add ( GTK_CONTAINER(winWG), vboxWG); /* create toolbar and push it to layout */ tbarWG = gtk_toolbar_new (); gtk_box_pack_start ( GTK_BOX(vboxWG), tbarWG, FALSE, FALSE, 0); // add a horizontal slider if (nz>1) { hAdjustment=gtk_adjustment_new(1,1,nz,1,1,0); dat->hSlider=gtk_hscale_new(GTK_ADJUSTMENT(hAdjustment)); gtk_scale_set_digits(GTK_SCALE(dat->hSlider),0); gtk_box_pack_start(GTK_BOX(vboxWG), dat->hSlider, FALSE,FALSE, 0); gtk_signal_connect(GTK_OBJECT(dat->hSlider),"value-changed", GTK_SIGNAL_FUNC(onSlide), dat); } /* create scrollbox that occupies and extends and push it to layout */ scrollWG = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start ( GTK_BOX(vboxWG), scrollWG, TRUE, TRUE, 5); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrollWG), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* add image to event box */ evBox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evBox), dat->imgWG); /* add image to scroll */ gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW(scrollWG), evBox); gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat); gtk_signal_connect(GTK_OBJECT(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrollWG))),"value-changed", GTK_SIGNAL_FUNC(onScroll), dat); /* create status bar and push it to layout */ dat->stbarWG = gtk_statusbar_new (); gtk_box_pack_start ( GTK_BOX(vboxWG), dat->stbarWG, FALSE, FALSE, 0); /* add zoom buttons */ iSize = gtk_toolbar_get_icon_size ( GTK_TOOLBAR(tbarWG) ); btnZoomInWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-in", iSize), "Zoom in" ); gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomInWG); g_signal_connect ( G_OBJECT(btnZoomInWG), "clicked", G_CALLBACK(onZoomInPress), dat); btnZoomOutWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-zoom-out", iSize), "Zoom out" ); gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOutWG); g_signal_connect ( G_OBJECT(btnZoomOutWG), "clicked", G_CALLBACK(onZoomOutPress), dat); btnZoomOneWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-yes", iSize), "1:1"); gtk_container_add ( GTK_CONTAINER(tbarWG), btnZoomOneWG); g_signal_connect ( G_OBJECT(btnZoomOneWG), "clicked", G_CALLBACK(onZoomOnePress), dat); /* add browsing buttons */ if ( nz > 1 ) { btnPrevWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-back", iSize), "Previous" ); gtk_container_add ( GTK_CONTAINER(tbarWG), btnPrevWG); g_signal_connect ( G_OBJECT(btnPrevWG), "clicked", G_CALLBACK(onPrevImPress), dat); btnNextWG = (GtkWidget *) gtk_tool_button_new ( gtk_image_new_from_stock("gtk-go-forward", iSize), "Next" ); gtk_container_add ( GTK_CONTAINER(tbarWG), btnNextWG); g_signal_connect ( G_OBJECT(btnNextWG), "clicked", G_CALLBACK(onNextImPress), dat); } gtk_signal_connect( GTK_OBJECT(evBox), "motion-notify-event", GTK_SIGNAL_FUNC(onMouseMove), dat); gtk_widget_set_events(evBox, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK ); /* resize to fit image */ width = gdk_screen_get_width ( gdk_screen_get_default() ); height = gdk_screen_get_height ( gdk_screen_get_default () ); width = ( nx + 20 < width - 20 ) ? ( nx + 20 ) : ( width - 20 ); height = ( ny + 80 < height - 20 ) ? ( ny + 80 ) : ( height - 20 ); if ( width < 150 ) width = 150; if ( height < 100 ) height = 100; gtk_window_resize ( GTK_WINDOW(winWG), width, height); /* show window */ gtk_widget_show_all (winWG); updateStatusBar(dat); gdk_flush(); }
int gzrt_message ( int flags, char * title, char * fmt, ... ) { GtkWidget * dialog; GtkWidget * image; GtkWidget * vbox; GtkWidget * hbox; GtkWidget * label; va_list ap; static char buffer[2048]; char * icon; int len, result; /* Start VA args */ va_start( ap, fmt ); /* Prepare message */ len = vsnprintf( buffer, sizeof(buffer), fmt, ap ); /* Print message to command line? */ if( (flags & MSG_F_CMD) || (flags & MSG_F_ECHO) ) { if( (flags & MSG_F_STDOUT) ) fputs( buffer, stdout ); else fputs( buffer, stderr ); /* Done */ if( (flags & MSG_F_CMD) ) goto cleanup; } /* Check title */ if( !title ) title = "Notice"; /* Get message type */ switch( flags & 0xFF000000 ) { case MSG_INFO: case MSG_MESSAGE: icon = GTK_STOCK_DIALOG_INFO; break; case MSG_ERROR: icon = GTK_STOCK_DIALOG_ERROR; break; case MSG_WARNING: icon = GTK_STOCK_DIALOG_WARNING; break; default: icon = GTK_STOCK_DIALOG_INFO; break; } /* Create GTK dialog */ dialog = gtk_dialog_new_with_buttons ( title, NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL ); vbox = GTK_DIALOG(dialog)->vbox; /* Create an hbox */ hbox = gtk_hbox_new( FALSE, 4 ); gtk_box_pack_start( GTK_BOX(vbox), hbox, TRUE, TRUE, 0 ); /* Get stock image */ image = gtk_image_new_from_stock( icon, GTK_ICON_SIZE_DIALOG ); gtk_box_pack_start( GTK_BOX(hbox), image, FALSE, FALSE, 8 ); /* Create message */ label = gtk_label_new( buffer ); gtk_box_pack_start( GTK_BOX(hbox), label, FALSE, TRUE, 8 ); /* Finalize dialog */ gtk_widget_show_all( dialog ); /* Run the dialog */ while( result = gtk_dialog_run( GTK_DIALOG(dialog) ) ) switch( result ) { case GTK_RESPONSE_ACCEPT: case GTK_RESPONSE_DELETE_EVENT: goto loopdone; break; } /* Destroy the dialog */ loopdone: gtk_widget_destroy( dialog ); /* End VA list */ cleanup: va_end( ap ); /* Fatal? */ if( (flags & MSG_F_FATAL) ) { char quit; /* Get quit code */ quit = flags >> 16 & 0xFF; /* Exit */ gzrt_exit( quit ); }
int main (int argc, char **argv) { GtkWidget *window, *grid; GtkWidget *label, *image, *box; GtkIconTheme *theme; GdkPixbuf *pixbuf; GtkIconSet *iconset; GtkIconSource *iconsource; gchar *icon_name = "gnome-terminal"; gchar *anim_filename = NULL; GIcon *icon; GFile *file; gtk_init (&argc, &argv); if (argc > 1) icon_name = argv[1]; if (argc > 2) anim_filename = argv[2]; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); label = gtk_label_new ("symbolic size"); gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1); label = gtk_label_new ("fixed size"); gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1); label = gtk_label_new ("GTK_IMAGE_PIXBUF"); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); theme = gtk_icon_theme_get_default (); pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48, 0, NULL); image = gtk_image_new_from_pixbuf (pixbuf); box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (box), image); gtk_grid_attach (GTK_GRID (grid), box, 2, 1, 1, 1); gtk_drag_source_set (box, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY); gtk_drag_source_add_image_targets (box); g_signal_connect (box, "drag_begin", G_CALLBACK (drag_begin), image); g_signal_connect (box, "drag_data_get", G_CALLBACK (drag_data_get), image); gtk_drag_dest_set (box, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, NULL, 0, GDK_ACTION_COPY); gtk_drag_dest_add_image_targets (box); g_signal_connect (box, "drag_data_received", G_CALLBACK (drag_data_received), image); label = gtk_label_new ("GTK_IMAGE_STOCK"); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; image = gtk_image_new_from_stock (GTK_STOCK_REDO, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1); label = gtk_label_new ("GTK_IMAGE_ICON_SET"); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); iconsource = gtk_icon_source_new (); gtk_icon_source_set_icon_name (iconsource, icon_name); iconset = gtk_icon_set_new (); gtk_icon_set_add_source (iconset, iconsource); image = gtk_image_new_from_icon_set (iconset, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 3, 1, 1); G_GNUC_END_IGNORE_DEPRECATIONS; label = gtk_label_new ("GTK_IMAGE_ICON_NAME"); gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 4, 1, 1); label = gtk_label_new ("GTK_IMAGE_GICON"); gtk_grid_attach (GTK_GRID (grid), label, 0, 5, 1, 1); icon = g_themed_icon_new_with_default_fallbacks ("folder-remote"); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); g_object_unref (icon); gtk_grid_attach (GTK_GRID (grid), image, 1, 5, 1, 1); file = g_file_new_for_path ("apple-red.png"); icon = g_file_icon_new (file); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); g_object_unref (icon); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 5, 1, 1); if (anim_filename) { label = gtk_label_new ("GTK_IMAGE_ANIMATION (from file)"); gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1); image = gtk_image_new_from_file (anim_filename); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 6, 1, 1); /* produce high load */ g_signal_connect_after (image, "draw", G_CALLBACK (anim_image_draw), NULL); } gtk_widget_show_all (window); gtk_main (); return 0; }
/** * \internal */ static GtkWidget * gebr_gui_program_edit_load(GebrGuiProgramEdit *program_edit, GebrGeoXmlParameters * parameters) { GtkWidget *frame; GtkWidget *vbox; GebrGeoXmlSequence *parameter; GebrGeoXmlParameterGroup *parameter_group; GSList *radio_group; frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(frame); parameter_group = gebr_geoxml_parameters_get_group(parameters); if (parameter_group != NULL) { GtkWidget *hbox; GtkWidget *button; GtkRcStyle *style; gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT); hbox = gtk_hbox_new(FALSE, 0); if (gebr_geoxml_parameter_group_get_is_instanciable(parameter_group)) { button = gtk_button_new(); style = gtk_rc_style_new(); style->xthickness = style->ythickness = 0; gtk_widget_modify_style(button, style); g_object_unref(style); g_object_set(button, "relief", GTK_RELIEF_NONE, NULL); g_object_set_data(G_OBJECT(button), "frame", frame); gtk_container_add(GTK_CONTAINER(button), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU)); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0); g_signal_connect(button, "clicked", G_CALLBACK(on_delete_clicked), parameter_group); g_object_set_data(G_OBJECT(frame), "delete", button); } if (program_edit->mpi_params) { button = gtk_button_new(); style = gtk_rc_style_new(); style->xthickness = style->ythickness = 0; gtk_widget_modify_style(button, style); g_object_unref(style); g_object_set(button, "relief", GTK_RELIEF_NONE, NULL); gtk_container_add(GTK_CONTAINER(button), gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_MENU)); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0); g_signal_connect(button, "clicked", G_CALLBACK(on_mpi_parameters_help_clicked), NULL); } button = gtk_button_new(); style = gtk_rc_style_new(); style->xthickness = style->ythickness = 0; gtk_widget_modify_style(button, style); g_object_unref(style); g_object_set(button, "relief", GTK_RELIEF_NONE, NULL); g_object_set_data(G_OBJECT(button), "frame", frame); g_object_set_data(G_OBJECT(frame), "arrow-down", button); g_signal_connect(button, "clicked", G_CALLBACK(on_arrow_down_clicked), parameter_group); gtk_container_add(GTK_CONTAINER(button), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE)); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0); button = gtk_button_new(); style = gtk_rc_style_new(); style->xthickness = style->ythickness = 0; gtk_widget_modify_style(button, style); g_object_unref(style); g_object_set(button, "relief", GTK_RELIEF_NONE, NULL); g_object_set_data(G_OBJECT(button), "frame", frame); g_object_set_data(G_OBJECT(frame), "arrow-up", button); g_signal_connect(button, "clicked", G_CALLBACK(on_arrow_up_clicked), parameter_group); gtk_container_add(GTK_CONTAINER(button), gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE)); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); } gtk_widget_show_all(vbox); gtk_container_add(GTK_CONTAINER(frame), vbox); GList *groups = NULL; radio_group = NULL; parameter = gebr_geoxml_parameters_get_first_parameter(parameters); for (gboolean first_parameter = TRUE; parameter != NULL; gebr_geoxml_sequence_next(¶meter)) { GtkWidget * widget; widget = gebr_gui_program_edit_load_parameter(program_edit, GEBR_GEOXML_PARAMETER(parameter), &radio_group); if (first_parameter) { /* used in on_group_expander_mnemonic_activate */ g_object_set_data(G_OBJECT(frame), "first-parameter", parameter); g_object_set_data(G_OBJECT(frame), "first-parameter-widget", widget); first_parameter = FALSE; } if (gebr_geoxml_parameter_get_group(GEBR_GEOXML_PARAMETER(parameter))) { gebr_geoxml_object_ref(parameter); groups = g_list_prepend(groups, GEBR_GEOXML_PARAMETER(parameter)); } gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); } for (GList *i = groups; i; i = i->next) gebr_gui_group_validate(program_edit->validator, i->data, program_edit->group_warning_widget); g_list_foreach(groups, (GFunc)gebr_geoxml_object_unref, NULL); g_list_free(groups); return frame; }
static void show_auth_dialog(LuakitAuthData *auth_data, const char *login, const char *password) { GtkWidget *widget = gtk_dialog_new(); GtkWindow *window = GTK_WINDOW(widget); GtkDialog *dialog = GTK_DIALOG(widget); gtk_dialog_add_buttons(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* set dialog properties */ 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); gtk_container_set_border_width(GTK_CONTAINER(dialog->action_area), 5); gtk_box_set_spacing(GTK_BOX(dialog->action_area), 6); gtk_window_set_resizable(window, FALSE); gtk_window_set_title(window, ""); gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); /* build contents */ GtkWidget *hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_box_pack_start(GTK_BOX(dialog->vbox), hbox, TRUE, TRUE, 0); GtkWidget *icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0); GtkWidget *main_vbox = gtk_vbox_new(FALSE, 18); gtk_box_pack_start(GTK_BOX(hbox), main_vbox, TRUE, TRUE, 0); SoupURI *uri = soup_message_get_uri(auth_data->msg); gchar *msg = g_strdup_printf("A username and password are being requested by the site %s", uri->host); GtkWidget *msg_label = gtk_label_new(msg); g_free(msg); gtk_misc_set_alignment(GTK_MISC(msg_label), 0.0, 0.5); gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE); gtk_box_pack_start(GTK_BOX(main_vbox), GTK_WIDGET(msg_label), FALSE, FALSE, 0); GtkWidget *vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(main_vbox), vbox, FALSE, FALSE, 0); /* the table that holds the entries */ GtkWidget *entry_container = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(entry_container), 0, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), entry_container, FALSE, FALSE, 0); GtkWidget *table = gtk_table_new(2, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_table_set_row_spacings(GTK_TABLE(table), 6); gtk_container_add(GTK_CONTAINER(entry_container), table); auth_data->login_entry = table_add_entry(table, 0, "Username:"******"Password:"******"Store password"); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkbutton))), TRUE); gtk_box_pack_start(GTK_BOX(remember_box), checkbutton, FALSE, FALSE, 0); auth_data->checkbutton = checkbutton; g_signal_connect(dialog, "response", G_CALLBACK(response_callback), auth_data); gtk_widget_show_all(widget); }
static void main_window_error_display (EmpathyMainWindow *window, TpAccount *account, const gchar *message) { GtkWidget *info_bar; GtkWidget *content_area; GtkWidget *label; GtkWidget *image; GtkWidget *retry_button; GtkWidget *edit_button; GtkWidget *close_button; GtkWidget *action_area; GtkWidget *action_table; gchar *str; const gchar *icon_name; str = g_markup_printf_escaped ("<b>%s</b>\n%s", tp_account_get_display_name (account), message); info_bar = g_hash_table_lookup (window->errors, account); if (info_bar) { label = g_object_get_data (G_OBJECT (info_bar), "label"); /* Just set the latest error and return */ gtk_label_set_markup (GTK_LABEL (label), str); g_free (str); return; } info_bar = gtk_info_bar_new (); gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_ERROR); gtk_widget_set_no_show_all (info_bar, TRUE); gtk_box_pack_start (GTK_BOX (window->errors_vbox), info_bar, FALSE, TRUE, 0); gtk_widget_show (info_bar); icon_name = tp_account_get_icon_name (account); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_show (image); label = gtk_label_new (str); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_widget_show (label); g_free (str); content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar)); gtk_box_pack_start (GTK_BOX (content_area), image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0); image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_BUTTON); retry_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (retry_button), image); gtk_widget_set_tooltip_text (retry_button, _("Reconnect")); gtk_widget_show (retry_button); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON); edit_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (edit_button), image); gtk_widget_set_tooltip_text (edit_button, _("Edit Account")); gtk_widget_show (edit_button); image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON); close_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (close_button), image); gtk_widget_set_tooltip_text (close_button, _("Close")); gtk_widget_show (close_button); action_table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (action_table), 2); gtk_widget_show (action_table); action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (info_bar)); gtk_box_pack_start (GTK_BOX (action_area), action_table, FALSE, FALSE, 0); gtk_table_attach (GTK_TABLE (action_table), retry_button, 0, 1, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); gtk_table_attach (GTK_TABLE (action_table), edit_button, 1, 2, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); gtk_table_attach (GTK_TABLE (action_table), close_button, 2, 3, 0, 1, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (GTK_SHRINK), 0, 0); g_object_set_data (G_OBJECT (info_bar), "label", label); g_object_set_data_full (G_OBJECT (info_bar), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (edit_button), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (close_button), "account", g_object_ref (account), g_object_unref); g_object_set_data_full (G_OBJECT (retry_button), "account", g_object_ref (account), g_object_unref); g_signal_connect (edit_button, "clicked", G_CALLBACK (main_window_error_edit_clicked_cb), window); g_signal_connect (close_button, "clicked", G_CALLBACK (main_window_error_close_clicked_cb), window); g_signal_connect (retry_button, "clicked", G_CALLBACK (main_window_error_retry_clicked_cb), window); gtk_widget_show (window->errors_vbox); g_hash_table_insert (window->errors, g_object_ref (account), info_bar); }
gboolean trust_prompt_show (EUserPrompterServerExtension *extension, gint prompt_id, const gchar *host, const gchar *markup, const CERTCertificate *pcert, const gchar *cert_fingerprint, const gchar *reason, const GSList *pissuers) { GtkWidget *dialog, *widget; GtkGrid *grid; gchar *tmp, *issuer, *subject, *head; GSList *issuers, *iter; CERTCertificate *cert; gint row = 0; cert = CERT_DupCertificate ((CERTCertificate *) pcert); issuers = g_slist_copy ((GSList *) pissuers); for (iter = issuers; iter; iter = g_slist_next (iter)) { if (iter->data) iter->data = CERT_DupCertificate (iter->data); } dialog = gtk_dialog_new_with_buttons ( _("Certificate trust..."), NULL, 0, _("_View Certificate"), GTK_RESPONSE_HELP, _("_Reject"), GTK_RESPONSE_REJECT, _("Accept _Temporarily"), GTK_RESPONSE_YES, _("_Accept Permanently"), GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_icon_name (GTK_WINDOW (dialog), "evolution"); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); grid = g_object_new ( GTK_TYPE_GRID, "orientation", GTK_ORIENTATION_HORIZONTAL, "row-homogeneous", FALSE, "row-spacing", 2, "column-homogeneous", FALSE, "column-spacing", 6, "hexpand", TRUE, "halign", GTK_ALIGN_FILL, "vexpand", TRUE, "valign", GTK_ALIGN_FILL, "border-width", 12, NULL); widget = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (grid)); widget = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); g_object_set ( G_OBJECT (widget), "vexpand", FALSE, "valign", GTK_ALIGN_START, "xpad", 6, NULL); gtk_grid_attach (grid, widget, 0, row, 1, 3); tmp = NULL; if (!markup || !*markup) { gchar *bhost; bhost = g_strconcat ("<b>", host, "</b>", NULL); tmp = g_strdup_printf (_("SSL certificate for '%s' is not trusted. Do you wish to accept it?"), bhost); g_free (bhost); markup = tmp; } head = g_strdup_printf ("%s\n\n%s", markup, _("Detailed information about the certificate:")); widget = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (widget), head); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0); g_free (head); g_free (tmp); gtk_grid_attach (grid, widget, 1, row, 2, 1); row++; issuer = CERT_NameToAscii (&cert->issuer); subject = CERT_NameToAscii (&cert->subject); trust_prompt_add_info_line (grid, _("Issuer:"), issuer, TRUE, &row); trust_prompt_add_info_line (grid, _("Subject:"), subject, TRUE, &row); trust_prompt_add_info_line (grid, _("Fingerprint:"), cert_fingerprint, TRUE, &row); trust_prompt_add_info_line (grid, _("Reason:"), reason, FALSE, &row); PORT_Free (issuer); PORT_Free (subject); g_object_set_data (G_OBJECT (dialog), TRUST_PROMP_ID_KEY, GINT_TO_POINTER (prompt_id)); g_object_set_data_full (G_OBJECT (dialog), TRUST_PROMP_CERT_KEY, cert, trust_prompt_free_certificate); g_object_set_data_full (G_OBJECT (dialog), TRUST_PROMP_ISSUERS_KEY, issuers, trust_prompt_free_issuers); g_signal_connect (dialog, "response", G_CALLBACK (trust_prompt_response_cb), extension); gtk_widget_show_all (GTK_WIDGET (grid)); gtk_widget_show (dialog); return TRUE; }
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; }
GtkWidget *gui_navbar_book_new(void) { GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *arrow1; GtkWidget *image2; UI_VBOX(vbox1, FALSE, 0); gtk_widget_show(vbox1); UI_HBOX(hbox1, FALSE, 0); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0); navbar_book.lookup_entry = gtk_entry_new(); gtk_widget_show(navbar_book.lookup_entry); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.lookup_entry, TRUE, TRUE, 0); gtk_editable_set_editable(GTK_EDITABLE(navbar_book.lookup_entry), TRUE); gtk_entry_set_invisible_char(GTK_ENTRY(navbar_book.lookup_entry), 9679); navbar_book.button_list = gtk_toggle_button_new(); gtk_widget_show(navbar_book.button_list); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.button_list, FALSE, FALSE, 0); #ifdef HAVE_GTK_314 arrow1 = gtk_image_new_from_icon_name("open-menu-symbolic", GTK_ICON_SIZE_BUTTON); #else arrow1 = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT); #endif gtk_widget_show(arrow1); gtk_container_add(GTK_CONTAINER(navbar_book.button_list), arrow1); navbar_book.button_left = gtk_button_new(); gtk_widget_show(navbar_book.button_left); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.button_left, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(navbar_book.button_left, _("Go outward, to the section containing this one")); gtk_button_set_relief(GTK_BUTTON(navbar_book.button_left), GTK_RELIEF_NONE); #ifdef HAVE_GTK_320 gtk_widget_set_focus_on_click(GTK_WIDGET(navbar_book.button_left), FALSE); #else gtk_button_set_focus_on_click(GTK_BUTTON(navbar_book.button_left), FALSE); #endif image1 = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image1); gtk_container_add(GTK_CONTAINER(navbar_book.button_left), image1); navbar_book.button_up = gtk_button_new(); gtk_widget_show(navbar_book.button_up); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.button_up, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(navbar_book.button_up, _("Go to previous item")); gtk_button_set_relief(GTK_BUTTON(navbar_book.button_up), GTK_RELIEF_NONE); #ifdef HAVE_GTK_320 gtk_widget_set_focus_on_click(GTK_WIDGET(navbar_book.button_up), FALSE); #else gtk_button_set_focus_on_click(GTK_BUTTON(navbar_book.button_up), FALSE); #endif image1 = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("go-up-symbolic", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image1); gtk_container_add(GTK_CONTAINER(navbar_book.button_up), image1); navbar_book.button_down = gtk_button_new(); gtk_widget_show(navbar_book.button_down); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.button_down, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(navbar_book.button_down, _("Go to next item")); gtk_button_set_relief(GTK_BUTTON(navbar_book.button_down), GTK_RELIEF_NONE); #ifdef HAVE_GTK_320 gtk_widget_set_focus_on_click(GTK_WIDGET(navbar_book.button_down), FALSE); #else gtk_button_set_focus_on_click(GTK_BUTTON(navbar_book.button_down), FALSE); #endif image2 = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("go-down-symbolic", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image2); gtk_container_add(GTK_CONTAINER(navbar_book.button_down), image2); navbar_book.button_right = gtk_button_new(); gtk_widget_show(navbar_book.button_right); gtk_box_pack_start(GTK_BOX(hbox1), navbar_book.button_right, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(navbar_book.button_right, _("Go inward, to the first subsection")); gtk_button_set_relief(GTK_BUTTON(navbar_book.button_right), GTK_RELIEF_NONE); #ifdef HAVE_GTK_320 gtk_widget_set_focus_on_click(GTK_WIDGET(navbar_book.button_right), FALSE); #else gtk_button_set_focus_on_click(GTK_BUTTON(navbar_book.button_right), FALSE); #endif image1 = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("go-next-symbolic", GTK_ICON_SIZE_BUTTON); #else gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON); #endif gtk_widget_show(image1); gtk_container_add(GTK_CONTAINER(navbar_book.button_right), image1); g_signal_connect((gpointer)navbar_book.lookup_entry, "activate", G_CALLBACK(on_entry_activate), NULL); g_signal_connect((gpointer)navbar_book.button_up, "clicked", G_CALLBACK(on_button_prev_clicked), NULL); g_signal_connect((gpointer)navbar_book.button_down, "clicked", G_CALLBACK(on_button_next_clicked), NULL); g_signal_connect((gpointer)navbar_book.button_left, "clicked", G_CALLBACK(on_button_parent_clicked), NULL); g_signal_connect((gpointer)navbar_book.button_right, "clicked", G_CALLBACK(on_button_child_clicked), NULL); g_signal_connect((gpointer)navbar_book.button_list, "button_press_event", G_CALLBACK(select_button_press_callback), NULL); g_signal_connect((gpointer)navbar_book.lookup_entry, "key_press_event", G_CALLBACK(lookup_entry_press_callback), NULL); return vbox1; }
void themes_init(AppearanceData* data) { GtkWidget *w, *del_button; GList *theme_list, *l; GtkListStore *theme_store; GtkTreeModel *sort_model; MateThemeMetaInfo *meta_theme = NULL; GtkIconView *icon_view; GtkCellRenderer *renderer; GtkSettings *settings; char *url; /* initialise some stuff */ mate_theme_init (); mate_wm_manager_init (); data->revert_application_font = NULL; data->revert_documents_font = NULL; data->revert_desktop_font = NULL; data->revert_windowtitle_font = NULL; data->revert_monospace_font = NULL; data->theme_save_dialog = NULL; data->theme_message_area = NULL; data->theme_info_icon = NULL; data->theme_error_icon = NULL; data->theme_custom = mate_theme_meta_info_new (); data->theme_icon = gdk_pixbuf_new_from_file (MATECC_PIXMAP_DIR "/theme-thumbnailing.png", NULL); data->theme_store = theme_store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); /* set up theme list */ theme_list = mate_theme_meta_info_find_all (); mate_theme_info_register_theme_change ((ThemeChangedCallback) theme_changed_on_disk_cb, data); data->theme_custom = theme_load_from_gsettings (data); data->theme_custom->name = g_strdup (CUSTOM_THEME_NAME); data->theme_custom->readable_name = g_strdup_printf ("<i>%s</i>", _("Custom")); for (l = theme_list; l; l = l->next) { MateThemeMetaInfo *info = l->data; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, info->readable_name, COL_NAME, info->name, COL_THUMBNAIL, data->theme_icon, -1); if (!meta_theme && theme_is_equal (data->theme_custom, info)) meta_theme = info; } if (!meta_theme) { /* add custom theme */ meta_theme = data->theme_custom; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, meta_theme->readable_name, COL_NAME, meta_theme->name, COL_THUMBNAIL, data->theme_icon, -1); theme_thumbnail_generate (meta_theme, data); } theme_list = g_list_sort (theme_list, (GCompareFunc) theme_list_sort_func); g_list_foreach (theme_list, (GFunc) theme_thumbnail_generate, data); g_list_free (theme_list); icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 5, "ypad", 5, "xalign", 0.5, "yalign", 1.0, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "pixbuf", COL_THUMBNAIL, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "alignment", PANGO_ALIGN_CENTER, "wrap-mode", PANGO_WRAP_WORD_CHAR, "wrap-width", gtk_icon_view_get_item_width (icon_view), "width", gtk_icon_view_get_item_width (icon_view), "xalign", 0.5, "yalign", 0.0, NULL); gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "markup", COL_LABEL, NULL); sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (theme_store)); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, theme_store_sort_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING); gtk_icon_view_set_model (icon_view, GTK_TREE_MODEL (sort_model)); g_signal_connect (icon_view, "selection-changed", (GCallback) theme_selection_changed_cb, data); g_signal_connect_after (icon_view, "realize", (GCallback) theme_select_name, meta_theme->name); w = appearance_capplet_get_widget (data, "theme_install"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_install_cb, data); w = appearance_capplet_get_widget (data, "theme_save"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_icon_name ("document-save-as", GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_save_cb, data); w = appearance_capplet_get_widget (data, "theme_custom"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_custom_cb, data); del_button = appearance_capplet_get_widget (data, "theme_delete"); g_signal_connect (del_button, "clicked", (GCallback) theme_delete_cb, data); w = appearance_capplet_get_widget (data, "theme_vbox"); gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE); g_signal_connect (w, "drag-data-received", (GCallback) theme_drag_data_received_cb, data); if (is_locked_down ()) gtk_widget_set_sensitive (w, FALSE); w = appearance_capplet_get_widget (data, "more_themes_linkbutton"); url = g_settings_get_string (data->settings, MORE_THEMES_URL_KEY); if (url != NULL && url[0] != '\0') { gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url); gtk_widget_show (w); } else { gtk_widget_hide (w); } g_free (url); /* listen to gsettings changes, too */ g_signal_connect (data->marco_settings, "changed::" MARCO_THEME_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->mouse_settings, "changed::" CURSOR_THEME_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->mouse_settings, "changed::" CURSOR_SIZE_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_FILE_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" GTK_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" DOCUMENT_FONT_KEY, G_CALLBACK (background_or_font_changed), data); if (data->caja_settings) g_signal_connect (data->caja_settings, "changed::" DESKTOP_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->marco_settings, "changed::" WINDOW_TITLE_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" MONOSPACE_FONT_KEY, G_CALLBACK (background_or_font_changed), data); settings = gtk_settings_get_default (); g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-theme-name", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-icon-theme-name", (GCallback) theme_setting_changed_cb, data); /* monitor individual font choice buttons, so "revert font" option (if any) can be cleared */ w = appearance_capplet_get_widget (data, "application_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "document_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "desktop_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "window_title_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "monospace_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); }
static void create_window (void) { jump_to_track_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(jump_to_track_win), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title(GTK_WINDOW(jump_to_track_win), _("Jump to Song")); g_signal_connect (jump_to_track_win, "key_press_event", (GCallback) keypress_cb, NULL); g_signal_connect (jump_to_track_win, "delete-event", (GCallback) delete_cb, NULL); gtk_container_set_border_width(GTK_CONTAINER(jump_to_track_win), 10); gtk_window_set_default_size(GTK_WINDOW(jump_to_track_win), 600, 500); GtkWidget * vbox = gtk_vbox_new (FALSE, 5); gtk_container_add(GTK_CONTAINER(jump_to_track_win), vbox); treeview = mlpgui_list_new (& callbacks, NULL, 0); gtk_tree_view_set_headers_visible ((GtkTreeView *) treeview, FALSE); mlpgui_list_add_column (treeview, NULL, 0, G_TYPE_INT, 7); mlpgui_list_add_column (treeview, NULL, 1, G_TYPE_STRING, -1); g_signal_connect (gtk_tree_view_get_selection ((GtkTreeView *) treeview), "changed", (GCallback) selection_changed, NULL); g_signal_connect (treeview, "row-activated", (GCallback) do_jump, NULL); GtkWidget * hbox = gtk_hbox_new (FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); /* filter box */ GtkWidget * search_label = gtk_label_new (_("Filter: ")); gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), _("_Filter:")); gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0); filter_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget ((GtkLabel *) search_label, filter_entry); g_signal_connect (filter_entry, "changed", (GCallback) fill_list, NULL); gtk_entry_set_activates_default ((GtkEntry *) filter_entry, TRUE); gtk_box_pack_start ((GtkBox *) hbox, filter_entry, TRUE, TRUE, 3); /* remember text entry */ GtkWidget * toggle2 = gtk_check_button_new_with_label (_("Remember")); gtk_toggle_button_set_active ((GtkToggleButton *) toggle2, mlp_get_bool ("mlpgui", "remember_jtf_entry")); gtk_box_pack_start(GTK_BOX(hbox), toggle2, FALSE, FALSE, 0); g_signal_connect (toggle2, "clicked", (GCallback) toggle_button_cb, "remember_jtf_entry"); /* clear button */ GtkWidget * rescan = gtk_button_new_with_mnemonic (_("Clea_r")); gtk_button_set_image ((GtkButton *) rescan, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(hbox), rescan, FALSE, FALSE, 0); g_signal_connect (rescan, "clicked", (GCallback) clear_cb, NULL); GtkWidget * scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add(GTK_CONTAINER(scrollwin), treeview); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); GtkWidget * bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 4); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); /* close dialog toggle */ GtkWidget * toggle = gtk_check_button_new_with_label(_("Close on Jump")); gtk_toggle_button_set_active ((GtkToggleButton *) toggle, mlp_get_bool ("mlpgui", "close_jtf_dialog")); gtk_box_pack_start(GTK_BOX(bbox), toggle, FALSE, FALSE, 0); g_signal_connect (toggle, "clicked", (GCallback) toggle_button_cb, "close_jtf_dialog"); /* queue button */ queue_button = gtk_button_new_with_mnemonic(_("_Queue")); gtk_button_set_image ((GtkButton *) queue_button, gtk_image_new_from_stock (AUD_STOCK_QUEUETOGGLE, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) bbox, queue_button, FALSE, FALSE, 0); g_signal_connect (queue_button, "clicked", (GCallback) do_queue, NULL); /* jump button */ GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO); gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0); g_signal_connect (jump, "clicked", (GCallback) do_jump, NULL); gtk_widget_set_can_default(jump, TRUE); gtk_widget_grab_default(jump); /* close button */ GtkWidget * close = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(bbox), close, FALSE, FALSE, 0); g_signal_connect (close, "clicked", (GCallback) mlpgui_jump_to_track_hide, NULL); gtk_widget_set_can_default(close, TRUE); }
static void aggregate_layer_add_menu_items ( VikAggregateLayer *val, GtkMenu *menu, gpointer vlp ) { // Data to pass on in menu functions static menu_array_values values; values[MA_VAL] = val; values[MA_VLP] = vlp; GtkWidget *item = gtk_menu_item_new(); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); GtkWidget *vis_submenu = gtk_menu_new (); item = gtk_menu_item_new_with_mnemonic ( _("_Visibility") ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show ( item ); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), vis_submenu ); item = gtk_image_menu_item_new_with_mnemonic ( _("_Show All") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_on), values ); gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("_Hide All") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_off), values ); gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("_Toggle") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_toggle), values ); gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item); gtk_widget_show ( item ); GtkWidget *submenu_sort = gtk_menu_new (); item = gtk_image_menu_item_new_with_mnemonic ( _("_Sort") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show ( item ); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu_sort ); item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Ascending") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_ASCENDING, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_a2z), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item ); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Descending") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_DESCENDING, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_z2a), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item ); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("Date Ascending") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_ASCENDING, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_timestamp_ascend), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item ); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("Date Descending") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_DESCENDING, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_timestamp_descend), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item ); gtk_widget_show ( item ); item = gtk_menu_item_new_with_mnemonic ( _("_Statistics") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_analyse), values ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("Track _List...") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_track_list_dialog), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); item = gtk_image_menu_item_new_with_mnemonic ( _("_Waypoint List...") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_waypoint_list_dialog), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item ); gtk_widget_show ( item ); GtkWidget *search_submenu = gtk_menu_new (); item = gtk_image_menu_item_new_with_mnemonic ( _("Searc_h") ); gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show ( item ); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), search_submenu ); item = gtk_menu_item_new_with_mnemonic ( _("By _Date...") ); g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_search_date), values ); gtk_menu_shell_append ( GTK_MENU_SHELL(search_submenu), item ); gtk_widget_set_tooltip_text (item, _("Find the first item with a specified date")); gtk_widget_show ( item ); }
static gboolean cm_dialog (CmParamsType *mix, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *hbox; GtkWidget *button; GtkWidget *label; GtkWidget *image; GtkWidget *table; gdouble red_value, green_value, blue_value; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); /* get values */ if (mix->monochrome) { red_value = mix->black.red_gain * 100; green_value = mix->black.green_gain * 100; blue_value = mix->black.blue_gain * 100; } else { switch (mix->output_channel) { case CM_RED_CHANNEL: red_value = mix->red.red_gain * 100; green_value = mix->red.green_gain * 100; blue_value = mix->red.blue_gain * 100; break; case CM_GREEN_CHANNEL: red_value = mix->green.red_gain * 100; green_value = mix->green.green_gain * 100; blue_value = mix->green.blue_gain * 100; break; case CM_BLUE_CHANNEL: red_value = mix->blue.red_gain * 100; green_value = mix->blue.green_gain * 100; blue_value = mix->blue.blue_gain * 100; break; default: g_assert_not_reached (); red_value = green_value = blue_value = 0.0; break; } } dialog = gimp_dialog_new (_("Channel Mixer"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_zoom_preview_new (drawable); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (cm_preview), mix); frame = gimp_frame_new (NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 6); gtk_frame_set_label_widget (GTK_FRAME (frame), hbox); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("O_utput channel:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); mix->combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo), GIMP_INT_STORE_VALUE, CM_RED_CHANNEL, GIMP_INT_STORE_LABEL, _("Red"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_RED, -1); gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo), GIMP_INT_STORE_VALUE, CM_GREEN_CHANNEL, GIMP_INT_STORE_LABEL, _("Green"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_GREEN, -1); gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo), GIMP_INT_STORE_VALUE, CM_BLUE_CHANNEL, GIMP_INT_STORE_LABEL, _("Blue"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_BLUE, -1); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo), mix->output_channel); g_signal_connect (mix->combo, "changed", G_CALLBACK (cm_combo_callback), mix); gtk_box_pack_start (GTK_BOX (hbox), mix->combo, TRUE, TRUE, 0); gtk_widget_show (mix->combo); if (mix->monochrome) gtk_widget_set_sensitive (mix->combo, FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), mix->combo); /*........................................................... */ table = gtk_table_new (3, 4, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED, GTK_ICON_SIZE_BUTTON); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); mix->red_data = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 0, _("_Red:"), 150, -1, red_value, -200.0, 200.0, 1.0, 10.0, 1, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (mix->red_data, "value-changed", G_CALLBACK (cm_red_scale_callback), mix); image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN, GTK_ICON_SIZE_BUTTON); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); mix->green_data = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 1, _("_Green:"), 150, -1, green_value, -200.0, 200.0, 1.0, 10.0, 1, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (mix->green_data, "value-changed", G_CALLBACK (cm_green_scale_callback), mix); image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE, GTK_ICON_SIZE_BUTTON); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); mix->blue_data = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 2, _("_Blue:"), 150, -1, blue_value, -200.0, 200.0, 1.0, 10.0, 1, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (mix->blue_data, "value-changed", G_CALLBACK (cm_blue_scale_callback), mix); vbox = gtk_vbox_new (6, FALSE); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /* The monochrome toggle */ mix->monochrome_toggle = gtk_check_button_new_with_mnemonic (_("_Monochrome")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle), mix->monochrome); gtk_box_pack_start (GTK_BOX (vbox), mix->monochrome_toggle, FALSE, FALSE, 0); gtk_widget_show (mix->monochrome_toggle); g_signal_connect (mix->monochrome_toggle, "toggled", G_CALLBACK (cm_monochrome_callback), mix); /* The preserve luminosity toggle */ mix->preserve_luminosity_toggle = gtk_check_button_new_with_mnemonic (_("Preserve _luminosity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->preserve_luminosity_toggle), mix->preserve_luminosity); gtk_box_pack_start (GTK_BOX (vbox), mix->preserve_luminosity_toggle, FALSE, FALSE, 0); gtk_widget_show (mix->preserve_luminosity_toggle); g_signal_connect (mix->preserve_luminosity_toggle, "toggled", G_CALLBACK (cm_preserve_luminosity_callback), mix); /*........................................................... */ /* Horizontal box for file i/o */ hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_end (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_from_stock (GTK_STOCK_OPEN); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (cm_load_file_callback), mix); button = gtk_button_new_from_stock (GTK_STOCK_SAVE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (cm_save_file_callback), mix); button = gtk_button_new_from_stock (GIMP_STOCK_RESET); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (cm_reset_callback), mix); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
SelectBooksDialog::SelectBooksDialog(bool showportions, GtkWindow *parent) /* This dialog selects books. This function takes the book from the project that is now open, and the language of that project. It then loads the books. bookset: Indicator for the caller's relevant books. */ { // Initialize variables. extern Settings *settings; myproject = settings->genconfig.project_get(); ProjectConfiguration *projectconfig = settings->projectconfig(myproject); mylanguage = projectconfig->language_get(); myselectables = project_get_books(myproject); myshowportions = showportions; // Build dialog. Shortcuts shortcuts(0); selectbooksdialog = gtk_dialog_new(); ustring title(_("Select books")); if (showportions) { title.append(_(" and portions")); } gtk_window_set_title(GTK_WINDOW(selectbooksdialog), title.c_str()); gtk_window_set_transient_for(GTK_WINDOW(selectbooksdialog), parent); gtk_window_set_position(GTK_WINDOW(selectbooksdialog), GTK_WIN_POS_CENTER_ALWAYS); // was GTK_WIN_POS_CENTER_ON_PARENT gtk_window_set_modal(GTK_WINDOW(selectbooksdialog), TRUE); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(selectbooksdialog)); gtk_widget_show(dialog_vbox1); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox11 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox11); gtk_box_pack_start(GTK_BOX(vbox1), hbox11, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox2); gtk_box_pack_start(GTK_BOX(hbox11), vbox2, TRUE, TRUE, 0); labelbooks = gtk_label_new(_("Books")); gtk_widget_show(labelbooks); gtk_box_pack_start(GTK_BOX(vbox2), labelbooks, FALSE, FALSE, 0); shortcuts.label(labelbooks); scrolledwindowbooks = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindowbooks); gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindowbooks, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowbooks), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowbooks), GTK_SHADOW_IN); treeviewbooks = gtk_tree_view_new(); gtk_widget_show(treeviewbooks); gtk_container_add(GTK_CONTAINER(scrolledwindowbooks), treeviewbooks); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewbooks), FALSE); vbox3 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox3); gtk_box_pack_start(GTK_BOX(hbox11), vbox3, TRUE, TRUE, 0); if (myshowportions) { labelportions = gtk_label_new(_("Portions")); gtk_widget_show(labelportions); gtk_box_pack_start(GTK_BOX(vbox3), labelportions, FALSE, FALSE, 0); shortcuts.label(labelportions); scrolledwindowportions = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindowportions); gtk_box_pack_start(GTK_BOX(vbox3), scrolledwindowportions, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowportions), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowportions), GTK_SHADOW_IN); treeviewportions = gtk_tree_view_new(); gtk_widget_show(treeviewportions); gtk_container_add(GTK_CONTAINER(scrolledwindowportions), treeviewportions); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewportions), FALSE); } table1 = gtk_table_new(2, 3, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, FALSE, 0); nobutton = gtk_button_new(); gtk_widget_show(nobutton); gtk_table_attach(GTK_TABLE(table1), nobutton, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment1); gtk_container_add(GTK_CONTAINER(nobutton), alignment1); hbox4 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox4); gtk_container_add(GTK_CONTAINER(alignment1), hbox4); image1 = gtk_image_new_from_stock("gtk-clear", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image1); gtk_box_pack_start(GTK_BOX(hbox4), image1, FALSE, FALSE, 0); label6 = gtk_label_new_with_mnemonic(_("No books")); gtk_widget_show(label6); gtk_box_pack_start(GTK_BOX(hbox4), label6, FALSE, FALSE, 0); shortcuts.label(label6); otbutton = gtk_button_new(); gtk_widget_show(otbutton); gtk_table_attach(GTK_TABLE(table1), otbutton, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment2); gtk_container_add(GTK_CONTAINER(otbutton), alignment2); hbox5 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox5); gtk_container_add(GTK_CONTAINER(alignment2), hbox5); image2 = gtk_image_new_from_stock("gtk-goto-first", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image2); gtk_box_pack_start(GTK_BOX(hbox5), image2, FALSE, FALSE, 0); label7 = gtk_label_new_with_mnemonic(_("Old Testament")); gtk_widget_show(label7); gtk_box_pack_start(GTK_BOX(hbox5), label7, FALSE, FALSE, 0); shortcuts.label(label7); ntbutton = gtk_button_new(); gtk_widget_show(ntbutton); gtk_table_attach(GTK_TABLE(table1), ntbutton, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment3 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment3); gtk_container_add(GTK_CONTAINER(ntbutton), alignment3); hbox6 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox6); gtk_container_add(GTK_CONTAINER(alignment3), hbox6); image3 = gtk_image_new_from_stock("gtk-goto-last", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image3); gtk_box_pack_start(GTK_BOX(hbox6), image3, FALSE, FALSE, 0); label8 = gtk_label_new_with_mnemonic(_("New Testament")); gtk_widget_show(label8); gtk_box_pack_start(GTK_BOX(hbox6), label8, FALSE, FALSE, 0); shortcuts.label(label8); otherbutton = gtk_button_new(); gtk_widget_show(otherbutton); gtk_table_attach(GTK_TABLE(table1), otherbutton, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment6 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment6); gtk_container_add(GTK_CONTAINER(otherbutton), alignment6); hbox9 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox9); gtk_container_add(GTK_CONTAINER(alignment6), hbox9); image6 = gtk_image_new_from_stock("gtk-dialog-warning", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image6); gtk_box_pack_start(GTK_BOX(hbox9), image6, FALSE, FALSE, 0); label11 = gtk_label_new_with_mnemonic(_("Other books")); gtk_widget_show(label11); gtk_box_pack_start(GTK_BOX(hbox9), label11, FALSE, FALSE, 0); shortcuts.label(label11); allbutton = gtk_button_new(); gtk_widget_show(allbutton); gtk_table_attach(GTK_TABLE(table1), allbutton, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment4 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment4); gtk_container_add(GTK_CONTAINER(allbutton), alignment4); hbox7 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox7); gtk_container_add(GTK_CONTAINER(alignment4), hbox7); image4 = gtk_image_new_from_stock("gtk-add", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image4); gtk_box_pack_start(GTK_BOX(hbox7), image4, FALSE, FALSE, 0); label9 = gtk_label_new_with_mnemonic(_("All books")); gtk_widget_show(label9); gtk_box_pack_start(GTK_BOX(hbox7), label9, FALSE, FALSE, 0); shortcuts.label(label9); currentbutton = gtk_button_new(); gtk_widget_show(currentbutton); gtk_table_attach(GTK_TABLE(table1), currentbutton, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); alignment5 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment5); gtk_container_add(GTK_CONTAINER(currentbutton), alignment5); hbox8 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox8); gtk_container_add(GTK_CONTAINER(alignment5), hbox8); image5 = gtk_image_new_from_stock("gtk-properties", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image5); gtk_box_pack_start(GTK_BOX(hbox8), image5, FALSE, FALSE, 0); label10 = gtk_label_new_with_mnemonic(_("Current book")); gtk_widget_show(label10); gtk_box_pack_start(GTK_BOX(hbox8), label10, FALSE, FALSE, 0); shortcuts.label(label10); dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(selectbooksdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); const gchar *helpfile; if (showportions) { helpfile = "file/print/portion"; } else { helpfile = "file/print/selection"; } new InDialogHelp(selectbooksdialog, NULL, &shortcuts, helpfile); cancelbutton = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton); gtk_dialog_add_action_widget(GTK_DIALOG(selectbooksdialog), cancelbutton, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true); shortcuts.stockbutton(cancelbutton); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(selectbooksdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) treeviewbooks, "key_press_event", G_CALLBACK(on_treeviewbooks_key_press_event), gpointer(this)); if (myshowportions) { g_signal_connect((gpointer) treeviewportions, "row_activated", G_CALLBACK(on_treeviewportions_row_activated), gpointer(this)); } g_signal_connect((gpointer) nobutton, "clicked", G_CALLBACK(on_nobutton_clicked), gpointer(this)); g_signal_connect((gpointer) otbutton, "clicked", G_CALLBACK(on_otbutton_clicked), gpointer(this)); g_signal_connect((gpointer) ntbutton, "clicked", G_CALLBACK(on_ntbutton_clicked), gpointer(this)); g_signal_connect((gpointer) otherbutton, "clicked", G_CALLBACK(on_otherbutton_clicked), gpointer(this)); g_signal_connect((gpointer) allbutton, "clicked", G_CALLBACK(on_allbutton_clicked), gpointer(this)); g_signal_connect((gpointer) currentbutton, "clicked", G_CALLBACK(on_currentbutton_clicked), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(treeviewbooks); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(labelbooks), treeviewbooks); if (myshowportions) gtk_label_set_mnemonic_widget(GTK_LABEL(labelportions), treeviewportions); // Storage, renderer, column and selection for books. { storebooks = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewbooks), GTK_TREE_MODEL(storebooks)); g_object_unref(storebooks); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); columnbooks = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewbooks), columnbooks); selectbooks = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewbooks)); gtk_tree_selection_set_mode(selectbooks, GTK_SELECTION_MULTIPLE); } // Storage, renderer, column and selection for portions. if (myshowportions) { storeportions = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewportions), GTK_TREE_MODEL(storeportions)); g_object_unref(storeportions); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); columnportions = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewportions), columnportions); selectportions = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewportions)); gtk_tree_selection_set_mode(selectportions, GTK_SELECTION_SINGLE); } // Load content. myselectables = project_get_books(myproject); loadbooks(); if (myshowportions) loadportions(); // Update gui. update_gui_event_id = 0; if (myshowportions) { update_gui_event_id = g_timeout_add_full(G_PRIORITY_DEFAULT, 100, GSourceFunc(on_update_gui_timeout), gpointer(this), NULL); } new DialogAutoScaler (selectbooksdialog, G_MAXINT); }
XttTblGtk::XttTblGtk(GtkWidget* a_parent_wid, void* a_parent_ctx, sevcli_tCtx a_sevcli, sevcli_sHistItem* itemlist, int item_cnt) : XttTbl(a_parent_ctx, a_sevcli), parent_wid(a_parent_wid) { int sts; pwr_tFileName fname; toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700, "default-width", 500, "title", "SevXtt Navigator", NULL); g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this); g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(xtttbl_focus_in_event), this); CoWowGtk::SetWindowIcon(toplevel); GtkWidget* vbox = gtk_vbox_new(FALSE, 0); // Menu // Accelerators GtkAccelGroup* accel_g = (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL); // File entry GtkWidget* file_print = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(file_print), gtk_image_new_from_stock("gtk-print", GTK_ICON_SIZE_MENU)); g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this); GtkWidget* file_login = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Login")); g_signal_connect(file_login, "activate", G_CALLBACK(activate_login), this); GtkWidget* file_logout = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Log_Out")); g_signal_connect(file_logout, "activate", G_CALLBACK(activate_logout), this); GtkWidget* file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this); GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_login); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_logout); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // Functions entry GtkWidget* functions_opensevhist = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Process History")); g_signal_connect(functions_opensevhist, "activate", G_CALLBACK(activate_opensevhist), this); gtk_widget_add_accelerator(functions_opensevhist, "activate", accel_g, 'g', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkWidget* functions_command = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Co_mmand")); g_signal_connect( functions_command, "activate", G_CALLBACK(activate_command), this); gtk_widget_add_accelerator(functions_command, "activate", accel_g, 'b', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkWidget* functions_delete_item = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Delete Item")); g_signal_connect(functions_delete_item, "activate", G_CALLBACK(activate_delete_item), this); GtkMenu* functions_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_opensevhist); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_command); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_delete_item); GtkWidget* functions = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Functions")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions); gtk_menu_item_set_submenu( GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu)); // View menu GtkWidget* view_tree_layout = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Tree Layout")); g_signal_connect( view_tree_layout, "activate", G_CALLBACK(activate_tree_layout), this); GtkWidget* view_list_layout = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_List Layout")); g_signal_connect( view_list_layout, "activate", G_CALLBACK(activate_list_layout), this); GtkWidget* view_zoom_in = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Zoom _In")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_in), gtk_image_new_from_stock("gtk-zoom-in", GTK_ICON_SIZE_MENU)); g_signal_connect( view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this); gtk_widget_add_accelerator(view_zoom_in, "activate", accel_g, 'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget* view_zoom_out = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Zoom _Out")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_out), gtk_image_new_from_stock("gtk-zoom-out", GTK_ICON_SIZE_MENU)); g_signal_connect( view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this); gtk_widget_add_accelerator(view_zoom_out, "activate", accel_g, 'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget* view_zoom_reset = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Zoom _Reset")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_reset), gtk_image_new_from_stock("gtk-zoom-100", GTK_ICON_SIZE_MENU)); g_signal_connect( view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this); GtkMenu* view_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_tree_layout); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_list_layout); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset); GtkWidget* view = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu)); // Help entry GtkWidget* help_overview = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Overview")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(help_overview), gtk_image_new_from_stock("gtk-help", GTK_ICON_SIZE_MENU)); g_signal_connect(help_overview, "activate", G_CALLBACK(activate_help), this); gtk_widget_add_accelerator(help_overview, "activate", accel_g, 'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget* help_project = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Project")); g_signal_connect( help_project, "activate", G_CALLBACK(activate_help_project), this); GtkWidget* help_proview = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_About Proview")); g_signal_connect( help_proview, "activate", G_CALLBACK(activate_help_proview), this); GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_overview); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_project); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_proview); GtkWidget* help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); // Toolbar GtkToolbar* tools = (GtkToolbar*)g_object_new(GTK_TYPE_TOOLBAR, NULL); GtkWidget* tools_opensevhist = gtk_button_new(); dcli_translate_filename(fname, "$pwr_exe/xtt_meth_trend.png"); gtk_container_add( GTK_CONTAINER(tools_opensevhist), gtk_image_new_from_file(fname)); g_signal_connect( tools_opensevhist, "clicked", G_CALLBACK(activate_opensevhist), this); g_object_set(tools_opensevhist, "can-focus", FALSE, NULL); gtk_toolbar_append_widget(tools, tools_opensevhist, CoWowGtk::translate_utf8("Open history item"), ""); GtkWidget* tools_zoom_in = gtk_button_new(); dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_in.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_in), gtk_image_new_from_file(fname)); g_signal_connect( tools_zoom_in, "clicked", G_CALLBACK(activate_zoom_in), this); g_object_set(tools_zoom_in, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_in, CoWowGtk::translate_utf8("Zoom in"), ""); GtkWidget* tools_zoom_out = gtk_button_new(); dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_out.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_out), gtk_image_new_from_file(fname)); g_signal_connect( tools_zoom_out, "clicked", G_CALLBACK(activate_zoom_out), this); g_object_set(tools_zoom_out, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_out, CoWowGtk::translate_utf8("Zoom out"), ""); GtkWidget* tools_zoom_reset = gtk_button_new(); dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_reset.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_reset), gtk_image_new_from_file(fname)); g_signal_connect( tools_zoom_reset, "clicked", G_CALLBACK(activate_zoom_reset), this); g_object_set(tools_zoom_reset, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_reset, CoWowGtk::translate_utf8("Zoom reset"), ""); // Statusbar and cmd input GtkWidget* statusbar = gtk_hbox_new(FALSE, 0); msg_label = gtk_label_new(""); gtk_widget_set_size_request(msg_label, -1, 25); cmd_prompt = gtk_label_new("xtt > "); gtk_widget_set_size_request(cmd_prompt, -1, 25); cmd_recall = new CoWowRecall(); cmd_entry = new CoWowEntryGtk(cmd_recall); cmd_input = cmd_entry->widget(); gtk_widget_set_size_request(cmd_input, -1, 25); g_signal_connect( cmd_input, "activate", G_CALLBACK(valchanged_cmd_input), this); gtk_box_pack_start(GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20); gtk_box_pack_start(GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 20); gtk_box_pack_start(GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 20); gtk_widget_show_all(statusbar); tblnav = new TblNavGtk(this, toplevel, itemlist, item_cnt, &brow_widget, &sts); tblnav->message_cb = &XttTbl::message; tblnav->is_authorized_cb = &XttTbl::is_authorized; tblnav->command_cb = &XttTbl::command_cb; gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3); gtk_container_add(GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all(toplevel); g_object_set(cmd_prompt, "visible", FALSE, NULL); g_object_set(cmd_input, "visible", FALSE, NULL); // Create help window CoXHelp* xhelp = new CoXHelpGtk(toplevel, this, xhelp_eUtility_Xtt, &sts); CoXHelp::set_default(xhelp); wow = new CoWowGtk(toplevel); if (!is_authorized(pwr_mAccess_AllSev, 0)) open_login(); if (!quiet) { if (cologin) // Set login window as parent to warranty as focus is left to parent. ((CoWowGtk*)wow)->SetParent(((CoLoginGtk*)cologin)->widgets.toplevel); wow->DisplayWarranty(); if (cologin) ((CoWowGtk*)wow)->SetParent(toplevel); } }
void procdialog_create_renice_dialog (ProcData *procdata) { ProcInfo *info = procdata->selected_process; GtkWidget *dialog = NULL; GtkWidget *dialog_vbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *priority_label; GtkWidget *grid; GtkAdjustment *renice_adj; GtkWidget *hscale; GtkWidget *button; GtkWidget *icon; gchar *text; gchar *dialog_title; if (renice_dialog) return; if (!info) return; dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"), info->name, info->pid); dialog = gtk_dialog_new_with_buttons (dialog_title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL); g_free (dialog_title); renice_dialog = dialog; gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5); button = gtk_button_new_with_mnemonic (_("Change _Priority")); gtk_widget_set_can_default (button, TRUE); icon = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100); gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100); new_nice_value = -100; dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID(grid), 12); gtk_grid_set_row_spacing (GTK_GRID(grid), 6); gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0); label = gtk_label_new_with_mnemonic (_("_Nice value:")); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 2); renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0); new_nice_value = 0; hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, renice_adj); gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale); gtk_scale_set_digits (GTK_SCALE (hscale), 0); gtk_widget_set_hexpand (hscale, TRUE); gtk_grid_attach (GTK_GRID (grid), hscale, 1, 0, 1, 1); text = g_strdup_printf(_("(%s Priority)"), procman::get_nice_level (info->nice)); priority_label = gtk_label_new (text); gtk_grid_attach (GTK_GRID (grid), priority_label, 1, 1, 1, 1); g_free(text); text = g_strconcat("<small><i><b>", _("Note:"), "</b> ", _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."), "</i></small>", NULL); label = gtk_label_new (_(text)); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); g_free (text); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (renice_dialog_button_pressed), procdata); g_signal_connect (G_OBJECT (renice_adj), "value_changed", G_CALLBACK (renice_scale_changed), priority_label); gtk_widget_show_all (dialog); }
static void gimp_path_editor_init (GimpPathEditor *editor) { GtkWidget *button_box; GtkWidget *button; GtkWidget *image; GtkWidget *scrolled_window; GtkWidget *tv; GtkTreeViewColumn *col; GtkCellRenderer *renderer; editor->file_entry = NULL; editor->sel_path = NULL; editor->num_items = 0; editor->upper_hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (editor), editor->upper_hbox, FALSE, TRUE, 0); gtk_widget_show (editor->upper_hbox); button_box = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX (editor->upper_hbox), button_box, FALSE, TRUE, 0); gtk_widget_show (button_box); editor->new_button = button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); image = gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); g_signal_connect (button, "clicked", G_CALLBACK (gimp_path_editor_new_clicked), editor); editor->up_button = button = gtk_button_new (); gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); g_signal_connect (button, "clicked", G_CALLBACK (gimp_path_editor_move_clicked), editor); editor->down_button = button = gtk_button_new (); gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); g_signal_connect (button, "clicked", G_CALLBACK (gimp_path_editor_move_clicked), editor); editor->delete_button = button = gtk_button_new (); gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); g_signal_connect (button, "clicked", G_CALLBACK (gimp_path_editor_delete_clicked), editor); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (editor), scrolled_window, TRUE, TRUE, 2); gtk_widget_show (scrolled_window); editor->dir_list = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (editor->dir_list)); g_object_unref (editor->dir_list); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (gimp_path_editor_writable_toggled), editor); editor->writable_column = col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, _("Writable")); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "active", COLUMN_WRITABLE); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col); gtk_tree_view_column_set_visible (col, FALSE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv), -1, _("Folder"), gtk_cell_renderer_text_new (), "text", COLUMN_UTF8, NULL); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), TRUE); gtk_container_add (GTK_CONTAINER (scrolled_window), tv); gtk_widget_show (tv); editor->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); g_signal_connect (editor->sel, "changed", G_CALLBACK (gimp_path_editor_selection_changed), editor); }
/* * display the interface selection dialog */ static void gtkui_unified_sniff(void) { GList *iface_list; const char *iface_desc = NULL; char err[100]; GtkWidget *iface_combo; pcap_if_t *dev; GtkWidget *dialog, *label, *hbox, *image; DEBUG_MSG("gtk_unified_sniff"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Input", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new ("Network interface : "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ iface_combo = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (iface_combo), iface_list); gtk_box_pack_start (GTK_BOX (hbox), iface_combo, FALSE, FALSE, 0); /* hitting Enter in the drop down box clicks OK */ g_object_set_data(G_OBJECT (GTK_COMBO (iface_combo)->entry), "dialog", dialog); g_signal_connect(G_OBJECT (GTK_COMBO (iface_combo)->entry), "activate", G_CALLBACK (gtkui_dialog_enter), NULL); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); /* render the contents of the dialog */ gtk_widget_show_all (hbox); /* show the dialog itself and become interactive */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (iface_combo)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } /* exit setup iterface */ gtk_widget_destroy(dialog); gtk_main_quit(); return; } gtk_widget_destroy(dialog); }
static void gimp_scrolled_preview_init (GimpScrolledPreview *preview) { GimpScrolledPreviewPrivate *priv; GtkWidget *image; GtkObject *adj; preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, GIMP_TYPE_SCROLLED_PREVIEW, GimpScrolledPreviewPrivate); priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); preview->nav_popup = NULL; priv->hscr_policy = GTK_POLICY_AUTOMATIC; priv->vscr_policy = GTK_POLICY_AUTOMATIC; priv->in_drag = FALSE; priv->frozen = 1; /* we are frozen during init */ /* scrollbars */ adj = gtk_adjustment_new (0, 0, GIMP_PREVIEW (preview)->width - 1, 1.0, GIMP_PREVIEW (preview)->width, GIMP_PREVIEW (preview)->width); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_scrolled_preview_h_scroll), preview); preview->hscr = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj)); gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table), preview->hscr, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); adj = gtk_adjustment_new (0, 0, GIMP_PREVIEW (preview)->height - 1, 1.0, GIMP_PREVIEW (preview)->height, GIMP_PREVIEW (preview)->height); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_scrolled_preview_v_scroll), preview); preview->vscr = gtk_vscrollbar_new (GTK_ADJUSTMENT (adj)); gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table), preview->vscr, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); /* Connect after here so that plug-ins get a chance to override the * default behavior. See bug #364432. */ g_signal_connect_after (GIMP_PREVIEW (preview)->area, "event", G_CALLBACK (gimp_scrolled_preview_area_event), preview); g_signal_connect (GIMP_PREVIEW (preview)->area, "realize", G_CALLBACK (gimp_scrolled_preview_area_realize), preview); g_signal_connect (GIMP_PREVIEW (preview)->area, "unrealize", G_CALLBACK (gimp_scrolled_preview_area_unrealize), preview); g_signal_connect (GIMP_PREVIEW (preview)->area, "size-allocate", G_CALLBACK (gimp_scrolled_preview_area_size_allocate), preview); /* navigation icon */ preview->nav_icon = gtk_event_box_new (); gtk_table_attach (GTK_TABLE (GIMP_PREVIEW(preview)->table), preview->nav_icon, 1,2, 1,2, GTK_SHRINK, GTK_SHRINK, 0, 0); image = gtk_image_new_from_stock (GIMP_STOCK_NAVIGATION, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (preview->nav_icon), image); gtk_widget_show (image); g_signal_connect (preview->nav_icon, "button-press-event", G_CALLBACK (gimp_scrolled_preview_nav_button_press), preview); priv->frozen = 0; /* thaw without actually calling draw/invalidate */ }