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

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