inline void button_clicked_entry_browse_directory (GtkWidget* widget, GtkEntry* entry)
{
gtkutil::FileChooser dirChooser(gtk_widget_get_toplevel(widget), _("Choose Directory"), true, true);
std::string curEntry = gtk_entry_get_text(entry);
if (g_path_is_absolute(curEntry.c_str()))
curEntry.clear();
dirChooser.setCurrentPath(curEntry);
std::string filename = dirChooser.display();
if (GTK_IS_WINDOW(gtk_widget_get_toplevel(widget))) {
gtk_window_present(GTK_WINDOW(gtk_widget_get_toplevel(widget)));
}
if (!filename.empty()) {
gtk_entry_set_text(entry, filename.c_str());
}
}
void
gdict_show_pref_dialog (GtkWidget *parent,
const gchar *title,
GdictSourceLoader *loader)
{
GtkWidget *dialog;
g_return_if_fail (GTK_IS_WIDGET (parent));
g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader));
if (parent != NULL)
dialog = g_object_get_data (G_OBJECT (parent), "gdict-pref-dialog");
else
dialog = global_dialog;
if (dialog == NULL)
{
dialog = g_object_new (GDICT_TYPE_PREF_DIALOG,
"source-loader", loader,
"title", title,
NULL);
g_object_ref_sink (dialog);
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete),
NULL);
if (parent != NULL && GTK_IS_WINDOW (parent))
{
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
g_object_set_data_full (G_OBJECT (parent), "gdict-pref-dialog",
dialog,
g_object_unref);
}
else
global_dialog = dialog;
}
gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (parent));
gtk_window_present (GTK_WINDOW (dialog));
}
GtkWindow *
ag_app_peek_first_window(AgApp *app)
{
GList *l;
for (
l = gtk_application_get_windows(GTK_APPLICATION(app));
l;
l = g_list_next(l)
) {
if (GTK_IS_WINDOW(l->data)) {
return GTK_WINDOW(l->data);
}
}
ag_app_new_window(app);
return ag_app_peek_first_window(app);
}
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));
}
GtkResponseType
ag_app_buttoned_dialog(GtkWindow *window,
GtkMessageType message_type,
const gchar *message,
const gchar *first_button_text,
...)
{
va_list ap;
const gchar *button_text;
gint response_id;
GtkWidget *dialog;
g_return_val_if_fail(GTK_IS_WINDOW(window), GTK_RESPONSE_NONE);
dialog = gtk_message_dialog_new(
window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
message_type,
GTK_BUTTONS_NONE,
"%s",
message
);
if (first_button_text) {
button_text = first_button_text;
va_start(ap, first_button_text);
response_id = va_arg(ap, gint);
gtk_dialog_add_button(GTK_DIALOG(dialog), button_text, response_id);
while ((button_text = va_arg(ap, gchar *)) != NULL) {
response_id = va_arg(ap, gint);
gtk_dialog_add_button(GTK_DIALOG(dialog), button_text, response_id);
}
va_end(ap);
}
response_id = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return response_id;
}
static gboolean
state_event_watcher (GSignalInvocationHint *hint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *object;
GtkWidget *widget;
AtkObject *atk_obj;
AtkObject *parent;
GdkEventWindowState *event;
gchar *signal_name;
object = g_value_get_object (param_values + 0);
if (!GTK_IS_WINDOW (object))
return FALSE;
event = g_value_get_boxed (param_values + 1);
if (event->type == GDK_WINDOW_STATE)
return FALSE;
widget = GTK_WIDGET (object);
if (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
signal_name = "maximize";
else if (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED)
signal_name = "minimize";
else if (event->new_window_state == 0)
signal_name = "restore";
else
return TRUE;
atk_obj = gtk_widget_get_accessible (widget);
if (GTK_IS_WINDOW_ACCESSIBLE (atk_obj))
{
parent = atk_object_get_parent (atk_obj);
if (parent == atk_get_root ())
g_signal_emit_by_name (atk_obj, signal_name);
return TRUE;
}
return FALSE;
}
void
rbgtk_initialize_gtkobject(VALUE obj, GtkObject *gtkobj)
{
gtkobj = g_object_ref(gtkobj);
gtk_object_sink(gtkobj);
G_INITIALIZE(obj, gtkobj);
if (GTK_IS_WINDOW(gtkobj) || GTK_IS_MENU_SHELL(gtkobj)) {
VALUE klass;
klass = rb_obj_class(obj);
if (rb_ivar_defined(klass, id__windows__) == Qfalse) {
rb_ivar_set(klass, id__windows__, rb_hash_new());
}
rb_hash_aset(rb_ivar_get(klass, id__windows__), obj, Qnil);
g_signal_connect_after(gtkobj, "destroy",
G_CALLBACK(remove_from_windows),
(gpointer)obj);
}
}
/* Ignores (x, y) on input, translates event coordinates to
* allocation relative (x, y) of the returned widget.
*/
static GtkWidget *
find_topmost_widget_coords_from_event (GdkEvent *event,
gint *x,
gint *y)
{
GtkAllocation allocation;
gint tx, ty;
gdouble dx, dy;
GtkWidget *tmp;
gdk_event_get_coords (event, &dx, &dy);
/* Returns coordinates relative to tmp's allocation. */
tmp = _gtk_widget_find_at_coords (event->any.window, dx, dy, &tx, &ty);
if (!tmp)
return NULL;
/* Make sure the pointer can actually be on the widget returned. */
gtk_widget_get_allocation (tmp, &allocation);
allocation.x = 0;
allocation.y = 0;
if (GTK_IS_WINDOW (tmp))
{
GtkBorder border;
_gtk_window_get_shadow_width (GTK_WINDOW (tmp), &border);
allocation.x = border.left;
allocation.y = border.top;
allocation.width -= border.left + border.right;
allocation.height -= border.top + border.bottom;
}
if (tx < allocation.x || tx >= allocation.width ||
ty < allocation.y || ty >= allocation.height)
return NULL;
if (x)
*x = tx;
if (y)
*y = ty;
return tmp;
}
/**
* games_settings_bind_window_state:
* @path: a valid #GSettings path
* @window: a #GtkWindow
*
* Restore the window configuration, and persist changes to the window configuration:
* window width and height, and maximised and fullscreen state.
* @window must not be realised yet.
*
* To make sure the state is saved at exit, g_settings_sync() must be called.
*/
void
games_settings_bind_window_state (const char *path,
GtkWindow *window)
{
WindowState *state;
int width, height;
gboolean maximised, fullscreen;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
state = g_slice_new0 (WindowState);
state->window = window;
state->settings = g_settings_new_with_path (SCHEMA_NAME, path);
/* We delay storing the state until exit */
g_settings_delay (state->settings);
g_object_set_data_full (G_OBJECT (window), "GamesSettings::WindowState",
state, (GDestroyNotify) free_window_state);
g_signal_connect (window, "configure-event",
G_CALLBACK (window_configure_event_cb), state);
g_signal_connect (window, "window-state-event",
G_CALLBACK (window_state_event_cb), state);
maximised = g_settings_get_boolean (state->settings, STATE_KEY_MAXIMIZED);
fullscreen = g_settings_get_boolean (state->settings, STATE_KEY_FULLSCREEN);
width = g_settings_get_int (state->settings, STATE_KEY_WIDTH);
height = g_settings_get_int (state->settings, STATE_KEY_HEIGHT);
if (width > 0 && height > 0) {
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
}
if (maximised) {
gtk_window_maximize (GTK_WINDOW (window));
}
if (fullscreen) {
gtk_window_fullscreen (GTK_WINDOW (window));
}
}
/**
* @fn void *startROS (void *user)
* @brief ROS thread.
*
* The main program wait until "ros_param_read" in order to allow the <br>
* ROS params to be also the Gtk Window and Widgets params.
* Then the ROS thread wait to the widgets creation before subcribing<br>
* to any topics, avoid to call public widget function for a widget not<br>
* yet created.
*/
void *startROS (void *user)
{
if (user != NULL)
{
struct arg *p_arg = (arg *) user;
ros::init (p_arg->argc, p_arg->argv, "gpsd_viewer");
ros::NodeHandle n;
std::string local_path;
std::string package_path = ros::package::getPath (ROS_PACKAGE_NAME);
ros::NodeHandle n_param ("~");
XmlRpc::XmlRpcValue xml_marker_center;
ROS_INFO ("Starting GPSD Viewer");
// -----------------------------------------------------------------
// **** allow widget creation
data->ros_param_read = true;
// **** wait to widget creation
while (!data->widget_created)
{
ROS_DEBUG ("Waiting widgets creation");
}
// -----------------------------------------------------------------
// **** topics subscribing
ros::Subscriber fix_sub;
fix_sub = n.subscribe ("/fix", 1, &gpsFixCallback);
pub_cmd= n.advertise<gpsd_viewer::cmd>("cmd",5);
ROS_INFO ("Spinning");
ros::spin ();
}
// **** stop the gtk main loop
if (GTK_IS_WINDOW (data->window))
{
gtk_main_quit ();
}
pthread_exit (NULL);
}
static void
sp_window_settings__window_realize (GtkWindow *window)
{
GtkApplication *app;
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
GList *list;
guint count = 0;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
geom.width = MAX (geom.width, WINDOW_MIN_WIDTH);
geom.height = MAX (geom.height, WINDOW_MIN_HEIGHT);
gtk_window_set_default_size (window, geom.width, geom.height);
/*
* If there are other windows currently visible other than this one,
* then ignore positioning and let the window manager decide.
*/
count = 0;
app = GTK_APPLICATION (g_application_get_default ());
list = gtk_application_get_windows (app);
for (; list != NULL; list = list->next)
{
GtkWindow *ele = list->data;
if (SP_IS_WINDOW (ele) && (ele != window) &&
gtk_widget_get_visible (GTK_WIDGET (window)))
count++;
}
if (count == 0)
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
}
/**
* eel_gtk_window_set_initial_geometry_from_string:
*
* Sets the position and size of a GtkWindow before the
* GtkWindow is shown. The geometry is passed in as a string.
* It is an error to call this on a window that
* is already on-screen. Takes into account screen size, and does
* some sanity-checking on the passed-in values.
*
* @window: A non-visible GtkWindow
* @geometry_string: A string suitable for use with eel_gdk_parse_geometry
* @minimum_width: If the width from the string is smaller than this,
* use this for the width.
* @minimum_height: If the height from the string is smaller than this,
* use this for the height.
* @ignore_position: If true position data from string will be ignored.
*/
void
eel_gtk_window_set_initial_geometry_from_string (GtkWindow *window,
const char *geometry_string,
guint minimum_width,
guint minimum_height,
gboolean ignore_position)
{
int left, top;
guint width, height;
EelGdkGeometryFlags geometry_flags;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (geometry_string != NULL);
/* Setting the default size doesn't work when the window is already showing.
* Someday we could make this move an already-showing window, but we don't
* need that functionality yet.
*/
g_return_if_fail (!gtk_widget_get_visible (GTK_WIDGET (window)));
geometry_flags = eel_gdk_parse_geometry (geometry_string, &left, &top, &width, &height);
/* Make sure the window isn't smaller than makes sense for this window.
* Other sanity checks are performed in set_initial_geometry.
*/
if (geometry_flags & EEL_GDK_WIDTH_VALUE)
{
width = MAX (width, minimum_width);
}
if (geometry_flags & EEL_GDK_HEIGHT_VALUE)
{
height = MAX (height, minimum_height);
}
/* Ignore saved window position if requested. */
if (ignore_position)
{
geometry_flags &= ~(EEL_GDK_X_VALUE | EEL_GDK_Y_VALUE);
}
eel_gtk_window_set_initial_geometry (window, geometry_flags, left, top, width, height);
}
inline void button_clicked_entry_browse_file (GtkWidget* widget, GtkEntry* entry)
{
std::string filename = gtk_entry_get_text(entry);
gtkutil::FileChooser fileChooser(gtk_widget_get_toplevel(widget), _("Choose File"), true, false);
if (!filename.empty()) {
fileChooser.setCurrentPath(os::stripFilename(filename));
fileChooser.setCurrentFile(filename);
}
std::string file = fileChooser.display();
if (GTK_IS_WINDOW(gtk_widget_get_toplevel(widget))) {
gtk_window_present(GTK_WINDOW(gtk_widget_get_toplevel(widget)));
}
if (!file.empty()) {
gtk_entry_set_text(entry, file.c_str());
}
}
void
dh_preferences_show_dialog (GtkWindow *parent)
{
g_return_if_fail (GTK_IS_WINDOW (parent));
if (prefs_dialog == NULL) {
prefs_dialog = GTK_WIDGET (g_object_new (DH_TYPE_PREFERENCES, NULL));
g_signal_connect (prefs_dialog,
"destroy",
G_CALLBACK (gtk_widget_destroyed),
&prefs_dialog);
}
if (parent != gtk_window_get_transient_for (GTK_WINDOW (prefs_dialog))) {
gtk_window_set_transient_for (GTK_WINDOW (prefs_dialog),
parent);
}
gtk_window_present (GTK_WINDOW (prefs_dialog));
}
static gboolean webViewWindowStateEvent(GtkWidget *widget, GdkEventWindowState *event, WebKitWebView *webView)
{
if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
const gchar *uri = webkit_web_frame_get_uri(frame);
GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
window = 0;
GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"%s is now full screen. Press ESC or f to exit.", uri);
g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
g_timeout_add(1500, (GSourceFunc) webViewFullscreenMessageWindowClose, dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
return TRUE;
}
/**
* gwy_app_wait_start:
* @window: A window.
* @message: A message to show in the wait dialog.
*
* Starts waiting for a window @window, creating a dialog with a progress bar.
*
* Waiting is global, there can be only one at a time.
**/
void
gwy_app_wait_start(GtkWidget *window,
const gchar *message)
{
if (window && !GTK_IS_WINDOW(window))
g_warning("Widget is not a window");
if (wait_widget || silent_waiting) {
g_warning("Already waiting on a widget, switching to the new one");
gwy_app_wait_switch_widget(window, message);
return;
}
canceled = FALSE;
if (!window)
silent_waiting = TRUE;
else
gwy_app_wait_create_dialog(window, message);
wait_widget = window;
}
static gboolean
_window_configure_cb (GtkWidget *widget,
GdkEventConfigure *event,
gpointer user_data)
{
ol_assert_ret (GTK_IS_WINDOW (widget), FALSE);
OlScrollModule *module = (OlScrollModule*) user_data;
if (module == NULL)
return FALSE;
if (_config_is_setting)
return FALSE;
_config_is_setting = TRUE;
gint width, height;
OlConfigProxy *config = ol_config_proxy_get_instance ();
gtk_window_get_size (GTK_WINDOW (widget), &width, &height);
ol_config_proxy_set_int (config, "ScrollMode/width", width);
ol_config_proxy_set_int (config, "ScrollMode/height", height);
_config_is_setting = FALSE;
return FALSE;
}
static void
gimp_display_shell_close_name_changed (GimpImage *image,
GimpMessageBox *box)
{
GtkWidget *window = gtk_widget_get_toplevel (GTK_WIDGET (box));
if (GTK_IS_WINDOW (window))
{
gchar *title = g_strdup_printf (_("Close %s"),
gimp_image_get_display_name (image));
gtk_window_set_title (GTK_WINDOW (window), title);
g_free (title);
}
gimp_message_box_set_primary_text (box,
_("Save the changes to image '%s' "
"before closing?"),
gimp_image_get_display_name (image));
}
static GObject *
find_action_owner (GtkActionable *actionable)
{
GtkWidget *widget = GTK_WIDGET (actionable);
const gchar *full_name;
const gchar *dot;
const gchar *name;
gchar *prefix;
GtkWidget *win;
GActionGroup *group;
full_name = gtk_actionable_get_action_name (actionable);
if (!full_name)
return NULL;
dot = strchr (full_name, '.');
prefix = g_strndup (full_name, dot - full_name);
name = dot + 1;
win = gtk_widget_get_ancestor (widget, GTK_TYPE_APPLICATION_WINDOW);
if (g_strcmp0 (prefix, "win") == 0)
{
if (G_IS_OBJECT (win))
return (GObject *)win;
}
else if (g_strcmp0 (prefix, "app") == 0)
{
if (GTK_IS_WINDOW (win))
return (GObject *)gtk_window_get_application (GTK_WINDOW (win));
}
while (widget != NULL)
{
group = _gtk_widget_get_action_group (widget, prefix);
if (group && g_action_group_has_action (group, name))
return (GObject *)widget;
widget = action_ancestor (widget);
}
return NULL;
}
/**
* gedit_utils_get_window_workspace: Get the workspace the window is on
*
* This function gets the workspace that the #GtkWindow is visible on,
* it returns GEDIT_ALL_WORKSPACES if the window is sticky, or if
* the window manager doesn support this function
*/
guint
gedit_utils_get_window_workspace (GtkWindow *gtkwindow)
{
#ifdef GDK_WINDOWING_X11
GdkWindow *window;
GdkDisplay *display;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;
guint *workspace;
gint err, result;
guint ret = GEDIT_ALL_WORKSPACES;
g_return_val_if_fail (GTK_IS_WINDOW (gtkwindow), 0);
g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (gtkwindow)), 0);
window = gtk_widget_get_window (GTK_WIDGET (gtkwindow));
display = gdk_drawable_get_display (window);
gdk_error_trap_push ();
result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),
0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,
&bytes_after, (gpointer) &workspace);
err = gdk_error_trap_pop ();
if (err != Success || result != Success)
return ret;
if (type == XA_CARDINAL && format == 32 && nitems > 0)
ret = workspace[0];
XFree (workspace);
return ret;
#else
/* FIXME: on mac etc proably there are native APIs
* to get the current workspace etc */
return 0;
#endif
}
/**
* gtk_test_create_widget:
* @widget_type: a valid widget type.
* @first_property_name: (allow-none): Name of first property to set or %NULL
* @...: value to set the first property to, followed by more
* name-value pairs, terminated by %NULL
*
* This function wraps g_object_new() for widget types.
* It'll automatically show all created non window widgets, also
* g_object_ref_sink() them (to keep them alive across a running test)
* and set them up for destruction during the next test teardown phase.
*
* Returns: (transfer none): a newly created widget.
*
* Since: 2.14
*/
GtkWidget*
gtk_test_create_widget (GType widget_type,
const gchar *first_property_name,
...)
{
GtkWidget *widget;
va_list var_args;
g_return_val_if_fail (g_type_is_a (widget_type, GTK_TYPE_WIDGET), NULL);
va_start (var_args, first_property_name);
widget = (GtkWidget*) g_object_new_valist (widget_type, first_property_name, var_args);
va_end (var_args);
if (widget)
{
if (!GTK_IS_WINDOW (widget))
gtk_widget_show (widget);
g_object_ref_sink (widget);
g_test_queue_unref (widget);
g_test_queue_destroy ((GDestroyNotify) gtk_widget_destroy, widget);
}
return widget;
}
static GtkWidget *
builder_get_toplevel (GtkBuilder *builder)
{
GSList *list, *walk;
GtkWidget *window = NULL;
list = gtk_builder_get_objects (builder);
for (walk = list; walk; walk = walk->next)
{
if (GTK_IS_WINDOW (walk->data) &&
gtk_widget_get_parent (walk->data) == NULL)
{
window = walk->data;
break;
}
}
g_slist_free (list);
return window;
}
wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
{
if (m_grabbed)
{
wxFAIL_MSG(_T("Window still grabbed"));
RemoveGrab();
}
m_isBeingDeleted = true;
// it may also be GtkScrolledWindow in the case of an MDI child
if (GTK_IS_WINDOW(m_widget))
{
gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
}
if (g_activeFrame == this)
g_activeFrame = NULL;
if (g_lastActiveFrame == this)
g_lastActiveFrame = NULL;
}
void
gimp_window_set_hint (GtkWindow *window,
GimpWindowHint hint)
{
g_return_if_fail (GTK_IS_WINDOW (window));
switch (hint)
{
case GIMP_WINDOW_HINT_NORMAL:
gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NORMAL);
break;
case GIMP_WINDOW_HINT_UTILITY:
gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_UTILITY);
break;
case GIMP_WINDOW_HINT_KEEP_ABOVE:
gtk_window_set_keep_above (window, TRUE);
break;
}
}
wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
{
if (m_grabbed)
{
wxASSERT_MSG( false, wxT("Window still grabbed"));
RemoveGrab();
}
SendDestroyEvent();
// it may also be GtkScrolledWindow in the case of an MDI child
if (GTK_IS_WINDOW(m_widget))
{
gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
}
if (g_activeFrame == this)
g_activeFrame = NULL;
if (g_lastActiveFrame == this)
g_lastActiveFrame = NULL;
}
static void gui_move(GtkWidget* window, GtkLayout* screen, gint x, gint y) {
if(GTK_IS_WINDOW(window)) {
gtk_window_move(GTK_WINDOW(window), x, y);
} else {
if(gtk_widget_get_parent(window) != GTK_WIDGET(screen))
//gtk_layout_put(screen, window, x, y);
g_assert(0 && "gui_move not a child");
else {
GValue value_x;
GValue value_y;
memset(&value_x, 0, sizeof(GValue));
memset(&value_y, 0, sizeof(GValue));
g_value_init(&value_x, G_TYPE_INT);
g_value_init(&value_y, G_TYPE_INT);
gtk_container_child_get_property(GTK_CONTAINER(screen), window, "x", &value_x);
gtk_container_child_get_property(GTK_CONTAINER(screen), window, "y", &value_y);
if(x != g_value_get_int (&value_x) || y != g_value_get_int(&value_y))
gtk_layout_move(screen, window, x, y);
}
}
}
void
e_shell_utils_run_preferences (EShell *shell)
{
GtkWidget *preferences_window;
GtkWindow *window;
preferences_window = e_shell_get_preferences_window (shell);
e_preferences_window_setup (E_PREFERENCES_WINDOW (preferences_window));
window = e_shell_get_active_window (shell);
g_return_if_fail (GTK_IS_WINDOW (window));
gtk_window_set_transient_for (
GTK_WINDOW (preferences_window),
window);
gtk_window_set_position (
GTK_WINDOW (preferences_window),
GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_present (GTK_WINDOW (preferences_window));
if (E_IS_SHELL_WINDOW (window)) {
EShellView *shell_view;
EShellWindow *shell_window;
EShellBackend *shell_backend;
EShellBackendClass *shell_backend_class;
const gchar *view_name;
shell_window = E_SHELL_WINDOW (window);
view_name = e_shell_window_get_active_view (shell_window);
shell_view = e_shell_window_get_shell_view (shell_window, view_name);
shell_backend = e_shell_view_get_shell_backend (shell_view);
shell_backend_class = E_SHELL_BACKEND_GET_CLASS (shell_backend);
if (shell_backend_class->preferences_page != NULL)
e_preferences_window_show_page (
E_PREFERENCES_WINDOW (preferences_window),
shell_backend_class->preferences_page);
}
}
/**
* gucharma_settings_add_window:
* @window: a #GtkWindow
*
* Restore the window configuration, and persist changes to the window configuration:
* window width and height, and maximised and fullscreen state.
* @window must not be realised yet.
*/
void
mcharmap_settings_add_window (GtkWindow *window)
{
#ifdef HAVE_MATECONF
WindowState *state;
int width, height;
gboolean maximised, fullscreen;
g_return_if_fail (GTK_IS_WINDOW (window));
#if GTK_CHECK_VERSION (2,20,0)
g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
#else
g_return_if_fail (!GTK_WIDGET_REALIZED (window));
#endif
state = g_slice_new0 (WindowState);
g_object_set_data_full (G_OBJECT (window), "GamesConf::WindowState",
state, (GDestroyNotify) free_window_state);
g_signal_connect (window, "configure-event",
G_CALLBACK (window_configure_event_cb), state);
g_signal_connect (window, "window-state-event",
G_CALLBACK (window_state_event_cb), state);
maximised = mateconf_client_get_bool (client, MATECONF_PREFIX "/maximized", NULL);
fullscreen = mateconf_client_get_bool (client, MATECONF_PREFIX "/fullscreen", NULL);
width = mateconf_client_get_int (client, MATECONF_PREFIX "/width", NULL);
height = mateconf_client_get_int (client, MATECONF_PREFIX "/height", NULL);
if (width > 0 && height > 0) {
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
}
if (maximised) {
gtk_window_maximize (GTK_WINDOW (window));
}
if (fullscreen) {
gtk_window_fullscreen (GTK_WINDOW (window));
}
#endif /* HAVE_MATECONF */
}
static gint
gail_window_get_index_in_parent (AtkObject *accessible)
{
GtkWidget* widget = GTK_ACCESSIBLE (accessible)->widget;
AtkObject* atk_obj = atk_get_root ();
gint index = -1;
if (widget == NULL)
/*
* State is defunct
*/
return -1;
gail_return_val_if_fail (GTK_IS_WIDGET (widget), -1);
index = ATK_OBJECT_CLASS (gail_window_parent_class)->get_index_in_parent (accessible);
if (index != -1)
return index;
if (GTK_IS_WINDOW (widget))
{
GtkWindow *window = GTK_WINDOW (widget);
if (GAIL_IS_TOPLEVEL (atk_obj))
{
GailToplevel* toplevel = GAIL_TOPLEVEL (atk_obj);
index = g_list_index (toplevel->window_list, window);
}
else
{
int i, sibling_count = atk_object_get_n_accessible_children (atk_obj);
for (i = 0; i < sibling_count && index == -1; ++i)
{
AtkObject *child = atk_object_ref_accessible_child (atk_obj, i);
if (accessible == child) index = i;
g_object_unref (G_OBJECT (child));
}
}
}
return index;
}
void
cb_media_image_widget_calc_size (CbMediaImageWidget *self)
{
GdkSurface *surface;
GdkMonitor *monitor;
GdkRectangle workarea;
int win_width;
int win_height;
g_assert (GTK_IS_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))));
/* :( */
gtk_widget_realize (gtk_widget_get_toplevel (GTK_WIDGET (self)));
surface = gtk_widget_get_surface (gtk_widget_get_toplevel (GTK_WIDGET (self)));
g_assert_nonnull (surface);
monitor = gdk_display_get_monitor_at_surface (gdk_display_get_default (),
surface);
if (!monitor)
{
g_warning (G_STRLOC ": monitor is NULL");
return;
}
gdk_monitor_get_workarea (monitor, &workarea);
win_width = MIN ((int)(workarea.width * 0.95), self->img_width);
win_height = MIN ((int)(workarea.height * 0.95), self->img_height);
if (win_width >= self->img_width)
g_object_set ((GObject *)self, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
if (win_height >= self->img_height)
g_object_set ((GObject *)self, "vscrollbar-policy", GTK_POLICY_NEVER, NULL);
gtk_widget_set_size_request ((GtkWidget *)self, win_width, win_height);
}
