void
panel_properties_dialog_present (PanelToplevel *toplevel)
{
PanelPropertiesDialog *dialog;
GtkBuilder *gui;
GError *error;
if (!panel_properties_dialog_quark)
panel_properties_dialog_quark =
g_quark_from_static_string ("panel-properties-dialog");
dialog = g_object_get_qdata (G_OBJECT (toplevel), panel_properties_dialog_quark);
if (dialog) {
gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_window_present (GTK_WINDOW (dialog->properties_dialog));
return;
}
gui = gtk_builder_new ();
gtk_builder_set_translation_domain (gui, GETTEXT_PACKAGE);
error = NULL;
gtk_builder_add_from_file (gui,
BUILDERDIR "/panel-properties-dialog.ui",
&error);
if (error) {
char *secondary;
secondary = g_strdup_printf (_("Unable to load file '%s': %s."),
BUILDERDIR"/panel-properties-dialog.ui",
error->message);
panel_error_dialog (GTK_WINDOW (toplevel),
gtk_window_get_screen (GTK_WINDOW (toplevel)),
"cannot_display_properties_dialog", TRUE,
_("Could not display properties dialog"),
secondary);
g_free (secondary);
g_error_free (error);
g_object_unref (gui);
return;
}
dialog = panel_properties_dialog_new (toplevel, gui);
g_object_unref (gui);
}
static void
action_nemo_manual_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
GError *error;
GtkWidget *dialog;
const char* helpuri;
const char* name = gtk_action_get_name (action);
error = NULL;
window = NEMO_WINDOW (user_data);
if (g_str_equal (name, "NemoHelpSearch")) {
helpuri = "help:gnome-help/files-search";
} else if (g_str_equal (name,"NemoHelpSort")) {
helpuri = "help:gnome-help/files-sort";
} else if (g_str_equal (name, "NemoHelpLost")) {
helpuri = "help:gnome-help/files-lost";
} else if (g_str_equal (name, "NemoHelpShare")) {
helpuri = "help:gnome-help/files-share";
} else {
helpuri = "help:gnome-help/files";
}
if (NEMO_IS_DESKTOP_WINDOW (window)) {
nemo_launch_application_from_command (gtk_window_get_screen (GTK_WINDOW (window)), "gnome-help", FALSE, NULL);
} else {
gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (window)),
helpuri,
gtk_get_current_event_time (), &error);
}
if (error) {
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_error_free (error);
}
}
static PanelPropertiesDialog *
panel_properties_dialog_new (PanelToplevel *toplevel,
GtkBuilder *gui)
{
PanelPropertiesDialog *dialog;
char *toplevel_settings_path;
dialog = g_new0 (PanelPropertiesDialog, 1);
g_object_set_qdata_full (G_OBJECT (toplevel),
panel_properties_dialog_quark,
dialog,
(GDestroyNotify) panel_properties_dialog_free);
dialog->toplevel = toplevel;
g_object_get (toplevel, "settings-path", &toplevel_settings_path, NULL);
dialog->settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA,
toplevel_settings_path);
dialog->settings_background = g_settings_get_child (dialog->settings,
PANEL_BACKGROUND_SCHEMA_CHILD);
g_free (toplevel_settings_path);
dialog->properties_dialog = PANEL_GTK_BUILDER_GET (gui, "panel_properties_dialog");
g_signal_connect_swapped (dialog->properties_dialog, "response",
G_CALLBACK (panel_properties_dialog_response), dialog);
g_signal_connect_swapped (dialog->properties_dialog, "destroy",
G_CALLBACK (panel_properties_dialog_destroy), dialog);
gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
dialog->writability_warn_general = PANEL_GTK_BUILDER_GET (gui, "writability_warn_general");
dialog->writability_warn_background = PANEL_GTK_BUILDER_GET (gui, "writability_warn_background");
panel_properties_dialog_setup_orientation_combo (dialog, gui);
panel_properties_dialog_size_spin_setup (dialog, gui);
panel_properties_dialog_expand_toggle_setup (dialog, gui);
panel_properties_dialog_autohide_toggle_setup (dialog, gui);
panel_properties_dialog_hidebuttons_toggle_setup (dialog, gui);
panel_properties_dialog_arrows_toggle_setup (dialog, gui);
panel_properties_dialog_image_chooser_setup (dialog, gui);
panel_properties_dialog_color_button_setup (dialog, gui);
panel_properties_dialog_opacity_scale_setup (dialog, gui);
panel_properties_dialog_background_radios_setup (dialog, gui);
g_signal_connect (dialog->settings_background, "changed",
G_CALLBACK (panel_properties_dialog_background_changed),
dialog);
panel_toplevel_push_autohide_disabler (dialog->toplevel);
panel_widget_register_open_dialog (panel_toplevel_get_panel_widget (dialog->toplevel),
dialog->properties_dialog);
gtk_widget_show (dialog->properties_dialog);
return dialog;
}
static gboolean
panel_popup_menu_left (PanelToplevel *toplevel,
guint button,
guint32 activate_time)
{
PanelWidget *panel_widget;
GtkWidget *menu;
PanelData *panel_data;
GdkEvent *current_event;
panel_widget = panel_toplevel_get_panel_widget (toplevel);
panel_data = g_object_get_data (G_OBJECT (toplevel), "PanelData");
current_event = gtk_get_current_event ();
if (current_event->type == GDK_BUTTON_PRESS)
panel_data->insertion_pos = panel_widget_get_cursorloc (panel_widget);
else
panel_data->insertion_pos = -1;
menu = make_popup_panel_menu (panel_widget);
//gtk_widget_set_usize(GTK_WINDOW (menu),10,10);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, activate_time);
gtk_menu_popdown (GTK_MENU (menu));
return FALSE;
}
// Constructor. Creates GTK widgets.
EntityClassChooser::EntityClassChooser () :
_widget(gtk_window_new(GTK_WINDOW_TOPLEVEL)), _treeStore(NULL), _selection(NULL), _addButton(NULL)
{
gtk_window_set_transient_for(GTK_WINDOW(_widget), GlobalRadiant().getMainWindow());
gtk_window_set_modal(GTK_WINDOW(_widget), TRUE);
gtk_window_set_position(GTK_WINDOW(_widget), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(_widget), ECLASS_CHOOSER_TITLE);
// Set the default size of the window
GdkScreen* scr = gtk_window_get_screen(GTK_WINDOW(_widget));
gint w = gdk_screen_get_width(scr);
gint h = gdk_screen_get_height(scr);
gtk_window_set_default_size(GTK_WINDOW(_widget), w / 3, h / 2);
// Create GUI elements and pack into main VBox
GtkWidget* vbx = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbx), createTreeView(), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbx), createUsagePanel(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbx), createButtonPanel(), FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(_widget), 12);
gtk_container_add(GTK_CONTAINER(_widget), vbx);
// Signals
g_signal_connect(_widget, "delete_event", G_CALLBACK(callbackHide), this);
}
static void
preferences_show_help (GtkWindow *parent,
char const *helpfile,
char const *sect_id)
{
GError *error = NULL;
GtkWidget *dialog;
char *help_string;
g_assert (helpfile != NULL);
g_assert (sect_id != NULL);
help_string = g_strdup_printf ("help:%s/%s", helpfile, sect_id);
gtk_show_uri (gtk_window_get_screen (parent),
help_string, gtk_get_current_event_time (),
&error);
g_free (help_string);
if (error) {
dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (dialog),
"response", G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_error_free (error);
}
}
gboolean
tray_toggle_visibility(gboolean force_hide)
{
static int x, y;
static GdkScreen *screen;
GtkWindow *win;
session *sess = sess_list->data;
if (!sticon)
return FALSE;
win = fe_gui_info_ptr(sess, 0);
tray_stop_flash();
tray_reset_counts();
if (!win)
return FALSE;
if (force_hide || GTK_WIDGET_VISIBLE(win))
{
gtk_window_get_position(win, &x, &y);
screen = gtk_window_get_screen(win);
gtk_widget_hide(GTK_WIDGET(win));
}
else
{
gtk_window_set_screen(win, screen);
gtk_window_move(win, x, y);
gtk_widget_show(GTK_WIDGET (win));
gtk_window_present(win);
}
return TRUE;
}
static gboolean
show_item_menu (GtkWidget *item,
GdkEventButton *bevent)
{
PanelWidget *panel_widget;
GtkWidget *menu;
if (panel_lockdown_get_locked_down ())
return FALSE;
panel_widget = menu_get_panel (item);
menu = g_object_get_data (G_OBJECT (item), "panel-item-context-menu");
if (!menu)
menu = create_item_context_menu (item, panel_widget);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel)));
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL, NULL, NULL,
bevent->button,
bevent->time);
return TRUE;
}
static void
realize (GtkWidget *widget)
{
AthenaDesktopWindow *window;
AthenaDesktopWindowDetails *details;
window = ATHENA_DESKTOP_WINDOW (widget);
details = window->details;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
/* Do the work of realizing. */
GTK_WIDGET_CLASS (athena_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
set_desktop_window_id (window, gtk_widget_get_window (widget));
details->size_changed_id =
g_signal_connect (gtk_window_get_screen (GTK_WINDOW (window)), "size_changed",
G_CALLBACK (athena_desktop_window_screen_size_changed), window);
}
GtkWidget*
remmina_widget_pool_find(GType type, const gchar *tag)
{
GtkWidget *widget;
gint i;
GdkScreen *screen;
gint screen_number;
guint workspace;
screen = gdk_screen_get_default();
screen_number = gdk_screen_get_number(screen);
workspace = remmina_public_get_current_workspace(screen);
if (remmina_widget_pool == NULL)
return NULL;
for (i = 0; i < remmina_widget_pool->len; i++)
{
widget = GTK_WIDGET(g_ptr_array_index(remmina_widget_pool, i));
if (!G_TYPE_CHECK_INSTANCE_TYPE(widget, type))
continue;
if (screen_number != gdk_screen_get_number(gtk_window_get_screen(GTK_WINDOW(widget))))
continue;
if (workspace != remmina_public_get_window_workspace(GTK_WINDOW(widget)))
continue;
if (tag && g_strcmp0((const gchar*) g_object_get_data(G_OBJECT(widget), "tag"), tag) != 0)
continue;
return widget;
}
return NULL;
}
static gboolean
panel_run_dialog_launch_command (PanelRunDialog *dialog,
const char *command,
const char *locale_command)
{
GdkScreen *screen;
gboolean result;
GError *error = NULL;
char **argv;
int argc;
GPid pid;
if (!command_is_executable (locale_command, &argc, &argv))
return FALSE;
screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->terminal_checkbox)))
mate_desktop_prepend_terminal_to_vector (&argc, &argv);
#if GTK_CHECK_VERSION (3, 0, 0)
result = g_spawn_async (NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH,
NULL,
NULL,
&pid,
&error);
#else
result = gdk_spawn_on_screen (screen,
NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, /* child setup func */
NULL, /* user data */
&pid, /* child pid */
&error);
#endif
if (!result) {
char *primary;
primary = g_markup_printf_escaped (_("Could not run command '%s'"),
command);
panel_error_dialog (GTK_WINDOW (dialog->run_dialog), NULL,
"cannot_spawn_command", TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
} else {
g_child_watch_add (pid, dummy_child_watch, NULL);
}
g_strfreev (argv);
return result;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1get_1screen
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GdkScreen* result;
jlong _result;
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
result = gtk_window_get_screen(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;
}
/********************************************************************\
* gnc_restore_window_size *
* restores the position and size of the given window, if these *
* these parameters have been saved earlier. Does nothing if no *
* saved values are found. *
* *
* Args: group - the preferences group to look in for saved coords *
* window - the window for which the coords are to be *
* restored *
* Returns: nothing *
\*******************************************************************/
void
gnc_restore_window_size(const char *group, GtkWindow *window)
{
gint wpos[2], wsize[2];
GVariant *geometry;
ENTER("");
g_return_if_fail(group != NULL);
g_return_if_fail(window != NULL);
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
geometry = gnc_prefs_get_value (group, GNC_PREF_LAST_GEOMETRY);
if (g_variant_is_of_type (geometry, (const GVariantType *) "(iiii)") )
{
gint screen_width;
gint screen_height;
#if GTK_CHECK_VERSION(3,22,0)
GdkWindow *win = gdk_screen_get_root_window (gtk_window_get_screen (window));
GdkMonitor *mon = gdk_display_get_monitor_at_window (gtk_widget_get_display (GTK_WIDGET(window)), win);
GdkRectangle monitor_size;
gdk_monitor_get_geometry (mon, &monitor_size);
screen_width = monitor_size.width;
screen_height = monitor_size.height;
#else
screen_width = gdk_screen_width(); //default screen
screen_height = gdk_screen_height(); //default screen
#endif
g_variant_get (geometry, "(iiii)",
&wpos[0], &wpos[1],
&wsize[0], &wsize[1]);
DEBUG("geometry from preferences - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
/* (-1, -1) means no geometry was saved (default preferences value) */
if ((wpos[0] != -1) && (wpos[1] != -1))
{
/* Keep the window on screen if possible */
if (screen_width != 0)
wpos[0] = wpos[0] % screen_width;
if (screen_height != 0)
wpos[1] = wpos[1] % screen_height;
DEBUG("geometry after screen adaption - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
gtk_window_move(window, wpos[0], wpos[1]);
}
/* Don't attempt to restore invalid sizes */
if ((wsize[0] > 0) && (wsize[1] > 0))
gtk_window_resize(window, wsize[0], wsize[1]);
}
g_variant_unref (geometry);
LEAVE("");
}
static void
realize (GtkWidget *widget)
{
NemoDesktopWindow *window;
NemoDesktopWindowDetails *details;
GdkVisual *visual;
window = NEMO_DESKTOP_WINDOW (widget);
details = window->details;
/* Make sure we get keyboard events */
gtk_widget_set_events (widget, gtk_widget_get_events (widget)
| GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
visual = gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget));
if (visual) {
gtk_widget_set_visual (widget, visual);
}
/* Do the work of realizing. */
GTK_WIDGET_CLASS (nemo_desktop_window_parent_class)->realize (widget);
/* This is the new way to set up the desktop window */
set_wmspec_desktop_hint (gtk_widget_get_window (widget));
set_desktop_window_id (window, gtk_widget_get_window (widget));
details->size_changed_id =
g_signal_connect (gtk_window_get_screen (GTK_WINDOW (window)), "size_changed",
G_CALLBACK (nemo_desktop_window_screen_size_changed), window);
}
static void
nautilus_bookmarks_window_response_callback (GtkDialog *dialog,
int response_id,
gpointer callback_data)
{
if (response_id == GTK_RESPONSE_HELP) {
GError *error = NULL;
gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (dialog)),
"ghelp:gnome-help#nautilus-bookmarks-edit",
gtk_get_current_event_time (), &error);
if (error) {
GtkWidget *err_dialog;
err_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (err_dialog),
"response", G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (err_dialog), FALSE);
gtk_widget_show (err_dialog);
g_error_free (error);
}
} else if (response_id == GTK_RESPONSE_CLOSE) {
gtk_widget_hide (GTK_WIDGET (dialog));
}
}
void background_info_set_background_by_file(BackgroundInfo* info,
const char* file)
{
g_message("[%s] file, :%s", __func__, file);
GError* error = NULL;
GdkScreen *screen;
screen = gtk_window_get_screen (GTK_WINDOW (info->container));
gint w = gdk_screen_get_width(screen);
gint h = gdk_screen_get_height(screen);
g_message("[%s] gdk_screen_get_width:%d, height: %d\n", __func__, w, h);
GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file,w,h,FALSE, &error);
if (error != NULL) {
g_warning("[%s] failed: %s\n", __func__, error->message);
g_error_free(error);
return;
}
g_mutex_lock(&info->m);
if (info->bg != NULL) {
cairo_surface_destroy(info->bg);
info->bg = NULL;
}
info->bg = gdk_cairo_surface_create_from_pixbuf(pb, 1,
gtk_widget_get_window(info->container));
g_mutex_unlock(&info->m);
g_object_unref(pb);
if (gtk_widget_get_realized(info->container)) {
gdk_window_invalidate_rect(gtk_widget_get_window(info->container),
NULL, TRUE);
}
}
static gboolean
spawn_synaptic (GtkWindow *window,
const gchar *path,
gint *child_pid)
{
gchar **argv;
GError *error = NULL;
gboolean retval = TRUE;
gint i = 0;
argv = g_new0 (gchar*, 6);
argv[i++] = g_find_program_in_path ("gksudo");
argv[i++] = g_strdup ("--desktop");
argv[i++] = g_strdup ("/usr/share/applications/synaptic.desktop");
argv[i++] = g_strdup ("--disable-grab");
argv[i++] = get_synaptic_command_line (window, path);
argv[i++] = NULL;
if (!gdk_spawn_on_screen (gtk_window_get_screen (window),
NULL, argv, NULL,
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, child_pid, &error))
{
show_error_dialog (window, (error) ? error->message : "");
g_error_free (error);
retval = FALSE;
}
g_strfreev (argv);
return retval;
}
// Create GTK widgets
ParticlesChooser::ParticlesChooser()
: _widget(gtk_window_new(GTK_WINDOW_TOPLEVEL)),
_particlesList(gtk_list_store_new(1, G_TYPE_STRING)),
_selectedParticle("")
{
// Set up main window
gtk_window_set_transient_for(GTK_WINDOW(_widget), GlobalMainFrame().getTopLevelWindow());
gtk_window_set_modal(GTK_WINDOW(_widget), TRUE);
gtk_window_set_title(GTK_WINDOW(_widget), _("Choose particles"));
gtk_window_set_position(GTK_WINDOW(_widget), GTK_WIN_POS_CENTER_ON_PARENT);
g_signal_connect(G_OBJECT(_widget), "delete-event",
G_CALLBACK(_onDestroy), this);
// Set the default size of the window
GdkScreen* scr = gtk_window_get_screen(GTK_WINDOW(_widget));
gint w = gdk_screen_get_width(scr);
gint h = gdk_screen_get_height(scr);
gtk_window_set_default_size(GTK_WINDOW(_widget), w / 3, h / 2);
// Main dialog vbox
GtkWidget* vbx = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(vbx), createTreeView(), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbx), createButtons(), FALSE, FALSE, 0);
// Add main vbox to dialog
gtk_container_set_border_width(GTK_CONTAINER(_widget), 12);
gtk_container_add(GTK_CONTAINER(_widget), vbx);
}
static void
action_help (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkWindow *window;
GtkWidget *dialog;
GtkApplication *application = user_data;
GError *error = NULL;
window = gtk_application_get_active_window (application);
gtk_show_uri (window ?
gtk_window_get_screen (GTK_WINDOW (window)) :
gdk_screen_get_default (),
"help:gnome-help/files",
gtk_get_current_event_time (), &error);
if (error) {
dialog = gtk_message_dialog_new (window ? GTK_WINDOW (window) : NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_error_free (error);
}
}
ParticleEditor::ParticleEditor () :
_widget(gtk_window_new(GTK_WINDOW_TOPLEVEL))
{
// Window properties
gtk_window_set_transient_for(GTK_WINDOW(_widget), GlobalRadiant().getMainWindow());
gtk_window_set_modal(GTK_WINDOW(_widget), TRUE);
gtk_window_set_title(GTK_WINDOW(_widget), PARTICLEEDITOR_TITLE);
gtk_window_set_position(GTK_WINDOW(_widget), GTK_WIN_POS_CENTER_ON_PARENT);
// Set the default size of the window
GdkScreen* scr = gtk_window_get_screen(GTK_WINDOW(_widget));
gint w = gdk_screen_get_width(scr);
gint h = gdk_screen_get_height(scr);
gtk_window_set_default_size(GTK_WINDOW(_widget), gint(w * 0.75), gint(h * 0.8));
// Create the model preview widget
gint glSize = gint(h * 0.4);
_particlePreview.setSize(glSize);
// Signals
//g_signal_connect(G_OBJECT(_widget), "delete_event", G_CALLBACK(callbackHide), this);
// Main window contains a VBox
GtkWidget* vbx = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbx), createPreviewPanel(), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbx), createButtons(), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(_widget), vbx);
}
void
panel_menu_button_popup_menu (PanelMenuButton *button,
guint n_button,
guint32 activate_time)
{
GdkScreen *screen;
g_return_if_fail (PANEL_IS_MENU_BUTTON (button));
panel_menu_button_create_menu (button);
panel_toplevel_push_autohide_disabler (button->priv->toplevel);
button_widget_set_ignore_leave (BUTTON_WIDGET (button), TRUE);
screen = gtk_window_get_screen (GTK_WINDOW (button->priv->toplevel));
gtk_menu_set_screen (GTK_MENU (button->priv->menu), screen);
gtk_menu_popup (GTK_MENU (button->priv->menu),
NULL,
NULL,
(GtkMenuPositionFunc) mate_panel_applet_position_menu,
GTK_WIDGET (button),
n_button,
activate_time);
}
static void
ide_application_actions_help (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeApplication *self = user_data;
GtkWindow *focused_window= NULL;
GdkScreen *screen = NULL;
GError *err = NULL;
g_assert (IDE_IS_APPLICATION (self));
focused_window = gtk_application_get_active_window (GTK_APPLICATION (self));
screen = gtk_window_get_screen (focused_window);
gtk_show_uri (screen,
"help:gnome-builder",
gtk_get_current_event_time (),
&err);
if (err)
{
g_message ("Unable to open help: %s\n", err->message);
g_error_free (err);
}
}
static gboolean
panel_popup_menu (PanelToplevel *toplevel,
guint button,
guint32 activate_time)
{
PanelWidget *panel_widget;
GtkWidget *menu;
PanelData *panel_data;
GdkEvent *current_event;
panel_widget = panel_toplevel_get_panel_widget (toplevel);
panel_data = g_object_get_data (G_OBJECT (toplevel), "PanelData");
current_event = gtk_get_current_event ();
if (current_event->type == GDK_BUTTON_PRESS)
panel_data->insert_pack_type = panel_widget_get_insert_pack_type_at_cursor (panel_widget);
else
panel_data->insert_pack_type = PANEL_OBJECT_PACK_START;
menu = make_popup_panel_menu (panel_widget);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, activate_time);
return TRUE;
}
/* Make email in about dialog clickable */
static void
about_dialog_handle_email_cb (GtkAboutDialog *about, const char *email_address, gpointer data)
{
GError *error = NULL;
gboolean ret;
char *cmdline;
GdkScreen *gscreen;
GtkWidget *error_dialog;
gscreen = gtk_window_get_screen (GTK_WINDOW (about));
cmdline = g_strconcat ("gnome-open mailto:", email_address, NULL);
ret = gdk_spawn_command_line_on_screen (gscreen, cmdline, &error);
g_free (cmdline);
if (ret == TRUE)
return;
g_error_free (error);
error = NULL;
cmdline = g_strconcat ("xdg-open mailto:", email_address, NULL);
ret = gdk_spawn_command_line_on_screen (gscreen, cmdline, &error);
g_free (cmdline);
if (ret == FALSE) {
error_dialog = gtk_message_dialog_new ( NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Failed to show url %s", error->message);
gtk_dialog_run (GTK_DIALOG (error_dialog));
g_error_free (error);
}
}
static void
applet_show_menu (AppletInfo *info,
GdkEventButton *event)
{
PanelWidget *panel_widget;
g_return_if_fail (info != NULL);
panel_widget = mate_panel_applet_get_panel_widget (info);
if (info->menu == NULL)
info->menu = mate_panel_applet_create_menu (info);
if (info->menu == NULL)
return;
mate_panel_applet_menu_set_recurse (GTK_MENU (info->menu),
"menu_panel",
panel_widget);
gtk_menu_set_screen (GTK_MENU (info->menu),
gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel)));
if (!gtk_widget_get_realized (info->menu))
gtk_widget_show (info->menu);
gtk_menu_popup (GTK_MENU (info->menu),
NULL,
NULL,
(GtkMenuPositionFunc) mate_panel_applet_position_menu,
info->widget,
event->button,
event->time);
}
void
show_help_dialog (GtkWindow *parent,
const char *section)
{
char *uri;
GError *error = NULL;
uri = g_strconcat ("help:engrampa", section ? "/" : NULL, section, NULL);
if (! show_uri (gtk_window_get_screen (parent), uri, GDK_CURRENT_TIME, &error)) {
GtkWidget *dialog;
dialog = _gtk_message_dialog_new (parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_DIALOG_ERROR,
_("Could not display help"),
error->message,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_clear_error (&error);
}
g_free (uri);
}
static void
applet_show_menu (AppletInfo *info,
GtkWidget *menu,
gboolean custom_position,
GdkEventButton *event)
{
PanelWidget *panel_widget;
g_return_if_fail (info != NULL);
if (menu == NULL)
return;
panel_widget = panel_applet_get_panel_widget (info);
panel_applet_menu_set_recurse (GTK_MENU (menu),
"menu_panel",
panel_widget);
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel)));
if (!gtk_widget_get_realized (menu))
gtk_widget_show (menu);
gtk_menu_popup (GTK_MENU (menu),
NULL,
NULL,
custom_position ?
(GtkMenuPositionFunc) panel_applet_position_menu : NULL,
info->widget,
event->button,
event->time);
}
static void
remove_popup (GtkWidget *popup)
{
GdkWindow *root;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkDisplay *display;
GdkDevice *pointer;
GdkDevice *keyboard;
GdkDeviceManager *device_manager;
#endif
root = gdk_screen_get_root_window (
gtk_window_get_screen (GTK_WINDOW (popup)));
gdk_window_remove_filter (root, (GdkFilterFunc) popup_filter, popup);
gtk_widget_destroy (popup);
#if GTK_CHECK_VERSION (3, 0, 0)
display = gdk_window_get_display (root);
device_manager = gdk_display_get_device_manager (display);
pointer = gdk_device_manager_get_client_pointer (device_manager);
keyboard = gdk_device_get_associated_device (pointer);
gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
#else
gdk_pointer_ungrab (GDK_CURRENT_TIME);
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
#endif
}
static void
action_caja_manual_callback (GtkAction *action,
gpointer user_data)
{
CajaWindow *window;
GError *error;
GtkWidget *dialog;
error = NULL;
window = CAJA_WINDOW (user_data);
gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (window)),
CAJA_IS_DESKTOP_WINDOW (window)
? "help:mate-user-guide"
: "help:mate-user-guide/goscaja-1",
gtk_get_current_event_time (), &error);
if (error)
{
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_error_free (error);
}
}
/* Ask X to move to the desktop on which @window currently is
* and the present @window. */
void
empathy_move_to_window_desktop (GtkWindow *window,
guint32 timestamp)
{
#ifdef GDK_WINDOWING_X11
GdkScreen *screen;
Screen *xscreen;
GdkWindow *gdk_window;
int workspace;
screen = gtk_window_get_screen (window);
if (!GDK_IS_X11_SCREEN (screen))
goto out;
xscreen = gdk_x11_screen_get_xscreen (screen);
gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
workspace = window_get_workspace (xscreen,
gdk_x11_window_get_xid (gdk_window));
if (workspace == -1)
goto out;
_wnck_activate_workspace (xscreen, workspace, timestamp);
out:
gtk_window_present_with_time (window, timestamp);
#endif
}