/**
* e_cursor_set:
* @widget: Any widget in a window, to which busy cursor has to be set
* cursor: The type of cursor to be set defined in e-cursor.h
*
* Sets the cursor specified, to the top level window of the given widget.
* It is not window aware, so if you popup a window, it will not have
* busy cursor set. That has to be handled seperately with a new call to this
* function.
*
* Return value:
**/
void e_cursor_set (GtkWidget *widget, ECursorType cursor)
{
GtkWidget *toplevel;
GdkCursor *window_cursor;
toplevel = gtk_widget_get_toplevel (widget);
if (GTK_WIDGET_TOPLEVEL (toplevel) && toplevel->window) {
switch (cursor) {
case E_CURSOR_NORMAL :
window_cursor = gdk_cursor_new (GDK_LEFT_PTR);
break;
case E_CURSOR_BUSY :
window_cursor = gdk_cursor_new (GDK_WATCH);
break;
default :
window_cursor = gdk_cursor_new (GDK_LEFT_PTR);
}
gdk_window_set_cursor (toplevel->window, window_cursor);
gdk_cursor_unref (window_cursor);
}
}
static void page_setup_cb (GtkWidget *widget, CustomWidgetInfo *info)
{
PrintData *data = info->data;
GtkPrintOperation *operation = data->operation;
GtkPrintSettings *settings;
GtkPageSetup *page_setup;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (widget);
#if GTK_CHECK_VERSION (2,18,0)
if (! gtk_widget_is_toplevel (toplevel))
#else
if (! GTK_WIDGET_TOPLEVEL (toplevel))
#endif
toplevel = NULL;
settings = gtk_print_operation_get_print_settings (operation);
if (! settings)
settings = gtk_print_settings_new ();
page_setup = gtk_print_operation_get_default_page_setup (operation);
page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (toplevel),
page_setup, settings);
gtk_print_operation_set_default_page_setup (operation, page_setup);
vik_print_preview_set_page_setup (VIK_PRINT_PREVIEW (info->preview),
page_setup);
update_page_setup (info);
}
bool Buttons_release(ButtonMask& buttons, guint button, guint state)
{
if(buttons != 0 && bitfield_disable(buttons, ButtonMask_for_event_button(button)) == 0)
{
ASSERT_MESSAGE(!g_accel_enabled, "Buttons_release: accelerators are enabled");
g_accel_enabled = true;
for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
{
GtkWindow* toplevel = *i;
ASSERT_MESSAGE(!window_has_accel(toplevel), "ERROR");
ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "enabling accel for non-toplevel window");
gtk_window_add_accel_group(toplevel, global_accel);
#if 0
globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": enabled global accelerators\n";
#endif
#if 0
accel_group_test(toplevel, global_accel);
#endif
}
GlobalQueuedAccelerators_commit();
}
buttons = bitfield_disable(buttons, ButtonMask_for_event_button(button));
#if 0
globalOutputStream() << "Buttons_release: ";
print_buttons(buttons);
#endif
return false;
}
int
_gtk_paned_get_position2 (GtkPaned *paned)
{
int pos;
GtkWidget *w;
GtkRequisition requisition;
int size;
if (! GTK_WIDGET_VISIBLE (paned))
return 0;
pos = gtk_paned_get_position (paned);
if (pos == 0)
return 0;
w = gtk_widget_get_toplevel (GTK_WIDGET (paned));
if (! GTK_WIDGET_TOPLEVEL (w))
return 0;
gtk_window_get_size (GTK_WINDOW (w), &(requisition.width), &(requisition.height));
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (paned)) == GTK_ORIENTATION_HORIZONTAL)
size = requisition.width;
else
size = requisition.height;
if (size == 0)
return 0;
return size - pos;
}
static gboolean
goo_canvas_item_accessible_grab_focus (AtkComponent *component)
{
GooCanvasItem *item;
GooCanvas *canvas;
GtkWidget *toplevel;
GObject *object;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component), FALSE);
object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component));
if (!object)
return FALSE;
item = GOO_CANVAS_ITEM (object);
canvas = goo_canvas_item_get_canvas (item);
if (!canvas)
return FALSE;
goo_canvas_grab_focus (canvas, item);
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (canvas));
if (GTK_WIDGET_TOPLEVEL (toplevel))
gtk_window_present (GTK_WINDOW (toplevel));
return TRUE;
}
bool Buttons_press(ButtonMask& buttons, guint button, guint state)
{
if(buttons == 0 && bitfield_enable(buttons, ButtonMask_for_event_button(button)) != 0)
{
ASSERT_MESSAGE(g_accel_enabled, "Buttons_press: accelerators not enabled");
g_accel_enabled = false;
for(WindowSet::iterator i = g_accel_windows.begin(); i != g_accel_windows.end(); ++i)
{
GtkWindow* toplevel = *i;
ASSERT_MESSAGE(window_has_accel(toplevel), "ERROR");
ASSERT_MESSAGE(GTK_WIDGET_TOPLEVEL(toplevel), "disabling accel for non-toplevel window");
gtk_window_remove_accel_group(toplevel, global_accel);
#if 0
globalOutputStream() << reinterpret_cast<unsigned int>(toplevel) << ": disabled global accelerators\n";
#endif
#if 0
accel_group_test(toplevel, global_accel);
#endif
}
}
buttons = bitfield_enable(buttons, ButtonMask_for_event_button(button));
#if 0
globalOutputStream() << "Buttons_press: ";
print_buttons(buttons);
#endif
return false;
}
/* pass NULL as selection to paste to both clipboard & X11 text */
void
gtkutil_copy_to_clipboard (GtkWidget *widget, GdkAtom selection,
const gchar *str)
{
GtkWidget *win;
GtkClipboard *clip, *clip2;
win = gtk_widget_get_toplevel (GTK_WIDGET (widget));
if (GTK_WIDGET_TOPLEVEL (win))
{
int len = strlen (str);
if (selection)
{
clip = gtk_widget_get_clipboard (win, selection);
gtk_clipboard_set_text (clip, str, len);
} else
{
/* copy to both primary X selection and clipboard */
clip = gtk_widget_get_clipboard (win, GDK_SELECTION_PRIMARY);
clip2 = gtk_widget_get_clipboard (win, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text (clip, str, len);
gtk_clipboard_set_text (clip2, str, len);
}
}
}
static void
advanced_button_clicked_cb (GtkWidget *button, gpointer user_data)
{
L2tpPluginUiWidget *self = L2TP_PLUGIN_UI_WIDGET (user_data);
L2tpPluginUiWidgetPrivate *priv = L2TP_PLUGIN_UI_WIDGET_GET_PRIVATE (self);
GtkWidget *dialog, *toplevel;
toplevel = gtk_widget_get_toplevel (priv->widget);
g_return_if_fail (GTK_WIDGET_TOPLEVEL (toplevel));
dialog = advanced_dialog_new (priv->advanced);
if (!dialog) {
g_warning ("%s: failed to create the Advanced dialog!", __func__);
return;
}
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (dialog));
if (!priv->window_added) {
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel));
priv->window_added = TRUE;
}
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (advanced_dialog_response_cb), self);
g_signal_connect (G_OBJECT (dialog), "close", G_CALLBACK (advanced_dialog_close_cb), self);
gtk_widget_show_all (dialog);
}
static void
gimp_dialog_factories_hide_foreach (gconstpointer key,
GimpDialogFactory *factory,
gpointer data)
{
GList *list;
for (list = factory->open_dialogs; list; list = g_list_next (list))
{
if (GTK_IS_WIDGET (list->data) && GTK_WIDGET_TOPLEVEL (list->data))
{
GimpDialogVisibilityState visibility = GIMP_DIALOG_VISIBILITY_UNKNOWN;
if (GTK_WIDGET_VISIBLE (list->data))
{
visibility = GIMP_DIALOG_VISIBILITY_VISIBLE;
gtk_widget_hide (GTK_WIDGET (list->data));
}
else
{
visibility = GIMP_DIALOG_VISIBILITY_INVISIBLE;
}
g_object_set_data (G_OBJECT (list->data),
GIMP_DIALOG_VISIBILITY_KEY,
GINT_TO_POINTER (visibility));
}
}
}
void ChromeClient::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)
{
// If a tooltip must be displayed it will be, afterwards, when
// setToolTip is called; this is just a work-around to make sure
// it updates its location correctly; see
// https://bugs.webkit.org/show_bug.cgi?id=15793.
g_object_set(m_webView, "has-tooltip", FALSE, NULL);
GdkDisplay* gdkDisplay;
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
if (GTK_WIDGET_TOPLEVEL(window))
gdkDisplay = gtk_widget_get_display(window);
else
gdkDisplay = gdk_display_get_default();
gtk_tooltip_trigger_tooltip_query(gdkDisplay);
// check if the element is a link...
bool isLink = hit.isLiveLink();
if (isLink) {
KURL url = hit.absoluteLinkURL();
if (!url.isEmpty() && url != m_hoveredLinkURL) {
TextDirection dir;
CString titleString = hit.title(dir).utf8();
CString urlString = url.prettyURL().utf8();
g_signal_emit_by_name(m_webView, "hovering-over-link", titleString.data(), urlString.data());
m_hoveredLinkURL = url;
}
} else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
g_signal_emit_by_name(m_webView, "hovering-over-link", 0, 0);
m_hoveredLinkURL = KURL();
}
}
//
// Get top level widget
//
GtkWidget *CPreview::GetTopLevel(void)
{
GtkWidget *toplevel = gtk_widget_get_toplevel(m_Widget);
if (GTK_WIDGET_TOPLEVEL(toplevel))
return toplevel;
return NULL;
}
static void
gimp_dialog_factories_show_foreach (gconstpointer key,
GimpDialogFactory *factory,
gpointer data)
{
GList *list;
for (list = factory->open_dialogs; list; list = g_list_next (list))
{
GtkWidget *widget = list->data;
if (GTK_IS_WIDGET (widget) && GTK_WIDGET_TOPLEVEL (widget))
{
GimpDialogVisibilityState visibility;
visibility =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
GIMP_DIALOG_VISIBILITY_KEY));
if (! GTK_WIDGET_VISIBLE (widget) &&
visibility == GIMP_DIALOG_VISIBILITY_VISIBLE)
{
/* Don't use gtk_window_present() here, we don't want the
* keyboard focus to move.
*/
gtk_widget_show (widget);
if (GTK_WIDGET_VISIBLE (widget))
gdk_window_raise (widget->window);
}
}
}
}
static gboolean
matecomponent_plug_button_event (GtkWidget *widget,
GdkEventButton *event)
{
#if defined (GDK_WINDOWING_X11)
XEvent xevent;
#endif
g_return_val_if_fail (MATECOMPONENT_IS_PLUG (widget), FALSE);
if (!MATECOMPONENT_PLUG (widget)->priv->forward_events || !GTK_WIDGET_TOPLEVEL (widget))
return FALSE;
#if defined (GDK_WINDOWING_X11)
if (event->type == GDK_BUTTON_PRESS) {
xevent.xbutton.type = ButtonPress;
/* X does an automatic pointer grab on button press
* if we have both button press and release events
* selected.
* We don't want to hog the pointer on our parent.
*/
gdk_display_pointer_ungrab
(gtk_widget_get_display (widget),
GDK_CURRENT_TIME);
} else
xevent.xbutton.type = ButtonRelease;
xevent.xbutton.display = GDK_WINDOW_XDISPLAY (widget->window);
xevent.xbutton.window = GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window);
xevent.xbutton.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window
(gdk_drawable_get_screen (widget->window)));
/*
* FIXME: the following might cause
* big problems for non-GTK apps
*/
xevent.xbutton.x = 0;
xevent.xbutton.y = 0;
xevent.xbutton.x_root = 0;
xevent.xbutton.y_root = 0;
xevent.xbutton.state = event->state;
xevent.xbutton.button = event->button;
xevent.xbutton.same_screen = TRUE; /* FIXME ? */
gdk_error_trap_push ();
XSendEvent (GDK_WINDOW_XDISPLAY (widget->window),
GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window),
False, NoEventMask, &xevent);
gdk_flush ();
gdk_error_trap_pop ();
#elif defined (GDK_WINDOWING_WIN32)
/* FIXME: Need to do something? */
#endif
return TRUE;
}
void
gmdb_about_cb(GtkWidget *button, gpointer data)
{
const gchar *authors[] = {
"Brian Bruns",
"Jeff Smith",
"Filip Van Raemdonck",
"Bernhard Reiter",
"Nirgal Vourgère",
NULL
};
const gchar *documenters[] = {
"Brian Bruns",
NULL
};
GtkWidget *parent;
GdkPixbuf *pixbuf=NULL;
FILE *flicense;
guint32 licenselen;
char *license;
parent = gtk_widget_get_toplevel (button);
if (!GTK_WIDGET_TOPLEVEL (parent))
parent = NULL;
if (!pixbuf)
pixbuf = gdk_pixbuf_new_from_file (GMDB_ICONDIR "logo.xpm", NULL);
flicense = fopen(GMDB_ICONDIR "COPYING", "r");
if (flicense)
{
fseek(flicense, 0, SEEK_END);
licenselen = ftell(flicense);
fseek(flicense, 0, SEEK_SET);
license = g_malloc(licenselen+1);
fread(license, 1, licenselen, flicense);
license[licenselen] = 0;
fclose(flicense);
} else {
fprintf(stderr, "Can't open " GMDB_ICONDIR "COPYING\n");
license = NULL;
}
gtk_show_about_dialog ((GtkWindow*)parent,
"authors", authors,
"comments", _("GNOME MDB Viewer is a grapical interface to "
"MDB Tools. It lets you view and export data and schema "
"from MDB files produced by MS Access 97/2000/XP/2003/2007/2010."),
"copyright", _("Copyright 2002-2012 Brian Bruns and others"),
"documenters", documenters,
"logo", pixbuf,
"program-name", _("GNOME MDB Viewer"),
"version", MDB_VERSION_NO,
"website", "http://mdbtools.sourceforge.net/",
"license", license,
NULL);
g_free(license);
}
static void
gimp_dialog_factory_dispose (GObject *object)
{
GimpDialogFactory *factory = GIMP_DIALOG_FACTORY (object);
GList *list;
gpointer key;
/* start iterating from the beginning each time we destroyed a
* toplevel because destroying a dock may cause lots of items
* to be removed from factory->open_dialogs
*/
while (factory->open_dialogs)
{
for (list = factory->open_dialogs; list; list = g_list_next (list))
{
if (GTK_WIDGET_TOPLEVEL (list->data))
{
gtk_widget_destroy (GTK_WIDGET (list->data));
break;
}
}
/* the list being non-empty without any toplevel is an error,
* so eek and chain up
*/
if (! list)
{
g_warning ("%s: stale non-toplevel entries in factory->open_dialogs",
G_STRFUNC);
break;
}
}
if (factory->open_dialogs)
{
g_list_free (factory->open_dialogs);
factory->open_dialogs = NULL;
}
if (factory->session_infos)
{
g_list_foreach (factory->session_infos, (GFunc) gimp_session_info_free,
NULL);
g_list_free (factory->session_infos);
factory->session_infos = NULL;
}
if (strcmp (GIMP_OBJECT (factory)->name, "toolbox") == 0)
key = "";
else
key = GIMP_OBJECT (factory)->name;
g_hash_table_remove (GIMP_DIALOG_FACTORY_GET_CLASS (object)->factories,
key);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
FloatRect ChromeClient::windowRect()
{
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
if (GTK_WIDGET_TOPLEVEL(window)) {
gint left, top, width, height;
gtk_window_get_position(GTK_WINDOW(window), &left, &top);
gtk_window_get_size(GTK_WINDOW(window), &width, &height);
return IntRect(left, top, width, height);
}
return FloatRect();
}
NS_IMETHODIMP
EmbedWindow::FocusPrevElement()
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel(GTK_WIDGET(mOwner->mOwningWidget));
if (!GTK_WIDGET_TOPLEVEL(toplevel))
return NS_OK;
g_signal_emit_by_name(G_OBJECT(toplevel), "move_focus",
GTK_DIR_TAB_BACKWARD);
return NS_OK;
}
/* The only toplevel widget in the toolbox factory is the toolbox */
static GtkWidget *
gimp_dialog_factory_get_toolbox (GimpDialogFactory *toolbox_factory)
{
GList *list;
for (list = toolbox_factory->open_dialogs; list; list = list->next)
{
if (GTK_IS_WIDGET (list->data) && GTK_WIDGET_TOPLEVEL (list->data))
return list->data;
}
return NULL;
}
static void
presence_chooser_set_status_editing (EmpathyPresenceChooser *self,
gboolean editing)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkWidget *entry;
if (priv->block_set_editing) {
return;
}
entry = gtk_bin_get_child (GTK_BIN (self));
if (editing) {
priv->editing_status = TRUE;
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_OK);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
_("Set status"));
gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
FALSE);
} else {
GtkWidget *window;
presence_chooser_set_favorite_icon (self);
gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
TRUE);
/* attempt to get the toplevel for this widget */
window = gtk_widget_get_toplevel (GTK_WIDGET (self));
if (GTK_WIDGET_TOPLEVEL (window) && GTK_IS_WINDOW (window)) {
/* unset the focus */
gtk_window_set_focus (GTK_WINDOW (window), NULL);
}
/* see presence_chooser_entry_focus_out_cb ()
* for what this does */
if (priv->focus_out_idle_source != 0) {
g_source_remove (priv->focus_out_idle_source);
priv->focus_out_idle_source = 0;
}
gtk_editable_set_position (GTK_EDITABLE (entry), 0);
priv->editing_status = FALSE;
}
}
static void
private_key_picker_helper (EAPMethod *parent, const char *filename, gboolean changed)
{
NMSetting8021x *setting;
NMSetting8021xCKFormat cert_format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
const char *password;
GtkWidget *widget;
widget = glade_xml_get_widget (parent->xml, "eap_tls_private_key_password_entry");
g_assert (widget);
password = gtk_entry_get_text (GTK_ENTRY (widget));
setting = (NMSetting8021x *) nm_setting_802_1x_new ();
nm_setting_802_1x_set_private_key (setting, filename, password, NM_SETTING_802_1X_CK_SCHEME_PATH, &cert_format, NULL);
g_object_unref (setting);
/* With PKCS#12, the client cert must be the same as the private key */
widget = glade_xml_get_widget (parent->xml, "eap_tls_user_cert_button");
if (cert_format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (widget));
gtk_widget_set_sensitive (widget, FALSE);
} else if (changed)
gtk_widget_set_sensitive (widget, TRUE);
/* Warn the user if the private key is unencrypted */
if (!eap_method_is_encrypted_private_key (filename)) {
GtkWidget *dialog;
GtkWidget *toplevel;
GtkWindow *parent_window = NULL;
toplevel = gtk_widget_get_toplevel (parent->ui_widget);
#if GTK_CHECK_VERSION(2,18,0)
if (gtk_widget_is_toplevel (toplevel))
#else
if (GTK_WIDGET_TOPLEVEL (toplevel))
#endif
parent_window = GTK_WINDOW (toplevel);
dialog = gtk_message_dialog_new (parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK,
"%s",
_("Unencrypted private keys are insecure"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s",
_("The selected private key does not appear to be protected by a password. This could allow your security credentials to be compromised. Please select a password-protected private key.\n\n(You can password-protect your private key with openssl)"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
static void hide_section_cb(GtkToggleToolButton *btn, GtkWidget *section)
{
GtkWidget *toplevel;
if (gtk_toggle_tool_button_get_active(btn)) {
gtk_object_set(GTK_OBJECT(btn), "stock-id", "gtk-go-down", NULL);
gtk_widget_show(section);
} else {
gtk_object_set(GTK_OBJECT(btn), "stock-id", "gtk-go-up", NULL);
gtk_widget_hide(section);
toplevel = gtk_widget_get_toplevel(GTK_WIDGET(btn));
if (GTK_WIDGET_TOPLEVEL(toplevel))
gtk_window_resize (GTK_WINDOW(toplevel), 1, 1);
}
}
static void
matecomponent_plug_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
dbgprintf ("matecomponent_plug_size_allocate %p: (%d, %d), (%d, %d) %d! %s\n",
widget,
allocation->x, allocation->y,
allocation->width, allocation->height,
GTK_WIDGET_TOPLEVEL (widget),
GTK_BIN (widget)->child ?
g_type_name_from_instance ((gpointer)GTK_BIN (widget)->child):
"No child!");
GTK_WIDGET_CLASS (matecomponent_plug_parent_class)->size_allocate (widget, allocation);
}
FloatRect screenRect(Widget* widget)
{
GtkWidget* container = gtk_widget_get_toplevel(GTK_WIDGET(widget->root()->hostWindow()->platformWindow()));
if (!GTK_WIDGET_TOPLEVEL(container))
return FloatRect();
GdkScreen* screen = gtk_widget_has_screen(container) ? gtk_widget_get_screen(container) : gdk_screen_get_default();
if (!screen)
return FloatRect();
gint monitor = gdk_screen_get_monitor_at_window(screen, GTK_WIDGET(container)->window);
GdkRectangle geometry;
gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
return FloatRect(geometry.x, geometry.y, geometry.width, geometry.height);
}
static void
end_clicked_cb (GtkButton *button, JanaGtkRecurrence *self)
{
GtkWidget *window, *datetime, *check, *toplevel, *vbox, *close, *align;
JanaGtkRecurrencePrivate *priv = RECURRENCE_PRIVATE (self);
JanaTime *time;
/* Time-editing dialog */
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (button));
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (GTK_WIDGET_TOPLEVEL (toplevel))
gtk_window_set_transient_for (GTK_WINDOW (window),
GTK_WINDOW (toplevel));
gtk_window_set_modal (GTK_WINDOW (window), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DIALOG);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
check = gtk_check_button_new_with_mnemonic ("Repeats _forever");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check),
priv->recur->end ? FALSE : TRUE);
time = priv->recur->end ?
jana_time_duplicate (priv->recur->end) :
jana_time_duplicate (priv->time);
jana_time_set_isdate (time, TRUE);
datetime = jana_gtk_date_time_new (time);
jana_gtk_date_time_set_editable (JANA_GTK_DATE_TIME (datetime), TRUE);
gtk_widget_set_sensitive (datetime, priv->recur->end ? TRUE : FALSE);
align = gtk_alignment_new (1.0, 0.5, 0.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 6, 0, 0, 0);
close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_container_add (GTK_CONTAINER (align), close);
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), datetime, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
g_object_set_data (G_OBJECT (window), "self", self);
g_signal_connect (check, "toggled",
G_CALLBACK (forever_toggled_cb), datetime);
g_signal_connect (close, "clicked",
G_CALLBACK (close_clicked_cb), datetime);
gtk_widget_show_all (window);
}
GtkWidget *
dialogs_get_toolbox (void)
{
GList *list;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (global_toolbox_factory), NULL);
for (list = global_toolbox_factory->open_dialogs;
list;
list = g_list_next (list))
{
if (GTK_WIDGET_TOPLEVEL (list->data))
return list->data;
}
return NULL;
}
static void
gimp_dialog_factories_unset_busy_foreach (gconstpointer key,
GimpDialogFactory *factory,
gpointer data)
{
GList *list;
for (list = factory->open_dialogs; list; list = g_list_next (list))
{
GtkWidget *widget = list->data;
if (GTK_IS_WIDGET (widget) && GTK_WIDGET_TOPLEVEL (widget))
{
if (widget->window)
gdk_window_set_cursor (widget->window, NULL);
}
}
}
void
_gtk_paned_set_position2 (GtkPaned *paned,
int pos)
{
GtkWidget *top_level;
int size;
top_level = gtk_widget_get_toplevel (GTK_WIDGET (paned));
if (! GTK_WIDGET_TOPLEVEL (top_level))
return;
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (paned)) == GTK_ORIENTATION_HORIZONTAL)
size = top_level->allocation.width;
else
size = top_level->allocation.height;
if (pos > 0)
gtk_paned_set_position (paned, size - pos);
}
int screenDepth(Widget* widget)
{
GtkWidget* container = GTK_WIDGET(widget->root()->hostWindow()->platformWindow());
if (!container)
return 24;
if (!GTK_WIDGET_REALIZED(container)) {
GtkWidget* toplevel = gtk_widget_get_toplevel(container);
if (GTK_WIDGET_TOPLEVEL(toplevel))
container = toplevel;
else
return 24;
}
GdkVisual* visual = gdk_drawable_get_visual(GDK_DRAWABLE(container->window));
return visual->depth;
}
/**
* called with a double-click on a date on a calendar
* set the choosen date in the entry
*
* \param pCalendar
* \param entry
*
* \return FALSE
* */
gboolean gsb_calendar_entry_select_date ( GtkCalendar *pCalendar,
GtkWidget *entry )
{
guint year, month, day;
GtkWidget *pTopLevelWidget;
/* get the popup to destroy it if we are in a popup */
pTopLevelWidget = gtk_widget_get_toplevel ( GTK_WIDGET ( pCalendar ) );
gtk_calendar_get_date ( pCalendar, &year, &month, &day);
gtk_entry_set_text ( GTK_ENTRY ( entry ),
gsb_format_date ( day, month + 1, year ));
gsb_form_widget_set_empty ( entry, FALSE );
if ( GTK_WIDGET_TOPLEVEL ( pTopLevelWidget ) )
gtk_widget_destroy ( pTopLevelWidget );
return FALSE;
}
static void
gtk_font_button_clicked (GtkButton *button)
{
GtkFontSelectionDialog *font_dialog;
GtkFontButton *font_button = GTK_FONT_BUTTON (button);
if (!font_button->priv->font_dialog)
{
GtkWidget *parent;
parent = gtk_widget_get_toplevel (GTK_WIDGET (font_button));
font_button->priv->font_dialog = gtk_font_selection_dialog_new (font_button->priv->title);
font_dialog = GTK_FONT_SELECTION_DIALOG (font_button->priv->font_dialog);
if (GTK_WIDGET_TOPLEVEL (parent) && GTK_IS_WINDOW (parent))
{
if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (font_dialog)))
gtk_window_set_transient_for (GTK_WINDOW (font_dialog), GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (font_dialog),
gtk_window_get_modal (GTK_WINDOW (parent)));
}
g_signal_connect (font_dialog->ok_button, "clicked",
G_CALLBACK (dialog_ok_clicked), font_button);
g_signal_connect (font_dialog->cancel_button, "clicked",
G_CALLBACK (dialog_cancel_clicked), font_button);
g_signal_connect (font_dialog, "destroy",
G_CALLBACK (dialog_destroy), font_button);
}
if (!GTK_WIDGET_VISIBLE (font_button->priv->font_dialog))
{
font_dialog = GTK_FONT_SELECTION_DIALOG (font_button->priv->font_dialog);
gtk_font_selection_dialog_set_font_name (font_dialog, font_button->priv->fontname);
}
gtk_window_present (GTK_WINDOW (font_button->priv->font_dialog));
}