static void file_save_as (CeditTab *tab, CeditWindow *window) { GtkWidget *save_dialog; GtkWindowGroup *wg; CeditDocument *doc; GFile *file; gboolean uri_set = FALSE; const CeditEncoding *encoding; CeditDocumentNewlineType newline_type; g_return_if_fail (CEDIT_IS_TAB (tab)); g_return_if_fail (CEDIT_IS_WINDOW (window)); cedit_debug (DEBUG_COMMANDS); save_dialog = cedit_file_chooser_dialog_new (_("Save As\342\200\246"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (save_dialog), TRUE); g_signal_connect (save_dialog, "confirm-overwrite", G_CALLBACK (confirm_overwrite_callback), NULL); wg = cedit_window_get_group (window); gtk_window_group_add_window (wg, GTK_WINDOW (save_dialog)); /* Save As dialog is modal to its main window */ gtk_window_set_modal (GTK_WINDOW (save_dialog), TRUE); /* Set the suggested file name */ doc = cedit_tab_get_document (tab); file = cedit_document_get_location (doc); if (file != NULL) { uri_set = gtk_file_chooser_set_file (GTK_FILE_CHOOSER (save_dialog), file, NULL); g_object_unref (file); } if (!uri_set) { GFile *default_path; gchar *docname; default_path = _cedit_window_get_default_location (window); docname = cedit_document_get_short_name_for_display (doc); if (default_path != NULL) { gchar *uri; uri = g_file_get_uri (default_path); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (save_dialog), uri); g_free (uri); g_object_unref (default_path); } gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), docname); g_free (docname); } /* Set suggested encoding */ encoding = cedit_document_get_encoding (doc); g_return_if_fail (encoding != NULL); newline_type = cedit_document_get_newline_type (doc); cedit_file_chooser_dialog_set_encoding (CEDIT_FILE_CHOOSER_DIALOG (save_dialog), encoding); cedit_file_chooser_dialog_set_newline_type (CEDIT_FILE_CHOOSER_DIALOG (save_dialog), newline_type); g_object_set_data (G_OBJECT (save_dialog), CEDIT_TAB_TO_SAVE_AS, tab); g_signal_connect (save_dialog, "response", G_CALLBACK (save_dialog_response_cb), window); gtk_widget_show (save_dialog); }
void e_composer_private_constructed (EMsgComposer *composer) { EMsgComposerPrivate *priv = composer->priv; EFocusTracker *focus_tracker; EComposerHeader *header; EShell *shell; EClientCache *client_cache; EHTMLEditor *editor; EHTMLEditorView *view; GtkUIManager *ui_manager; GtkAction *action; GtkWidget *container; GtkWidget *widget; GtkWidget *send_widget; GtkWindow *window; GSettings *settings; const gchar *path; gchar *filename, *gallery_path; gint ii; GError *error = NULL; editor = e_msg_composer_get_editor (composer); ui_manager = e_html_editor_get_ui_manager (editor); view = e_html_editor_get_view (editor); settings = e_util_ref_settings ("org.gnome.evolution.mail"); shell = e_msg_composer_get_shell (composer); client_cache = e_shell_get_client_cache (shell); /* Each composer window gets its own window group. */ window = GTK_WINDOW (composer); priv->window_group = gtk_window_group_new (); gtk_window_group_add_window (priv->window_group, window); priv->async_actions = gtk_action_group_new ("async"); priv->charset_actions = gtk_action_group_new ("charset"); priv->composer_actions = gtk_action_group_new ("composer"); priv->extra_hdr_names = g_ptr_array_new (); priv->extra_hdr_values = g_ptr_array_new (); priv->charset = e_composer_get_default_charset (); priv->is_from_new_message = FALSE; priv->set_signature_from_message = FALSE; priv->disable_signature = FALSE; priv->busy = FALSE; priv->saved_editable = FALSE; priv->drop_occured = FALSE; priv->dnd_is_uri = FALSE; priv->check_if_signature_is_changed = FALSE; priv->ignore_next_signature_change = FALSE; priv->dnd_history_saved = FALSE; priv->focused_entry = NULL; e_composer_actions_init (composer); filename = e_composer_find_data_file ("evolution-composer.ui"); gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error); g_free (filename); /* We set the send button as important to have a label */ path = "/main-toolbar/pre-main-toolbar/send"; send_widget = gtk_ui_manager_get_widget (ui_manager, path); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE); composer_setup_charset_menu (composer); if (error != NULL) { /* Henceforth, bad things start happening. */ g_critical ("%s", error->message); g_clear_error (&error); } /* Configure an EFocusTracker to manage selection actions. */ focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer)); action = e_html_editor_get_action (editor, "cut"); e_focus_tracker_set_cut_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "copy"); e_focus_tracker_set_copy_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "paste"); e_focus_tracker_set_paste_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "select-all"); e_focus_tracker_set_select_all_action (focus_tracker, action); action = e_html_editor_get_action (editor, "undo"); e_focus_tracker_set_undo_action (focus_tracker, action); action = e_html_editor_get_action (editor, "redo"); e_focus_tracker_set_redo_action (focus_tracker, action); priv->focus_tracker = focus_tracker; widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (composer), widget); gtk_widget_show (widget); container = widget; /* Construct the main menu and toolbar. */ widget = e_html_editor_get_managed_widget (editor, "/main-menu"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); widget = e_html_editor_get_managed_widget (editor, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the header table. */ widget = e_composer_header_table_new (client_cache); gtk_container_set_border_width (GTK_CONTAINER (widget), 6); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); priv->header_table = g_object_ref (widget); gtk_widget_show (widget); header = e_composer_header_table_get_header ( E_COMPOSER_HEADER_TABLE (widget), E_COMPOSER_HEADER_SUBJECT); e_binding_bind_property ( view, "spell-checker", header->input_widget, "spell-checker", G_BINDING_SYNC_CREATE); /* Construct the editing toolbars. We'll have to reparent * the embedded EHTMLEditorView a little further down. */ widget = GTK_WIDGET (editor); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the attachment paned. */ widget = e_attachment_paned_new (); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); priv->attachment_paned = g_object_ref_sink (widget); gtk_widget_show (widget); e_binding_bind_property ( view, "editable", widget, "sensitive", G_BINDING_SYNC_CREATE); container = e_attachment_paned_get_content_area ( E_ATTACHMENT_PANED (priv->attachment_paned)); widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); gtk_widget_show (widget); container = widget; widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT); gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE); priv->gallery_scrolled_window = g_object_ref (widget); gtk_widget_show (widget); /* Reparent the scrolled window containing the web view * widget into the content area of the top attachment pane. */ widget = GTK_WIDGET (view); widget = gtk_widget_get_parent (widget); gtk_widget_reparent (widget, container); /* Construct the picture gallery. */ container = priv->gallery_scrolled_window; /* FIXME This should be an EMsgComposer property. */ gallery_path = g_settings_get_string ( settings, "composer-gallery-path"); widget = e_picture_gallery_new (gallery_path); gtk_container_add (GTK_CONTAINER (container), widget); priv->gallery_icon_view = g_object_ref_sink (widget); g_free (gallery_path); e_signal_connect_notify_swapped ( view, "notify::mode", G_CALLBACK (composer_update_gallery_visibility), composer); g_signal_connect_swapped ( ACTION (PICTURE_GALLERY), "toggled", G_CALLBACK (composer_update_gallery_visibility), composer); /* Initial sync */ composer_update_gallery_visibility (composer); /* Bind headers to their corresponding actions. */ for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) { EComposerHeaderTable *table; EComposerHeader *header; GtkAction *action; table = E_COMPOSER_HEADER_TABLE (priv->header_table); header = e_composer_header_table_get_header (table, ii); switch (ii) { case E_COMPOSER_HEADER_FROM: e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); action = ACTION (VIEW_FROM_OVERRIDE); e_binding_bind_property ( header, "override-visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); continue; case E_COMPOSER_HEADER_BCC: action = ACTION (VIEW_BCC); break; case E_COMPOSER_HEADER_CC: action = ACTION (VIEW_CC); break; case E_COMPOSER_HEADER_REPLY_TO: action = ACTION (VIEW_REPLY_TO); e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); break; case E_COMPOSER_HEADER_SUBJECT: e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); continue; default: continue; } e_binding_bind_property ( header, "sensitive", action, "sensitive", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); e_binding_bind_property ( header, "visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } /* Disable actions that start asynchronous activities while an * asynchronous activity is in progress. We enforce this with * a simple inverted binding to EMsgComposer's "busy" property. */ e_binding_bind_property ( composer, "busy", priv->async_actions, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); e_binding_bind_property ( composer, "busy", priv->header_table, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_unref (settings); }
static void dma_data_view_goto_activate (GtkWidget *menu_item, DmaDataView *view) { GtkWidget *toplevel; GtkWidget *frame; GtkWidget *vbox; GtkWindowGroup *toplevel_group; GtkWindowGroup *goto_window_group; toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view)); toplevel_group = gtk_window_get_group (GTK_WINDOW (toplevel)); goto_window_group = gtk_window_get_group (GTK_WINDOW (view->goto_window)); if (view->goto_window != NULL) { if (toplevel_group) gtk_window_group_add_window (toplevel_group, GTK_WINDOW (view->goto_window)); else if (goto_window_group) gtk_window_group_remove_window (goto_window_group, GTK_WINDOW (view->goto_window)); } else { view->goto_window = gtk_window_new (GTK_WINDOW_POPUP); if (toplevel_group) gtk_window_group_add_window (toplevel_group, GTK_WINDOW (view->goto_window)); gtk_window_set_modal (GTK_WINDOW (view->goto_window), TRUE); g_signal_connect (view->goto_window, "delete_event", G_CALLBACK (dma_data_view_goto_delete_event), view); g_signal_connect (view->goto_window, "key_press_event", G_CALLBACK (dma_data_view_goto_key_press_event), view); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_widget_show (frame); gtk_container_add (GTK_CONTAINER (view->goto_window), frame); vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 3); /* add entry */ view->goto_entry = gtk_entry_new (); gtk_entry_set_icon_from_stock (GTK_ENTRY (view->goto_entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_JUMP_TO); gtk_widget_show (view->goto_entry); gtk_container_add (GTK_CONTAINER (vbox), view->goto_entry); gtk_widget_realize (view->goto_entry); } dma_data_view_goto_position_func (view); gtk_entry_set_text (GTK_ENTRY (view->goto_entry), "0x"); gtk_widget_show (view->goto_window); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view->address), FALSE); gtk_widget_grab_focus (view->goto_entry); send_focus_change (view->goto_entry, TRUE); gtk_editable_set_position (GTK_EDITABLE (view->goto_entry), -1); }
static void add_or_remove (GeditEncodingsComboBox *menu, GtkTreeModel *model) { GtkTreeIter iter; gboolean add_item = FALSE; if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (menu), &iter)) { gtk_tree_model_get (model, &iter, ADD_COLUMN, &add_item, -1); } if (!add_item) { menu->priv->activated_item = gtk_combo_box_get_active (GTK_COMBO_BOX (menu)); } else { GtkWidget *dialog; GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu)); if (!gtk_widget_is_toplevel (toplevel)) toplevel = NULL; g_signal_handler_block (menu, menu->priv->changed_id); gtk_combo_box_set_active (GTK_COMBO_BOX (menu), menu->priv->activated_item); g_signal_handler_unblock (menu, menu->priv->changed_id); dialog = gedit_encodings_dialog_new(); if (toplevel != NULL) { GtkWindowGroup *wg; gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel)); if (gtk_window_has_group (GTK_WINDOW (toplevel))) { wg = gtk_window_get_group (GTK_WINDOW (toplevel)); } else { wg = gtk_window_group_new (); gtk_window_group_add_window (wg, GTK_WINDOW (toplevel)); } gtk_window_group_add_window (wg, GTK_WINDOW (dialog)); } gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), menu); gtk_widget_show (dialog); } }
static void create_window (void) { GtkWidget *bar; GtkWidget *table; GtkWidget *contents; GtkUIManager *ui; GtkWidget *sw; GtkActionGroup *actions; GError *error; GtkWindowGroup *group; main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); group = gtk_window_group_new (); gtk_window_group_add_window (group, GTK_WINDOW (main_window)); g_object_unref (group); gtk_window_set_default_size (GTK_WINDOW (main_window), 400, 600); g_signal_connect (main_window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); actions = gtk_action_group_new ("Actions"); gtk_action_group_add_actions (actions, entries, n_entries, NULL); ui = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui, actions, 0); gtk_window_add_accel_group (GTK_WINDOW (main_window), gtk_ui_manager_get_accel_group (ui)); gtk_container_set_border_width (GTK_CONTAINER (main_window), 0); error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); } table = gtk_table_new (1, 3, FALSE); gtk_container_add (GTK_CONTAINER (main_window), table); bar = gtk_ui_manager_get_widget (ui, "/MenuBar"); gtk_widget_show (bar); gtk_table_attach (GTK_TABLE (table), bar, /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); 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_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_widget_grab_focus (contents); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); g_signal_connect_object (buffer, "changed", G_CALLBACK (buffer_changed_callback), NULL, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), NULL, 0); g_signal_connect_object (main_window, "window_state_event", G_CALLBACK (update_resize_grip), statusbar, 0); update_ui (); gtk_widget_show_all (main_window); }
nsresult EmbedPrompter::Create(PromptType aType, GtkWindow* aParentWindow) { mWindow = gtk_dialog_new_with_buttons(mTitle.get(), aParentWindow, (GtkDialogFlags)0, NULL); // only add the dialog to the window group if the parent already has a window group, // so as not to break app's expectations about modal dialogs. if (aParentWindow && aParentWindow->group) { gtk_window_group_add_window (aParentWindow->group, GTK_WINDOW (mWindow)); } // gtk will resize this for us as necessary gtk_window_set_default_size(GTK_WINDOW(mWindow), 100, 50); // this HBox will contain the icon, and a vbox which contains the // dialog text and other widgets. GtkWidget* dialogHBox = gtk_hbox_new(FALSE, 12); // Set up dialog properties according to the GNOME HIG // (http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows) gtk_container_set_border_width(GTK_CONTAINER(mWindow), 6); gtk_dialog_set_has_separator(GTK_DIALOG(mWindow), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(mWindow)->vbox), 12); gtk_container_set_border_width(GTK_CONTAINER(dialogHBox), 6); // This is the VBox which will contain the label and other controls. GtkWidget* contentsVBox = gtk_vbox_new(FALSE, 12); // get the stock icon for this dialog and put it in the box const gchar* iconDesc = DialogTable[aType].icon; GtkWidget* icon = gtk_image_new_from_stock(iconDesc, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0); gtk_box_pack_start(GTK_BOX(dialogHBox), icon, FALSE, FALSE, 0); // now pack the label into the vbox GtkWidget* label = gtk_label_new(mMessageText.get()); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), label, FALSE, FALSE, 0); int widgetFlags = DialogTable[aType].flags; if (widgetFlags & (INCLUDE_USERNAME | INCLUDE_PASSWORD)) { // If we're creating a username and/or password field, make an hbox // which will contain two vboxes, one for the labels and one for the // text fields. This will let us line up the textfields. GtkWidget* userPassHBox = gtk_hbox_new(FALSE, 12); GtkWidget* userPassLabels = gtk_vbox_new(TRUE, 6); GtkWidget* userPassFields = gtk_vbox_new(TRUE, 6); if (widgetFlags & INCLUDE_USERNAME) { GtkWidget* userLabel = gtk_label_new("User Name:"); gtk_box_pack_start(GTK_BOX(userPassLabels), userLabel, FALSE, FALSE, 0); mUserField = gtk_entry_new(); if (!mUser.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get()); gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE); gtk_box_pack_start(GTK_BOX(userPassFields), mUserField, FALSE, FALSE, 0); } if (widgetFlags & INCLUDE_PASSWORD) { GtkWidget* passLabel = gtk_label_new("Password:"); gtk_box_pack_start(GTK_BOX(userPassLabels), passLabel, FALSE, FALSE, 0); mPassField = gtk_entry_new(); if (!mPass.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get()); gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE); gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE); gtk_box_pack_start(GTK_BOX(userPassFields), mPassField, FALSE, FALSE, 0); } gtk_box_pack_start(GTK_BOX(userPassHBox), userPassLabels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(userPassHBox), userPassFields, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(contentsVBox), userPassHBox, FALSE, FALSE, 0); } if (aType == TYPE_PROMPT) { mTextField = gtk_entry_new(); if (!mTextValue.IsEmpty()) gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get()); gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0); } // Add a checkbox if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) { mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox), mCheckValue); gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))), TRUE); gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0); } // Add a dropdown menu if (aType == TYPE_SELECT) { // Build up a GtkMenu containing the items GtkWidget* menu = gtk_menu_new(); for (PRUint32 i = 0; i < mItemCount; ++i) { GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get()); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); } // Now create an OptionMenu and set this as the menu mOptionMenu = gtk_option_menu_new(); gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu); gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0); } if (aType == TYPE_UNIVERSAL) { // Create buttons based on the flags passed in. for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) { if (!mButtonLabels[i].IsEmpty()) gtk_dialog_add_button(GTK_DIALOG(mWindow), mButtonLabels[i].get(), i); } gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0); } else { // Create standard ok and cancel buttons if (widgetFlags & INCLUDE_CANCEL) gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); gtk_widget_grab_default(okButton); } // Pack the contentsVBox into the dialogHBox and the dialog. gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(mWindow)->vbox), dialogHBox, FALSE, FALSE, 0); return NS_OK; }
void GtkNSSSecurityWarningDialogs::DoDialog (nsIInterfaceRequestor *aContext, const char *aPrefName, GtkMessageType aType, GtkButtonsType aButtons, int aDefaultResponse, const char *aPrimary, const char *aSecondary, const char *aButtonText, PRBool *_retval) { if (_retval) *_retval = PR_FALSE; nsresult rv; PRBool show = PR_TRUE; nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService (NS_PREFSERVICE_CONTRACTID)); if (prefBranch && aPrefName) { rv = prefBranch->GetBoolPref (aPrefName, &show); if (NS_FAILED(rv)) show = PR_TRUE; } char *showOncePref = NULL; PRBool showOnce = PR_FALSE; if (!show && prefBranch && aPrefName) { showOncePref = g_strconcat (aPrefName, ".show_once", NULL); rv = prefBranch->GetBoolPref (showOncePref, &showOnce); if (NS_FAILED (rv)) showOnce = PR_FALSE; } if (!show && !showOnce) { g_free (showOncePref); if (_retval) *_retval = PR_TRUE; return; } AutoJSContextStack stack; rv = stack.Init (); if (NS_FAILED (rv)) return; /* Didn't you know it, mozilla SUCKS! * the "aContext" interface requestor is made from a nsIDOMWindow, * but can only give out a nsIPrompt, from where there's no way to get * the nsIDOMWindow back! * * However GaleonUtils::FindGtkParent falls back to the current active * window so this vageuly works for us at the moment * * https://bugzilla.mozilla.org/show_bug.cgi?id=277587 */ nsCOMPtr<nsIDOMWindow> domWin (do_GetInterface (aContext)); GtkWidget *parent = GaleonUtils::FindGtkParent (domWin); GtkDialogFlags flags = parent ? (GtkDialogFlags)0 : GTK_DIALOG_MODAL; #if GTK_CHECK_VERSION(2,6,0) GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (parent), flags, aType, aButtons, "%s", aPrimary); if (aSecondary) { gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", aSecondary); } #else GtkWidget *dialog = hig_alert_new (GTK_WINDOW (parent), flags, aType == GTK_MESSAGE_INFO ? HIG_ALERT_INFORMATION : HIG_ALERT_CONFIRMATION, aPrimary, aSecondary, NULL); if (aButtons == GTK_BUTTONS_OK) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); } else if (aButtons == GTK_BUTTONS_CANCEL) { gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); } else { g_assert_not_reached(); } #endif if (parent && GTK_WINDOW (parent)->group) { gtk_window_group_add_window (GTK_WINDOW (parent)->group, GTK_WINDOW (dialog)); } if (aButtonText) { gtk_dialog_add_button (GTK_DIALOG (dialog), aButtonText, GTK_RESPONSE_ACCEPT); } gtk_dialog_set_default_response (GTK_DIALOG (dialog), aDefaultResponse); int response = gtk_dialog_run (GTK_DIALOG (dialog)); if (_retval) *_retval = response == GTK_RESPONSE_ACCEPT; if (prefBranch && showOncePref && showOnce) { prefBranch->SetBoolPref (showOncePref, PR_FALSE); } gtk_widget_destroy (dialog); g_free (showOncePref); }
bool wxPopupWindow::Create( wxWindow *parent, int style ) { if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) || !CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") )) { wxFAIL_MSG( wxT("wxPopupWindow creation failed") ); return false; } // Unlike windows, top level windows are created hidden by default. m_isShown = false; // All dialogs should really have this style m_windowStyle |= wxTAB_TRAVERSAL; m_widget = gtk_window_new( GTK_WINDOW_POPUP ); g_object_ref( m_widget ); gtk_widget_set_name( m_widget, "wxPopupWindow" ); // wxPopupWindow is used for different windows as well // gtk_window_set_type_hint( GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_COMBO ); // Popup windows can be created without parent, so handle this correctly. if (parent) { GtkWidget *toplevel = gtk_widget_get_toplevel( parent->m_widget ); if (GTK_IS_WINDOW (toplevel)) { #if GTK_CHECK_VERSION(2,10,0) #ifndef __WXGTK3__ if (!gtk_check_version(2,10,0)) #endif { gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (m_widget)); } #endif gtk_window_set_transient_for (GTK_WINDOW (m_widget), GTK_WINDOW (toplevel)); } gtk_window_set_screen (GTK_WINDOW (m_widget), gtk_widget_get_screen (GTK_WIDGET (parent->m_widget))); } gtk_window_set_resizable (GTK_WINDOW (m_widget), FALSE); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_dialog_delete_callback), this); m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); if (m_parent) m_parent->AddChild( this ); PostCreation(); m_time = gtk_get_current_event_time(); g_signal_connect (m_widget, "button_press_event", G_CALLBACK (gtk_popup_button_press), this); return true; }
static void moo_position_window_real (GtkWidget *window, GtkWidget *parent, gboolean at_mouse, gboolean at_coords, int x, int y) { GtkWidget *toplevel = NULL; g_return_if_fail (GTK_IS_WINDOW (window)); if (parent) toplevel = gtk_widget_get_toplevel (parent); if (toplevel && !GTK_IS_WINDOW (toplevel)) toplevel = NULL; if (toplevel) { gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (toplevel)); #ifdef __WIN32__ g_signal_handlers_disconnect_by_func (window, (gpointer) on_hide, NULL); g_signal_connect (window, "unmap", G_CALLBACK (on_hide), NULL); #endif } if (toplevel && GTK_WINDOW(toplevel)->group) gtk_window_group_add_window (GTK_WINDOW(toplevel)->group, GTK_WINDOW (window)); if (!at_mouse && !at_coords && parent && GTK_WIDGET_REALIZED (parent)) { if (GTK_IS_WINDOW (parent)) { gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT); } else { GdkWindow *parent_window = gtk_widget_get_parent_window (parent); gdk_window_get_origin (parent_window, &x, &y); x += parent->allocation.x; y += parent->allocation.y; x += parent->allocation.width / 2; y += parent->allocation.height / 2; at_coords = TRUE; } } if (at_mouse) { gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); } else if (at_coords) { GdkPoint *coord = g_new (GdkPoint, 1); coord->x = x; coord->y = y; gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_NONE); g_object_set_data_full (G_OBJECT (window), "moo-coords", coord, g_free); if (!GTK_WIDGET_REALIZED (window)) { g_signal_handlers_disconnect_by_func (window, (gpointer) position_window, NULL); g_signal_connect (window, "realize", G_CALLBACK (position_window), NULL); } else { position_window (GTK_WINDOW (window)); } } }
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *aReturn) { NS_ENSURE_ARG_POINTER(aReturn); nsXPIDLCString title; title.Adopt(ToNewUTF8String(mTitle)); GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget); GtkFileChooserAction action = GetGtkFileChooserAction(mMode); const gchar *accept_button = (action == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE : GTK_STOCK_OPEN; #if (MOZ_PLATFORM_MAEMO == 5) GtkWidget *file_chooser = hildon_file_chooser_dialog_new_with_properties(parent_widget, "action", action, "open-button-text", accept_button, NULL); gtk_window_set_title(GTK_WINDOW(file_chooser), title); #else GtkWidget *file_chooser = gtk_file_chooser_dialog_new(title, parent_widget, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); if (mAllowURLs) { gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE); } #endif if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SAVE) { GtkWidget *img_preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser), img_preview); g_signal_connect(file_chooser, "update-preview", G_CALLBACK(UpdateFilePreviewWidget), img_preview); } if (parent_widget && parent_widget->group) { gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser)); } NS_ConvertUTF16toUTF8 defaultName(mDefault); switch (mMode) { case nsIFilePicker::modeOpenMultiple: gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), TRUE); break; case nsIFilePicker::modeSave: gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser), defaultName.get()); break; } nsCOMPtr<nsIFile> defaultPath; if (mDisplayDirectory) { mDisplayDirectory->Clone(getter_AddRefs(defaultPath)); } else if (mPrevDisplayDirectory) { mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath)); } if (defaultPath) { if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) { // Try to select the intended file. Even if it doesn't exist, GTK still switches // directories. defaultPath->AppendNative(defaultName); nsCAutoString path; defaultPath->GetNativePath(path); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get()); } else { nsCAutoString directory; defaultPath->GetNativePath(directory); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory.get()); } } gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT); PRInt32 count = mFilters.Length(); for (PRInt32 i = 0; i < count; ++i) { // This is fun... the GTK file picker does not accept a list of filters // so we need to split out each string, and add it manually. char **patterns = g_strsplit(mFilters[i].get(), ";", -1); if (!patterns) { return NS_ERROR_OUT_OF_MEMORY; } GtkFileFilter *filter = gtk_file_filter_new(); for (int j = 0; patterns[j] != NULL; ++j) { nsCAutoString caseInsensitiveFilter = MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j])); gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get()); } g_strfreev(patterns); if (!mFilterNames[i].IsEmpty()) { // If we have a name for our filter, let's use that. const char *filter_name = mFilterNames[i].get(); gtk_file_filter_set_name(filter, filter_name); } else { // If we don't have a name, let's just use the filter pattern. const char *filter_pattern = mFilters[i].get(); gtk_file_filter_set_name(filter, filter_pattern); } gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter); // Set the initially selected filter if (mSelectedType == i) { gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter); } } gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE); gint response = RunDialog(GTK_DIALOG(file_chooser)); switch (response) { case GTK_RESPONSE_OK: case GTK_RESPONSE_ACCEPT: ReadValuesFromFileChooser(file_chooser); *aReturn = nsIFilePicker::returnOK; if (mMode == nsIFilePicker::modeSave) { nsCOMPtr<nsILocalFile> file; GetFile(getter_AddRefs(file)); if (file) { PRBool exists = PR_FALSE; file->Exists(&exists); if (exists) *aReturn = nsIFilePicker::returnReplace; } } break; case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_CLOSE: case GTK_RESPONSE_DELETE_EVENT: *aReturn = nsIFilePicker::returnCancel; break; default: NS_WARNING("Unexpected response"); *aReturn = nsIFilePicker::returnCancel; break; } gtk_widget_destroy(file_chooser); return NS_OK; }
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *aReturn) { NS_ENSURE_ARG_POINTER(aReturn); nsXPIDLCString title; title.Adopt(ToNewUTF8String(mTitle)); GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget); GtkFileChooserAction action = GetGtkFileChooserAction(mMode); const gchar *accept_button = (mMode == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE : GTK_STOCK_OPEN; GtkWidget *file_chooser = _gtk_file_chooser_dialog_new(title, parent_widget, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL); if (parent_widget && parent_widget->group) { gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser)); } if (mMode == nsIFilePicker::modeOpenMultiple) { _gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(file_chooser), TRUE); } else if (mMode == nsIFilePicker::modeSave) { char *default_filename = ToNewUTF8String(mDefault); _gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser), NS_STATIC_CAST(const gchar*, default_filename)); nsMemory::Free(default_filename); } gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT); nsCAutoString directory; if (mDisplayDirectory) { mDisplayDirectory->GetNativePath(directory); } else if (mPrevDisplayDirectory) { mPrevDisplayDirectory->GetNativePath(directory); } if (!directory.IsEmpty()) { _gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory.get()); } PRInt32 count = mFilters.Count(); for (PRInt32 i = 0; i < count; ++i) { // This is fun... the GTK file picker does not accept a list of filters // so we need to split out each string, and add it manually. char **patterns = g_strsplit(mFilters[i]->get(), ";", -1); if (!patterns) { return NS_ERROR_OUT_OF_MEMORY; } GtkFileFilter *filter = _gtk_file_filter_new (); for (int j = 0; patterns[j] != NULL; ++j) { _gtk_file_filter_add_pattern (filter, g_strstrip (patterns[j])); } g_strfreev(patterns); if (!mFilterNames[i]->IsEmpty()) { // If we have a name for our filter, let's use that. const char *filter_name = mFilterNames[i]->get(); _gtk_file_filter_set_name (filter, filter_name); } else { // If we don't have a name, let's just use the filter pattern. const char *filter_pattern = mFilters[i]->get(); _gtk_file_filter_set_name (filter, filter_pattern); } _gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter); // Set the initially selected filter if (mSelectedType == i) { _gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(file_chooser), filter); } } PRBool checkForOverwrite = PR_TRUE; if (_gtk_file_chooser_set_do_overwrite_confirmation) { checkForOverwrite = PR_FALSE; // Only available in GTK 2.8 _gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE); } gint response = gtk_dialog_run (GTK_DIALOG (file_chooser)); switch (response) { case GTK_RESPONSE_ACCEPT: ReadValuesFromFileChooser(file_chooser); *aReturn = nsIFilePicker::returnOK; if (mMode == nsIFilePicker::modeSave) { nsCOMPtr<nsILocalFile> file; GetFile(getter_AddRefs(file)); if (file) { PRBool exists = PR_FALSE; file->Exists(&exists); if (exists) { PRBool overwrite = !checkForOverwrite || confirm_overwrite_file (file_chooser, file); if (overwrite) { *aReturn = nsIFilePicker::returnReplace; } else { *aReturn = nsIFilePicker::returnCancel; } } } } break; case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_CLOSE: case GTK_RESPONSE_DELETE_EVENT: *aReturn = nsIFilePicker::returnCancel; break; default: NS_WARNING("Unexpected response"); *aReturn = nsIFilePicker::returnCancel; break; } gtk_widget_destroy(file_chooser); return NS_OK; }
static void gnc_date_edit_popup (GNCDateEdit *gde) { GtkWidget *toplevel; struct tm mtm; gboolean date_was_valid; GdkDevice *device, *keyboard, *pointer; g_return_if_fail (GNC_IS_DATE_EDIT (gde)); ENTER("gde %p", gde); device = gtk_get_current_event_device (); /* This code is pretty much just copied from gtk_date_edit_get_date */ date_was_valid = qof_scan_date (gtk_entry_get_text (GTK_ENTRY (gde->date_entry)), &mtm.tm_mday, &mtm.tm_mon, &mtm.tm_year); if (!date_was_valid) { /* No valid date. Hacky workaround: Instead of crashing we randomly choose today's date. */ gnc_tm_get_today_start(&mtm); } mtm.tm_mon--; /* Hope the user does not actually mean years early in the A.D. days... * This date widget will obviously not work for a history program :-) */ if (mtm.tm_year >= 1900) mtm.tm_year -= 1900; gnc_tm_set_day_start(&mtm); /* Set the calendar. */ gtk_calendar_select_day (GTK_CALENDAR (gde->calendar), 1); gtk_calendar_select_month (GTK_CALENDAR (gde->calendar), mtm.tm_mon, 1900 + mtm.tm_year); gtk_calendar_select_day (GTK_CALENDAR (gde->calendar), mtm.tm_mday); /* Make sure we'll get notified of clicks outside the popup * window so we can properly pop down if that happens. */ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (gde)); if (GTK_IS_WINDOW (toplevel)) { gtk_window_group_add_window ( gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (gde->cal_popup)); gtk_window_set_transient_for (GTK_WINDOW (gde->cal_popup), GTK_WINDOW (toplevel)); } position_popup (gde); gtk_widget_show (gde->cal_popup); gtk_widget_grab_focus (gde->cal_popup); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gde->date_button), TRUE); if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) { keyboard = device; pointer = gdk_device_get_associated_device (device); } else { pointer = device; keyboard = gdk_device_get_associated_device (device); } if (!gtk_widget_has_focus (gde->calendar)) gtk_widget_grab_focus (gde->calendar); if (!popup_grab_on_window (gtk_widget_get_window ((GTK_WIDGET(gde->cal_popup))), keyboard, pointer, GDK_CURRENT_TIME)) { gtk_widget_hide (gde->cal_popup); LEAVE("Failed to grab window"); return; } gtk_grab_add (gde->cal_popup); LEAVE(" "); }
static gboolean cg_combo_flags_popup_idle (gpointer data) { CgComboFlags *combo; CgComboFlagsPrivate *priv; GtkTreeSelection* selection; GtkWidget *toplevel; GtkWidget *scrolled; GdkWindow *window; GdkDeviceManager* device_manager; gint height, width, x, y; combo = CG_COMBO_FLAGS (data); priv = CG_COMBO_FLAGS_PRIVATE (combo); g_assert (priv->window == NULL); priv->window = gtk_window_new (GTK_WINDOW_POPUP); g_object_ref (G_OBJECT (priv->window)); gtk_window_set_resizable (GTK_WINDOW (priv->window), FALSE); g_signal_connect (G_OBJECT (priv->window), "key_press_event", G_CALLBACK (cg_combo_flags_window_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->window), "button_press_event", G_CALLBACK (cg_combo_flags_window_button_press_cb), combo); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (priv->window), scrolled); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_widget_show (scrolled); priv->treeview = gtk_tree_view_new_with_model (priv->model); gtk_widget_show (priv->treeview); gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview); g_signal_connect (G_OBJECT (priv->treeview), "key_press_event", G_CALLBACK (cg_combo_flags_treeview_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->treeview), "button_press_event", G_CALLBACK (cg_combo_flags_treeview_button_press_cb), combo); priv->column = gtk_tree_view_column_new (); g_object_ref (G_OBJECT (priv->column)); cg_combo_flags_sync_cells (combo, GTK_CELL_LAYOUT (priv->column)); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), priv->column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->treeview), TRUE); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo)); if (GTK_IS_WINDOW (toplevel)) { gtk_window_group_add_window (gtk_window_get_group ( GTK_WINDOW (toplevel)), GTK_WINDOW (priv->window)); gtk_window_set_transient_for (GTK_WINDOW (priv->window), GTK_WINDOW (toplevel)); } gtk_window_set_screen (GTK_WINDOW (priv->window), gtk_widget_get_screen (GTK_WIDGET (combo))); cg_combo_flags_get_position (combo, &x, &y, &width, &height); gtk_widget_set_size_request (priv->window, width, height); gtk_window_move (GTK_WINDOW(priv->window), x, y); gtk_widget_show (priv->window); gtk_widget_grab_focus (priv->window); if (!gtk_widget_has_focus (priv->treeview)) gtk_widget_grab_focus (priv->treeview); window = gtk_widget_get_window (priv->window); device_manager = gdk_display_get_device_manager (gdk_window_get_display (window)); priv->pointer_device = gdk_device_manager_get_client_pointer (device_manager); priv->keyboard_device = gdk_device_get_associated_device (priv->pointer_device); gtk_grab_add (priv->window); gdk_device_grab (priv->pointer_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, GDK_CURRENT_TIME); gdk_device_grab (priv->keyboard_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, GDK_CURRENT_TIME); return FALSE; }