/* shows an error dialog making it transient for @parent */ void gdict_show_error_dialog (GtkWindow *parent, const gchar *message, const gchar *detail) { GtkWidget *dialog; g_return_if_fail ((parent == NULL) || (GTK_IS_WINDOW (parent))); g_return_if_fail (message != NULL); dialog = gtk_message_dialog_new (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", message); gtk_window_set_title (GTK_WINDOW (dialog), ""); if (detail) gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", detail); if (parent && gtk_window_get_group (parent)) gtk_window_group_add_window (gtk_window_get_group (parent), GTK_WINDOW (dialog)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); }
static void gdict_window_created_cb (GdictWindow *parent, GdictWindow *new_window, gpointer user_data) { GdictApp *app = GDICT_APP (user_data); /* this might seem convoluted - but it's necessary, since I don't want * GdictWindow to know about the GdictApp singleton. every time a new * window is created by a GdictWindow, it will register its "child window" * here; the lifetime handlers will check every child window created and * destroyed, and will add/remove it to the windows list accordingly */ g_signal_connect (new_window, "created", G_CALLBACK (gdict_window_created_cb), app); g_signal_connect (new_window, "destroy", G_CALLBACK (gdict_window_destroy_cb), app); if (gtk_window_get_group (GTK_WINDOW (parent))) gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (parent)), GTK_WINDOW (new_window)); app->windows = g_slist_prepend (app->windows, new_window); app->current_window = new_window; }
void pluma_plugins_engine_configure_plugin (PlumaPluginsEngine *engine, PlumaPluginInfo *info, GtkWindow *parent) { GtkWidget *conf_dlg; GtkWindowGroup *wg; pluma_debug (DEBUG_PLUGINS); g_return_if_fail (info != NULL); conf_dlg = pluma_plugin_create_configure_dialog (info->plugin); g_return_if_fail (conf_dlg != NULL); gtk_window_set_transient_for (GTK_WINDOW (conf_dlg), parent); wg = gtk_window_get_group (parent); if (wg == NULL) { wg = gtk_window_group_new (); gtk_window_group_add_window (wg, parent); } gtk_window_group_add_window (wg, GTK_WINDOW (conf_dlg)); gtk_window_set_modal (GTK_WINDOW (conf_dlg), TRUE); gtk_widget_show (conf_dlg); }
JNIEXPORT jlong JNICALL Java_org_gnome_gtk_GtkWindow_gtk_1window_1get_1group ( JNIEnv* env, jclass cls, jlong _self ) { GtkWindowGroup* result; jlong _result; GtkWindow* self; // convert parameter self self = (GtkWindow*) _self; // call function result = gtk_window_get_group(self); // cleanup parameter self // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, FALSE); } // and finally return _result; }
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 ); 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_resizable (GTK_WINDOW (m_widget), FALSE); gtk_window_set_screen (GTK_WINDOW (m_widget), gtk_widget_get_screen (GTK_WIDGET (parent->m_widget))); 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; }
void _gtk_dialog_add_to_window_group (GtkDialog *dialog) { GtkWidget *toplevel; g_return_if_fail (dialog != NULL); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (dialog)); if (gtk_widget_is_toplevel (toplevel) && gtk_window_has_group (GTK_WINDOW (toplevel))) gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (dialog)); }
static gboolean realize_hook(GSignalInvocationHint*, unsigned, const GValue* param_values, void*) { void* p = g_value_peek_pointer(param_values); if (GTK_IS_SCROLLBAR(p)) { GtkWindow* toplevel = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(p))); GtkWindow* transient_parent = gtk_window_get_transient_for(toplevel); if (transient_parent && gtk_window_has_group(toplevel)) { GtkWindowGroup* group = gtk_window_get_group(toplevel); GtkWindowGroup* group_parent = gtk_window_get_group(transient_parent); if (group != group_parent) { gtk_window_group_add_window(group_parent, toplevel); gtk_grab_add(GTK_WIDGET(toplevel)); } } } return true; }
GtkWindowGroup * ephy_gui_ensure_window_group (GtkWindow *window) { GtkWindowGroup *group; group = gtk_window_get_group (window); if (group == NULL) { group = gtk_window_group_new (); gtk_window_group_add_window (group, window); g_object_unref (group); } return group; }
void eom_plugin_engine_configure_plugin (EomPluginInfo *info, GtkWindow *parent) { GtkWidget *conf_dlg; GtkWindowGroup *wg; eom_debug (DEBUG_PLUGINS); g_return_if_fail (info != NULL); conf_dlg = eom_plugin_create_configure_dialog (info->plugin); g_return_if_fail (conf_dlg != NULL); gtk_window_set_transient_for (GTK_WINDOW (conf_dlg), parent); // Will return a default group if no group is set wg = gtk_window_get_group (parent); // For now assign a dedicated window group if it is // the default one until we know if this is really needed if (wg == gtk_window_get_group (NULL)) { wg = gtk_window_group_new (); gtk_window_group_add_window (wg, parent); } gtk_window_group_add_window (wg, GTK_WINDOW (conf_dlg)); gtk_window_set_modal (GTK_WINDOW (conf_dlg), TRUE); gtk_widget_show (conf_dlg); }
/** * hildon_app_menu_popup: * @menu: a #HildonAppMenu * @parent_window: a #GtkWindow * * Displays a menu on top of a window and makes it available for * selection. * * Since: 2.2 **/ void hildon_app_menu_popup (HildonAppMenu *menu, GtkWindow *parent_window) { g_return_if_fail (HILDON_IS_APP_MENU (menu)); g_return_if_fail (GTK_IS_WINDOW (parent_window)); if (hildon_app_menu_has_visible_children (menu)) { GtkWindowGroup *group; hildon_app_menu_set_parent_window (menu, parent_window); group = gtk_window_get_group (parent_window); gtk_window_group_add_window (group, GTK_WINDOW (menu)); gtk_widget_show (GTK_WIDGET (menu)); } }
void gedit_warning (GtkWindow *parent, const gchar *format, ...) { va_list args; gchar *str; GtkWidget *dialog; GtkWindowGroup *wg = NULL; g_return_if_fail (format != NULL); if (parent != NULL) wg = gtk_window_get_group (parent); va_start (args, format); str = g_strdup_vprintf (format, args); va_end (args); dialog = gtk_message_dialog_new_with_markup ( parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", str); g_free (str); if (wg != NULL) gtk_window_group_add_window (wg, GTK_WINDOW (dialog)); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); }
gint screenshot_show_dialog (GtkWindow *parent, GtkMessageType message_type, GtkButtonsType buttons_type, const gchar *message, const gchar *detail) { GtkWidget *dialog; GtkWindowGroup *group; gint response; g_return_val_if_fail ((parent == NULL) || (GTK_IS_WINDOW (parent)), GTK_RESPONSE_NONE); g_return_val_if_fail (message != NULL, GTK_RESPONSE_NONE); dialog = gtk_message_dialog_new (parent, GTK_DIALOG_DESTROY_WITH_PARENT, message_type, buttons_type, "%s", message); gtk_window_set_title (GTK_WINDOW (dialog), ""); if (detail) gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", detail); if (parent) { group = gtk_window_get_group (parent); if (group != NULL) gtk_window_group_add_window (group, GTK_WINDOW (dialog)); } response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return response; }
/** * gnm_cell_combo_view_popdown: * @sov: #SheetObjectView * @activate_time: event time * * Open the popup window associated with @sov **/ void gnm_cell_combo_view_popdown (SheetObjectView *sov, guint32 activate_time) { GocItem *view = GOC_ITEM (sov); GnmPane *pane = GNM_PANE (view->canvas); SheetControlGUI *scg = pane->simple.scg; SheetObject *so = sheet_object_view_get_so (sov); Sheet const *sheet = sheet_object_get_sheet (so); GtkWidget *frame, *popup, *list, *container; int root_x, root_y; gboolean make_buttons = FALSE; GtkTreePath *clip = NULL, *select = NULL; GtkWindow *toplevel = wbcg_toplevel (scg_wbcg (scg)); GdkWindow *popup_window; GdkDevice *device; GnmRange const *merge; popup = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_type_hint (GTK_WINDOW (popup), GDK_WINDOW_TYPE_HINT_COMBO); gtk_window_group_add_window (gtk_window_get_group (toplevel), GTK_WINDOW (popup)); go_gtk_window_set_transient (toplevel, GTK_WINDOW (popup)); gtk_window_set_resizable (GTK_WINDOW (popup), FALSE); gtk_window_set_decorated (GTK_WINDOW (popup), FALSE); gtk_window_set_screen (GTK_WINDOW (popup), gtk_widget_get_screen (GTK_WIDGET (toplevel))); list = ccombo_create_list (GNM_CCOMBO_VIEW (sov), so, &clip, &select, &make_buttons); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE); g_object_set_data (G_OBJECT (list), SOV_ID, sov); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); #if 0 range_dump (&so->anchor.cell_bound, ""); g_printerr (" : so = %p, view = %p\n", so, view); #endif if (clip != NULL) { GtkWidget *sw = gtk_scrolled_window_new ( gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (list)), gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (list))); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); g_object_set_data_full (G_OBJECT (list), "clip", clip, (GDestroyNotify)gtk_tree_path_free); gtk_container_add (GTK_CONTAINER (sw), list); /* * Do the sizing in a realize handler as newer versions of * gtk+ give us zero sizes until then. */ g_signal_connect_after (list, "realize", G_CALLBACK (cb_realize_treeview), sw); container = sw; } else container = list; if (make_buttons) { GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *button; button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); g_signal_connect_swapped (button, "clicked", G_CALLBACK (cb_ccombo_cancel_button), list); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 6); button = gtk_button_new_from_stock (GTK_STOCK_OK); g_signal_connect_swapped (button, "clicked", G_CALLBACK (cb_ccombo_ok_button), list); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 6); gtk_box_pack_start (GTK_BOX (vbox), container, FALSE, TRUE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); container = vbox; } gtk_container_add (GTK_CONTAINER (frame), container); /* do the popup */ gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (pane)), &root_x, &root_y); if (sheet->text_is_rtl) { GtkAllocation pa; gtk_widget_get_allocation (GTK_WIDGET (pane), &pa); root_x += pa.width; root_x -= scg_colrow_distance_get (scg, TRUE, pane->first.col, so->anchor.cell_bound.start.col + 1); } else root_x += scg_colrow_distance_get (scg, TRUE, pane->first.col, so->anchor.cell_bound.start.col); merge = gnm_sheet_merge_is_corner (sheet, &(so->anchor.cell_bound.start)); gtk_window_move (GTK_WINDOW (popup), root_x, root_y + scg_colrow_distance_get (scg, FALSE, pane->first.row, so->anchor.cell_bound.start.row + ((merge == NULL) ? 1 : range_height (merge)))); gtk_container_add (GTK_CONTAINER (popup), frame); g_signal_connect (popup, "key_press_event", G_CALLBACK (cb_ccombo_key_press), list); g_signal_connect (popup, "button_press_event", G_CALLBACK (cb_ccombo_button_press), list); g_signal_connect_after (popup, "button_release_event", G_CALLBACK (cb_ccombo_button_release), list); g_signal_connect (list, "motion_notify_event", G_CALLBACK (cb_ccombo_list_motion), list); g_signal_connect (list, "button_press_event", G_CALLBACK (cb_ccombo_list_button_press), popup); gtk_widget_show_all (popup); /* after we show the window setup the selection (showing the list * clears the selection) */ if (select != NULL) { gtk_tree_selection_select_path ( gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), select); gtk_tree_view_set_cursor (GTK_TREE_VIEW (list), select, NULL, FALSE); gtk_tree_path_free (select); } gtk_widget_grab_focus (popup); gtk_widget_grab_focus (GTK_WIDGET (list)); ccombo_focus_change (GTK_WIDGET (list), TRUE); popup_window = gtk_widget_get_window (popup); device = gtk_get_current_event_device (); if (0 == gdk_device_grab (device, popup_window, GDK_OWNERSHIP_APPLICATION, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, activate_time)) { if (0 == gdk_device_grab (gdk_device_get_associated_device (device), popup_window, GDK_OWNERSHIP_APPLICATION, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, activate_time)) gtk_grab_add (popup); else gdk_device_ungrab (device, activate_time); } }
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 void gtk_popup_button_popup_real (GtkPopupButton *popup_button, GdkDevice *device) { GtkPopupButtonPrivate *priv = popup_button->priv; GtkAllocation button_allocation, dock_allocation; GdkScreen *screen; gint monitor_num; GdkRectangle monitor; GtkWidget *toplevel; GdkDevice *keyboard, *pointer; guint32 time; gint x, y; g_return_if_fail (GTK_IS_POPUP_BUTTON (popup_button)); g_return_if_fail (GDK_IS_DEVICE (device)); if (!gtk_widget_get_realized (GTK_WIDGET (popup_button))) return; if (gtk_widget_get_mapped (priv->dock)) return; if (priv->grab_pointer && priv->grab_keyboard) return; time = gtk_get_current_event_time (); 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); } toplevel = gtk_widget_get_toplevel (GTK_WIDGET (popup_button)); if (GTK_IS_WINDOW (toplevel)) gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (priv->dock)); /* positioning */ gtk_widget_show (priv->dock); gtk_widget_get_allocation (GTK_WIDGET (popup_button), &button_allocation); gdk_window_get_root_coords (gtk_widget_get_window (GTK_WIDGET (popup_button)), button_allocation.x, button_allocation.y, &x, &y); gtk_widget_get_allocation (GTK_WIDGET (priv->dock), &dock_allocation); x = (x + button_allocation.width / 2) - (dock_allocation.width / 2); y = y - dock_allocation.height; GdkWindow *window = window = gtk_widget_get_window (GTK_WIDGET (popup_button)); screen = gtk_widget_get_screen (GTK_WIDGET (priv->dock)); monitor_num = gdk_screen_get_monitor_at_window (screen, window); gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); if (x < monitor.x) x = monitor.x; else if (x + dock_allocation.width > monitor.x + monitor.width) x = monitor.x + monitor.width - dock_allocation.width; gtk_window_move (GTK_WINDOW (priv->dock), x, y); /* grabbing */ gtk_widget_grab_focus (priv->dock); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (popup_button), TRUE); if (gdk_device_grab (pointer, gtk_widget_get_window (priv->dock), GDK_OWNERSHIP_WINDOW, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, time) != GDK_GRAB_SUCCESS) { gtk_device_grab_remove (priv->dock, pointer); gtk_widget_hide (priv->dock); return; } if (gdk_device_grab (keyboard, gtk_widget_get_window (priv->dock), GDK_OWNERSHIP_WINDOW, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, time) != GDK_GRAB_SUCCESS) { gdk_device_ungrab (pointer, time); gtk_device_grab_remove (priv->dock, pointer); gtk_widget_hide (priv->dock); return; } gtk_device_grab_add (priv->dock, pointer, TRUE); priv->grab_pointer = pointer; priv->grab_keyboard = keyboard; }
static void ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN gboolean immediate) // IN { ViewAutoDrawerPrivate *priv = that->priv; GtkWidget *toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that)); GtkWindow *window; GtkAllocation allocation; if (!toplevel || !gtk_widget_is_toplevel(toplevel)) { // The autoDrawer cannot function properly without a toplevel. return; } window = GTK_WINDOW(toplevel); /* * We decide to open the drawer by OR'ing several conditions. Evaluating a * condition can have the side-effect of setting 'immediate' to TRUE, so we * cannot stop evaluating the conditions after we have found one to be TRUE. */ priv->opened = FALSE; /* Is the AutoDrawer pinned? */ if (priv->pinned) { immediate = TRUE; priv->opened = TRUE; } /* Is the mouse cursor inside the event box? */ { int x; int y; gtk_widget_get_pointer(priv->evBox, &x, &y); gtk_widget_get_allocation(priv->evBox, &allocation); g_assert(gtk_container_get_border_width( GTK_CONTAINER(priv->evBox)) == 0); if ( (guint)x < (guint)allocation.width && (guint)y < (guint)allocation.height) { priv->opened = TRUE; } } /* If there is a focused widget, is it inside the event box? */ { GtkWidget *focus; focus = gtk_window_get_focus(window); if (focus && gtk_widget_is_ancestor(focus, priv->evBox)) { /* * Override the default 'immediate' to make sure the 'over' widget * immediately appears along with the widget the focused widget. */ immediate = TRUE; priv->opened = TRUE; } } /* If input is grabbed, is it on behalf of a widget inside the event box? */ if (!priv->inputUngrabbed) { GtkWidget *grabbed = NULL; if (gtk_window_has_group (window)) { GtkWindowGroup *group = gtk_window_get_group (window); grabbed = gtk_window_group_get_current_grab (group); } if (!grabbed) { grabbed = gtk_grab_get_current(); } if (grabbed && GTK_IS_MENU(grabbed)) { /* * With cascading menus, the deepest menu owns the grab. Traverse the * menu hierarchy up until we reach the attach widget for the whole * hierarchy. */ for (;;) { GtkWidget *menuAttach; GtkWidget *menuItemParent; menuAttach = gtk_menu_get_attach_widget(GTK_MENU(grabbed)); if (!menuAttach) { /* * It is unfortunately not mandatory for a menu to have a proper * attach widget set. */ break; } grabbed = menuAttach; if (!GTK_IS_MENU_ITEM(grabbed)) { break; } menuItemParent = gtk_widget_get_parent(grabbed); g_return_if_fail(menuItemParent); if (!GTK_IS_MENU(menuItemParent)) { break; } grabbed = menuItemParent; } } if (grabbed && gtk_widget_is_ancestor(grabbed, priv->evBox)) { /* * Override the default 'immediate' to make sure the 'over' widget * immediately appears along with the widget the grab happens on * behalf of. */ immediate = TRUE; priv->opened = TRUE; } } if (priv->delayConnection) { g_source_remove(priv->delayConnection); } if (priv->forceClosing) { ViewAutoDrawerEnforce(that, TRUE); } else if (immediate) { ViewAutoDrawerEnforce(that, FALSE); } else { priv->delayConnection = g_timeout_add(priv->delayValue, (GSourceFunc)ViewAutoDrawerOnEnforceDelay, that); } }
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 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; }