/* 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;
}
