static void
show_wireless_dialog (GtkWidget *toplevel,
NMClient *client,
GtkWidget *dialog)
{
WirelessDialogClosure *closure;
g_debug ("About to parent and show a network dialog");
g_assert (gtk_widget_is_toplevel (toplevel));
g_object_set (G_OBJECT (dialog),
"modal", TRUE,
"transient-for", toplevel,
NULL);
closure = g_slice_new (WirelessDialogClosure);
closure->client = g_object_ref (client);
g_signal_connect_data (dialog, "response",
G_CALLBACK (wireless_dialog_response_cb),
closure, wireless_dialog_closure_closure_notify, 0);
g_object_bind_property (G_OBJECT (toplevel), "visible",
G_OBJECT (dialog), "visible",
G_BINDING_SYNC_CREATE);
}
/**
* gtk_show_uri_simple:
* @widget: widget that triggered the action
* @uri: the uri
*
* Show the given @uri. Uses same screen as @widget.
*/
void
gtk_show_uri_simple (GtkWidget * widget, const gchar * uri)
{
GError *error = NULL;
g_return_if_fail (widget);
g_return_if_fail (uri);
#if GTK_CHECK_VERSION (3, 22, 0)
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (!gtk_widget_is_toplevel (toplevel)) {
GST_WARNING ("Failed lookup widgets window\n");
}
GtkWindow *window = GTK_WINDOW(toplevel);
if (!gtk_show_uri_on_window (window, uri,gtk_get_current_event_time (), &error)) {
GST_WARNING ("Failed to display help: %s\n", error->message);
g_error_free (error);
}
#else
GdkScreen *screen = gtk_widget_get_screen (widget);
if (!gtk_show_uri (screen, uri, gtk_get_current_event_time (), &error)) {
GST_WARNING ("Failed to display help: %s\n", error->message);
g_error_free (error);
}
#endif
}
void show_dialog() const
{
Gtk::MessageDialog* dialog = new Gtk::MessageDialog(
m_simple_desc,
false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_NONE,
false);
Gtk::Window* parent = NULL;
Gtk::Widget* toplevel_widget = m_widget->get_toplevel();
if(gtk_widget_is_toplevel(toplevel_widget->gobj()))
parent = dynamic_cast<Gtk::Window*>(toplevel_widget);
g_assert(parent != NULL);
dialog->set_transient_for(*parent);
dialog->add_button(_("_Close"), Gtk::RESPONSE_CLOSE);
dialog->set_secondary_text(m_detail_desc, true);
dialog->signal_response().connect(
sigc::hide(
sigc::bind(
sigc::ptr_fun(dispose_dialog),
dialog)));
dialog->show();
}
static void
gtk_tooltip_set_last_window (GtkTooltip *tooltip,
GdkWindow *window)
{
GtkWidget *window_widget = NULL;
if (tooltip->last_window == window)
return;
if (tooltip->last_window)
g_object_remove_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
tooltip->last_window = window;
if (window)
g_object_add_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
if (window)
gdk_window_get_user_data (window, (gpointer *) &window_widget);
if (window_widget)
window_widget = gtk_widget_get_toplevel (window_widget);
if (window_widget &&
window_widget != tooltip->window &&
gtk_widget_is_toplevel (window_widget) &&
GTK_IS_WINDOW (window_widget))
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window),
GTK_WINDOW (window_widget));
else
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window), NULL);
}
extern gint
nwam_pref_dialog_run(NwamPrefIFace *iface, GtkWidget *w)
{
NwamPrefInterface *interface = NWAM_GET_PREF_INTERFACE (iface);
GtkWidget *parent = NULL;
GtkWindow *window = nwam_pref_dialog_get_window(iface);
gint response = GTK_RESPONSE_NONE;
g_return_val_if_fail(interface != NULL, FALSE);
g_return_val_if_fail(window != NULL, FALSE);
if (w) {
parent = gtk_widget_get_toplevel(w);
if (gtk_widget_is_toplevel(parent)) {
gtk_window_set_transient_for(window, GTK_WINDOW(parent));
}
}
gtk_window_set_modal(window, parent != NULL);
response = gtk_dialog_run(GTK_DIALOG(window));
debug_response_id(response);
return response;
}
/**
* seahorse_util_prompt_delete:
* @text: The text to display in the delete-dialog
* @parent: The widget to display the dialog for. Can be NULL
*
* Displays a modal dialog with "cancel" and "delete"
*
* Returns: TRUE if the user pressed "delete", FALSE else
*/
gboolean
seahorse_util_prompt_delete (const gchar *text, GtkWidget *parent)
{
GtkWidget *warning, *button;
gint response;
if (parent) {
if (!GTK_IS_WIDGET (parent)) {
g_warn_if_reached ();
parent = NULL;
} else {
if (!GTK_IS_WINDOW (parent))
parent = gtk_widget_get_toplevel (parent);
if (!GTK_IS_WINDOW (parent) && gtk_widget_is_toplevel (parent))
parent = NULL;
}
}
warning = gtk_message_dialog_new (GTK_WINDOW (parent), GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
"%s", text);
button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_dialog_add_action_widget (GTK_DIALOG (warning), GTK_WIDGET (button), GTK_RESPONSE_REJECT);
gtk_widget_show (button);
button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_dialog_add_action_widget (GTK_DIALOG (warning), GTK_WIDGET (button), GTK_RESPONSE_ACCEPT);
gtk_widget_show (button);
response = gtk_dialog_run (GTK_DIALOG (warning));
gtk_widget_destroy (warning);
return (response == GTK_RESPONSE_ACCEPT);
}
static void
apn_button_clicked (GtkButton *button, gpointer user_data)
{
CEPageMobile *self = CE_PAGE_MOBILE (user_data);
CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);
NMAMobileWizard *wizard;
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (CE_PAGE (self)->page);
g_return_if_fail (gtk_widget_is_toplevel (toplevel));
if (!priv->window_added) {
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel));
priv->window_added = TRUE;
}
wizard = nma_mobile_wizard_new (GTK_WINDOW (toplevel),
priv->window_group,
NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS,
FALSE,
apn_button_mobile_wizard_done,
self);
if (wizard)
nma_mobile_wizard_present (wizard);
}
/* shows a questiong popup with given (char*) as message */
gint show_question(GtkWidget *widget, gpointer message) {
GtkWidget *toplevel; /* the toplevel window */
GtkWidget *dialog; /* the dialog object */
int ret = -1; /* return value (clicked button) GTK_RESPONSE_NO or GTK_RESPONSE_YES */
/* get toplevel from widget */
toplevel = gtk_widget_get_toplevel(widget);
/* show window only if toplevel */
if (gtk_widget_is_toplevel(toplevel)) {
/* create new dialog */
dialog = gtk_message_dialog_new(GTK_WINDOW(toplevel), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, "%s", (char*)message);
/* set title */
gtk_window_set_title(GTK_WINDOW(dialog), "Question");
/* run dialog and get click as int */
ret = gtk_dialog_run(GTK_DIALOG(dialog));
/* destroy dialog */
gtk_widget_destroy(dialog);
}
/* return clicked button */
return(ret);
}
/** \brief Create the working dialog
Builds the dialog with a message saying that the effect is working.
And make sure to connect to the cancel.
*/
void
ExecutionEnv::createWorkingDialog (void) {
if (_visibleDialog != NULL) {
_visibleDialog->hide();
delete _visibleDialog;
_visibleDialog = NULL;
}
SPDesktop *desktop = (SPDesktop *)_doc;
GtkWidget *toplevel = gtk_widget_get_toplevel(GTK_WIDGET(desktop->canvas));
if (!toplevel || !gtk_widget_is_toplevel (toplevel))
return;
Gtk::Window *window = Glib::wrap(GTK_WINDOW(toplevel), false);
gchar * dlgmessage = g_strdup_printf(_("'%s' working, please wait..."), _(_effect->get_name()));
_visibleDialog = new Gtk::MessageDialog(*window,
dlgmessage,
false, // use markup
Gtk::MESSAGE_INFO,
Gtk::BUTTONS_CANCEL,
true); // modal
_visibleDialog->signal_response().connect(sigc::mem_fun(this, &ExecutionEnv::workingCanceled));
g_free(dlgmessage);
if (!_effect->is_silent()){
_visibleDialog->show();
}
return;
}
static gboolean
gal_a11y_e_cell_grab_focus (AtkComponent *component)
{
GalA11yECell *a11y;
gint index;
GtkWidget *toplevel;
GalA11yETableItem *a11yTableItem;
a11y = GAL_A11Y_E_CELL (component);
/* for e_cell_vbox's children, we just grab the e_cell_vbox */
if (GAL_A11Y_IS_E_CELL_VBOX (a11y->parent)) {
return atk_component_grab_focus (ATK_COMPONENT (a11y->parent));
}
a11yTableItem = GAL_A11Y_E_TABLE_ITEM (a11y->parent);
index = atk_object_get_index_in_parent (ATK_OBJECT (a11y));
atk_selection_clear_selection (ATK_SELECTION (a11yTableItem));
atk_selection_add_selection (ATK_SELECTION (a11yTableItem), index);
gtk_widget_grab_focus (
GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
toplevel = gtk_widget_get_toplevel (
GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
if (toplevel && gtk_widget_is_toplevel (toplevel))
gtk_window_present (GTK_WINDOW (toplevel));
return TRUE;
}
/**
* e_notice:
* @parent: the dialog's parent window, or %NULL
* @type: the type of dialog (%GTK_MESSAGE_INFO, %GTK_MESSAGE_WARNING,
* or %GTK_MESSAGE_ERROR)
* @format: printf-style format string, followed by arguments
*
* Convenience function to show a dialog with a message and an "OK"
* button.
**/
void
e_notice (gpointer parent,
GtkMessageType type,
const gchar *format,
...)
{
GtkWidget *dialog;
va_list args;
gchar *str;
va_start (args, format);
str = g_strdup_vprintf (format, args);
dialog = gtk_message_dialog_new (
NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
type, GTK_BUTTONS_OK, "%s", str);
va_end (args);
g_free (str);
if (parent && !gtk_widget_is_toplevel (parent))
parent = gtk_widget_get_toplevel (parent);
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
static void
gail_window_get_size (AtkComponent *component,
gint *width,
gint *height)
{
GtkWidget *widget = GTK_ACCESSIBLE (component)->widget;
GdkRectangle rect;
if (widget == NULL)
/*
* State is defunct
*/
return;
gail_return_if_fail (GTK_IS_WINDOW (widget));
if (!gtk_widget_is_toplevel (widget))
{
AtkComponentIface *parent_iface;
parent_iface = (AtkComponentIface *) g_type_interface_peek_parent (ATK_COMPONENT_GET_IFACE (component));
parent_iface->get_size (component, width, height);
return;
}
gdk_window_get_frame_extents (widget->window, &rect);
*width = rect.width;
*height = rect.height;
}
static gboolean
gst_gtk_base_sink_start_on_main (GstBaseSink * bsink)
{
GstGtkBaseSink *gst_sink = GST_GTK_BASE_SINK (bsink);
GstGtkBaseSinkClass *klass = GST_GTK_BASE_SINK_GET_CLASS (bsink);
GtkWidget *toplevel;
if (gst_gtk_base_sink_get_widget (gst_sink) == NULL)
return FALSE;
/* After this point, gtk_sink->widget will always be set */
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (gst_sink->widget));
if (!gtk_widget_is_toplevel (toplevel)) {
/* sanity check */
g_assert (klass->window_title);
/* User did not add widget its own UI, let's popup a new GtkWindow to
* make gst-launch-1.0 work. */
gst_sink->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (gst_sink->window), 640, 480);
gtk_window_set_title (GTK_WINDOW (gst_sink->window), klass->window_title);
gtk_container_add (GTK_CONTAINER (gst_sink->window), toplevel);
gst_sink->window_destroy_id = g_signal_connect (gst_sink->window, "destroy",
G_CALLBACK (window_destroy_cb), gst_sink);
}
return TRUE;
}
void
ViewAutoDrawer_Close(ViewAutoDrawer *that) // IN
{
GtkWindow *window;
GtkWidget *focus;
GtkWidget *toplevel;
g_return_if_fail(VIEW_IS_AUTODRAWER(that));
toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
if (!toplevel || !gtk_widget_is_toplevel(toplevel)) {
// The autoDrawer cannot function properly without a toplevel.
return;
}
window = GTK_WINDOW(toplevel);
focus = gtk_window_get_focus(window);
if (focus && gtk_widget_is_ancestor(focus, that->priv->evBox)) {
gtk_window_set_focus(window, NULL);
}
that->priv->forceClosing = TRUE;
that->priv->closeConnection =
g_timeout_add(ViewDrawer_GetCloseTime(&that->parent) +
that->priv->delayValue,
(GSourceFunc)ViewAutoDrawerOnCloseDelay, that);
/* This change happens programmatically. Always react to it immediately. */
ViewAutoDrawerUpdate(that, TRUE);
}
/* 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_is_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);
}
}
}
/* Create the dialog and connects its buttons */
static void
ensure_dialog (GtkColorButton *button)
{
GtkWidget *parent, *dialog;
if (button->priv->cs_dialog != NULL)
return;
parent = gtk_widget_get_toplevel (GTK_WIDGET (button));
button->priv->cs_dialog = dialog = gtk_color_chooser_dialog_new (button->priv->title, NULL);
if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent))
{
if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (dialog)))
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (dialog),
gtk_window_get_modal (GTK_WINDOW (parent)));
}
g_signal_connect (dialog, "response",
G_CALLBACK (dialog_response), button);
g_signal_connect (dialog, "destroy",
G_CALLBACK (dialog_destroy), button);
}
void ChromeClient::setWindowRect(const FloatRect& rect)
{
IntRect intrect = IntRect(rect);
WebKitWebWindowFeatures* webWindowFeatures = webkit_web_view_get_window_features(m_webView);
g_object_set(webWindowFeatures,
"x", intrect.x(),
"y", intrect.y(),
"width", intrect.width(),
"height", intrect.height(),
NULL);
gboolean autoResizeWindow;
WebKitWebSettings* settings = webkit_web_view_get_settings(m_webView);
g_object_get(settings, "auto-resize-window", &autoResizeWindow, NULL);
if (!autoResizeWindow)
return;
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
if (gtk_widget_is_toplevel(window)) {
gtk_window_move(GTK_WINDOW(window), intrect.x(), intrect.y());
gtk_window_resize(GTK_WINDOW(window), intrect.width(), intrect.height());
}
}
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);
}
static gboolean webViewLeavingFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
{
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
if (gtk_widget_is_toplevel(window) && GTK_IS_WINDOW(window) && !GTK_IS_OFFSCREEN_WINDOW(window))
g_signal_handlers_disconnect_by_func(window, G_CALLBACK(webViewWindowStateEvent), webView);
gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) showWidget, NULL);
return FALSE;
}
static inline void
set_transient_toplevel_window(GtkWindow *target, GtkWidget *widget)
{
GtkWidget *toplevel = gtk_widget_get_toplevel(widget);
if (gtk_widget_is_toplevel(toplevel) && GTK_IS_WINDOW(toplevel))
gtk_window_set_transient_for(target, GTK_WINDOW(toplevel));
}
static void
gtk_drag_dest_realized (GtkWidget *widget)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel))
gdk_window_register_dnd (gtk_widget_get_window (toplevel));
}
static gboolean
signature_manager_run_script_dialog (ESignatureManager *manager,
ESignature *signature,
const gchar *title)
{
GtkWidget *dialog;
GFile *script_file;
const gchar *name;
const gchar *filename;
const gchar *script_name;
gboolean success = FALSE;
gpointer parent;
gchar *path;
parent = gtk_widget_get_toplevel (GTK_WIDGET (manager));
parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
dialog = e_signature_script_dialog_new (parent);
gtk_window_set_title (GTK_WINDOW (dialog), title);
name = e_signature_get_name (signature);
filename = e_signature_get_filename (signature);
if (filename != NULL && name != NULL) {
script_file = g_file_new_for_path (filename);
script_name = name;
e_signature_script_dialog_set_script_file (
E_SIGNATURE_SCRIPT_DIALOG (dialog), script_file);
e_signature_script_dialog_set_script_name (
E_SIGNATURE_SCRIPT_DIALOG (dialog), script_name);
g_object_unref (script_file);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_OK)
goto exit;
script_file = e_signature_script_dialog_get_script_file (
E_SIGNATURE_SCRIPT_DIALOG (dialog));
script_name = e_signature_script_dialog_get_script_name (
E_SIGNATURE_SCRIPT_DIALOG (dialog));
path = g_file_get_path (script_file);
e_signature_set_name (signature, script_name);
e_signature_set_filename (signature, path);
g_free (path);
g_object_unref (script_file);
success = TRUE;
exit:
gtk_widget_destroy (dialog);
return success;
}
static void
gtk_drag_dest_hierarchy_changed (GtkWidget *widget,
GtkWidget *previous_toplevel)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel) && gtk_widget_get_realized (toplevel))
gdk_window_register_dnd (gtk_widget_get_window (toplevel));
}
static int
uni_image_view_button_press (GtkWidget * widget, GdkEventButton * ev)
{
gtk_widget_grab_focus(widget);
UniImageView *view = UNI_IMAGE_VIEW (widget);
VnrWindow *vnr_win = VNR_WINDOW(gtk_widget_get_toplevel(widget));
g_assert(gtk_widget_is_toplevel(GTK_WIDGET(vnr_win)));
if(ev->type == GDK_2BUTTON_PRESS && ev->button == 1 && vnr_win->prefs->behavior_click == VNR_PREFS_CLICK_FULLSCREEN)
{
vnr_window_toggle_fullscreen(vnr_win);
return 1;
}
else if(ev->type == GDK_2BUTTON_PRESS && ev->button == 1 && vnr_win->prefs->behavior_click == VNR_PREFS_CLICK_NEXT)
{
int width;
gdk_drawable_get_size(GDK_DRAWABLE(widget->window), &width, NULL);
if(ev->x/width < 0.5)
vnr_window_prev(vnr_win);
else
vnr_window_next(vnr_win, TRUE);
return 1;
}
else if (ev->type == GDK_BUTTON_PRESS && ev->button == 1)
{
return uni_dragger_button_press (UNI_DRAGGER(view->tool), ev);
}
else if (ev->type == GDK_2BUTTON_PRESS && ev->button == 1)
{
if (view->fitting == UNI_FITTING_FULL ||
(view->fitting == UNI_FITTING_NORMAL && view->zoom != 1.0))
uni_image_view_set_zoom_with_center (view, 1., ev->x, ev->y,
FALSE);
else
uni_image_view_set_fitting (view, UNI_FITTING_FULL);
return 1;
}
else if(ev->type == GDK_BUTTON_PRESS && ev->button == 3)
{
gtk_menu_popup(GTK_MENU(VNR_WINDOW(gtk_widget_get_toplevel (widget))->popup_menu),
NULL, NULL, NULL, NULL, ev->button,
gtk_get_current_event_time());
}
else if(ev->type == GDK_BUTTON_PRESS && ev->button == 8)
{
vnr_window_prev(vnr_win);
}
else if(ev->type == GDK_BUTTON_PRESS && ev->button == 9)
{
vnr_window_next(vnr_win, TRUE);
}
return 0;
}
/* Create the dialog and connects its buttons */
static void
ensure_dialog (GtkSourceStyleSchemeChooserButton *button)
{
GtkSourceStyleSchemeChooserButtonPrivate *priv = GET_PRIV (button);
GtkWidget *parent, *dialog, *scrolled_window;
GtkWidget *content_area;
if (priv->dialog != NULL)
{
return;
}
parent = gtk_widget_get_toplevel (GTK_WIDGET (button));
/* TODO: have a ChooserDialog? */
priv->dialog = dialog = gtk_dialog_new_with_buttons (_("Select a Style"),
GTK_WINDOW (parent),
GTK_DIALOG_DESTROY_WITH_PARENT |
GTK_DIALOG_USE_HEADER_BAR,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Select"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrolled_window, 325, 450);
gtk_widget_show (scrolled_window);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_container_add (GTK_CONTAINER (content_area), scrolled_window);
priv->chooser = GTK_SOURCE_STYLE_SCHEME_CHOOSER_WIDGET (gtk_source_style_scheme_chooser_widget_new ());
gtk_widget_show (GTK_WIDGET (priv->chooser));
gtk_source_style_scheme_chooser_set_style_scheme (GTK_SOURCE_STYLE_SCHEME_CHOOSER (priv->chooser),
priv->scheme);
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (priv->chooser));
if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent))
{
if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (dialog)))
{
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
}
gtk_window_set_modal (GTK_WINDOW (dialog),
gtk_window_get_modal (GTK_WINDOW (parent)));
}
g_signal_connect (dialog, "response",
G_CALLBACK (dialog_response), button);
g_signal_connect (dialog, "destroy",
G_CALLBACK (dialog_destroy), button);
}
static void
ViewAutoDrawerOnHierarchyChanged(ViewAutoDrawer *that, // IN
GtkWidget *oldToplevel) // IN
{
GtkWidget *newToplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
if (oldToplevel && gtk_widget_is_toplevel(oldToplevel)) {
g_signal_handlers_disconnect_by_func(oldToplevel,
G_CALLBACK(ViewAutoDrawerOnSetFocus),
that);
}
if (newToplevel && gtk_widget_is_toplevel(newToplevel)) {
g_signal_connect_after(newToplevel, "set-focus",
G_CALLBACK(ViewAutoDrawerOnSetFocus), that);
}
/* This change happens programmatically. Always react to it immediately. */
ViewAutoDrawerUpdate(that, TRUE);
}
Gtk::Window&
Gobby::PreferencesDialog::Security::get_toplevel(Gtk::Widget& widget)
{
Gtk::Window* parent = NULL;
Gtk::Widget* toplevel_widget = widget.get_toplevel();
if(gtk_widget_is_toplevel(toplevel_widget->gobj()))
parent = dynamic_cast<Gtk::Window*>(toplevel_widget);
g_assert(parent != NULL);
return *parent;
}
/* find the toplevel widget for @widget */
static GtkWindow *
get_toplevel_window (GtkWidget *widget)
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (widget);
if (!gtk_widget_is_toplevel (toplevel))
return NULL;
else
return GTK_WINDOW (toplevel);
}
static void
real_queue_resize (GtkWidget *widget)
{
GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED);
GTK_PRIVATE_SET_FLAG (widget, GTK_REQUEST_NEEDED);
if (widget->parent)
_gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
else if (gtk_widget_is_toplevel (widget) && GTK_IS_CONTAINER (widget))
_gtk_container_queue_resize (GTK_CONTAINER (widget));
}
FloatRect ChromeClient::windowRect()
{
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
if (gtk_widget_is_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();
}
