void sp_text_edit_dialog (void) { if (!dlg) { GtkWidget *mainvb, *nb, *vb, *hb, *txt, *fontsel, *preview, *f, *tbl, *l, *px, *c, *b, *hs; GtkTextBuffer *tb; GList *sl; int i; gchar title[500]; sp_ui_dialog_title_string (SP_VERB_DIALOG_TEXT, title); dlg = sp_window_new (title, TRUE); if (x == -1000 || y == -1000) { x = prefs_get_int_attribute (prefs_path, "x", 0); y = prefs_get_int_attribute (prefs_path, "y", 0); } if (w ==0 || h == 0) { w = prefs_get_int_attribute (prefs_path, "w", 0); h = prefs_get_int_attribute (prefs_path, "h", 0); } if (x != 0 || y != 0) gtk_window_move ((GtkWindow *) dlg, x, y); else gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER); if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h); sp_transientize (dlg); wd.win = dlg; wd.stop = 0; g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd); gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg); gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg); g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg); gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE); mainvb = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (dlg), mainvb); nb = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (nb), 4); gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (dlg), "notebook", nb); /* Vbox inside notebook */ vb = gtk_vbox_new (FALSE, 0); /* Textview */ f = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_IN); tb = gtk_text_buffer_new (NULL); txt = gtk_text_view_new_with_buffer (tb); gtk_widget_set_size_request (txt, -1, 64); gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE); gtk_container_add (GTK_CONTAINER (f), txt); gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg); g_object_set_data (G_OBJECT (dlg), "text", tb); g_object_set_data (G_OBJECT (dlg), "textw", txt); /* HBox containing font selection and layout */ hb = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0); fontsel = sp_font_selector_new (); g_signal_connect (G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg); gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel); /* Layout */ f = gtk_frame_new (_("Layout")); gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4); tbl = gtk_table_new (3, 4, FALSE); gtk_table_set_row_spacings (GTK_TABLE (tbl), 4); gtk_table_set_col_spacings (GTK_TABLE (tbl), 4); gtk_container_add (GTK_CONTAINER (f), tbl); l = gtk_label_new (_("Alignment:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0); px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR); b = gtk_radio_button_new (NULL); g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b); px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR); b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b))); g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b); px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR); b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b))); g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_table_attach (GTK_TABLE (tbl), b, 3, 4, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b); l = gtk_label_new (_("Orientation:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0); px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_LR, GTK_ICON_SIZE_LARGE_TOOLBAR); b = gtk_radio_button_new (NULL); g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_object_set_data (G_OBJECT (dlg), "writing_mode_lr", b); px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_TB, GTK_ICON_SIZE_LARGE_TOOLBAR); b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b))); g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_object_set_data (G_OBJECT (dlg), "writing_mode_tb", b); l = gtk_label_new (_("Line spacing:")); gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5); gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0); c = gtk_combo_new (); gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE); gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE); gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE); gtk_widget_set_size_request (c, 64, -1); /* Setup strings */ sl = NULL; for (i = 0; spacings[i]; i++) { sl = g_list_prepend (sl, (void *) spacings[i]); } sl = g_list_reverse (sl); gtk_combo_set_popdown_strings ((GtkCombo *) c, sl); g_list_free (sl); g_signal_connect ((GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg); gtk_table_attach (GTK_TABLE (tbl), c, 1, 4, 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0); g_object_set_data (G_OBJECT (dlg), "line_spacing", c); /* Font preview */ preview = sp_font_preview_new (); gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4); g_object_set_data (G_OBJECT (dlg), "preview", preview); l = gtk_label_new (_("Text and font")); gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l); /* Buttons */ hs = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (mainvb), hs, FALSE, FALSE, 0); hb = gtk_hbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (hb), 4); gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0); b = gtk_button_new_with_label (_("Set as default")); g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg); gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "default", b); b = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg); gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0); b = gtk_button_new_from_stock (GTK_STOCK_APPLY); g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg); gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dlg), "apply", b); g_signal_connect (G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_modify_selection), dlg); g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_change_selection), dlg); sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE); gtk_widget_show_all (dlg); } gtk_window_present ((GtkWindow *) dlg); }
PpJobsDialog * pp_jobs_dialog_new (GtkWindow *parent, UserResponseCallback user_callback, gpointer user_data, gchar *printer_name) { PpJobsDialog *dialog; GtkWidget *widget; GError *error = NULL; gchar *objects[] = { "jobs-dialog", NULL }; guint builder_result; gchar *title; dialog = g_new0 (PpJobsDialog, 1); dialog->builder = gtk_builder_new (); dialog->parent = GTK_WIDGET (parent); builder_result = gtk_builder_add_objects_from_file (dialog->builder, DATADIR"/jobs-dialog.ui", objects, &error); if (builder_result == 0) { g_warning ("Could not load ui: %s", error->message); g_error_free (error); return NULL; } dialog->dialog = (GtkWidget *) gtk_builder_get_object (dialog->builder, "jobs-dialog"); dialog->user_callback = user_callback; dialog->user_data = user_data; dialog->printer_name = g_strdup (printer_name); dialog->current_job_id = -1; dialog->ref_count = 0; /* connect signals */ g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (dialog->dialog, "response", G_CALLBACK (jobs_dialog_response_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "content-alignment"); g_signal_connect (widget, "size-allocate", G_CALLBACK (update_alignment_padding), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-cancel-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-hold-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "job-release-button"); g_signal_connect (widget, "clicked", G_CALLBACK (job_process_cb), dialog); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "jobs-title"); title = g_strdup_printf (_("%s Active Jobs"), printer_name); gtk_label_set_label (GTK_LABEL (widget), title); g_free (title); populate_jobs_list (dialog); gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent)); gtk_window_present (GTK_WINDOW (dialog->dialog)); gtk_widget_show_all (GTK_WIDGET (dialog->dialog)); return dialog; }
void cairo_dock_show_desklet (CairoDesklet *pDesklet) { if (pDesklet) gtk_window_present(GTK_WINDOW(pDesklet->pWidget)); }
HybridChatWindow* hybrid_chat_window_create(HybridAccount *account, const gchar *id, HybridChatWindowType type) { HybridChatWindow *chat = NULL; HybridConversation *conv = NULL; HybridBuddy *buddy; HybridModule *proto; HybridIMOps *ops; g_return_val_if_fail(account != NULL, NULL); g_return_val_if_fail(id != NULL, NULL); if (type == HYBRID_CHAT_PANEL_SYSTEM) { if (!(buddy = (hybrid_blist_find_buddy(account, id)))) { hybrid_debug_error("conv", "FATAL, can't find buddy"); return NULL; } proto = account->proto; ops = proto->info->im_ops; /* we will check whether the protocol allows this buddy to be activated. */ if (ops->chat_start) { if (!ops->chat_start(account, buddy)) { return NULL; } } } if ((chat = hybrid_conv_find_chat(id))) { conv = chat->parent; goto found; } /* * Whether to show the chat dialog in a single window. */ if (hybrid_pref_get_boolean(NULL, "single_chat_window")) { if (!conv_list) { conv = hybrid_conv_create(); conv_list = g_slist_append(conv_list, conv); } else { conv = conv_list->data; } } else { conv = hybrid_conv_create(); conv_list = g_slist_append(conv_list, conv); } chat = g_new0(HybridChatWindow, 1); chat->id = g_strdup(id); chat->parent = conv; chat->account = account; chat->type = type; chat->logs = hybrid_logs_create(account, id); if (type == HYBRID_CHAT_PANEL_SYSTEM) { chat->data = buddy; } conv->chat_buddies = g_slist_append(conv->chat_buddies, chat); init_chat_window(chat); return chat; found: gtk_notebook_set_current_page(GTK_NOTEBOOK(conv->notebook), gtk_notebook_page_num(GTK_NOTEBOOK(conv->notebook), chat->vbox)); /* focus the send textview */ gtk_widget_grab_focus(chat->sendtext); gtk_window_present(GTK_WINDOW(chat->parent->window)); return chat; }
/* Menu Callback : Configure preferences */ void menu_preferences_cb(GtkAction *action, StickyNotesApplet *applet) { stickynotes_applet_update_prefs(); gtk_window_set_screen(GTK_WINDOW(stickynotes->w_prefs), gtk_widget_get_screen(applet->w_applet)); gtk_window_present(GTK_WINDOW(stickynotes->w_prefs)); }
gboolean floating_window_delete_present( ui::Window floating, GdkEventFocus *event, ui::Window main_window ){ if ( gtk_window_is_active( floating ) || gtk_window_is_active( main_window ) ) { gtk_window_present( main_window ); } return FALSE; }
void view_padding_color_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpDisplay *display; GimpImageWindow *window; GimpDisplayShell *shell; GimpDisplayOptions *options; gboolean fullscreen; return_if_no_display (display, data); shell = gimp_display_get_shell (display); window = gimp_display_shell_get_window (shell); if (window) fullscreen = gimp_image_window_get_fullscreen (window); else fullscreen = FALSE; if (fullscreen) options = shell->fullscreen_options; else options = shell->options; #define PADDING_COLOR_DIALOG_KEY "gimp-padding-color-dialog" switch ((GimpCanvasPaddingMode) value) { case GIMP_CANVAS_PADDING_MODE_DEFAULT: case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK: case GIMP_CANVAS_PADDING_MODE_DARK_CHECK: dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); options->padding_mode_set = TRUE; gimp_display_shell_set_padding (shell, (GimpCanvasPaddingMode) value, &options->padding_color); break; case GIMP_CANVAS_PADDING_MODE_CUSTOM: { GtkWidget *dialog; dialog = dialogs_get_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); if (! dialog) { GimpImage *image = gimp_display_get_image (display); GimpDisplayShell *shell = gimp_display_get_shell (display); dialog = gimp_color_dialog_new (GIMP_VIEWABLE (image), action_data_get_context (data), _("Set Canvas Padding Color"), GIMP_ICON_FONT, _("Set Custom Canvas Padding Color"), GTK_WIDGET (shell), NULL, NULL, &options->padding_color, FALSE, FALSE); g_signal_connect (dialog, "update", G_CALLBACK (view_padding_color_dialog_update), shell); dialogs_attach_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); } break; case GIMP_CANVAS_PADDING_MODE_RESET: dialogs_destroy_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); { GimpDisplayOptions *default_options; options->padding_mode_set = FALSE; if (fullscreen) default_options = display->config->default_fullscreen_view; else default_options = display->config->default_view; gimp_display_shell_set_padding (shell, default_options->padding_mode, &default_options->padding_color); } break; } }
void cd_do_change_current_icon (Icon *pIcon, CairoDock *pDock) { //\_________________ on gere le cachage et le montrage du dock precedent et actuel. if (myData.pCurrentDock != NULL && pDock != myData.pCurrentDock && myData.pCurrentDock != g_pMainDock) // on remet au repos dock precedemment anime. { cairo_dock_emit_leave_signal (myData.pCurrentDock); } if (pDock != NULL && pDock != g_pMainDock && pDock != myData.pCurrentDock) // on montre le nouveau dock { if (pDock != NULL) { if (pDock->iRefCount > 0) { CairoDock *pParentDock = NULL; Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock); if (pPointingIcon != NULL) { cairo_dock_show_subdock (pPointingIcon, pParentDock, FALSE); // utile pour le montrage des sous-docks au clic. } } else { cairo_dock_pop_up (pDock); } cairo_dock_emit_enter_signal (pDock); } } if (pDock != NULL) { gtk_window_present (GTK_WINDOW (pDock->pWidget)); } //\_________________ on gere l'allumage et l'eteignage de l'icone precedente et actuelle. if (myData.pCurrentIcon != NULL && pIcon != myData.pCurrentIcon) // on remet au repos l'icone precedemment anime. { myData.bIgnoreIconState = TRUE; cairo_dock_stop_icon_animation (myData.pCurrentIcon); myData.bIgnoreIconState = FALSE; cairo_dock_redraw_icon (myData.pCurrentIcon, CAIRO_CONTAINER (myData.pCurrentDock)); /// utile ?... } if (pIcon != NULL && myData.pCurrentIcon != pIcon) // on anime la nouvelle icone. { int x = pIcon->fXAtRest + pIcon->fWidth/2 + (- pDock->fFlatDockWidth + pDock->iMaxDockWidth)/2; int y = pIcon->fDrawY + pIcon->fHeight/2 * pIcon->fScale; if (1||myData.pCurrentDock != pDock) { cairo_dock_emit_motion_signal (pDock, x, y); } else { myData.iPrevMouseX = myData.iMouseX; myData.iPrevMouseY = myData.iMouseY; myData.iMotionCount = 10; } myData.iMouseX = x; myData.iMouseY = y; cairo_dock_request_icon_animation (pIcon, pDock, myConfig.cIconAnimation, 1e6); // interrompt l'animation de "mouse over". cairo_dock_launch_animation (CAIRO_CONTAINER (pDock)); //if (myAccessibility.bShowSubDockOnClick) // cairo_dock_show_subdock (pIcon, pDock, FALSE); } myData.pCurrentDock = pDock; myData.pCurrentIcon = pIcon; if (myData.pCurrentDock == NULL) gtk_window_present (GTK_WINDOW (g_pMainDock->pWidget)); }
static void cb_show_details (GtkWidget *button, AppearanceData *data) { if (!data->font_details) { GtkAdjustment *adjustment; GtkWidget *widget; EnumGroup *group; data->font_details = glade_xml_get_widget (data->xml, "render_details"); gtk_window_set_transient_for (GTK_WINDOW (data->font_details), GTK_WINDOW (glade_xml_get_widget (data->xml, "appearance_window"))); widget = glade_xml_get_widget (data->xml, "dpi_spinner"); /* pick a sensible maximum dpi */ adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); adjustment->upper = DPI_HIGH_REASONABLE_VALUE; dpi_load (data->client, GTK_SPIN_BUTTON (widget)); g_signal_connect (widget, "value_changed", G_CALLBACK (dpi_value_changed), data->client); gconf_client_notify_add (data->client, FONT_DPI_KEY, dpi_changed, widget, NULL, NULL); setup_font_sample (glade_xml_get_widget (data->xml, "antialias_none_sample"), ANTIALIAS_NONE, HINT_FULL); setup_font_sample (glade_xml_get_widget (data->xml, "antialias_grayscale_sample"), ANTIALIAS_GRAYSCALE, HINT_FULL); setup_font_sample (glade_xml_get_widget (data->xml, "antialias_subpixel_sample"), ANTIALIAS_RGBA, HINT_FULL); group = enum_group_create ( FONT_ANTIALIASING_KEY, antialias_enums, ANTIALIAS_GRAYSCALE, glade_xml_get_widget (data->xml, "antialias_none_radio"), ANTIALIAS_NONE, glade_xml_get_widget (data->xml, "antialias_grayscale_radio"), ANTIALIAS_GRAYSCALE, glade_xml_get_widget (data->xml, "antialias_subpixel_radio"), ANTIALIAS_RGBA, NULL); data->font_groups = g_slist_prepend (data->font_groups, group); setup_font_sample (glade_xml_get_widget (data->xml, "hint_none_sample"), ANTIALIAS_GRAYSCALE, HINT_NONE); setup_font_sample (glade_xml_get_widget (data->xml, "hint_slight_sample"), ANTIALIAS_GRAYSCALE, HINT_SLIGHT); setup_font_sample (glade_xml_get_widget (data->xml, "hint_medium_sample"), ANTIALIAS_GRAYSCALE, HINT_MEDIUM); setup_font_sample (glade_xml_get_widget (data->xml, "hint_full_sample"), ANTIALIAS_GRAYSCALE, HINT_FULL); group = enum_group_create ( FONT_HINTING_KEY, hint_enums, HINT_FULL, glade_xml_get_widget (data->xml, "hint_none_radio"), HINT_NONE, glade_xml_get_widget (data->xml, "hint_slight_radio"), HINT_SLIGHT, glade_xml_get_widget (data->xml, "hint_medium_radio"), HINT_MEDIUM, glade_xml_get_widget (data->xml, "hint_full_radio"), HINT_FULL, NULL); data->font_groups = g_slist_prepend (data->font_groups, group); gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_rgb_image")), GNOMECC_PIXMAP_DIR "/subpixel-rgb.png"); gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_bgr_image")), GNOMECC_PIXMAP_DIR "/subpixel-bgr.png"); gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_vrgb_image")), GNOMECC_PIXMAP_DIR "/subpixel-vrgb.png"); gtk_image_set_from_file (GTK_IMAGE (glade_xml_get_widget (data->xml, "subpixel_vbgr_image")), GNOMECC_PIXMAP_DIR "/subpixel-vbgr.png"); group = enum_group_create ( FONT_RGBA_ORDER_KEY, rgba_order_enums, RGBA_RGB, glade_xml_get_widget (data->xml, "subpixel_rgb_radio"), RGBA_RGB, glade_xml_get_widget (data->xml, "subpixel_bgr_radio"), RGBA_BGR, glade_xml_get_widget (data->xml, "subpixel_vrgb_radio"), RGBA_VRGB, glade_xml_get_widget (data->xml, "subpixel_vbgr_radio"), RGBA_VBGR, NULL); data->font_groups = g_slist_prepend (data->font_groups, group); g_signal_connect (G_OBJECT (data->font_details), "response", G_CALLBACK (cb_details_response), NULL); g_signal_connect (G_OBJECT (data->font_details), "delete_event", G_CALLBACK (gtk_true), NULL); } gtk_window_present (GTK_WINDOW (data->font_details)); }
void on_tray_restore (GtkMenuItem *menuitem, gpointer user_data) { gtk_widget_show(window1); gtk_window_present(GTK_WINDOW(window1)); g_tray.Hide(); }
static void on_open_files( GtkAction* action, FindFile* data ) { GtkTreeModel* model; GtkTreeSelection* sel; GtkTreeIter it; GList *row, *rows, *sel_files; GHashTable* hash; GtkWidget* w; VFSFileInfo* fi; gboolean open_files_has_dir = FALSE; //sfm PtkFileBrowser* file_browser = NULL; //sfm gboolean open_files = TRUE; if ( action ) open_files = (0 == strcmp( gtk_action_get_name(action), "OpenAction") ); sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( data->result_view ) ); rows = gtk_tree_selection_get_selected_rows( sel, &model ); if( ! rows ) return; //sfm this frees list when new value inserted - caused segfault //hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, open_files ? (GDestroyNotify)vfs_file_info_list_free : NULL ); hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL ); for( row = rows; row; row = row->next ) { char* dir; GtkTreePath* tp = (GtkTreePath*)row->data; if( gtk_tree_model_get_iter( model, &it, tp ) ) { if( open_files ) /* open files */ gtk_tree_model_get( model, &it, COL_INFO, &fi, COL_DIR, &dir, -1 ); else /* open containing folders */ gtk_tree_model_get( model, &it, COL_DIR, &dir, -1 ); if( open_files ) { GList *l; l = g_hash_table_lookup( hash, dir ); l = g_list_prepend( l, vfs_file_info_ref(fi) ); g_hash_table_insert( hash, dir, l ); //sfm caused segfault with destroy function if ( vfs_file_info_is_dir( fi ) ) //sfm open_files_has_dir = TRUE; } else { if( g_hash_table_lookup( hash, dir ) ) g_free( dir ); g_hash_table_insert( hash, dir, NULL ); } } gtk_tree_path_free( tp ); } g_list_free( rows ); if( open_files ) { if ( open_files_has_dir ) { w = GTK_WIDGET( fm_main_window_get_last_active() ); if( ! w ) { w = fm_main_window_new(); gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height ); } gtk_window_present( (GtkWindow*)w ); file_browser = (PtkFileBrowser*)fm_main_window_get_current_file_browser( (FMMainWindow*)w ); } g_hash_table_foreach_steal( hash, (GHRFunc)open_file, file_browser ); } else { w = GTK_WIDGET( fm_main_window_get_last_active() ); if( ! w ) { w = fm_main_window_new(); gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height ); } g_hash_table_foreach( hash, (GHFunc)open_dir, w ); gtk_window_present( (GtkWindow*)w ); } g_hash_table_destroy( hash ); }
void terminal_encoding_dialog_show (GtkWindow *transient_parent) { TerminalApp *app; GtkCellRenderer *cell_renderer; GtkTreeViewColumn *column; GtkTreeModel *model; EncodingDialogData *data; if (encoding_dialog) { gtk_window_set_transient_for (GTK_WINDOW (encoding_dialog), transient_parent); gtk_window_present (GTK_WINDOW (encoding_dialog)); return; } data = g_new (EncodingDialogData, 1); if (!terminal_util_load_builder_file ("encodings-dialog.ui", "encodings-dialog", &data->dialog, "add-button", &data->add_button, "remove-button", &data->remove_button, "available-treeview", &data->available_tree_view, "displayed-treeview", &data->active_tree_view, NULL)) { g_free (data); return; } g_object_set_data_full (G_OBJECT (data->dialog), "GT::Data", data, (GDestroyNotify) encoding_dialog_data_free); gtk_window_set_transient_for (GTK_WINDOW (data->dialog), transient_parent); gtk_window_set_role (GTK_WINDOW (data->dialog), "mate-terminal-encodings"); g_signal_connect (data->dialog, "response", G_CALLBACK (response_callback), data); /* buttons */ g_signal_connect (data->add_button, "clicked", G_CALLBACK (button_clicked_cb), data); g_signal_connect (data->remove_button, "clicked", G_CALLBACK (button_clicked_cb), data); /* Tree view of available encodings */ /* Column 1 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Description"), cell_renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column (data->available_tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); /* Column 2 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Encoding"), cell_renderer, "text", COLUMN_CHARSET, NULL); gtk_tree_view_append_column (data->available_tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET); data->available_selection = gtk_tree_view_get_selection (data->available_tree_view); gtk_tree_selection_set_mode (data->available_selection, GTK_SELECTION_BROWSE); g_signal_connect (data->available_selection, "changed", G_CALLBACK (selection_changed_cb), data); /* Tree view of selected encodings */ /* Column 1 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Description"), cell_renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column (data->active_tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); /* Column 2 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Encoding"), cell_renderer, "text", COLUMN_CHARSET, NULL); gtk_tree_view_append_column (data->active_tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET); /* Add the data */ data->active_selection = gtk_tree_view_get_selection (data->active_tree_view); gtk_tree_selection_set_mode (data->active_selection, GTK_SELECTION_BROWSE); g_signal_connect (data->active_selection, "changed", G_CALLBACK (selection_changed_cb), data); data->base_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, TERMINAL_TYPE_ENCODING); app = terminal_app_get (); encodings_list_changed_cb (app, data); g_signal_connect (app, "encoding-list-changed", G_CALLBACK (encodings_list_changed_cb), data); /* Now turn on sorting */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->base_store), COLUMN_NAME, GTK_SORT_ASCENDING); model = encodings_create_treemodel (data->base_store, FALSE); gtk_tree_view_set_model (data->available_tree_view, model); g_object_unref (model); model = encodings_create_treemodel (data->base_store, TRUE); gtk_tree_view_set_model (data->active_tree_view, model); g_object_unref (model); g_object_unref (data->base_store); gtk_window_present (GTK_WINDOW (data->dialog)); encoding_dialog = data->dialog; g_signal_connect (data->dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &encoding_dialog); }
static gboolean _lib_tagging_tag_show(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, dt_lib_module_t *self) { int mouse_over_id = -1; int zoom = dt_conf_get_int("plugins/lighttable/images_in_row"); // the order is: // if(zoom == 1) => currently shown image // else if(selection not empty) => selected images // else if(cursor over image) => hovered image // else => return if(zoom == 1 || dt_collection_get_selected_count(darktable.collection) == 0) { mouse_over_id = dt_control_get_mouse_over_id(); if(mouse_over_id < 0) return TRUE; } dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data; d->floating_tag_imgid = mouse_over_id; gint x, y; gint px, py, w, h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); w = gdk_window_get_width(gtk_widget_get_window(center)); h = gdk_window_get_height(gtk_widget_get_window(center)); x = px + 0.5 * (w - FLOATING_ENTRY_WIDTH); y = py + h - 50; /* put the floating box at the mouse pointer */ // gint pointerx, pointery; // GdkDevice *device = // gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget))); // gdk_window_get_device_position (gtk_widget_get_window (widget), device, &pointerx, &pointery, NULL); // x = px + pointerx + 1; // y = py + pointery + 1; d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */ gtk_widget_set_can_focus(d->floating_tag_window, TRUE); gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window)); gtk_widget_set_opacity(d->floating_tag_window, 0.8); gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y); GtkWidget *entry = gtk_entry_new(); gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1); gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK); GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_completion_set_popup_set_width(completion, FALSE); gtk_entry_set_completion(GTK_ENTRY(entry), completion); gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1); gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry); g_signal_connect(entry, "focus-out-event", G_CALLBACK(_lib_tagging_tag_destroy), d->floating_tag_window); g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self); gtk_widget_show_all(d->floating_tag_window); gtk_widget_grab_focus(entry); gtk_window_present(GTK_WINDOW(d->floating_tag_window)); return TRUE; }
void show_about_window(void) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GdkPixbuf *pixbuf; gchar *buf; if (about) { gtk_window_present(GTK_WINDOW(about)); return; } about = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(about), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_wmclass(GTK_WINDOW(about), "about", "GQview"); g_signal_connect(G_OBJECT(about), "delete_event", G_CALLBACK(about_delete_cb), NULL); gtk_window_set_title(GTK_WINDOW(about), _("About - GQview")); gtk_container_set_border_width(GTK_CONTAINER(about), PREF_PAD_BORDER); vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE); gtk_container_add(GTK_CONTAINER(about), vbox); gtk_widget_show(vbox); pixbuf = pixbuf_inline(PIXBUF_INLINE_LOGO); button = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(pixbuf); gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0); gtk_widget_show(button); buf = g_strdup_printf(_("GQview %s\n\nCopyright (c) %s John Ellis\nwebsite: %s\nemail: %s\n\nReleased under the GNU General Public License"), VERSION, "2006", "gqview.sourceforge.net", "*****@*****.**"); label = gtk_label_new(buf); g_free(buf); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_widget_show(label); hbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button = pref_button_new(NULL, NULL, _("Credits..."), FALSE, G_CALLBACK(about_credits_cb), NULL); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_show(button); button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(about_window_close), NULL); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_grab_default(button); gtk_widget_show(button); window_set_icon(about, NULL, NULL); gtk_widget_show(about); }
void wxTopLevelWindowGTK::Restore() { // "Present" seems similar enough to "restore" gtk_window_present( GTK_WINDOW( m_widget ) ); }
void show_login() { GtkWidget *image; GtkWidget *hbox_toplevel; GtkWidget *vbox; GtkWidget *button; GtkWidget *hbox; GtkWidget *label; GtkWidget *vbox2; GtkWidget *table; #ifdef GAIM_SMALL_SCREEN #ifdef ENABLE_HILDON GtkWidget *hbox1; GtkWidget *vbox1; #endif GtkWidget *hseparator; #endif /* Do we already have a main window opened? If so, bring it back, baby... ribs... yeah */ #ifdef ENABLE_HILDON if (login_app_view) { hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); g_object_unref(login_app_view); return; } mainwindow = current_app_view = login_app_view = hildon_appview_new(_("Login")); hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); hbox_toplevel = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(login_app_view), hbox_toplevel); g_signal_connect(G_OBJECT(login_app_view), "delete_event", G_CALLBACK(login_window_closed), login_app_view); #else if (mainwindow) { gtk_window_present(GTK_WINDOW(mainwindow)); return; } #ifdef GAIM_SMALL_SCREEN mainwindow = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(mainwindow), TRUE); gtk_dialog_set_has_separator(mainwindow, FALSE); #else mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif gtk_window_set_role(GTK_WINDOW(mainwindow), "login"); gtk_window_set_resizable(GTK_WINDOW(mainwindow), FALSE); gtk_window_set_title(GTK_WINDOW(mainwindow), _("Login")); gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5); g_signal_connect(G_OBJECT(mainwindow), "delete_event", G_CALLBACK(login_window_closed), mainwindow); hbox_toplevel = gtk_hbox_new(FALSE, 0); #ifdef GAIM_SMALL_SCREEN gtk_container_add(GTK_CONTAINER(GTK_DIALOG(mainwindow)->vbox), hbox_toplevel); #else gtk_container_add(GTK_CONTAINER(mainwindow), hbox_toplevel); #endif #endif vbox_toplevel = vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_toplevel), vbox, FALSE, FALSE, BOX_SPACING); #ifdef GAIM_SMALL_SCREEN /* Now for the button box */ hbox = gtk_hbox_new(FALSE, 0); #ifdef ENABLE_HILDON hbox1 = gtk_hbox_new(FALSE, BOX_SPACING); vbox1 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox1, TRUE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0); vbox = vbox1; #else gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); #endif /* lets put the image also in the hbox */ image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); #ifdef ENABLE_HILDON gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0); #else gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); #endif /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 2); #else image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0); #endif table = gtk_table_new (2, 2, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); /* why isn't there a gtk_label_new_with_markup? */ label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Account:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); name = gaim_gtk_account_option_menu_new(NULL, TRUE, G_CALLBACK(combo_changed), NULL, NULL); gtk_label_set_mnemonic_widget(GTK_LABEL(label), name); gtk_widget_show (name); gtk_table_attach (GTK_TABLE (table), name, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Password:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); pass = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), pass); gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE); gtk_table_attach (GTK_TABLE (table), pass, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); #ifndef GAIM_SMALL_SCREEN g_signal_connect(G_OBJECT(pass), "activate", G_CALLBACK(dologin), mainwindow); /* gtk_box_pack_start(GTK_BOX(vbox2), pass, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0); */ /* Now for the button box */ hbox = gtk_hbox_new(TRUE, 0); /* gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); #endif /* Now grab the focus that we need */ if (gaim_accounts_get_all()) { GaimAccount *account = gaim_accounts_get_all()->data; if (gaim_account_get_remember_password(account)) { combo_changed(NULL, account, NULL); gtk_widget_grab_focus(button); } else { gtk_widget_grab_focus(pass); } } else { gaim_gtk_accounts_window_show(); gtk_widget_grab_focus(button); } #ifndef ENABLE_HILDON /* And raise the curtain! */ gtk_widget_show_all(mainwindow); #else gtk_widget_show_all(login_app_view); #endif }
void wxTopLevelWindowGTK::Raise() { gtk_window_present( GTK_WINDOW( m_widget ) ); }
void WPkgGtk::pop() { gtk_window_present( GTK_WINDOW(toplevel)); }
gboolean floating_window_destroy_present( ui::Window floating, ui::Window main_window ){ if ( gtk_window_is_active( floating ) || gtk_window_is_active( main_window ) ) { gtk_window_present( main_window ); } return FALSE; }
gint setup_game (GtkAction * action, gpointer data) { GtkWidget *box, *box2, *label, *button, *frame; GtkWidget *table; GtkWidget *combo; gchar *ts; int i; if (setupdialog) { gtk_window_present (GTK_WINDOW (setupdialog)); return FALSE; } setupdialog = gtk_dialog_new_with_buttons (_("Tali Preferences"), GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 2); gtk_window_set_resizable (GTK_WINDOW (setupdialog), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (setupdialog), FALSE); g_signal_connect (G_OBJECT (setupdialog), "delete_event", G_CALLBACK (setupdialog_destroy), NULL); button = gtk_button_new_from_stock (GTK_STOCK_OK); g_signal_connect (G_OBJECT (setupdialog), "response", G_CALLBACK (do_setup), NULL); table = gtk_table_new (3, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 5); gtk_table_set_row_spacings (GTK_TABLE (table), 18); gtk_table_set_col_spacings (GTK_TABLE (table), 18); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), table, FALSE, FALSE, 0); frame = games_frame_new (_("Human Players")); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); box = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Spinner (number of humans) ---*/ OriginalNumberOfHumans = NumberOfHumans; box2 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Number of players:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); HumanAdj = gtk_adjustment_new ((gfloat) NumberOfHumans, 1.0, 6.0, 1.0, 6.0, 0.0); HumanSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (HumanAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), HumanSpinner); g_signal_connect (G_OBJECT (HumanAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), HumanAdj); gtk_box_pack_start (GTK_BOX (box2), HumanSpinner, TRUE, TRUE, 0); frame = games_frame_new (_("Computer Opponents")); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0); box = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), box); /*--- Button ---*/ button = gtk_check_button_new_with_mnemonic (_("_Delay between rolls")); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), DoDelay); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (set_as_int), &tmpDoDelay); /*--- Spinner (number of computers) ---*/ OriginalNumberOfComputers = NumberOfComputers; box2 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("N_umber of opponents:")); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); ComputerAdj = gtk_adjustment_new ((gfloat) NumberOfComputers, 0.0, 5.0, 1.0, 5.0, 0.0); ComputerSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ComputerAdj), 10, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), ComputerSpinner); g_signal_connect (G_OBJECT (ComputerAdj), "value_changed", G_CALLBACK (MaxPlayersCheck), ComputerAdj); gtk_box_pack_start (GTK_BOX (box2), ComputerSpinner, TRUE, TRUE, 0); box2 = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Difficulty:")); gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0); combo = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Easy")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Medium")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("difficulty", "Hard")); skill_level = 0; while (NUM_TRIALS > skill_level_table[skill_level].trials && skill_level < (SKILL_LEVEL_TABLE_SIZE - 1)) skill_level++; gtk_combo_box_set_active(GTK_COMBO_BOX(combo), skill_level); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetSkillLevel), combo); gtk_box_pack_start(GTK_BOX(box2), combo, FALSE, FALSE, 0); /*--- Combo (yahtzee or kismet style ----*/ frame = games_frame_new (_("Game Type")); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 2, 3, GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0); combo = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("game type", "Regular")); gtk_combo_box_append_text(GTK_COMBO_BOX(combo), C_("game type", "Colors")); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), game_type); NewGameType = game_type; g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetGameType), combo); gtk_container_add (GTK_CONTAINER (frame), combo); /*--- PLAYER NAMES FRAME ----*/ frame = games_frame_new (_("Player Names")); gtk_table_attach_defaults (GTK_TABLE (table), frame, 1, 2, 0, 3); box = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), box); for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) { box2 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0); ts = g_strdup_printf ("_%1d:", i + 1); label = gtk_label_new_with_mnemonic (ts); g_free (ts); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); PlayerNames[i] = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), PlayerNames[i]); ts = g_strdup_printf ("PlayerName%1d", i + 1); gtk_widget_set_name (PlayerNames[i], ts); g_free (ts); gtk_entry_set_text (GTK_ENTRY (PlayerNames[i]), players[i].name); gtk_box_pack_start (GTK_BOX (box2), PlayerNames[i], FALSE, FALSE, 0); } gtk_widget_show_all (setupdialog); return FALSE; }
static void init_chat_window_body(GtkWidget *vbox, HybridChatWindow *chat) { GtkWidget *scroll; GtkWidget *button; GtkWidget *image_icon; GtkWidget *limit_label; GtkTextBuffer *send_buffer; gchar *word_limit_string; gint word_limit; HybridAccount *account; HybridModule *module; HybridIMOps *ops; g_return_if_fail(vbox != NULL); g_return_if_fail(chat != NULL); /* create buddy tips panel */ create_buddy_tips_panel(vbox, chat); /* create textview */ scroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); chat->textview = text_ops->create(); g_signal_connect(chat->textview, "focus-in-event", GTK_SIGNAL_FUNC(focus_in_cb), chat); gtk_container_add(GTK_CONTAINER(scroll), chat->textview); /* create toolbar */ chat->toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(chat->toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start(GTK_BOX(vbox), chat->toolbar, FALSE, FALSE, 0); image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/logs.png"); button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar), _("Chat logs"), _("View chat logs"), NULL, image_icon, NULL, NULL); if (IS_SYSTEM_CHAT(chat)) { gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar)); image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/nudge.png"); button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar), _("Screen jitter"), _("Send a screen jitter"), NULL, image_icon, NULL, NULL); gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar)); account = chat->account; module = account->proto; ops = module->info->im_ops; if (ops->chat_word_limit && (word_limit = ops->chat_word_limit(account)) > 0) { word_limit_string = g_strdup_printf(_("Total %d character, left "), word_limit); limit_label = gtk_label_new(word_limit_string); g_free(word_limit_string); word_limit_string = g_strdup_printf(_("[<span color='#0099ff'>%d</span>] characters"), word_limit); chat->words_left_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(chat->words_left_label), word_limit_string); g_free(word_limit_string); gtk_container_add(GTK_CONTAINER(chat->toolbar), limit_label); gtk_container_add(GTK_CONTAINER(chat->toolbar), chat->words_left_label); } } gtk_widget_show_all(chat->toolbar); /* create textview */ scroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(vbox), scroll, FALSE, FALSE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); chat->sendtext = gtk_text_view_new(); gtk_widget_set_size_request(chat->sendtext, 0, 80); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(chat->sendtext), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(scroll), chat->sendtext); g_signal_connect(chat->sendtext, "key_press_event", G_CALLBACK(key_pressed_cb), chat->parent); g_signal_connect(chat->sendtext, "focus-in-event", GTK_SIGNAL_FUNC(focus_in_cb), chat); send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(chat->sendtext)); g_signal_connect(send_buffer, "changed", G_CALLBACK(sendtext_buffer_changed), chat); gtk_window_present(GTK_WINDOW(chat->parent->window)); /* focus the send textview */ GTK_WIDGET_SET_FLAGS(chat->sendtext, GTK_CAN_FOCUS); gtk_widget_grab_focus(chat->sendtext); gtk_widget_show_all(scroll); gtk_widget_show_all(vbox); }
void show_track_properties_dlg (int ctx) { last_ctx = ctx; if (tracks) { for (int i = 0; i < numtracks; i++) { deadbeef->pl_item_unref (tracks[i]); } free (tracks); tracks = NULL; numtracks = 0; } deadbeef->pl_lock (); ddb_playlist_t *plt = deadbeef->plt_get_curr (); if (!plt) { deadbeef->pl_unlock (); return; } int num = 0; if (ctx == DDB_ACTION_CTX_SELECTION) { num = deadbeef->plt_getselcount (plt); } else if (ctx == DDB_ACTION_CTX_PLAYLIST) { num = deadbeef->plt_get_item_count (plt, PL_MAIN); } else if (ctx == DDB_ACTION_CTX_NOWPLAYING) { num = 1; } if (num <= 0) { deadbeef->pl_unlock (); return; } tracks = malloc (sizeof (DB_playItem_t *) * num); if (!tracks) { fprintf (stderr, "gtkui: failed to alloc %d bytes to store selected tracks\n", (int)(num * sizeof (void *))); deadbeef->pl_unlock (); return; } if (ctx == DDB_ACTION_CTX_NOWPLAYING) { DB_playItem_t *it = deadbeef->streamer_get_playing_track (); if (!it) { free (tracks); tracks = NULL; deadbeef->pl_unlock (); return; } tracks[0] = it; } else { int n = 0; DB_playItem_t *it = deadbeef->pl_get_first (PL_MAIN); while (it) { if (ctx == DDB_ACTION_CTX_PLAYLIST || deadbeef->pl_is_selected (it)) { assert (n < num); deadbeef->pl_item_ref (it); tracks[n++] = it; } DB_playItem_t *next = deadbeef->pl_get_next (it, PL_MAIN); deadbeef->pl_item_unref (it); it = next; } } numtracks = num; deadbeef->pl_unlock (); GtkTreeView *tree; GtkTreeView *proptree; if (!trackproperties) { trackproperties = create_trackproperties (); gtk_window_set_transient_for (GTK_WINDOW (trackproperties), GTK_WINDOW (mainwin)); wingeom_restore (trackproperties, "trkproperties", -1, -1, 300, 400, 0); // metadata tree tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); gtk_tree_view_set_model (tree, GTK_TREE_MODEL (store)); GtkCellRenderer *rend_text = gtk_cell_renderer_text_new (); rend_text2 = GTK_CELL_RENDERER (ddb_cell_renderer_text_multiline_new ()); g_signal_connect ((gpointer)rend_text2, "edited", G_CALLBACK (on_metadata_edited), store); GtkTreeViewColumn *col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_text, "text", 0, NULL); GtkTreeViewColumn *col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_text2, "text", 1, NULL); gtk_tree_view_append_column (tree, col1); gtk_tree_view_append_column (tree, col2); // properties tree proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties")); propstore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (proptree, GTK_TREE_MODEL (propstore)); GtkCellRenderer *rend_propkey = gtk_cell_renderer_text_new (); GtkCellRenderer *rend_propvalue = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (rend_propvalue), "editable", TRUE, NULL); col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_propkey, "text", 0, NULL); col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_propvalue, "text", 1, NULL); gtk_tree_view_append_column (proptree, col1); gtk_tree_view_append_column (proptree, col2); } else { tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties")); propstore = GTK_LIST_STORE (gtk_tree_view_get_model (proptree)); gtk_list_store_clear (propstore); } if (numtracks == 1) { deadbeef->pl_lock (); gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), deadbeef->pl_find_meta_raw (tracks[0], ":URI")); deadbeef->pl_unlock (); } else { gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), _("[Multiple values]")); } g_object_set (G_OBJECT (rend_text2), "editable", TRUE, NULL); GtkWidget *widget = trackproperties; GtkWidget *w; const char *meta; trkproperties_fill_metadata (); gtk_widget_set_sensitive (lookup_widget (widget, "write_tags"), TRUE); gtk_widget_show (widget); gtk_window_present (GTK_WINDOW (widget)); }
extern void popup_all_resv(GtkTreeModel *model, GtkTreeIter *iter, int id) { char *name = NULL; char title[100] = {0}; ListIterator itr = NULL; popup_info_t *popup_win = NULL; GError *error = NULL; gtk_tree_model_get(model, iter, SORTID_NAME, &name, -1); switch(id) { case PART_PAGE: snprintf(title, 100, "Partition(s) with reservation %s", name); break; case JOB_PAGE: snprintf(title, 100, "Job(s) in reservation %s", name); break; case NODE_PAGE: snprintf(title, 100, "Node(s) in reservation %s ", name); break; case SUBMIT_PAGE: snprintf(title, 100, "Submit job in reservation %s", name); break; case INFO_PAGE: snprintf(title, 100, "Full info for reservation %s", name); break; default: g_print("resv got %d\n", id); } itr = list_iterator_create(popup_list); while ((popup_win = list_next(itr))) { if (popup_win->spec_info) if (!xstrcmp(popup_win->spec_info->title, title)) { break; } } list_iterator_destroy(itr); if (!popup_win) { if (id == INFO_PAGE) popup_win = create_popup_info(id, RESV_PAGE, title); else popup_win = create_popup_info(RESV_PAGE, id, title); } else { g_free(name); gtk_window_present(GTK_WINDOW(popup_win->popup)); return; } /* Pass the model and the structs from the iter so we can always get the current node_inx. */ popup_win->model = model; popup_win->iter = *iter; popup_win->node_inx_id = SORTID_NODE_INX; switch(id) { case JOB_PAGE: case INFO_PAGE: popup_win->spec_info->search_info->gchar_data = name; //specific_info_job(popup_win); break; case NODE_PAGE: case PART_PAGE: g_free(name); gtk_tree_model_get(model, iter, SORTID_NODELIST, &name, -1); popup_win->spec_info->search_info->gchar_data = name; popup_win->spec_info->search_info->search_type = SEARCH_NODE_NAME; //specific_info_node(popup_win); break; case SUBMIT_PAGE: break; default: g_print("resv got unknown type %d\n", id); } if (!sview_thread_new((gpointer)popup_thr, popup_win, false, &error)) { g_printerr ("Failed to create resv popup thread: %s\n", error->message); return; } }
void on_write_tags_clicked (GtkButton *button, gpointer user_data) { deadbeef->pl_lock (); GtkTreeView *tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); GtkTreeModel *model = GTK_TREE_MODEL (gtk_tree_view_get_model (tree)); // delete all metadata properties that are not in the listview for (int i = 0; i < numtracks; i++) { DB_metaInfo_t *meta = deadbeef->pl_get_metadata_head (tracks[i]); while (meta) { DB_metaInfo_t *next = meta->next; if (meta->key[0] != ':' && meta->key[0] != '!' && meta->key[0] != '_') { GtkTreeIter iter; gboolean res = gtk_tree_model_get_iter_first (model, &iter); while (res) { GValue key = {0,}; gtk_tree_model_get_value (model, &iter, 2, &key); const char *skey = g_value_get_string (&key); if (!strcasecmp (skey, meta->key)) { // field found, don't delete break; } res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter); } if (!res) { // field not found, delete deadbeef->pl_delete_metadata (tracks[i], meta); } } meta = next; } } // put all metainfo into track gtk_tree_model_foreach (model, set_metadata_cb, NULL); deadbeef->pl_unlock (); for (int i = 0; i < numtracks; i++) { ddb_event_track_t *ev = (ddb_event_track_t *)deadbeef->event_alloc (DB_EV_TRACKINFOCHANGED); ev->track = tracks[i]; deadbeef->pl_item_ref (ev->track); deadbeef->event_send ((ddb_event_t*)ev, 0, 0); } progress_aborted = 0; progressdlg = create_progressdlg (); gtk_window_set_title (GTK_WINDOW (progressdlg), _("Writing tags...")); g_signal_connect ((gpointer) progressdlg, "delete_event", G_CALLBACK (on_progress_delete_event), NULL); GtkWidget *cancelbtn = lookup_widget (progressdlg, "cancelbtn"); g_signal_connect ((gpointer) cancelbtn, "clicked", G_CALLBACK (on_progress_abort), NULL); gtk_widget_show_all (progressdlg); gtk_window_present (GTK_WINDOW (progressdlg)); gtk_window_set_transient_for (GTK_WINDOW (progressdlg), GTK_WINDOW (trackproperties)); // start new thread for writing metadata intptr_t tid = deadbeef->thread_start (write_meta_worker, NULL); deadbeef->thread_detach (tid); }
void gradients_save_as_pov_ray_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context; GimpGradient *gradient; GtkWidget *dialog; context = gimp_container_view_get_context (editor->view); gradient = gimp_context_get_gradient (context); if (! gradient) return; #define SAVE_AS_POV_DIALOG_KEY "gimp-save-as-pov-ray-dialog" dialog = dialogs_get_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY); if (! dialog) { gchar *title = g_strdup_printf (_("Save '%s' as POV-Ray"), gimp_object_get_name (gradient)); dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_OK, NULL); g_free (title); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data (G_OBJECT (dialog), "gimp", context->gimp); gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (GTK_WIDGET (editor))); gtk_window_set_role (GTK_WINDOW (dialog), "gimp-gradient-save-pov"); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); g_signal_connect (dialog, "response", G_CALLBACK (gradients_save_as_pov_ray_response), gradient); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect_object (dialog, "destroy", G_CALLBACK (g_object_unref), g_object_ref (gradient), G_CONNECT_SWAPPED); gimp_help_connect (dialog, gimp_standard_help_func, GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL); dialogs_attach_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); }
void on_add_field_activate (GtkMenuItem *menuitem, gpointer user_data) { GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); if (!gtk_widget_is_focus(GTK_WIDGET (treeview))) { return; // do not add field if Metadata tab is not focused } GtkWidget *dlg = create_entrydialog (); gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (trackproperties)); gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_RESPONSE_OK); gtk_window_set_title (GTK_WINDOW (dlg), _("Field name")); GtkWidget *e; e = lookup_widget (dlg, "title_label"); gtk_label_set_text (GTK_LABEL(e), _("Name:")); for (;;) { int res = gtk_dialog_run (GTK_DIALOG (dlg)); if (res == GTK_RESPONSE_OK) { e = lookup_widget (dlg, "title"); const char *text = gtk_entry_get_text (GTK_ENTRY(e)); GtkTreeIter iter; // check for _ and : if (text[0] == '_' || text[0] == ':' || text[0] == '!') { GtkWidget *d = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Field names must not start with : or _")); gtk_window_set_title (GTK_WINDOW (d), _("Cannot add field")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); continue; } // check if a field with the same name already exists int dup = 0; gboolean res = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter); while (res) { GValue value = {0,}; gtk_tree_model_get_value (GTK_TREE_MODEL (store), &iter, 2, &value); const char *svalue = g_value_get_string (&value); if (!strcasecmp (svalue, text)) { dup = 1; break; } res = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter); } if (!dup) { int l = strlen (text); char title[l+3]; snprintf (title, sizeof (title), "<%s>", text); const char *value = ""; const char *key = text; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, title, 1, value, 2, key, -1); GtkTreePath *path; gint rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL); path = gtk_tree_path_new_from_indices (rows - 1, -1); gtk_tree_view_set_cursor (treeview, path, NULL, TRUE); // set cursor onto new field gtk_tree_path_free(path); trkproperties_modified = 1; } else { GtkWidget *d = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Field with such name already exists, please try different name.")); gtk_window_set_title (GTK_WINDOW (d), _("Cannot add field")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); continue; } } break; } gtk_widget_destroy (dlg); gtk_window_present (GTK_WINDOW (trackproperties)); }
/** * gva_main_init: * * Initializes the main window. * * This function should be called once when the application starts. **/ void gva_main_init (void) { gchar *text; gva_tree_view_init (); gtk_box_pack_start ( GTK_BOX (GVA_WIDGET_MAIN_VBOX), gva_ui_get_managed_widget ("/main-menu"), FALSE, FALSE, 0); gtk_action_connect_proxy ( GVA_ACTION_VIEW_AVAILABLE, GVA_WIDGET_MAIN_VIEW_BUTTON_0); gtk_action_connect_proxy ( GVA_ACTION_VIEW_FAVORITES, GVA_WIDGET_MAIN_VIEW_BUTTON_1); gtk_action_connect_proxy ( GVA_ACTION_VIEW_RESULTS, GVA_WIDGET_MAIN_VIEW_BUTTON_2); gtk_action_connect_proxy ( GVA_ACTION_PROPERTIES, GVA_WIDGET_MAIN_PROPERTIES_BUTTON); gtk_action_connect_proxy ( GVA_ACTION_START, GVA_WIDGET_MAIN_START_GAME_BUTTON); gtk_widget_set_sensitive ( GVA_WIDGET_MAIN_MUTE_BUTTON, gva_mame_supports_sound ()); gconf_bridge_bind_property ( gconf_bridge_get (), GVA_GCONF_SOUND_MUTED, G_OBJECT (GVA_WIDGET_MAIN_MUTE_BUTTON), "muted"); gconf_bridge_bind_window ( gconf_bridge_get (), GVA_GCONF_WINDOW_PREFIX, GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW), TRUE, FALSE); /* Initialize the search entry. */ text = gva_main_get_last_search_text (); gtk_entry_set_text (GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY), text); g_free (text); #if !GTK_CHECK_VERSION(2,14,0) && !defined WITH_GNOME /* Requires that we link against libgnome. */ gtk_action_set_sensitive (GVA_ACTION_CONTENTS, FALSE); #endif gtk_action_set_sensitive (GVA_ACTION_PROPERTIES, FALSE); gtk_action_set_sensitive (GVA_ACTION_RECORD, FALSE); gtk_action_set_sensitive (GVA_ACTION_SEARCH, FALSE); gtk_action_set_sensitive (GVA_ACTION_SHOW_CLONES, FALSE); gtk_action_set_sensitive (GVA_ACTION_START, FALSE); gtk_action_set_sensitive (GVA_ACTION_VIEW_AVAILABLE, FALSE); gtk_action_set_sensitive (GVA_ACTION_VIEW_FAVORITES, FALSE); gtk_action_set_sensitive (GVA_ACTION_VIEW_RESULTS, FALSE); gtk_action_set_visible (GVA_ACTION_INSERT_FAVORITE, FALSE); gtk_action_set_visible (GVA_ACTION_REMOVE_FAVORITE, FALSE); gtk_window_present (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW)); }
void linphone_gtk_log_show(void){ gtk_widget_show(log_window); gtk_window_present(GTK_WINDOW(log_window)); }
gboolean socket_lock_input_cb(GIOChannel *source, GIOCondition condition, gpointer data) { gint fd, sock; gchar buf[BUFFER_LENGTH]; struct sockaddr_in caddr; socklen_t caddr_len = sizeof(caddr); GtkWidget *window = data; gboolean popup = FALSE; fd = g_io_channel_unix_get_fd(source); sock = accept(fd, (struct sockaddr *)&caddr, &caddr_len); /* first get the command */ while (socket_fd_gets(sock, buf, sizeof(buf)) != -1) { if (strncmp(buf, "open", 4) == 0) { while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { handle_input_filename(g_strstrip(buf)); } popup = TRUE; } else if (strncmp(buf, "doclist", 7) == 0) { gchar *doc_list = build_document_list(); if (NZV(doc_list)) socket_fd_write_all(sock, doc_list, strlen(doc_list)); else /* send ETX (end-of-text) in case we have no open files, we must send anything * otherwise the client would hang on reading */ socket_fd_write_all(sock, "\3", 1); g_free(doc_list); } else if (strncmp(buf, "line", 4) == 0) { while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { g_strstrip(buf); /* remove \n char */ /* on any error we get 0 which should be safe enough as fallback */ cl_options.goto_line = atoi(buf); } } else if (strncmp(buf, "column", 6) == 0) { while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { g_strstrip(buf); /* remove \n char */ /* on any error we get 0 which should be safe enough as fallback */ cl_options.goto_column = atoi(buf); } } #ifdef G_OS_WIN32 else if (strncmp(buf, "window", 6) == 0) { HWND hwnd = (HWND) gdk_win32_drawable_get_handle(GDK_DRAWABLE(window->window)); socket_fd_write(sock, (gchar *)&hwnd, sizeof(hwnd)); } #endif } if (popup) { #ifdef GDK_WINDOWING_X11 /* Set the proper interaction time on the window. This seems necessary to make * gtk_window_present() really bring the main window into the foreground on some * window managers like Gnome's metacity. * Code taken from Gedit. */ gdk_x11_window_set_user_time(window->window, gdk_x11_get_server_time(window->window)); #endif gtk_window_present(GTK_WINDOW(window)); #ifdef G_OS_WIN32 gdk_window_show(window->window); #endif } socket_fd_close(sock); return TRUE; }
void create_about_window() { if (about_window) { gtk_window_present(GTK_WINDOW(about_window)); return; } GtkWidget *vbox = gtk_vbox_new(FALSE,3); GtkWidget *hbox; /* Create a new about_window */ about_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(about_window), GTK_WIN_POS_CENTER); gtk_window_set_has_resize_grip(GTK_WINDOW(about_window), FALSE); gtk_window_set_title (GTK_WINDOW (about_window), _(_L("關於 gcin"))); g_signal_connect (G_OBJECT (about_window), "destroy", G_CALLBACK (callback_close), NULL); g_signal_connect (G_OBJECT (about_window), "delete_event", G_CALLBACK (callback_close), NULL); /* Sets the border width of the about_window. */ gtk_container_set_border_width (GTK_CONTAINER (about_window), 10); GtkWidget *label_version; GtkWidget *image; /* Create box for image and label */ hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); GtkWidget *separator = gtk_hseparator_new (); gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 3); // this doesn't work on win32 #if GTK_CHECK_VERSION(2,18,9) && UNIX && 0 char tmp[1024]; sprintf(tmp, "<a href='"FURL_LINUX"'>%s</a>\n" "<a href='"FURL_WIN32"'>%s</a>\n" "<a href='"LOG_URL"'>%s</a>\n" "<a href='"ET26_URL"'>%s</a>\n" "<a href='"PUNC_URL"'>%s</a>\n" "<a href='"ADD_PHRASE_URL"'>%s</a>\n" "<a href='"SPLIT_PHRASE_URL"'>%s</a>\n", _(_L("前往 gcin 討論區")), _(_L("gcin也有 Windows版")), _(_L("gcin改變記錄")), _(_L("推薦使用26鍵的注音鍵盤")), _(_L("使用詞音輸入標點符號")), _(_L("如何新增詞")), _(_L("如何手動斷詞")) ); GtkWidget *label = gtk_label_new(tmp); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); #else static struct { unich_t *label_str; char *url; } lab_url[] = { #if UNIX {_L("討論區"), FURL_LINUX }, {_L("gcin也有 Windows版"), FURL_WIN32}, #else {_L("討論區"), FURL_WIN32 }, {_L("gcin也有 Linux版"), FURL_LINUX}, #endif {_L("gcin也有 Android版"), FURL_ANDROID}, {_L("gcin改變記錄"), LOG_URL}, {_L("推薦使用26鍵的注音鍵盤"), ET26_URL}, {_L("使用詞音輸入標點符號"), PUNC_URL}, {_L("如何新增詞"), ADD_PHRASE_URL}, {_L("如何手動斷詞"), SPLIT_PHRASE_URL}, #if WIN32 {_L("IE內使用gcin"), IE_URL}, #endif {NULL} }; int i; for(i=0; lab_url[i].url; i++) { GtkWidget *button = gtk_button_new_with_label(_(lab_url[i].label_str)); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback_url), lab_url[i].url); } #endif #if UNIX image = gtk_image_new_from_file (SYS_ICON_DIR"/hicolor/64x64/apps/gcin.png"); #else char gcin_png[128]; sys_icon_fname("gcin.png", gcin_png); image = gtk_image_new_from_file (gcin_png); #endif label_version = gtk_label_new ("version " GCIN_VERSION " " __DATE__); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 3); gtk_box_pack_start (GTK_BOX (hbox), label_version, FALSE, FALSE, 3); gtk_container_add (GTK_CONTAINER (about_window), vbox); GtkWidget *button = gtk_button_new_with_label (_(_L("關閉"))); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 3); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback_close), (gpointer) "cool button"); gtk_widget_show_all (about_window); return; }