/* Public VpnPasswordDialog methods */ GtkWidget * vpn_password_dialog_new (const char *title, const char *message, const char *password) { GtkWidget *dialog; VpnPasswordDialogPrivate *priv; GtkLabel *message_label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *dialog_icon; GtkBox *content, *action_area; dialog = gtk_widget_new (VPN_TYPE_PASSWORD_DIALOG, NULL); if (!dialog) return NULL; priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog); gtk_window_set_title (GTK_WINDOW (dialog), title); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("_Cancel"), GTK_RESPONSE_CANCEL, _("_OK"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))); action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))); /* Setup the dialog */ #if !GTK_CHECK_VERSION (2,22,0) gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); #endif gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5); gtk_box_set_spacing (action_area, 6); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); g_signal_connect (dialog, "show", G_CALLBACK (dialog_show_callback), dialog); g_signal_connect (dialog, "close", G_CALLBACK (dialog_close_callback), dialog); /* The table that holds the captions */ priv->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (priv->table), 12); gtk_grid_set_row_spacing (GTK_GRID (priv->table), 6); gtk_container_add (GTK_CONTAINER (priv->table_alignment), priv->table); priv->password_entry = gtk_entry_new (); priv->password_entry_secondary = gtk_entry_new (); priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords")); /* We want to hold on to these during the table rearrangement */ g_object_ref_sink (priv->password_entry); g_object_ref_sink (priv->password_entry_secondary); g_object_ref_sink (priv->show_passwords_checkbox); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE); g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect_swapped (priv->password_entry_secondary, "activate", G_CALLBACK (gtk_window_activate_default), dialog); g_signal_connect (priv->show_passwords_checkbox, "toggled", G_CALLBACK (show_passwords_toggled_cb), dialog); add_table_rows (VPN_PASSWORD_DIALOG (dialog)); /* Adds some eye-candy to the dialog */ #if GTK_CHECK_VERSION (3,1,6) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); dialog_icon = gtk_image_new_from_icon_name (_("dialog-password"), GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0); /* Fills the vbox */ #if GTK_CHECK_VERSION (3,1,6) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); #else main_vbox = gtk_vbox_new (FALSE, 18); #endif if (message) { message_label = GTK_LABEL (gtk_label_new (message)); gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (message_label, TRUE); gtk_label_set_max_width_chars (message_label, 35); gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label)); gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0); gtk_size_group_add_widget (priv->group, priv->table_alignment); } #if GTK_CHECK_VERSION (3,1,6) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), priv->table_alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_box_pack_start (content, hbox, FALSE, FALSE, 0); gtk_widget_show_all (GTK_WIDGET (content)); vpn_password_dialog_set_password (VPN_PASSWORD_DIALOG (dialog), password); return GTK_WIDGET (dialog); }
static void codecs_box_init (CodecsBox *self) { GtkWidget *image = NULL; GtkWidget *scroll_window = NULL; GtkWidget *button = NULL; GtkWidget *buttons_vbox = NULL; GtkWidget *alignment = NULL; GtkListStore *list_store = NULL; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CODECS_BOX_TYPE, CodecsBoxPrivate); self->priv->type = Ekiga::Call::Audio; self->priv->audio_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (AUDIO_CODECS_SCHEMA)); self->priv->video_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (VIDEO_CODECS_SCHEMA)); self->priv->codecs_list = gtk_tree_view_new (); gtk_box_set_spacing (GTK_BOX (self), 6); gtk_box_set_homogeneous (GTK_BOX (self), FALSE); list_store = gtk_list_store_new (COLUMN_CODEC_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->codecs_list), TRUE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->codecs_list), TRUE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->codecs_list),0); gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->codecs_list), GTK_TREE_MODEL (list_store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->codecs_list), FALSE); /* Set all Colums */ renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", COLUMN_CODEC_ACTIVE, NULL); gtk_tree_view_column_add_attribute (column, renderer, "activatable", COLUMN_CODEC_SELECTABLE); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 25); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); g_signal_connect (renderer, "toggled", G_CALLBACK (codec_toggled_cb), (gpointer) self); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); g_object_set (G_OBJECT (renderer), "weight", PANGO_WEIGHT_BOLD, NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_CLOCKRATE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_PROTOCOLS, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); scroll_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll_window), GTK_SHADOW_IN); gtk_widget_set_size_request (scroll_window, -1, 130); gtk_container_add (GTK_CONTAINER (scroll_window), GTK_WIDGET (self->priv->codecs_list)); gtk_box_pack_start (GTK_BOX (self), scroll_window, TRUE, TRUE, 0); /* The buttons */ alignment = gtk_alignment_new (1, 0.5, 0, 0); buttons_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (alignment), buttons_vbox); image = gtk_image_new_from_icon_name ("go-up", GTK_ICON_SIZE_MENU); button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_set_tooltip_text (button, _("Move selected codec priority upwards")); gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (button), "operation", (gpointer) "up"); g_signal_connect (button, "clicked", G_CALLBACK (codec_moved_cb), (gpointer) self); image = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_MENU); button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_set_tooltip_text (button, _("Move selected codec priority downwards")); gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (button), "operation", (gpointer) "down"); g_signal_connect (button, "clicked", G_CALLBACK (codec_moved_cb), (gpointer) self); gtk_box_pack_start (GTK_BOX (self), alignment, FALSE, FALSE, 0); gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE); gtk_widget_show_all (GTK_WIDGET (self)); }
void create_mainwindow(void) { char *imagename; GtkWidget *vbox_gs; GtkWidget *menu; GtkWidget *hbox25; GtkWidget *tab_button_icon; GtkWidget *label; #ifndef USE_WEBKIT2 GtkWidget *scrolledwindow; #endif GtkWidget *box_book; GdkPixbuf *pixbuf; /* GTK_SHADOW_NONE GTK_SHADOW_IN GTK_SHADOW_OUT GTK_SHADOW_ETCHED_IN GTK_SHADOW_ETCHED_OUT */ settings.shadow_type = GTK_SHADOW_IN; XI_print(("%s xiphos-%s\n", "Starting", VERSION)); XI_print(("%s\n\n", "Building Xiphos interface")); widgets.studypad_dialog = NULL; /* A rough scektch of the main window (widgets.app) and it's children * widgets.app * | * vbox_gs * | * +--|----+ * | | * menu hbox25 * | * widgets.epaned * | * widgets.vboxMain * | | * widgets.hboxtb widgets.page * | | * widgets.hpaned nav_toolbar * | | * widgets.vpaned---+ +----------------------------widgets.vpaned2---------------+ * | | | | * widgets.vbox_previewer widgets.vbox_text widgets.notebook_comm_book widgets.box_dict * | | | * widgets.notebook_bible_parallel widgets.box_comm box_book * | * widgets.notebook_text * */ // The toplevel Xiphos window widgets.app = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(widgets.app), _("Xiphos - Bible Study Software")); g_object_set_data(G_OBJECT(widgets.app), "widgets.app", widgets.app); gtk_widget_set_size_request(widgets.app, 680, 425); gtk_widget_set_can_focus(widgets.app, 1); gtk_window_set_resizable(GTK_WINDOW(widgets.app), TRUE); // The app icon. // FIXME:: This should be a big copy of the logo because GTK does the scaling (GTK 3.16?) imagename = image_locator("gs2-48x48.png"); pixbuf = gdk_pixbuf_new_from_file(imagename, NULL); g_free(imagename); gtk_window_set_icon(GTK_WINDOW(widgets.app), pixbuf); // The main box for our toplevel window. UI_VBOX(vbox_gs, FALSE, 0); gtk_widget_show(vbox_gs); gtk_container_add(GTK_CONTAINER(widgets.app), vbox_gs); // Add the main menu. menu = gui_create_main_menu(); gtk_box_pack_start(GTK_BOX(vbox_gs), menu, FALSE, TRUE, 0); // Another box UI_HBOX(hbox25, FALSE, 0); gtk_widget_show(hbox25); gtk_box_pack_start(GTK_BOX(vbox_gs), hbox25, TRUE, TRUE, 0); // widgets.epaned widgets.epaned = UI_HPANE(); gtk_widget_show(widgets.epaned); #ifndef HAVE_GTK_314 gtk_container_set_border_width(GTK_CONTAINER(widgets.epaned), 4); #endif gtk_box_pack_start(GTK_BOX(hbox25), widgets.epaned, TRUE, TRUE, 0); // Another box UI_VBOX(widgets.vboxMain, FALSE, 0); gtk_widget_show(widgets.vboxMain); gtk_paned_pack2(GTK_PANED(widgets.epaned), widgets.vboxMain, TRUE, TRUE); #ifndef HAVE_GTK_314 gtk_container_set_border_width(GTK_CONTAINER(widgets.vboxMain), 2); #endif /* * Notebook to have separate passages opened at once the passages are not * actually open but are switched between similar to bookmarks */ UI_HBOX(widgets.hboxtb, FALSE, 0); if (settings.browsing) gtk_widget_show(widgets.hboxtb); gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.hboxtb, FALSE, FALSE, 0); widgets.button_new_tab = gtk_button_new(); // Don't show button here in case !settings.browsing #ifdef HAVE_GTK_310 tab_button_icon = gtk_image_new_from_icon_name("tab-new-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); #else tab_button_icon = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR); #endif gtk_widget_show(tab_button_icon); gtk_container_add(GTK_CONTAINER(widgets.button_new_tab), tab_button_icon); gtk_button_set_relief(GTK_BUTTON(widgets.button_new_tab), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.button_new_tab, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(widgets.button_new_tab, _("Open a new tab")); widgets.notebook_main = gtk_notebook_new(); gtk_widget_show(widgets.notebook_main); gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.notebook_main, TRUE, TRUE, 0); gtk_widget_set_size_request(widgets.notebook_main, -1, 25); gtk_notebook_set_scrollable(GTK_NOTEBOOK(widgets.notebook_main), TRUE); gtk_notebook_popup_enable(GTK_NOTEBOOK(widgets.notebook_main)); gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_main), FALSE); // Main passage tabbed notebook end // Another box UI_VBOX(widgets.page, FALSE, 0); gtk_widget_show(widgets.page); gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.page, TRUE, TRUE, 0); //nav toolbar nav_toolbar = gui_navbar_versekey_new(); gtk_box_pack_start(GTK_BOX(widgets.page), nav_toolbar, FALSE, FALSE, 0); // widgets.hpaned widgets.hpaned = UI_HPANE(); gtk_widget_show(widgets.hpaned); gtk_box_pack_start(GTK_BOX(widgets.page), widgets.hpaned, TRUE, TRUE, 0); // widgets.vpaned widgets.vpaned = UI_VPANE(); gtk_widget_show(widgets.vpaned); gtk_widget_set_size_request(widgets.vpaned, 50, -1); gtk_paned_pack1(GTK_PANED(widgets.hpaned), widgets.vpaned, TRUE, FALSE); // widgets.vpaned2 widgets.vpaned2 = UI_VPANE(); gtk_widget_show(widgets.vpaned2); gtk_widget_set_size_request(widgets.vpaned2, 50, -1); gtk_paned_pack2(GTK_PANED(widgets.hpaned), widgets.vpaned2, TRUE, FALSE); // widgets.vbox_text UI_VBOX(widgets.vbox_text, FALSE, 0); gtk_widget_show(widgets.vbox_text); gtk_paned_pack1(GTK_PANED(widgets.vpaned), widgets.vbox_text, TRUE, TRUE); // Bible/parallel notebook widgets.notebook_bible_parallel = gtk_notebook_new(); gtk_widget_show(widgets.notebook_bible_parallel); gtk_box_pack_start(GTK_BOX(widgets.vbox_text), widgets.notebook_bible_parallel, TRUE, TRUE, 0); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_bible_parallel), GTK_POS_BOTTOM); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_bible_parallel), TRUE); gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_bible_parallel), FALSE); gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_bible_parallel), 1); g_signal_connect(G_OBJECT(widgets.notebook_bible_parallel), "change-current-page", G_CALLBACK(on_notebook_bible_parallel_switch_page), NULL); // Text notebook (The bible text show in the standard view) widgets.notebook_text = gui_create_bible_pane(); gtk_container_add(GTK_CONTAINER(widgets.notebook_bible_parallel), widgets.notebook_text); label = gtk_label_new(_("Standard View")); gtk_widget_show(label); gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_bible_parallel), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel), 0), label); // Another box (For the previewer?) UI_VBOX(widgets.vbox_previewer, FALSE, 0); gtk_widget_show(widgets.vbox_previewer); gtk_paned_pack2(GTK_PANED(widgets.vpaned), widgets.vbox_previewer, TRUE, TRUE); gtk_container_set_border_width(GTK_CONTAINER(widgets.vbox_previewer), 2); #ifndef USE_WEBKIT2 scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *) scrolledwindow, settings.shadow_type); #endif widgets.html_previewer_text = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, VIEWER_TYPE)); gtk_widget_show(widgets.html_previewer_text); #ifdef USE_WEBKIT2 gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), widgets.html_previewer_text, TRUE, TRUE, 0); #else gtk_container_add(GTK_CONTAINER(scrolledwindow), widgets.html_previewer_text); #endif // Commentary/book notebook widgets.notebook_comm_book = gtk_notebook_new(); gtk_widget_show(widgets.notebook_comm_book); gtk_paned_pack1(GTK_PANED(widgets.vpaned2), widgets.notebook_comm_book, TRUE, TRUE); gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_comm_book), 1); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_comm_book), GTK_POS_BOTTOM); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_comm_book), TRUE); gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_comm_book), FALSE); // Commentary pane widgets.box_comm = gui_create_commentary_pane(); gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), widgets.box_comm); label = gtk_label_new(_("Commentary View")); gtk_widget_show(label); gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 0), label); // Book pane box_book = gui_create_book_pane(); gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), box_book); label = gtk_label_new(_("Book View")); gtk_widget_show(label); gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 1), label); // Dict/lex widgets.box_dict = gui_create_dictionary_pane(); gtk_paned_pack2(GTK_PANED(widgets.vpaned2), widgets.box_dict, TRUE, TRUE); // Statusbar widgets.appbar = gtk_statusbar_new(); if (settings.statusbar) { gtk_widget_show(widgets.appbar); } #ifndef USE_GTK_3 gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(widgets.appbar), TRUE); #endif gtk_box_pack_start(GTK_BOX(vbox_gs), widgets.appbar, FALSE, TRUE, 0); gui_set_statusbar(_("Welcome to Xiphos")); g_signal_connect((gpointer)vbox_gs, "key_press_event", G_CALLBACK(on_vbox1_key_press_event), NULL); g_signal_connect((gpointer)vbox_gs, "key_release_event", G_CALLBACK(on_vbox1_key_release_event), NULL); g_signal_connect(G_OBJECT(widgets.notebook_comm_book), "switch_page", G_CALLBACK(on_notebook_comm_book_switch_page), NULL); g_signal_connect(G_OBJECT(widgets.app), "delete_event", G_CALLBACK(delete_event), NULL); g_signal_connect((gpointer)widgets.app, "configure_event", G_CALLBACK(on_configure_event), NULL); g_signal_connect(G_OBJECT(widgets.epaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"epaned"); g_signal_connect(G_OBJECT(widgets.vpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned"); g_signal_connect(G_OBJECT(widgets.vpaned2), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned2"); g_signal_connect(G_OBJECT(widgets.hpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"hpaned1"); gtk_widget_grab_focus(navbar_versekey.lookup_entry); gtk_window_set_default_size((GtkWindow *)widgets.app, settings.gs_width, settings.gs_height); main_window_created = TRUE; }
GtkWidget * palette_import_dialog_new (GimpContext *context) { ImportDialog *dialog; GimpGradient *gradient; GtkWidget *button; GtkWidget *main_hbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *abox; GtkSizeGroup *size_group; GSList *group = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); gradient = gimp_context_get_gradient (context); dialog = g_slice_new0 (ImportDialog); dialog->import_type = GRADIENT_IMPORT; dialog->context = gimp_context_new (context->gimp, "Palette Import", context); dialog->dialog = gimp_dialog_new (_("Import a New Palette"), "gimp-palette-import", NULL, 0, gimp_standard_help_func, GIMP_HELP_PALETTE_IMPORT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("_Import"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-convert", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data_full (G_OBJECT (dialog->dialog), "palette-import-dialog", dialog, (GDestroyNotify) palette_import_free); g_signal_connect (dialog->dialog, "response", G_CALLBACK (palette_import_response), dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_GRADIENT, import_dialog_drop_callback, dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_IMAGE, import_dialog_drop_callback, dialog); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* The "Source" frame */ frame = gimp_frame_new (_("Select Source")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (5, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); dialog->gradient_radio = gtk_radio_button_new_with_mnemonic (group, _("_Gradient")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio)); gtk_table_attach (GTK_TABLE (table), dialog->gradient_radio, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->gradient_radio); g_signal_connect (dialog->gradient_radio, "toggled", G_CALLBACK (palette_import_grad_callback), dialog); dialog->image_radio = gtk_radio_button_new_with_mnemonic (group, _("I_mage")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->image_radio, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->image_radio); g_signal_connect (dialog->image_radio, "toggled", G_CALLBACK (palette_import_image_callback), dialog); gtk_widget_set_sensitive (dialog->image_radio, ! gimp_container_is_empty (context->gimp->images)); dialog->sample_merged_toggle = gtk_check_button_new_with_mnemonic (_("Sample _Merged")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle), TRUE); gtk_table_attach (GTK_TABLE (table), dialog->sample_merged_toggle, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->sample_merged_toggle); g_signal_connect_swapped (dialog->sample_merged_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->selection_only_toggle = gtk_check_button_new_with_mnemonic (_("_Selected Pixels only")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle), FALSE); gtk_table_attach (GTK_TABLE (table), dialog->selection_only_toggle, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->selection_only_toggle); g_signal_connect_swapped (dialog->selection_only_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->file_radio = gtk_radio_button_new_with_mnemonic (group, _("Palette _file")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->file_radio, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->file_radio); g_signal_connect (dialog->file_radio, "toggled", G_CALLBACK (palette_import_file_callback), dialog); size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); /* The gradient menu */ dialog->gradient_combo = gimp_container_combo_box_new (gimp_data_factory_get_container (context->gimp->gradient_factory), dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, NULL, 0.0, 0.5, dialog->gradient_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->gradient_combo); /* The image menu */ dialog->image_combo = gimp_container_combo_box_new (context->gimp->images, dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, NULL, 0.0, 0.5, dialog->image_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->image_combo); /* Palette file name entry */ dialog->file_chooser = gtk_file_chooser_button_new (_("Select Palette File"), GTK_FILE_CHOOSER_ACTION_OPEN); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->file_chooser); g_object_unref (size_group); /* The "Import" frame */ frame = gimp_frame_new (_("Import Options")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* The source's name */ dialog->entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (dialog->entry), gradient ? gimp_object_get_name (gradient) : _("New import")); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Palette _name:"), 0.0, 0.5, dialog->entry, 2, FALSE); /* The # of colors */ dialog->num_colors = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("N_umber of colors:"), -1, 5, 256, 2, 10000, 1, 10, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->num_colors, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The columns */ dialog->columns = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("C_olumns:"), -1, 5, 16, 0, 64, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (dialog->columns, "value-changed", G_CALLBACK (palette_import_columns_changed), dialog); /* The interval */ dialog->threshold = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("I_nterval:"), -1, 5, 1, 1, 128, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->threshold, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The "Preview" frame */ frame = gimp_frame_new (_("Preview")); gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); dialog->preview = gimp_view_new_full_by_types (dialog->context, GIMP_TYPE_VIEW, GIMP_TYPE_PALETTE, 192, 192, 1, TRUE, FALSE, FALSE); gtk_container_add (GTK_CONTAINER (abox), dialog->preview); gtk_widget_show (dialog->preview); dialog->no_colors_label = gtk_label_new (_("The selected source contains no colors.")); gtk_widget_set_size_request (dialog->no_colors_label, 194, -1); gtk_label_set_line_wrap (GTK_LABEL (dialog->no_colors_label), TRUE); gimp_label_set_attributes (GTK_LABEL (dialog->no_colors_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), dialog->no_colors_label, FALSE, FALSE, 0); gtk_widget_show (dialog->no_colors_label); /* keep the dialog up-to-date */ g_signal_connect (context->gimp->images, "add", G_CALLBACK (palette_import_image_add), dialog); g_signal_connect (context->gimp->images, "remove", G_CALLBACK (palette_import_image_remove), dialog); g_signal_connect (dialog->context, "gradient-changed", G_CALLBACK (palette_import_gradient_changed), dialog); g_signal_connect (dialog->context, "image-changed", G_CALLBACK (palette_import_image_changed), dialog); g_signal_connect (dialog->file_chooser, "selection-changed", G_CALLBACK (palette_import_filename_changed), dialog); palette_import_grad_callback (dialog->gradient_radio, dialog); return dialog->dialog; }
static void add_address_row (CEPageIP6 *page, const gchar *address, const gchar *network, const gchar *gateway) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); gtk_entry_set_text (GTK_ENTRY (widget), network); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Address")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 2, 1, 1); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_left (row_grid, 10); gtk_widget_set_margin_right (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->address_list), row); update_row_sensitivity (page, page->address_list); }
static GtkWidget *linphone_gtk_create_call_log_menu(GtkWidget *call_log){ GtkWidget *menu=NULL; GtkWidget *menu_item; gchar *call_label=NULL; gchar *text_label=NULL; gchar *add_contact_label=NULL; gchar *name=NULL; GtkWidget *image; GtkTreeSelection *select; GtkTreeIter iter; select=gtk_tree_view_get_selection(GTK_TREE_VIEW(call_log)); if (select!=NULL){ GtkTreeModel *model=NULL; if (gtk_tree_selection_get_selected (select,&model,&iter)){ gpointer pcl; LinphoneAddress *la; LinphoneCallLog *cl; gtk_tree_model_get(model,&iter,2,&pcl,-1); cl = (LinphoneCallLog *)pcl; la = linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl); name=linphone_address_as_string(la); call_label=g_strdup_printf(_("Call %s"),name); text_label=g_strdup_printf(_("Send text to %s"),name); if (!linphone_gtk_is_friend(linphone_gtk_get_core(), name)) { add_contact_label=g_strdup_printf(_("Add %s to your contact list"),name); } ms_free(name); menu=gtk_menu_new(); } } if (menu && call_label){ menu_item=gtk_image_menu_item_new_with_label(call_label); image=gtk_image_new_from_icon_name("linphone-start-call",GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image); gtk_widget_show(image); gtk_widget_show(menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_selected,call_log); } if (menu && text_label){ menu_item=gtk_image_menu_item_new_with_label(text_label); image=gtk_image_new_from_icon_name("linphone-start-chat",GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image); gtk_widget_show(image); gtk_widget_show(menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_chat_selected,call_log); } if (menu && add_contact_label){ menu_item=gtk_image_menu_item_new_with_label(add_contact_label); image=gtk_image_new_from_icon_name("linphone-contact-add",GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image); gtk_widget_show(image); gtk_widget_show(menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_add_contact,call_log); } if (menu) { gtk_widget_show(menu); gtk_menu_attach_to_widget(GTK_MENU(menu),call_log, NULL); } if (add_contact_label) g_free(add_contact_label); if (call_label) g_free(call_label); if (text_label) g_free(text_label); return menu; }
static void setup_photo_popup (UmPhotoDialog *um) { GtkWidget *menu, *menuitem, *image; guint x, y; const gchar * const * dirs; guint i; GDir *dir; const char *face; gboolean none_item_shown; gboolean added_faces; menu = gtk_menu_new (); x = 0; y = 0; none_item_shown = added_faces = FALSE; dirs = g_get_system_data_dirs (); for (i = 0; dirs[i] != NULL; i++) { char *path; path = g_build_filename (dirs[i], "pixmaps", "faces", NULL); dir = g_dir_open (path, 0, NULL); if (dir == NULL) { g_free (path); continue; } while ((face = g_dir_read_name (dir)) != NULL) { char *filename; added_faces = TRUE; filename = g_build_filename (path, face, NULL); menuitem = menu_item_for_filename (um, filename); g_free (filename); if (menuitem == NULL) continue; gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (menuitem), x, x + 1, y, y + 1); gtk_widget_show (menuitem); x++; if (x >= ROW_SPAN - 1) { y++; x = 0; } } g_dir_close (dir); g_free (path); if (added_faces) break; } if (!added_faces) goto skip_faces; image = gtk_image_new_from_icon_name ("avatar-default", GTK_ICON_SIZE_DIALOG); menuitem = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (menuitem), image); gtk_widget_show_all (menuitem); gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (menuitem), x, x + 1, y, y + 1); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (none_icon_selected), um); gtk_widget_show (menuitem); none_item_shown = TRUE; y++; skip_faces: if (!none_item_shown) { menuitem = gtk_menu_item_new_with_label (_("Disable image")); gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (menuitem), 0, ROW_SPAN - 1, y, y + 1); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (none_icon_selected), um); gtk_widget_show (menuitem); y++; } /* Separator */ menuitem = gtk_separator_menu_item_new (); gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (menuitem), 0, ROW_SPAN - 1, y, y + 1); gtk_widget_show (menuitem); y++; #ifdef HAVE_CHEESE um->take_photo_menuitem = gtk_menu_item_new_with_label (_("Take a photo...")); gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (um->take_photo_menuitem), 0, ROW_SPAN - 1, y, y + 1); g_signal_connect (G_OBJECT (um->take_photo_menuitem), "activate", G_CALLBACK (webcam_icon_selected), um); gtk_widget_set_sensitive (um->take_photo_menuitem, FALSE); gtk_widget_show (um->take_photo_menuitem); um->monitor = cheese_camera_device_monitor_new (); g_signal_connect (G_OBJECT (um->monitor), "added", G_CALLBACK (device_added), um); g_signal_connect (G_OBJECT (um->monitor), "removed", G_CALLBACK (device_removed), um); cheese_camera_device_monitor_coldplug (um->monitor); y++; #endif /* HAVE_CHEESE */ menuitem = gtk_menu_item_new_with_label (_("Browse for more pictures...")); gtk_menu_attach (GTK_MENU (menu), GTK_WIDGET (menuitem), 0, ROW_SPAN - 1, y, y + 1); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (file_icon_selected), um); gtk_widget_show (menuitem); um->photo_popup = menu; }
static int _progress(Prefs * prefs, char * argv[]) { Progress p; struct stat st; GtkWidget * vbox; GtkWidget * hbox; GtkSizeGroup * left; GtkSizeGroup * right; GtkWidget * widget; PangoFontDescription * bold; char const * q; unsigned long id; memset(&p, 0, sizeof(p)); p.prefs = prefs; if(prefs->bufsiz == 0) errno = EINVAL; if(prefs->bufsiz == 0 || (p.buf = malloc(prefs->bufsiz)) == NULL) return _progress_error(&p, "malloc", 1); p.bufsiz = prefs->bufsiz; if(pipe(p.fds) != 0) return _progress_error(&p, "pipe", 1); if((p.pid = fork()) == -1) { close(p.fds[0]); close(p.fds[1]); return _progress_error(&p, "fork", 1); } if(p.pid != 0) return _progress_exec(&p, argv); close(p.fds[0]); if(gettimeofday(&p.tv, NULL) != 0) return _progress_error(&p, "gettimeofday", 1); if(prefs->filename == NULL) prefs->filename = _("Standard input"); else if((p.fd = open(prefs->filename, O_RDONLY)) < 0) return _progress_error(&p, prefs->filename, 1); else if(fstat(p.fd, &st) == 0 && S_ISREG(st.st_mode)) prefs->length = st.st_size; p.in_channel = g_io_channel_unix_new(p.fd); g_io_channel_set_encoding(p.in_channel, NULL, NULL); p.in_id = 0; g_idle_add(_progress_idle_in, &p); p.out_channel = g_io_channel_unix_new(p.fds[1]); g_io_channel_set_encoding(p.out_channel, NULL, NULL); p.out_id = 0; /* graphical interface */ if((prefs->flags & PREFS_x) == 0) { p.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); #if GTK_CHECK_VERSION(3, 0, 0) && !GTK_CHECK_VERSION(3, 14, 0) gtk_window_set_has_resize_grip(GTK_WINDOW(p.window), FALSE); #endif gtk_window_set_title(GTK_WINDOW(p.window), prefs->title != NULL ? prefs->title : _("Progress")); g_signal_connect_swapped(p.window, "delete-event", G_CALLBACK( _progress_closex), p.window); } else { p.window = gtk_plug_new(0); g_signal_connect_swapped(p.window, "embedded", G_CALLBACK( _progress_embedded), &p); } #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else vbox = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); #endif left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* file */ widget = gtk_label_new(_("File: ")); bold = pango_font_description_new(); pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); if((q = g_filename_to_utf8(prefs->filename, -1, NULL, NULL, NULL)) == NULL) q = prefs->filename; widget = gtk_label_new(q); gtk_label_set_ellipsize(GTK_LABEL(widget), PANGO_ELLIPSIZE_MIDDLE); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(right, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* done */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(_("Done: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); p.done = gtk_label_new(_("0.0 kB")); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(p.done, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(p.done), 0.0, 0.5); #endif gtk_size_group_add_widget(right, p.done); gtk_box_pack_start(GTK_BOX(hbox), p.done, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); /* remaining */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(_("Remaining: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); p.remaining = gtk_label_new(""); g_timeout_add(250, _progress_timeout, &p); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(p.remaining, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(p.remaining), 0.0, 0.5); #endif gtk_size_group_add_widget(right, p.remaining); gtk_box_pack_start(GTK_BOX(hbox), p.remaining, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); /* progress */ p.progress = gtk_progress_bar_new(); p.pulse = 0; if(prefs->prefix != NULL) { #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif widget = gtk_label_new(prefs->prefix); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); gtk_size_group_add_widget(right, p.progress); gtk_box_pack_start(GTK_BOX(hbox), p.progress, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4); } else gtk_box_pack_start(GTK_BOX(vbox), p.progress, TRUE, TRUE, 4); /* cancel */ #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif #if GTK_CHECK_VERSION(3, 10, 0) widget = gtk_button_new_with_label(_("Cancel")); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON)); #else widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL); #endif g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK( _progress_cancel), NULL); gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(p.window), vbox); gtk_container_set_border_width(GTK_CONTAINER(p.window), 4); gtk_widget_show_all(vbox); if((prefs->flags & PREFS_x) == 0) /* show the window */ gtk_widget_show(p.window); else { /* print the window ID and force a flush */ id = gtk_plug_get_id(GTK_PLUG(p.window)); printf("%lu\n", id); fclose(stdout); } gtk_main(); close(p.fd); close(p.fds[1]); return p.ret; }
static GObject * gdict_database_chooser_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObjectClass *parent_class; GObject *object; GdictDatabaseChooser *chooser; GdictDatabaseChooserPrivate *priv; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *hbox; parent_class = G_OBJECT_CLASS (gdict_database_chooser_parent_class); object = parent_class->constructor (type, n_params, params); chooser = GDICT_DATABASE_CHOOSER (object); priv = chooser->priv; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (chooser), sw, TRUE, TRUE, 0); gtk_widget_show (sw); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("databases", renderer, "text", DB_COLUMN_DESCRIPTION, "weight", DB_COLUMN_CURRENT, NULL); priv->treeview = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)), "changed", G_CALLBACK (selection_changed_cb), chooser); g_signal_connect (priv->treeview, "row-activated", G_CALLBACK (row_activated_cb), chooser); gtk_container_add (GTK_CONTAINER (sw), priv->treeview); gtk_widget_show (priv->treeview); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); priv->buttons_box = hbox; priv->refresh_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (priv->refresh_button), gtk_image_new_from_icon_name ("view-refresh", GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (priv->refresh_button, "clicked", G_CALLBACK (refresh_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), priv->refresh_button, FALSE, FALSE, 0); gtk_widget_show (priv->refresh_button); gtk_widget_set_tooltip_text (priv->refresh_button, _("Reload the list of available databases")); priv->clear_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (priv->clear_button), gtk_image_new_from_icon_name ("edit-clear", GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (priv->clear_button, "clicked", G_CALLBACK (clear_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0); gtk_widget_show (priv->clear_button); gtk_widget_set_tooltip_text (priv->clear_button, _("Clear the list of available databases")); gtk_box_pack_end (GTK_BOX (chooser), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); return object; }
static gboolean lcms_icc_apply_dialog (gint32 image, cmsHPROFILE src_profile, cmsHPROFILE dest_profile, gboolean *dont_ask) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle = NULL; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Convert to RGB working space?"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_APPLY, _("_Keep"), GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Convert"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-convert", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = lcms_icc_profile_src_label_new (image, src_profile); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); label = lcms_icc_profile_dest_label_new (dest_profile); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (dont_ask) { toggle = gtk_check_button_new_with_mnemonic (_("_Don't ask me again")); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE); gtk_widget_show (toggle); } run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (dont_ask) { *dont_ask = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)); } gtk_widget_destroy (dialog); return run; }
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; GdkGeometry geo; 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); geo.min_width = 400; geo.min_height = 300; geo.max_width = 800; geo.max_height = 600; gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL, &geo, GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE); 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; }
static void moko_talking_init (MokoTalking *talking) { MokoTalkingPrivate *priv; GtkWidget *notebook; GtkWidget *toolbar, *image, *vbox, *hbox, *label, *align, *frame, *main_vbox; GtkWidget *duration; GtkToolItem *item; gint i; priv = talking->priv = MOKO_TALKING_GET_PRIVATE (talking); /* initialize dtimer to NULL */ priv->dtimer = NULL; notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM); priv->notebook = notebook; /* status page */ main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/phone.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); priv->incoming_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_ANSWER, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Answer"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_answer_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_IGNORE, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Ignore"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_silence_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_REJECT, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Reject"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_reject_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Volume controls */ priv->headphone = moko_alsa_volume_control_new (); moko_alsa_volume_control_set_device_from_name (priv->headphone, "neo1973"); moko_alsa_volume_control_set_element_from_name (priv->headphone, "Headphone"); priv->volume = moko_alsa_volume_scale_new (GTK_ORIENTATION_HORIZONTAL); moko_alsa_volume_scale_set_control (MOKO_ALSA_VOLUME_SCALE (priv->volume), priv->headphone); /* Outgoing call and talking share the same toolbar */ priv->main_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_SPEAKER, GTK_ICON_SIZE_BUTTON); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "toggled", G_CALLBACK (on_speaker_toggled), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->speaker_toggle_btn = item; image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_HANGUP, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Hangup"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_cancel_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The title label and image */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); priv->title = label = gtk_label_new ("Incoming Call"); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 8); priv->icon = image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (align), image); priv->duration = duration = gtk_label_new ("00:00:00"); gtk_misc_set_alignment (GTK_MISC (duration), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), duration, FALSE, FALSE, 0); /* The status area */ align = gtk_alignment_new (0.5, 0.5, 1, 0 ); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_container_set_border_width (GTK_CONTAINER (frame), 10); gtk_container_add (GTK_CONTAINER (align), frame); hbox = gtk_hbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), hbox); priv->person = image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); priv->status = label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* The volume control */ gtk_box_pack_start (GTK_BOX (vbox), priv->volume, FALSE, TRUE, 12); /* Load the pixbufs */ for (i = 0; i < N_PICS; i++) { if (i == 0) priv->talking[i] = gdk_pixbuf_new_from_file (PKGDATADIR"/talking.png", NULL); else { gchar *name = g_strdup_printf ("%s/talking_%d.png", PKGDATADIR, i-1); priv->talking[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); } if (G_IS_OBJECT (priv->talking[i])) g_object_ref (priv->talking[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/outgoing_%d.png", PKGDATADIR, i); priv->outgoing[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->outgoing[i])) g_object_ref (priv->outgoing[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/incoming_%d.png", PKGDATADIR, i); priv->incoming[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->incoming[i])) g_object_ref (priv->incoming[i]); } /* dtmf page */ GtkWidget *pad, *display; main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/dtmf.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); display = moko_dialer_textview_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), display); priv->dtmf_display = display; pad = moko_dialer_panel_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), pad); g_signal_connect (pad, "user_input", G_CALLBACK (on_pad_user_input), talking); priv->dtmf_pad = pad; priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (priv->window, "delete-event", G_CALLBACK (window_delete_event_cb), talking); gtk_container_add (GTK_CONTAINER (priv->window), notebook); gtk_widget_show_all (notebook); }
void mobile_connection_new (GtkWindow *parent, const char *detail, NMRemoteSettings *settings, PageNewConnectionResultFunc result_func, gpointer user_data) { NMAMobileWizard *wizard; WizardInfo *info; GtkWidget *dialog, *vbox, *gsm_radio, *cdma_radio, *label, *content, *alignment; GtkWidget *hbox, *image; gint response; NMAMobileWizardAccessMethod method; info = g_malloc0 (sizeof (WizardInfo)); info->result_func = result_func; info->settings = g_object_ref (settings); info->user_data = user_data; wizard = nma_mobile_wizard_new (parent, NULL, NM_DEVICE_MODEM_CAPABILITY_NONE, FALSE, new_connection_mobile_wizard_done, info); if (wizard) { nma_mobile_wizard_present (wizard); return; } /* Fall back to just asking for GSM vs. CDMA */ dialog = gtk_dialog_new_with_buttons (_("Select Mobile Broadband Provider Type"), parent, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect (dialog, "delete-event", G_CALLBACK (cancel_dialog), NULL); gtk_window_set_icon_name (GTK_WINDOW (dialog), "nm-device-wwan"); content = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); alignment = gtk_alignment_new (0, 0, 0.5, 0.5); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); gtk_box_pack_start (GTK_BOX (content), alignment, TRUE, FALSE, 6); #if GTK_CHECK_VERSION (3,1,6) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else hbox = gtk_hbox_new (FALSE, 6); #endif gtk_container_add (GTK_CONTAINER (alignment), hbox); image = gtk_image_new_from_icon_name ("nm-device-wwan", GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0); gtk_misc_set_padding (GTK_MISC (image), 0, 6); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 6); #if GTK_CHECK_VERSION (3,1,6) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, FALSE, 0); label = gtk_label_new (_("Select the technology your mobile broadband provider uses. If you are unsure, ask your provider.")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 12); gsm_radio = gtk_radio_button_new_with_mnemonic (NULL, _("My provider uses _GSM-based technology (i.e. GPRS, EDGE, UMTS, HSDPA)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gsm_radio), TRUE); gtk_box_pack_start (GTK_BOX (vbox), gsm_radio, FALSE, FALSE, 6); /* Translators: CDMA has 'D' accelerator key; 'C' collides with 'Cancel' button. You may need to change it according to your language. */ cdma_radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (gsm_radio), _("My provider uses C_DMA-based technology (i.e. 1xRTT, EVDO)")); gtk_box_pack_start (GTK_BOX (vbox), cdma_radio, FALSE, FALSE, 6); gtk_widget_show_all (dialog); memset (&method, 0, sizeof (method)); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cdma_radio))) { method.devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO; method.provider_name = _("CDMA"); } else { method.devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS; method.provider_name = _("GSM"); } } gtk_widget_destroy (dialog); new_connection_mobile_wizard_done (NULL, (response != GTK_RESPONSE_OK), (response == GTK_RESPONSE_OK) ? &method : NULL, info); }
static void moko_history_init (MokoHistory *history) { MokoHistoryPrivate *priv; GtkIconTheme *theme; gint i; GtkListStore *store; GtkTreeIter iter; GtkWidget *toolbar, *combo, *image, *scroll; GtkToolItem *item; GtkCellRenderer *renderer; GdkPixbuf *icon; priv = history->priv = MOKO_HISTORY_GET_PRIVATE (history); /* Create the icons */ theme = gtk_icon_theme_get_default (); for (i = 0; i < N_CALL_TYPES; i++) { icons[i] = gtk_icon_theme_load_icon (theme, icon_names[i], GTK_ICON_SIZE_MENU, 0, NULL); } /* Toolbar */ toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (history), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_DIAL, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Dial"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (on_dial_clicked), (gpointer)history); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->dial_button = item; image = gtk_image_new_from_icon_name (MOKO_STOCK_SMS_NEW, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "SMS"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (on_sms_clicked), (gpointer)history); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->sms_button = item; image = gtk_image_new_from_icon_name (MOKO_STOCK_CONTACT_NEW, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Contact"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_save_clicked), history); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->save_button = item; item = gtk_tool_button_new_from_stock (GTK_STOCK_DELETE); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (on_delete_clicked), (gpointer)history); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->delete_button = item; /* Filter combo */ store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); gtk_list_store_insert_with_values (store, &iter, 0, 0, icons[CALL_INCOMING], 1, "Call History - Received", 2, HISTORY_FILTER_RECEIVED, -1); gtk_list_store_insert_with_values (store, &iter, 0, 0, icons[CALL_OUTGOING], 1, "Call History - Dialed", 2, HISTORY_FILTER_DIALED, -1); gtk_list_store_insert_with_values (store, &iter, 0, 0, icons[CALL_MISSED], 1, "Call History - Missed", 2, HISTORY_FILTER_MISSED, -1); icon = gtk_icon_theme_load_icon (theme, MOKO_STOCK_CALL_HISTORY, GTK_ICON_SIZE_MENU, 0, NULL); gtk_list_store_insert_with_values (store, &iter, 0, 0, icon, 1, "Call History - All", 2, HISTORY_FILTER_ALL, -1); /* add to contact/save menu */ GtkWidget *menu_item; priv->save_menu = gtk_menu_new (); gtk_menu_attach_to_widget (GTK_MENU (priv->save_menu), GTK_WIDGET (priv->save_button), NULL); menu_item = gtk_menu_item_new_with_label ("New Contact"); gtk_menu_shell_append (GTK_MENU_SHELL (priv->save_menu), menu_item); menu_item = gtk_menu_item_new_with_label ("Add to Contact"); gtk_menu_shell_append (GTK_MENU_SHELL (priv->save_menu), menu_item); gtk_widget_show_all (priv->save_menu); /* filter combo */ combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); priv->combo = combo; gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_filter_changed), history); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "pixbuf", 0, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "xpad", 10, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 1, NULL); gtk_box_pack_start (GTK_BOX (history), combo, FALSE, FALSE, 0); /* Treeview */ scroll = moko_finger_scroll_new (); gtk_box_pack_start (GTK_BOX (history), scroll, TRUE, TRUE, 0); priv->treeview = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->treeview), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_container_add (GTK_CONTAINER (scroll), priv->treeview); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)), "changed", G_CALLBACK (on_tree_selection_changed), history); gtk_widget_show_all (GTK_WIDGET (history)); }
DialogSimulator * dialog_simulator_new () { register int i; register DialogSimulator *dlg; char *str_item_bar[N_DIALOG_SIMULATOR_ITEM_BAR] = { gettext ("_Channel"), gettext ("_Simulate"), gettext ("_Graphical"), gettext ("_Help") }, *str_item_system[N_DIALOG_SIMULATOR_ITEM_SYSTEM] = { gettext ("_New"), gettext ("_Open"), gettext ("_Edit"), gettext ("_Save"), gettext ("S_ave as"), NULL, gettext ("E_xit")}, *str_item_simulate[N_DIALOG_SIMULATOR_ITEM_SIMULATE] = { gettext ("_Start"), gettext ("Sto_p"), NULL, gettext ("Conse_rvation error"), NULL, gettext ("Sa_ve solution"), gettext ("Save _graphical")}, *str_item_graphic[N_DIALOG_SIMULATOR_ITEM_GRAPHIC] = { gettext ("_Options"), NULL, gettext ("_View animation"), gettext ("_Stop animation")}, *str_item_help[N_DIALOG_SIMULATOR_ITEM_HELP] = { gettext ("_Help"), gettext ("_About")}, *str_buttons[N_DIALOG_SIMULATOR_BUTTONS] = { gettext ("Exit"), NULL, gettext ("New system"), gettext ("Open system"), gettext ("Edit system"), gettext ("Save system"), gettext ("Save system as"), NULL, gettext ("Start simulation"), gettext ("Stop simulation"), gettext ("Conservation error"), gettext ("Save solution"), gettext ("Save graphical"), NULL, gettext ("Graphical options"), gettext ("View animation"), gettext ("Stop animation"), NULL, gettext ("Help"), gettext ("About")}, *image_buttons[N_DIALOG_SIMULATOR_BUTTONS] = { "application-exit", NULL, "document-new", "document-open", "document-properties", "document-save", "document-save-as", NULL, "system-run", "process-stop", "dialog-information", "document-revert", "document-print", NULL, "preferences-system", "call-start", "call-stop", NULL, "help-browser", "help-about"}; dlg = (DialogSimulator *) g_try_malloc (sizeof (DialogSimulator)); if (!dlg) return 0; dlg->menu = (GtkMenuBar *) gtk_menu_bar_new (); for (i = 0; i < N_DIALOG_SIMULATOR_ITEM_BAR; ++i) { if (str_item_bar[i]) dlg->item_bar[i] = (GtkMenuItem *) gtk_menu_item_new_with_mnemonic (str_item_bar[i]); else dlg->item_bar[i] = (GtkMenuItem *) gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (dlg->menu), GTK_WIDGET (dlg->item_bar[i])); } dlg->menu_system = (GtkMenu *) gtk_menu_new (); for (i = 0; i < N_DIALOG_SIMULATOR_ITEM_SYSTEM; ++i) { if (str_item_system[i]) dlg->item_system[i] = (GtkMenuItem *) gtk_menu_item_new_with_mnemonic (str_item_system[i]); else dlg->item_system[i] = (GtkMenuItem *) gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (dlg->menu_system), GTK_WIDGET (dlg->item_system[i])); } gtk_menu_item_set_submenu (dlg->item_bar[0], GTK_WIDGET (dlg->menu_system)); dlg->menu_simulate = (GtkMenu *) gtk_menu_new (); for (i = 0; i < N_DIALOG_SIMULATOR_ITEM_SIMULATE; ++i) { if (str_item_simulate[i]) dlg->item_simulate[i] = (GtkMenuItem *) gtk_menu_item_new_with_mnemonic (str_item_simulate[i]); else dlg->item_simulate[i] = (GtkMenuItem *) gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (dlg->menu_simulate), GTK_WIDGET (dlg->item_simulate[i])); } gtk_menu_item_set_submenu (dlg->item_bar[1], GTK_WIDGET (dlg->menu_simulate)); dlg->menu_graphic = (GtkMenu *) gtk_menu_new (); for (i = 0; i < N_DIALOG_SIMULATOR_ITEM_GRAPHIC; ++i) { if (str_item_graphic[i]) dlg->item_graphic[i] = (GtkMenuItem *) gtk_menu_item_new_with_mnemonic (str_item_graphic[i]); else dlg->item_graphic[i] = (GtkMenuItem *) gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (dlg->menu_graphic), GTK_WIDGET (dlg->item_graphic[i])); } gtk_menu_item_set_submenu (dlg->item_bar[2], GTK_WIDGET (dlg->menu_graphic)); dlg->menu_help = (GtkMenu *) gtk_menu_new (); for (i = 0; i < N_DIALOG_SIMULATOR_ITEM_HELP; ++i) { if (str_item_help[i]) dlg->item_help[i] = (GtkMenuItem *) gtk_menu_item_new_with_mnemonic (str_item_help[i]); else dlg->item_help[i] = (GtkMenuItem *) gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (dlg->menu_help), GTK_WIDGET (dlg->item_help[i])); } gtk_menu_item_set_submenu (dlg->item_bar[3], GTK_WIDGET (dlg->menu_help)); dlg->toolbar = (GtkToolbar *) gtk_toolbar_new (); for (i = 0; i < N_DIALOG_SIMULATOR_BUTTONS; ++i) { if (str_buttons[i]) { dlg->button[i] = (GtkToolItem *) gtk_tool_button_new (gtk_image_new_from_icon_name (image_buttons[i], GTK_ICON_SIZE_SMALL_TOOLBAR), str_buttons[i]); gtk_widget_set_tooltip_text (GTK_WIDGET (dlg->button[i]), str_buttons[i]); } else dlg->button[i] = (GtkToolItem *) gtk_separator_tool_item_new (); gtk_toolbar_insert (dlg->toolbar, dlg->button[i], -1); } dlg->graphic = jbw_graphic_new (0, 6, 6, 6, draw_graphic); jbw_graphic_set_logo (dlg->graphic, "swigs.png"); dlg->label_simulation = (GtkLabel *) gtk_label_new (gettext ("Simulation time")); dlg->progress_simulation = (GtkProgressBar *) gtk_progress_bar_new (); dlg->label_cpu = (GtkLabel *) gtk_label_new (gettext ("Computational time")); gtk_widget_set_sensitive (GTK_WIDGET (dlg->label_cpu), 0); dlg->entry_cpu = (JBWFloatEntry *) jbw_float_entry_new (); dlg->label_error = (GtkLabel *) gtk_label_new (gettext ("Conservation error")); dlg->entry_error = (JBWFloatEntry *) jbw_float_entry_new (); dlg->box_bar = (GtkGrid *) gtk_grid_new (); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->label_simulation), 0, 0, 1, 1); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->progress_simulation), 1, 0, 1, 1); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->label_cpu), 2, 0, 1, 1); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->entry_cpu), 3, 0, 1, 1); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->label_error), 4, 0, 1, 1); gtk_grid_attach (dlg->box_bar, GTK_WIDGET (dlg->entry_error), 5, 0, 1, 1); dlg->button_bar = (GtkButton *) gtk_button_new (); gtk_container_add (GTK_CONTAINER (dlg->button_bar), GTK_WIDGET (dlg->box_bar)); gtk_widget_set_sensitive (GTK_WIDGET (dlg->button_bar), 0); dlg->box = (GtkGrid *) gtk_grid_new (); gtk_grid_attach (dlg->box, GTK_WIDGET (dlg->menu), 0, 0, 1, 1); gtk_grid_attach (dlg->box, GTK_WIDGET (dlg->toolbar), 0, 1, 1, 1); gtk_grid_attach (dlg->box, GTK_WIDGET (dlg->button_bar), 0, 2, 1, 1); dlg->pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (gtk_image_new_from_file ("logo.png"))); dlg->window = (GtkWindow *) gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (dlg->window, "SWIGS"); gtk_window_set_icon (dlg->window, dlg->pixbuf); gtk_container_add (GTK_CONTAINER (dlg->window), GTK_WIDGET (dlg->box)); gtk_widget_show_all (GTK_WIDGET (dlg->window)); #if JBW_GRAPHIC==JBW_GRAPHIC_GLUT g_signal_connect (dlg->window, "destroy", glutLeaveMainLoop, NULL); #else g_signal_connect (dlg->window, "destroy", gtk_main_quit, NULL); #endif g_signal_connect (dlg->item_system[0], "activate", dialog_simulator_new_system, 0); g_signal_connect_swapped (dlg->item_system[1], "activate", (void (*)) dialog_open_system_new, dialog_open_system); g_signal_connect (dlg->item_system[2], "activate", dialog_simulator_edit, 0); g_signal_connect_swapped (dlg->item_system[3], "activate", (void (*)) system_save_xml, sys); g_signal_connect (dlg->item_system[4], "activate", dialog_simulator_save_as, 0); g_signal_connect (dlg->item_system[6], "activate", (void (*)) exit, 0); g_signal_connect_swapped (dlg->item_simulate[0], "activate", (void (*)) dialog_simulator_start, dlg); g_signal_connect (dlg->item_simulate[1], "activate", dialog_simulator_stop, 0); g_signal_connect (dlg->item_simulate[3], "activate", dialog_simulator_mass, 0); g_signal_connect (dlg->item_simulate[5], "activate", dialog_save_solution_new, 0); g_signal_connect (dlg->item_simulate[6], "activate", dialog_save_graphical_new, 0); g_signal_connect_swapped (dlg->item_graphic[0], "activate", (void (*)) dialog_graphical_options_new, dlg->window); g_signal_connect_swapped (dlg->item_graphic[2], "activate", (void *) dialog_simulator_animate, dlg); g_signal_connect (dlg->item_graphic[3], "activate", dialog_simulator_stop, 0); g_signal_connect_swapped (dlg->item_help[0], "activate", dialog_simulator_help, dlg); g_signal_connect_swapped (dlg->item_help[1], "activate", dialog_simulator_about, dlg); g_signal_connect (dlg->button[0], "clicked", (void (*)) exit, 0); g_signal_connect (dlg->button[2], "clicked", dialog_simulator_new_system, 0); g_signal_connect_swapped (dlg->button[3], "clicked", (void (*)) dialog_open_system_new, dialog_open_system); g_signal_connect (dlg->button[4], "clicked", dialog_simulator_edit, 0); g_signal_connect_swapped (dlg->button[5], "clicked", (void (*)) system_save_xml, sys); g_signal_connect (dlg->button[6], "clicked", dialog_simulator_save_as, 0); g_signal_connect_swapped (dlg->button[8], "clicked", (void (*)) dialog_simulator_start, dlg); g_signal_connect (dlg->button[9], "clicked", dialog_simulator_stop, 0); g_signal_connect (dlg->button[10], "clicked", dialog_simulator_mass, 0); g_signal_connect (dlg->button[11], "clicked", dialog_save_solution_new, 0); g_signal_connect (dlg->button[12], "clicked", dialog_save_graphical_new, 0); g_signal_connect_swapped (dlg->button[14], "clicked", (void (*)) dialog_graphical_options_new, dlg->window); g_signal_connect_swapped (dlg->button[15], "clicked", (void *) dialog_simulator_animate, dlg); g_signal_connect (dlg->button[16], "clicked", dialog_simulator_stop, 0); g_signal_connect_swapped (dlg->button[18], "clicked", (void (*)) dialog_simulator_help, dlg); g_signal_connect_swapped (dlg->button[19], "clicked", (void (*)) dialog_simulator_about, dlg); dialog_simulator_actualize (dlg); window_parent = dlg->window; return dlg; }
static void empathy_password_dialog_constructed (GObject *object) { EmpathyPasswordDialog *dialog; EmpathyPasswordDialogPriv *priv; TpAccount *account; GtkWidget *icon; GtkBox *box; gchar *text; dialog = EMPATHY_PASSWORD_DIALOG (object); priv = dialog->priv; g_assert (priv->handler != NULL); priv->grabbing = FALSE; account = empathy_server_sasl_handler_get_account (priv->handler); tp_g_signal_connect_object (priv->handler, "invalidated", G_CALLBACK (password_dialog_handler_invalidated_cb), object, 0); /* dialog */ gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); priv->ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_widget_set_sensitive (priv->ok_button, FALSE); text = g_strdup_printf (_("Enter your password for account\n<b>%s</b>"), tp_account_get_display_name (account)); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), text); g_free (text); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION); box = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))); /* dialog icon */ icon = gtk_image_new_from_icon_name (tp_account_get_icon_name (account), GTK_ICON_SIZE_DIALOG); gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), icon); gtk_widget_show (icon); /* entry */ priv->entry = gtk_entry_new (); gtk_entry_set_visibility (GTK_ENTRY (priv->entry), FALSE); /* entry clear icon */ gtk_entry_set_icon_from_stock (GTK_ENTRY (priv->entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_sensitive (GTK_ENTRY (priv->entry), GTK_ENTRY_ICON_SECONDARY, FALSE); g_signal_connect (priv->entry, "icon-release", G_CALLBACK (clear_icon_released_cb), NULL); g_signal_connect (priv->entry, "changed", G_CALLBACK (password_entry_changed_cb), dialog); g_signal_connect (priv->entry, "activate", G_CALLBACK (password_entry_activate_cb), dialog); gtk_box_pack_start (box, priv->entry, FALSE, FALSE, 0); gtk_widget_show (priv->entry); /* remember password ticky box */ priv->ticky = gtk_check_button_new_with_label (_("Remember password")); gtk_box_pack_start (box, priv->ticky, FALSE, FALSE, 0); /* only show it if we actually support it */ if (empathy_server_sasl_handler_can_save_response_somewhere (priv->handler)) gtk_widget_show (priv->ticky); g_signal_connect (dialog, "response", G_CALLBACK (password_dialog_response_cb), dialog); g_signal_connect (dialog, "window-state-event", G_CALLBACK (password_dialog_window_state_changed), dialog); g_signal_connect (dialog, "map-event", G_CALLBACK (password_dialog_grab_keyboard), dialog); g_signal_connect (dialog, "unmap-event", G_CALLBACK (password_dialog_ungrab_keyboard), dialog); gtk_widget_grab_focus (priv->entry); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ALWAYS); }
GtkWidget *gui_cardview_create_window(GtkAccelGroup *accel_group) { GtkCellRenderer *renderer; GtkWidget *scrolled_window; GtkTreeViewColumn *column; GtkWidget *base_container; GtkWidget *toolbar; GtkWidget *colheader; GtkWidget *colitem; /* Create base window container */ base_container = gtk_box_new(GTK_ORIENTATION_VERTICAL,0); /* Create the toolbar */ TB_CARD_VIEW[0].callback_data = create_analyzer_menu(accel_group); toolbar = gui_toolbar_new(TB_CARD_VIEW); gtk_box_pack_start (GTK_BOX (base_container), toolbar, FALSE, FALSE, 0); /* Create a new scrolled window, with scrollbars only if needed */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_end (GTK_BOX (base_container), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); CARDVIEW = gtk_tree_view_new (); g_signal_connect(CARDVIEW, "button-press-event", (GCallback) menu_cardview_button_press_event, NULL); g_signal_connect(CARDVIEW, "key-press-event", (GCallback) menu_cardview_key_press_event, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), CARDVIEW); /* --- Column #0 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,"Items"); gtk_tree_view_column_set_resizable(column,TRUE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, internal_cell_renderer_icon_cb, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, internal_cell_renderer_markup_cb, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(CARDVIEW), column); /* --- Column #1 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,"Size"); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, internal_cell_renderer_size_cb, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(CARDVIEW), column); g_object_set(renderer, "foreground", "blue", NULL); /* --- Column #2 --- */ renderer = custom_cell_renderer_flexi_new(TRUE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (CARDVIEW), -1, NULL, renderer, "raw-value", CC_VAL, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW (CARDVIEW),2); gtk_tree_view_column_set_resizable(column,TRUE); gtk_tree_view_column_set_visible (column,FALSE); gtk_tree_view_column_set_clickable(column,TRUE); g_signal_connect(column,"clicked",(GCallback)menu_cardview_column_activated,NULL); colheader = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,10); gtk_box_pack_start (GTK_BOX (colheader), gtk_label_new("Raw value"), FALSE, FALSE, 0); if ((colitem = gtk_image_new_from_icon_name("gtk-convert",GTK_ICON_SIZE_MENU))) { gtk_box_pack_start (GTK_BOX (colheader), colitem, FALSE, FALSE, 0); } gtk_widget_show_all(colheader); gtk_widget_set_tooltip_text(colheader,"Click to switch to 'interpreted' data."); gtk_tree_view_column_set_widget(column,colheader); /* --- Column #3 --- */ renderer = custom_cell_renderer_flexi_new(FALSE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (CARDVIEW), -1, NULL, renderer, "raw-value", CC_VAL, "alt_text", CC_ALT, "mime-type", CC_MIME_TYPE, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW (CARDVIEW),3); gtk_tree_view_column_set_resizable(column,TRUE); gtk_tree_view_column_set_clickable(column,TRUE); g_signal_connect(column,"clicked",(GCallback)menu_cardview_column_activated,NULL); colheader = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,10); gtk_box_pack_start (GTK_BOX (colheader), gtk_label_new("Interpreted value"), FALSE, FALSE, 0); if ((colitem = gtk_image_new_from_icon_name("gtk-convert",GTK_ICON_SIZE_MENU))) { gtk_box_pack_start (GTK_BOX (colheader), colitem, FALSE, FALSE, 0); } gtk_widget_show_all(colheader); gtk_widget_set_tooltip_text(colheader,"Click to switch to 'raw' data."); gtk_tree_view_column_set_widget(column,colheader); /* add the dat model */ /* CARD_DATA_STORE = */ dyntree_model_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(CARDVIEW),GTK_TREE_MODEL(CARD_DATA_STORE)); g_object_unref(CARD_DATA_STORE); return base_container; }
static GtkWidget * gimp_prop_kelvin_presets_new (GObject *config, const gchar *property_name) { GtkWidget *button; GtkWidget *menu; gint i; const struct { gdouble kelvin; const gchar *label; } kelvin_presets[] = { { 1700, N_("1,700 K – Match flame") }, { 1850, N_("1,850 K – Candle flame, sunset/sunrise") }, { 3000, N_("3,000 K – Soft (or warm) white compact fluorescent lamps") }, { 3000, N_("3,300 K – Incandescent lamps") }, { 3200, N_("3,200 K – Studio lamps, photofloods, etc.") }, { 3350, N_("3,350 K – Studio \"CP\" light") }, { 4100, N_("4,100 K – Moonlight") }, { 5000, N_("5,000 K – D50") }, { 5000, N_("5,000 K – Cool white/daylight compact fluorescent lamps") }, { 5000, N_("5,000 K – Horizon daylight") }, { 5500, N_("5,500 K – D55") }, { 5500, N_("5,500 K – Vertical daylight, electronic flash") }, { 6200, N_("6,200 K – Xenon short-arc lamp") }, { 6500, N_("6,500 K – D65") }, { 6500, N_("6,500 K – Daylight, overcast") }, { 7500, N_("7,500 K – D75") }, { 9300, N_("9,300 K") } }; button = gtk_button_new (); gtk_widget_set_can_focus (button, FALSE); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name (GIMP_STOCK_MENU_LEFT, GTK_ICON_SIZE_MENU)); menu = gtk_menu_new (); gtk_menu_attach_to_widget (GTK_MENU (menu), button, NULL); g_signal_connect (button, "button-press-event", G_CALLBACK (gimp_prop_kelvin_presets_button_press), menu); for (i = 0; i < G_N_ELEMENTS (kelvin_presets); i++) { GtkWidget *item; gdouble *kelvin; item = gtk_menu_item_new_with_label (gettext (kelvin_presets[i].label)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); g_object_set_data_full (G_OBJECT (item), "property-name", g_strdup (property_name), (GDestroyNotify) g_free); kelvin = g_new (gdouble, 1); *kelvin = kelvin_presets[i].kelvin; g_object_set_data_full (G_OBJECT (item), "kelvin", kelvin, (GDestroyNotify) g_free); g_signal_connect (item, "activate", G_CALLBACK (gimp_prop_kelvin_presets_activate), config); } return button; }
static GtkWidget *create_status_picture(LinphoneOnlineStatus ss, GtkIconSize icon_size){ const char *icon_name = status_to_icon_name(ss); if(icon_name) return gtk_image_new_from_icon_name(icon_name, icon_size); else return NULL; }
static void interactive_dialog_clicked (GtkButton *button, gpointer user_data) { GtkWidget *content_area; GtkWidget *dialog; GtkWidget *hbox; GtkWidget *image; GtkWidget *table; GtkWidget *local_entry1; GtkWidget *local_entry2; GtkWidget *label; gint response; dialog = gtk_dialog_new_with_buttons ("Interactive Dialog", GTK_WINDOW (window), GTK_DIALOG_MODAL| GTK_DIALOG_DESTROY_WITH_PARENT, _("_OK"), GTK_RESPONSE_OK, "_Cancel", GTK_RESPONSE_CANCEL, NULL); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); gtk_container_set_border_width (GTK_CONTAINER (hbox), 8); gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name ("dialog-question", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); table = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (table), 4); gtk_grid_set_column_spacing (GTK_GRID (table), 4); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); label = gtk_label_new_with_mnemonic ("_Entry 1"); gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1); local_entry1 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (local_entry1), gtk_entry_get_text (GTK_ENTRY (entry1))); gtk_grid_attach (GTK_GRID (table), local_entry1, 1, 0, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), local_entry1); label = gtk_label_new_with_mnemonic ("E_ntry 2"); gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1); local_entry2 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (local_entry2), gtk_entry_get_text (GTK_ENTRY (entry2))); gtk_grid_attach (GTK_GRID (table), local_entry2, 1, 1, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), local_entry2); gtk_widget_show_all (hbox); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { gtk_entry_set_text (GTK_ENTRY (entry1), gtk_entry_get_text (GTK_ENTRY (local_entry1))); gtk_entry_set_text (GTK_ENTRY (entry2), gtk_entry_get_text (GTK_ENTRY (local_entry2))); } gtk_widget_destroy (dialog); }
static void place_widgets (MateWeatherApplet *gw_applet) { GtkRequisition req; int total_size = 0; gboolean horizontal = FALSE; int panel_size = gw_applet->size; const gchar *temp; const gchar *icon_name; switch (gw_applet->orient) { case MATE_PANEL_APPLET_ORIENT_LEFT: case MATE_PANEL_APPLET_ORIENT_RIGHT: horizontal = FALSE; break; case MATE_PANEL_APPLET_ORIENT_UP: case MATE_PANEL_APPLET_ORIENT_DOWN: horizontal = TRUE; break; } /* Create the weather icon */ icon_name = weather_info_get_icon_name (gw_applet->mateweather_info); gw_applet->image = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_BUTTON); if (icon_name != NULL) { gtk_widget_size_request(gw_applet->image, &req); if (horizontal) total_size += req.height; else total_size += req.width; } /* Create the temperature label */ gw_applet->label = gtk_label_new("0\302\260F"); /* Update temperature text */ temp = weather_info_get_temp_summary(gw_applet->mateweather_info); if (temp) gtk_label_set_text(GTK_LABEL(gw_applet->label), temp); /* Check the label size to determine box layout */ gtk_widget_size_request(gw_applet->label, &req); if (horizontal) total_size += req.height; else total_size += req.width; /* Pack the box */ if (gw_applet->box) gtk_widget_destroy (gw_applet->box); if (horizontal && (total_size <= panel_size)) gw_applet->box = gtk_vbox_new(FALSE, 0); else if (horizontal && (total_size > panel_size)) gw_applet->box = gtk_hbox_new(FALSE, 2); else if (!horizontal && (total_size <= panel_size)) gw_applet->box = gtk_hbox_new(FALSE, 2); else gw_applet->box = gtk_vbox_new(FALSE, 0); /* Rebuild the applet it's visual area */ gtk_container_add (GTK_CONTAINER (gw_applet->container), gw_applet->box); gtk_box_pack_start (GTK_BOX (gw_applet->box), gw_applet->image, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (gw_applet->box), gw_applet->label, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (gw_applet->applet)); }
gint main (gint argc, gchar **argv) { GTask *task; GCancellable *cancellable; gchar *file = NULL, *oper = NULL; const gchar *title = NULL; gint ii; GError *error = NULL; #ifdef G_OS_WIN32 e_util_win32_initialize (); #endif bindtextdomain (GETTEXT_PACKAGE, EVOLUTION_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init_with_args ( &argc, &argv, NULL, options, GETTEXT_PACKAGE, &error); if (error != NULL) { g_printerr ("%s\n", error->message); g_error_free (error); exit (EXIT_FAILURE); } if (opt_remaining != NULL) { for (ii = 0; ii < g_strv_length (opt_remaining); ii++) { if (backup_op) { title = _("Evolution Back Up"); oper = _("Backing up to the file %s"); bk_file = g_strdup ((gchar *) opt_remaining[ii]); file = bk_file; } else if (restore_op) { title = _("Evolution Restore"); oper = _("Restoring from the file %s"); res_file = g_strdup ((gchar *) opt_remaining[ii]); file = res_file; } else if (check_op) { d (g_message ("Checking %s", (gchar *) opt_remaining[ii])); chk_file = g_strdup ((gchar *) opt_remaining[ii]); } } } cancellable = g_cancellable_new (); if (gui_arg && !check_op) { GtkWidget *widget, *container; GtkWidget *action_area; GtkWidget *content_area; const gchar *txt, *txt2; gchar *str = NULL; gchar *markup; gtk_window_set_default_icon_name ("evolution"); /* Backup / Restore only can have GUI. * We should restrict the rest. */ progress_dialog = gtk_dialog_new_with_buttons ( title, NULL, GTK_DIALOG_MODAL, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); gtk_container_set_border_width ( GTK_CONTAINER (progress_dialog), 12); action_area = gtk_dialog_get_action_area ( GTK_DIALOG (progress_dialog)); content_area = gtk_dialog_get_content_area ( GTK_DIALOG (progress_dialog)); /* Override GtkDialog defaults */ gtk_box_set_spacing (GTK_BOX (content_area), 12); gtk_container_set_border_width (GTK_CONTAINER (content_area), 0); gtk_box_set_spacing (GTK_BOX (action_area), 12); gtk_container_set_border_width (GTK_CONTAINER (action_area), 0); if (oper && file) str = g_strdup_printf (oper, file); container = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (container), 6); gtk_grid_set_row_spacing (GTK_GRID (container), 0); gtk_widget_show (container); gtk_box_pack_start ( GTK_BOX (content_area), container, FALSE, TRUE, 0); widget = gtk_image_new_from_icon_name ( "edit-copy", GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0); gtk_widget_show (widget); gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 1, 3); g_object_set ( G_OBJECT (widget), "halign", GTK_ALIGN_FILL, "valign", GTK_ALIGN_FILL, "vexpand", TRUE, NULL); if (backup_op) { txt = _("Backing up Evolution Data"); txt2 = _("Please wait while Evolution is backing up your data."); } else if (restore_op) { txt = _("Restoring Evolution Data"); txt2 = _("Please wait while Evolution is restoring your data."); } else { g_return_val_if_reached (EXIT_FAILURE); } markup = g_markup_printf_escaped ("<b><big>%s</big></b>", txt); widget = gtk_label_new (markup); gtk_label_set_line_wrap (GTK_LABEL (widget), FALSE); gtk_label_set_use_markup (GTK_LABEL (widget), TRUE); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0); gtk_widget_show (widget); g_free (markup); gtk_grid_attach (GTK_GRID (container), widget, 1, 0, 1, 1); g_object_set ( G_OBJECT (widget), "halign", GTK_ALIGN_FILL, "hexpand", TRUE, "valign", GTK_ALIGN_FILL, NULL); markup = g_strconcat ( txt2, " ", _("This may take a while depending " "on the amount of data in your account."), NULL); widget = gtk_label_new (markup); gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); gtk_widget_show (widget); g_free (markup); gtk_grid_attach (GTK_GRID (container), widget, 1, 1, 1, 1); g_object_set ( G_OBJECT (widget), "halign", GTK_ALIGN_FILL, "hexpand", TRUE, "valign", GTK_ALIGN_FILL, NULL); pbar = gtk_progress_bar_new (); if (str != NULL) { markup = g_markup_printf_escaped ("<i>%s</i>", str); widget = gtk_label_new (markup); gtk_label_set_use_markup (GTK_LABEL (widget), TRUE); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); g_free (markup); g_free (str); gtk_grid_attach (GTK_GRID (container), widget, 1, 2, 1, 1); g_object_set ( G_OBJECT (widget), "halign", GTK_ALIGN_FILL, "hexpand", TRUE, "valign", GTK_ALIGN_FILL, NULL); gtk_grid_attach (GTK_GRID (container), pbar, 1, 3, 1, 1); } else gtk_grid_attach (GTK_GRID (container), pbar, 1, 2, 1, 1); g_object_set ( G_OBJECT (pbar), "halign", GTK_ALIGN_FILL, "hexpand", TRUE, "valign", GTK_ALIGN_FILL, NULL); g_signal_connect ( progress_dialog, "response", G_CALLBACK (dlg_response), cancellable); gtk_widget_show_all (progress_dialog); } else if (check_op) { /* For sanity we don't need gui */ check (chk_file, NULL); exit (result == 0 ? 0 : 1); } if (gui_arg) { e_named_timeout_add_full ( G_PRIORITY_DEFAULT, 50, pbar_update, g_object_ref (cancellable), (GDestroyNotify) g_object_unref); } task = g_task_new (cancellable, cancellable, NULL, NULL); g_task_run_in_thread (task, start_job); g_object_unref (task); gtk_main (); g_object_unref (cancellable); e_util_cleanup_settings (); return result; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; gchar *build_date; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany"); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); gtk_widget_set_state(header_eventbox, GTK_STATE_SELECTED); gtk_widget_set_state(header_label, GTK_STATE_SELECTED); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0); /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); build_date = utils_parse_and_format_build_date(__DATE__); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date); g_free(build_date); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
static void gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass) { GtkWidget *grid; GtkWidget *label; GtkWidget *exp; gchar *str; g_return_if_fail (GDAUI_IS_DSN_EDITOR (config)); gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL); /* allocate private structure */ config->priv = g_new0 (GdauiDsnEditorPrivate, 1); config->priv->dsn_info = g_new0 (GdaDsnInfo, 1); config->priv->no_change_signal = TRUE; /* data source's name and icon */ GtkWidget *hbox_header; hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6); config->priv->icon = gtk_image_new (); gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0); config->priv->wname = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10); GtkWidget *menu_button; menu_button = gtk_menu_button_new (); gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0); GtkWidget *menu_icon; menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon); GMenu *smenu; smenu = g_menu_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu)); GMenuItem *mitem; mitem = g_menu_item_new ("Test data source", "win.DSNTest"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy"); g_menu_insert_item (smenu, -1, mitem); GtkWindow *win; win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config); /* stack in a scrolled window */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6); /* Stack */ config->priv->stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_container_add (GTK_CONTAINER (sw), config->priv->stack); /* set up widgets */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_widget_show (grid); label = gtk_label_new_with_mnemonic (_("_System wide data source:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); config->priv->is_system = gtk_check_button_new (); gtk_widget_show (config->priv->is_system); g_signal_connect (G_OBJECT (config->priv->is_system), "toggled", G_CALLBACK (field_toggled_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1); str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:")); label = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); config->priv->wprovider = gdaui_provider_selector_new (); gtk_widget_set_hexpand (config->priv->wprovider, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider); gtk_widget_show (config->priv->wprovider); g_signal_connect (G_OBJECT (config->priv->wprovider), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1); label = gtk_label_new_with_mnemonic (_("_Description:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); config->priv->wdesc = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc); gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE); gtk_widget_set_vexpand (config->priv->wdesc, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc); g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1); config->priv->warning = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (config->priv->warning), _("<span foreground='red'>The database provider used by this data source is not available,\n" "editing the data source's attributes is disabled</span>")); gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER); gtk_widget_set_hexpand (config->priv->warning, TRUE); g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL); gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE); gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1); gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION); /* connection's spec */ config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_spec); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS); /* connection's authentication */ config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_auth); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH); config->priv->no_change_signal = FALSE; }
static void add_route_row (CEPageIP6 *page, const gchar *address, gint prefix, const gchar *gateway, gint metric) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); if (prefix > 0) { gchar *s = g_strdup_printf ("%d", prefix); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); /* Translators: Please see https://en.wikipedia.org/wiki/Metrics_(networking) */ label = gtk_label_new (C_("network parameters", "Metric")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 4, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "metric", widget); if (metric > 0) { gchar *s = g_strdup_printf ("%d", metric); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 4, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Route")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 1, 1, 4); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_left (row_grid, 10); gtk_widget_set_margin_right (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->routes_list), row); update_row_sensitivity (page, page->routes_list); }
gboolean clock_check(gpointer dummy) { if (dummy) {}; int xneur_pid = -1; char *ps_command = (char *) malloc(1024 * sizeof(char)); if (xneur_old_pid == -1) xneur_old_pid = 1; snprintf(ps_command, 1024, "ps -p %d | grep xneur", xneur_old_pid); FILE *fp = popen(ps_command, "r"); free (ps_command); if (fp != NULL) { char buffer[NAME_MAX]; if (fgets(buffer, NAME_MAX, fp) != NULL) xneur_pid = xneur_old_pid; pclose(fp); } if (xneur_pid == -1) xneur_pid = xconfig->get_pid(xconfig); int xneur_state = xconfig->manual_mode; int xneur_group = get_active_kbd_group(dpy); if (get_kbd_group_count(dpy) != xconfig->handle->total_languages) { for (int i = 0; i < MAX_LAYOUTS; i++) { if (tray->images[i] != NULL) g_free(tray->images[i]); } gtk_widget_destroy(GTK_WIDGET(tray->menu)); tray->menu = NULL; g_spawn_command_line_async(PACKAGE, NULL); gtk_main_quit(); } if (xneur_pid == xneur_old_pid && xneur_state == xneur_old_state && xneur_group == xneur_old_group && force_update == FALSE) return TRUE; force_update = FALSE; xneur_old_pid = xneur_pid; xneur_old_state = xneur_state; xneur_old_group = xneur_group; int lang = get_active_kbd_group(dpy); gchar *hint; gchar *status_text; //float saturation = 1.0; if (xneur_pid != -1) { //saturation = 1.0; hint = g_strdup_printf("%s%s%s", _("X Neural Switcher running ("), xconfig->handle->languages[lang].dir, ")"); status_text = g_strdup_printf("%s", _("Stop daemon")); } else { //saturation = 0.25; hint = g_strdup_printf("%s%s%s", _("X Neural Switcher stopped ("), xconfig->handle->languages[lang].dir, ")"); status_text = g_strdup_printf("%s", _("Start daemon")); } gtk_menu_item_set_label(GTK_MENU_ITEM(tray->status), status_text); gint kbd_gr = get_active_kbd_group(dpy); const char *icon_name = get_tray_icon_name(tray->images[kbd_gr]); if (tray->tray_icon) { gtk_widget_hide_all(GTK_WIDGET(tray->tray_icon)); gtk_widget_destroy (tray->image); if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); tray->image = gtk_label_new ((const gchar *)layout_name); gtk_label_set_justify (GTK_LABEL(tray->image), GTK_JUSTIFY_CENTER); free(layout_name); } else { tray->image = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR); } gtk_container_add(GTK_CONTAINER(tray->evbox), tray->image); gtk_widget_show_all(GTK_WIDGET(tray->tray_icon)); } else if (tray->status_icon) { if (gtk_status_icon_is_embedded(tray->status_icon)) { if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); GdkPixbuf *pb = text_to_gtk_pixbuf (layout_name); free(layout_name); pb = gdk_pixbuf_add_alpha(pb, TRUE, 255, 255, 255); gtk_status_icon_set_from_pixbuf(tray->status_icon, pb); g_object_unref(pb); } else { gtk_status_icon_set_from_icon_name(tray->status_icon, icon_name); } gtk_status_icon_set_tooltip(tray->status_icon, hint); } } #ifdef HAVE_APP_INDICATOR else if (tray->app_indicator) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].name); if (strcasecmp(show_in_the_tray, "Text") == 0) { #ifdef HAVE_DEPREC_APP_INDICATOR app_indicator_set_icon (tray->app_indicator, icon_name); #else app_indicator_set_label (tray->app_indicator, layout_name, layout_name); app_indicator_set_icon (tray->app_indicator, ""); #endif } else { #ifdef HAVE_DEPREC_APP_INDICATOR app_indicator_set_icon (tray->app_indicator, icon_name); #else app_indicator_set_icon (tray->app_indicator, icon_name); app_indicator_set_label (tray->app_indicator,"", ""); #endif } free(layout_name); } #endif g_free (hint); g_free (status_text); return TRUE; }
static void setup_window (CsmFailWhaleDialog *fail_dialog) { CsmFailWhaleDialogPrivate *priv; GtkWidget *alignment; GtkWidget *box; GtkWidget *image; GtkWidget *label; GtkWidget *message_label; GtkWidget *button_box; GtkWidget *button; char *markup; priv = fail_dialog->priv; gtk_window_set_title (GTK_WINDOW (fail_dialog), ""); gtk_window_set_icon_name (GTK_WINDOW (fail_dialog), CSM_ICON_COMPUTER_FAIL); if (!fail_dialog->priv->debug_mode) { gtk_window_set_skip_taskbar_hint (GTK_WINDOW (fail_dialog), TRUE); gtk_window_set_keep_above (GTK_WINDOW (fail_dialog), TRUE); gtk_window_stick (GTK_WINDOW (fail_dialog)); gtk_window_set_position (GTK_WINDOW (fail_dialog), GTK_WIN_POS_CENTER_ALWAYS); /* only works if there is a window manager which is unlikely */ gtk_window_fullscreen (GTK_WINDOW (fail_dialog)); } alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (fail_dialog), alignment); g_object_set (alignment, "valign", GTK_ALIGN_CENTER, NULL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_widget_show (box); gtk_container_add (GTK_CONTAINER (alignment), box); image = gtk_image_new_from_icon_name (CSM_ICON_COMPUTER_FAIL, csm_util_get_computer_fail_icon_size ()); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0); label = gtk_label_new (NULL); markup = g_strdup_printf ("<b><big>%s</big></b>", _("Oh no! Something has gone wrong.")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); if (!priv->allow_logout) message_label = gtk_label_new (_("A problem has occurred and the system can't recover. Please contact a system administrator")); else message_label = gtk_label_new (_("A problem has occurred and the system can't recover.\nPlease log out and try again.")); gtk_label_set_justify (GTK_LABEL (message_label), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (message_label), TRUE); gtk_widget_show (message_label); gtk_box_pack_start (GTK_BOX (box), message_label, FALSE, FALSE, 0); button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_container_set_border_width (GTK_CONTAINER (button_box), 20); gtk_widget_show (button_box); gtk_box_pack_end (GTK_BOX (box), button_box, FALSE, FALSE, 0); if (priv->allow_logout) { button = gtk_button_new_with_mnemonic (_("_Log Out")); gtk_widget_show (button); gtk_box_pack_end (GTK_BOX (button_box), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (on_logout_clicked), fail_dialog); } }
void create_tray_icon (void) { dpy = XOpenDisplay(NULL); gxneur_config_read_str("show_in_the_tray", &show_in_the_tray); gxneur_config_read_str("rendering_engine", &rendering_engine); gxneur_config_add_notify("show_in_the_tray", show_in_the_tray_callback, NULL); gxneur_config_add_notify("rendering_engine", rendering_engine_callback, NULL); if (arg_show_in_the_tray) g_free(show_in_the_tray), show_in_the_tray = g_strdup(arg_show_in_the_tray); if (arg_rendering_engine) g_free(rendering_engine), rendering_engine = g_strdup(arg_rendering_engine); if (!show_in_the_tray) show_in_the_tray = g_strdup(DEFAULT_SHOW_IN_THE_TRAY); if (!rendering_engine) rendering_engine = g_strdup(DEFAULT_RENDERING_ENGINE); tray = g_new0(struct _tray_icon, 1); #ifdef HAVE_APP_INDICATOR tray->app_indicator = NULL; #endif tray->status_icon = NULL; tray->tray_icon = NULL; // Init pixbuf array for (int i = 0; i < MAX_LAYOUTS; i++) { tray->images[i] = NULL; } // Load images names for (int i = 0; i < xconfig->handle->total_languages; i++) { char *layout_name = strdup(xconfig->handle->languages[i].dir); tray->images[i] = g_strdup_printf("%s-%s", PACKAGE, layout_name); free(layout_name); } tray->menu = create_menu(tray, xconfig->manual_mode); int tray_icon_created = 0; int tray_icon_failed = 0; if (strcasecmp(rendering_engine, "AppIndicator") == 0) { #ifdef HAVE_APP_INDICATOR // App indicator tray->app_indicator = app_indicator_new ("X Neural Switcher", PACKAGE, APP_INDICATOR_CATEGORY_APPLICATION_STATUS); if (tray->app_indicator) { app_indicator_set_status (tray->app_indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu (tray->app_indicator, tray->menu); tray_icon_created = 1; tray_icon_failed = 0; } else { tray_icon_failed = 1; } #else tray_icon_failed = 1; #endif } gint kbd_gr = get_active_kbd_group(dpy); // Tray icon if (strcasecmp(rendering_engine, "Built-in") == 0 /*|| tray_icon_failed*/) { tray->tray_icon = _gtk_tray_icon_new(_("X Neural Switcher")); if (tray->tray_icon) { g_signal_connect(G_OBJECT(tray->tray_icon), "button_press_event", G_CALLBACK(tray_icon_press), NULL); tray->evbox = gtk_event_box_new(); gtk_event_box_set_visible_window(GTK_EVENT_BOX(tray->evbox), 0); if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); tray->image = gtk_label_new ((const gchar *)layout_name); gtk_label_set_justify (GTK_LABEL(tray->image), GTK_JUSTIFY_CENTER); free(layout_name); } else { tray->image = gtk_image_new_from_icon_name(tray->images[kbd_gr], GTK_ICON_SIZE_LARGE_TOOLBAR); } gtk_container_add(GTK_CONTAINER(tray->evbox), tray->image); gtk_container_add(GTK_CONTAINER(tray->tray_icon), tray->evbox); gtk_widget_show_all(GTK_WIDGET(tray->tray_icon)); tray_icon_created = 1; tray_icon_failed = 0; } else { tray_icon_failed = 1; } } // Status Icon if (tray_icon_failed || !tray_icon_created || strcasecmp(rendering_engine, "StatusIcon") == 0 ) { tray->status_icon = gtk_status_icon_new(); g_signal_connect(G_OBJECT(tray->status_icon), "activate", G_CALLBACK(status_icon_on_click), NULL); g_signal_connect(G_OBJECT(tray->status_icon), "popup-menu", G_CALLBACK(status_icon_on_menu), NULL); gtk_status_icon_set_from_icon_name(tray->status_icon, PACKAGE); gtk_status_icon_set_tooltip_text(tray->status_icon, "X Neural Switcher"); gtk_status_icon_set_visible(tray->status_icon, TRUE); if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); GdkPixbuf *pb = text_to_gtk_pixbuf (layout_name); free(layout_name); pb = gdk_pixbuf_add_alpha(pb, TRUE, 255, 255, 255); gtk_status_icon_set_from_pixbuf(tray->status_icon, pb); g_object_unref(pb); } else { gtk_status_icon_set_from_icon_name(tray->status_icon, tray->images[kbd_gr]); } } force_update = TRUE; g_timeout_add(1000, clock_check, 0); }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *button; GIcon *gicon; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name ("gtk3-demo", GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); image = gtk_image_new_from_resource ("/images/floppybuddy.gif"); gtk_container_add (GTK_CONTAINER (frame), image); /* Symbolic icon */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Symbolic themed icon</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ image = gtk_image_new_from_pixbuf (NULL); gtk_container_add (GTK_CONTAINER (frame), image); start_progressive_loading (image); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), vbox); } if (!gtk_widget_get_visible (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
GtkWidget* mooToolBar (void) { GtkWidget *toolbar; GtkIconSize tmp_toolbar_icon_size; GtkWidget *tmp_image; GtkWidget *toolbar_button_start; GtkWidget *mooSettings; GtkWidget *separatortoolitem2; GtkWidget *toolbar_button_quit; GtkAccelGroup *accel_group; gchar* filename; accel_group = gtk_accel_group_new (); toolbar = gtk_toolbar_new (); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar)); filename = g_build_filename (g_get_current_dir(), "moo.png", NULL); tmp_image = gtk_image_new_from_file (filename); gtk_widget_show (tmp_image); toolbar_button_start = (GtkWidget*) gtk_tool_button_new (tmp_image, "New Game"); gtk_widget_show (toolbar_button_start); gtk_container_add (GTK_CONTAINER (toolbar), toolbar_button_start); gtk_widget_add_accelerator (toolbar_button_start, "clicked", accel_group, GDK_N, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); tmp_image = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU); gtk_widget_show (tmp_image); mooSettings = (GtkWidget*) gtk_tool_button_new (tmp_image, "Game Level"); gtk_widget_show (mooSettings); gtk_container_add (GTK_CONTAINER (toolbar), mooSettings); gtk_widget_add_accelerator (mooSettings, "clicked", accel_group, GDK_l, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); separatortoolitem2 = (GtkWidget*) gtk_separator_tool_item_new (); gtk_widget_show (separatortoolitem2); gtk_container_add (GTK_CONTAINER (toolbar), separatortoolitem2); tmp_image = gtk_image_new_from_icon_name ("gtk-quit", GTK_ICON_SIZE_MENU); gtk_widget_show (tmp_image); toolbar_button_quit = (GtkWidget*) gtk_tool_button_new (tmp_image, ("Quit")); gtk_widget_show (toolbar_button_quit); gtk_container_add (GTK_CONTAINER (toolbar), toolbar_button_quit); gtk_widget_add_accelerator (toolbar_button_quit, "clicked", accel_group, GDK_N, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_signal_connect ((gpointer) toolbar_button_start, "clicked", G_CALLBACK (init_new), NULL); g_signal_connect ((gpointer) mooSettings, "clicked", G_CALLBACK (init_Settings), NULL); g_signal_connect ((gpointer) toolbar_button_quit, "clicked", G_CALLBACK (gtk_main_quit), NULL); return toolbar; }