void
meta_draw_window_decoration (decor_t *d)
{
Display *xdisplay =
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
cairo_surface_t *surface;
Picture src;
MetaButtonState button_states [META_BUTTON_TYPE_LAST];
MetaButtonLayout button_layout;
MetaFrameGeometry fgeom;
MetaFrameFlags flags;
MetaFrameType frame_type;
MetaTheme *theme;
GtkStyleContext *context;
cairo_t *cr;
gint i;
GdkRectangle clip;
Region top_region = NULL;
Region bottom_region = NULL;
Region left_region = NULL;
Region right_region = NULL;
gdouble meta_active_opacity, meta_inactive_opacity;
gboolean meta_active_shade_opacity, meta_inactive_shade_opacity;
g_object_get (settings, "metacity-active-opacity", &meta_active_opacity, NULL);
g_object_get (settings, "metacity-inactive-opacity", &meta_inactive_opacity, NULL);
g_object_get (settings, "metacity-active-shade-opacity", &meta_active_shade_opacity, NULL);
g_object_get (settings, "metacity-inactive-shade-opacity", &meta_inactive_shade_opacity, NULL);
double alpha = (d->active) ? meta_active_opacity : meta_inactive_opacity;
gboolean shade_alpha = (d->active) ? meta_active_shade_opacity :
meta_inactive_shade_opacity;
MetaFrameStyle *frame_style;
GtkWidget *style_window;
GdkRGBA bg_rgba;
if (!d->surface || !d->picture)
return;
if (decoration_alpha == 1.0)
alpha = 1.0;
if (cairo_xlib_surface_get_depth (d->surface) == 32)
{
context = gtk_widget_get_style_context (d->frame->style_window_rgba);
style_window = d->frame->style_window_rgba;
}
else
{
context = gtk_widget_get_style_context (d->frame->style_window_rgb);
style_window = d->frame->style_window_rgb;
}
cr = cairo_create (d->buffer_surface ? d->buffer_surface : d->surface);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
theme = meta_theme_get_current ();
frame_type = meta_frame_type_from_string (d->frame->type);
if (frame_type == META_FRAME_TYPE_LAST)
frame_type = META_FRAME_TYPE_NORMAL;
meta_get_decoration_geometry (d, theme, &flags, &fgeom, &button_layout,
frame_type, &clip);
if ((d->prop_xid || !d->buffer_surface) && !d->frame_window)
draw_shadow_background (d, cr, d->shadow, d->context);
for (i = 0; i < META_BUTTON_TYPE_LAST; ++i)
button_states[i] = meta_button_state_for_button_type (d, i);
frame_style = meta_theme_get_frame_style (theme,
frame_type,
flags);
gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg_rgba);
bg_rgba.alpha = 1.0;
if (frame_style->window_background_color)
{
meta_color_spec_render (frame_style->window_background_color,
gtk_widget_get_style_context (style_window),
&bg_rgba);
bg_rgba.alpha = frame_style->window_background_alpha / 255.0;
}
/* Draw something that will be almost invisible to user. This is hacky way
* to fix invisible decorations. */
cairo_set_source_rgba (cr, 0, 0, 0, 0.01);
cairo_rectangle (cr, 0, 0, 1, 1);
cairo_fill (cr);
/* ------------ */
cairo_destroy (cr);
if (d->frame_window)
surface = create_surface (clip.width, clip.height, d->frame->style_window_rgb);
else
surface = create_surface (clip.width, clip.height, d->frame->style_window_rgba);
cr = cairo_create (surface);
gdk_cairo_set_source_rgba (cr, &bg_rgba);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
src = XRenderCreatePicture (xdisplay, cairo_xlib_surface_get_drawable (surface),
get_format_for_surface (d, surface), 0, NULL);
cairo_paint (cr);
meta_theme_draw_frame (theme,
style_window,
cr,
frame_type,
flags,
clip.width - fgeom.left_width - fgeom.right_width,
clip.height - fgeom.top_height - fgeom.bottom_height,
d->layout,
d->frame->text_height,
&button_layout,
button_states,
d->icon_pixbuf,
NULL);
if (fgeom.top_height)
{
top_region = meta_get_top_border_region (&fgeom, clip.width);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, 0,
d->picture,
&d->border_layout,
BORDER_TOP,
top_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.bottom_height)
{
bottom_region = meta_get_bottom_border_region (&fgeom, clip.width);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, clip.height - fgeom.bottom_height,
d->picture,
&d->border_layout,
BORDER_BOTTOM,
bottom_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.left_width)
{
left_region = meta_get_left_border_region (&fgeom, clip.height);
decor_blend_border_picture (xdisplay,
d->context,
src,
0, fgeom.top_height,
d->picture,
&d->border_layout,
BORDER_LEFT,
left_region,
alpha * 0xffff,
shade_alpha,
0);
}
if (fgeom.right_width)
{
right_region = meta_get_right_border_region (&fgeom, clip.height);
decor_blend_border_picture (xdisplay,
d->context,
src,
clip.width - fgeom.right_width, fgeom.top_height,
d->picture,
&d->border_layout,
BORDER_RIGHT,
right_region,
alpha * 0xffff,
shade_alpha,
0);
}
cairo_destroy (cr);
cairo_surface_destroy (surface);
XRenderFreePicture (xdisplay, src);
copy_to_front_buffer (d);
if (d->frame_window)
{
GdkWindow *gdk_frame_window = gtk_widget_get_window (d->decor_window);
GdkPixbuf *pixbuf = gdk_pixbuf_get_from_surface (d->surface, 0, 0, d->width, d->height);
gtk_image_set_from_pixbuf (GTK_IMAGE (d->decor_image), pixbuf);
g_object_unref (pixbuf);
gtk_window_resize (GTK_WINDOW (d->decor_window), d->width, d->height);
gdk_window_move (gdk_frame_window,
d->context->left_corner_space - 1,
d->context->top_corner_space - 1);
gdk_window_lower (gdk_frame_window);
}
if (d->prop_xid)
{
/* translate from frame to client window space */
if (top_region)
XOffsetRegion (top_region, -fgeom.left_width, -fgeom.top_height);
if (bottom_region)
XOffsetRegion (bottom_region, -fgeom.left_width, 0);
if (left_region)
XOffsetRegion (left_region, -fgeom.left_width, 0);
decor_update_meta_window_property (d, theme, flags,
top_region,
bottom_region,
left_region,
right_region);
d->prop_xid = 0;
}
if (top_region)
XDestroyRegion (top_region);
if (bottom_region)
XDestroyRegion (bottom_region);
if (left_region)
XDestroyRegion (left_region);
if (right_region)
XDestroyRegion (right_region);
}
void
compzillaWindow::SendKeyEvent (int eventType, nsIDOMKeyEvent *keyEv)
{
DOMTimeStamp timestamp;
PRBool ctrl, shift, alt, meta;
int state = 0;
keyEv->GetTimeStamp (×tamp);
if (!timestamp) {
timestamp = gtk_get_current_event_time (); // CurrentTime;
}
keyEv->GetAltKey (&alt);
keyEv->GetCtrlKey (&ctrl);
keyEv->GetShiftKey (&shift);
keyEv->GetMetaKey (&meta);
if (ctrl) {
state |= ControlMask;
}
if (shift) {
state |= ShiftMask;
}
if (alt) {
state |= Mod1Mask;
}
if (meta) {
state |= Mod2Mask;
}
PRUint32 keycode;
keyEv->GetKeyCode (&keycode);
unsigned int xkeysym = DOMKeyCodeToKeySym (keycode);
#ifdef USE_GDK_KEYMAP
// FIXME: There's probably some annoying reason, like XKB, we need to use
// the GDK version. But for now I'm in denial.
GdkKeymapKey *keys = NULL;
int n_keys = 0;
if (!gdk_keymap_get_entries_for_keyval (gdk_keymap_get_for_display (gdk_display_get_default ()),
xkeysym,
&keys,
&n_keys)) {
ERROR ("Unknown keyval '%d' ignored.\n", xkeysym);
return;
}
unsigned int xkeycode = 0;
for (int i = 0; i < n_keys; i++) {
if (keys [i].keycode) {
xkeycode = keys [i].keycode;
break;
}
}
g_free (keys);
SPEW_EVENT ("SendKeyEvent: gdk_keymap_get_entries_for_keyval keysym=%p, "
"keycode=%p\n", xkeysym, xkeycode);
#else
unsigned int xkeycode = XKeysymToKeycode (mDisplay, xkeysym);
#endif
// Build up the XEvent we will send
XEvent xev = { 0 };
xev.xkey.type = eventType;
xev.xkey.serial = 0;
xev.xkey.display = mDisplay;
xev.xkey.window = mWindow;
xev.xkey.root = mAttr.root;
xev.xkey.time = timestamp;
xev.xkey.state = state;
xev.xkey.keycode = xkeycode;
xev.xkey.same_screen = True;
// Figure out who to send to
long xevMask;
switch (eventType) {
case _KeyPress:
xevMask = KeyPressMask;
break;
case KeyRelease:
xevMask = KeyReleaseMask;
break;
default:
NS_NOTREACHED ("Unknown eventType");
return;
}
SPEW_EVENT ("SendKeyEvent: %s%s win=%p, child=%p, state=%p, keycode=%u, "
"timestamp=%d\n",
eventType == _KeyPress ? "PRESS" : "",
eventType == KeyRelease ? "RELEASE" : "",
mWindow, mWindow, state, xkeycode, timestamp);
XSendEvent (mDisplay, mWindow, True, xevMask, &xev);
keyEv->StopPropagation ();
keyEv->PreventDefault ();
}
static GdkPixbuf *
screenshot_fallback_get_pixbuf (GdkRectangle *rectangle)
{
GdkWindow *root, *wm_window = NULL;
GdkPixbuf *screenshot;
GdkRectangle real_coords, screenshot_coords;
Window wm;
GtkBorder frame_offset = { 0, 0, 0, 0 };
GdkWindow *window;
window = screenshot_fallback_find_current_window ();
screenshot_fallback_get_window_rect_coords (window,
screenshot_config->include_border,
&real_coords,
&screenshot_coords);
wm = find_wm_window (window);
if (wm != None)
{
GdkRectangle wm_real_coords;
wm_window = gdk_x11_window_foreign_new_for_display
(gdk_window_get_display (window), wm);
screenshot_fallback_get_window_rect_coords (wm_window,
FALSE,
&wm_real_coords,
NULL);
frame_offset.left = (gdouble) (real_coords.x - wm_real_coords.x);
frame_offset.top = (gdouble) (real_coords.y - wm_real_coords.y);
frame_offset.right = (gdouble) (wm_real_coords.width - real_coords.width - frame_offset.left);
frame_offset.bottom = (gdouble) (wm_real_coords.height - real_coords.height - frame_offset.top);
}
if (rectangle)
{
screenshot_coords.x = rectangle->x - screenshot_coords.x;
screenshot_coords.y = rectangle->y - screenshot_coords.y;
screenshot_coords.width = rectangle->width;
screenshot_coords.height = rectangle->height;
}
root = gdk_get_default_root_window ();
screenshot = gdk_pixbuf_get_from_window (root,
screenshot_coords.x, screenshot_coords.y,
screenshot_coords.width, screenshot_coords.height);
if (!screenshot_config->take_window_shot &&
!screenshot_config->take_area_shot)
mask_monitors (screenshot, root);
#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
if (screenshot_config->include_border && (wm != None))
{
XRectangle *rectangles;
GdkPixbuf *tmp;
int rectangle_count, rectangle_order, i;
/* we must use XShape to avoid showing what's under the rounder corners
* of the WM decoration.
*/
rectangles = XShapeGetRectangles (GDK_DISPLAY_XDISPLAY (gdk_display_get_default()),
wm,
ShapeBounding,
&rectangle_count,
&rectangle_order);
if (rectangles && rectangle_count > 0)
{
gboolean has_alpha = gdk_pixbuf_get_has_alpha (screenshot);
tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
screenshot_coords.width, screenshot_coords.height);
gdk_pixbuf_fill (tmp, 0);
for (i = 0; i < rectangle_count; i++)
{
gint rec_x, rec_y;
gint rec_width, rec_height;
gint y;
/* If we're using invisible borders, the ShapeBounding might not
* have the same size as the frame extents, as it would include the
* areas for the invisible borders themselves.
* In that case, trim every rectangle we get by the offset between the
* WM window size and the frame extents.
*/
rec_x = rectangles[i].x;
rec_y = rectangles[i].y;
rec_width = rectangles[i].width - (frame_offset.left + frame_offset.right);
rec_height = rectangles[i].height - (frame_offset.top + frame_offset.bottom);
if (real_coords.x < 0)
{
rec_x += real_coords.x;
rec_x = MAX(rec_x, 0);
rec_width += real_coords.x;
}
if (real_coords.y < 0)
{
rec_y += real_coords.y;
rec_y = MAX(rec_y, 0);
rec_height += real_coords.y;
}
if (screenshot_coords.x + rec_x + rec_width > gdk_screen_width ())
rec_width = gdk_screen_width () - screenshot_coords.x - rec_x;
if (screenshot_coords.y + rec_y + rec_height > gdk_screen_height ())
rec_height = gdk_screen_height () - screenshot_coords.y - rec_y;
for (y = rec_y; y < rec_y + rec_height; y++)
{
guchar *src_pixels, *dest_pixels;
gint x;
src_pixels = gdk_pixbuf_get_pixels (screenshot)
+ y * gdk_pixbuf_get_rowstride(screenshot)
+ rec_x * (has_alpha ? 4 : 3);
dest_pixels = gdk_pixbuf_get_pixels (tmp)
+ y * gdk_pixbuf_get_rowstride (tmp)
+ rec_x * 4;
for (x = 0; x < rec_width; x++)
{
*dest_pixels++ = *src_pixels++;
*dest_pixels++ = *src_pixels++;
*dest_pixels++ = *src_pixels++;
if (has_alpha)
*dest_pixels++ = *src_pixels++;
else
*dest_pixels++ = 255;
}
}
}
g_object_unref (screenshot);
screenshot = tmp;
XFree (rectangles);
}
}
#endif /* HAVE_X11_EXTENSIONS_SHAPE_H */
/* if we have a selected area, there were by definition no cursor in the
* screenshot */
if (screenshot_config->include_pointer && !rectangle)
{
GdkCursor *cursor;
GdkPixbuf *cursor_pixbuf;
cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_LEFT_PTR);
cursor_pixbuf = gdk_cursor_get_image (cursor);
if (cursor_pixbuf != NULL)
{
GdkDeviceManager *manager;
GdkDevice *device;
GdkRectangle rect;
gint cx, cy, xhot, yhot;
manager = gdk_display_get_device_manager (gdk_display_get_default ());
device = gdk_device_manager_get_client_pointer (manager);
if (wm_window != NULL)
gdk_window_get_device_position (wm_window, device,
&cx, &cy, NULL);
else
gdk_window_get_device_position (window, device,
&cx, &cy, NULL);
sscanf (gdk_pixbuf_get_option (cursor_pixbuf, "x_hot"), "%d", &xhot);
sscanf (gdk_pixbuf_get_option (cursor_pixbuf, "y_hot"), "%d", &yhot);
/* in rect we have the cursor window coordinates */
rect.x = cx + real_coords.x;
rect.y = cy + real_coords.y;
rect.width = gdk_pixbuf_get_width (cursor_pixbuf);
rect.height = gdk_pixbuf_get_height (cursor_pixbuf);
/* see if the pointer is inside the window */
if (gdk_rectangle_intersect (&real_coords, &rect, &rect))
{
gint cursor_x, cursor_y;
cursor_x = cx - xhot - frame_offset.left;
cursor_y = cy - yhot - frame_offset.top;
gdk_pixbuf_composite (cursor_pixbuf, screenshot,
cursor_x, cursor_y,
rect.width, rect.height,
cursor_x, cursor_y,
1.0, 1.0,
GDK_INTERP_BILINEAR,
255);
}
g_object_unref (cursor_pixbuf);
g_object_unref (cursor);
}
}
screenshot_fallback_fire_flash (window, rectangle);
return screenshot;
}
int CreateTopWindow(void)
{
#ifdef MOUSE_POINTER_CHANGE
#ifdef WIN32
static const gchar *cr[CURSOR_MODE_3270] = { "arrow",
"wait",
"arrow",
"sizenwse", // Top-left
"sizenesw", // Top-right
"sizens", // Top
"sizenesw", // Bottom-left
"sizenwse", // Bottom-right
"sizens", // Bottom
"sizewe", // Left
"sizewe", // Right
"sizeall" // Inside
};
#else
static int cr[CURSOR_MODE_3270] = { GDK_XTERM,
GDK_WATCH,
GDK_X_CURSOR,
GDK_TOP_LEFT_CORNER, // Top-left
GDK_TOP_RIGHT_CORNER, // Top-right
GDK_TOP_SIDE, // Top
GDK_BOTTOM_LEFT_CORNER, // Bottom-left
GDK_BOTTOM_RIGHT_CORNER, // Bottom-right
GDK_BOTTOM_SIDE, // Bottom
GDK_LEFT_SIDE, // Left
GDK_RIGHT_SIDE, // Right
GDK_FLEUR // Inside
};
#endif // WIN32
int f;
#endif // MOUSE_POINTER_CHANGE
static const struct ui_menu_setup_table widget_setup[] =
{
{ "fontselect", setup_font_select_menu },
{ "inputmethod", setup_input_methods_menu },
{ "screensizes", setup_screen_size_menu },
{ NULL, NULL }
};
gchar *ptr;
init_actions();
#ifdef MOUSE_POINTER_CHANGE
// Load mouse pointers
#ifdef WIN32
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new_from_name(gdk_display_get_default(), cr[f]);
#else
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new(cr[f]);
#endif
#endif // MOUSE_POINTER_CHANGE
if(!CreateTerminalWindow())
return -1;
// Load UI - Create toplevel window
ptr = g_build_filename(program_data,"ui",NULL);
topwindow = create_window_from_ui_files(ptr,terminal,widget_setup);
g_free(ptr);
// Load program logo
load_icon();
/*
if(program_logo && g_file_test(program_logo,G_FILE_TEST_IS_REGULAR))
{
pix = gdk_pixbuf_new_from_file(program_logo,NULL);
}
else
{
gchar *filename = g_build_filename(program_data,PROGRAM_LOGO,NULL);
if(g_file_test(filename,G_FILE_TEST_IS_REGULAR))
pix = gdk_pixbuf_new_from_file(filename, NULL);
Trace("pixbuf(%s): %p",filename,pix);
g_free(filename);
}
if(pix)
{
gtk_window_set_icon(GTK_WINDOW(topwindow),pix);
g_object_set_data_full(G_OBJECT(topwindow),"logo",pix,g_object_unref);
#if defined( HAVE_IGEMAC )
gtk_osxapplication_set_dock_icon_pixbuf(osxapp,pix);
#endif
}
*/
gtk_action_set_sensitive(action_by_id[ACTION_RESELECT],FALSE);
g_signal_connect(G_OBJECT(topwindow),"destroy",G_CALLBACK(action_quit),0);
// gtk_window_set_icon_list(GTK_WINDOW(topwindow),main_icon);
gtk_window_set_default_size(GTK_WINDOW(topwindow),590,430);
ptr = GetString("TopWindow","Title","");
settitle(ptr);
g_free(ptr);
action_restore(0);
gtk_window_set_position(GTK_WINDOW(topwindow),GTK_WIN_POS_CENTER);
return 0;
}
int
main (int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context = NULL;
gchar *summary;
gchar *app_name;
#ifdef G_OS_UNIX
gchar *desktop_file_name;
#endif
GAppInfo *info = NULL;
GAppLaunchContext *launch_context;
GList *l;
GFile *f;
setlocale (LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, GTK_LOCALEDIR);
textdomain (GETTEXT_PACKAGE);
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
#endif
/* Translators: this message will appear immediately after the */
/* usage string - Usage: COMMAND [OPTION...] <THIS_MESSAGE> */
context =
g_option_context_new (_("APPLICATION [URI...] — launch an APPLICATION"));
/* Translators: this message will appear after the usage string */
/* and before the list of options. */
summary = _("Launch an application (specified by its desktop file name),\n"
"optionally passing one or more URIs as arguments.");
g_option_context_set_summary (context, summary);
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error != NULL)
{
g_printerr (_("Error parsing commandline options: %s\n"), error->message);
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ());
g_printerr ("\n");
g_error_free (error);
return 1;
}
if (show_version)
{
g_print ("%d.%d.%d\n",
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
return 0;
}
if (!args)
{
/* Translators: the %s is the program name. This error message */
/* means the user is calling gtk-launch without any argument. */
g_printerr (_("%s: missing application name"), g_get_prgname ());
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ());
g_printerr ("\n");
return 1;
}
gtk_init (&argc, &argv);
app_name = *args;
#ifdef G_OS_UNIX
if (g_str_has_suffix (app_name, ".desktop"))
desktop_file_name = g_strdup (app_name);
else
desktop_file_name = g_strconcat (app_name, ".desktop", NULL);
info = G_APP_INFO (g_desktop_app_info_new (desktop_file_name));
g_free (desktop_file_name);
#else
#warning Please add support for creating AppInfo from id for your OS
g_printerr (_("Creating AppInfo from id not supported on non unix operating systems"));
#endif
args++;
if (!info)
{
/* Translators: the first %s is the program name, the second one */
/* is the application name. */
g_printerr (_("%s: no such application %s"),
g_get_prgname (), app_name);
g_printerr ("\n");
return 2;
}
l = NULL;
for (; *args; args++)
{
f = g_file_new_for_commandline_arg (*args);
l = g_list_append (l, f);
}
launch_context = (GAppLaunchContext*) gdk_display_get_app_launch_context (gdk_display_get_default ());
if (!g_app_info_launch (info, l, launch_context, &error))
{
/* Translators: the first %s is the program name, the second one */
/* is the error message. */
g_printerr (_("%s: error launching application: %s\n"),
g_get_prgname (), error->message);
return 3;
}
g_object_unref (info);
g_object_unref (launch_context);
g_list_free_full (l, g_object_unref);
return 0;
}
/**
* gdk_pointer_ungrab:
* @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
* timestamp is available.
*
* Ungrabs the pointer on the default display, if it is grabbed by this
* application.
*
* Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
* instead.
**/
void
gdk_pointer_ungrab (guint32 time)
{
gdk_display_pointer_ungrab (gdk_display_get_default (), time);
}
/**
* gdk_keyboard_ungrab:
* @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
* timestamp is available.
*
* Ungrabs the keyboard on the default display, if it is grabbed by this
* application.
*
* Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
* instead.
**/
void
gdk_keyboard_ungrab (guint32 time)
{
gdk_display_keyboard_ungrab (gdk_display_get_default (), time);
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
GdkRectangle rect;
GdkWindow *window;
if (popup->current_selected_entry)
{
if (popup->outline)
unselect_image (popup->current_selected_entry->widget);
else
unselect_workspace (popup->current_selected_entry->widget);
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
select_image (te->widget);
else
select_workspace (te->widget);
if (popup->outline)
{
cairo_region_t *region;
cairo_region_t *inner_region;
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
window = gtk_widget_get_window (popup->outline_window);
/* Do stuff behind gtk's back */
gdk_window_hide (window);
meta_core_increment_event_serial (
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
rect = te->rect;
rect.x = 0;
rect.y = 0;
gdk_window_move_resize (window,
te->rect.x, te->rect.y,
te->rect.width, te->rect.height);
gdk_window_set_background_rgba (window, &black);
region = cairo_region_create_rectangle (&rect);
inner_region = cairo_region_create_rectangle (&te->inner_rect);
cairo_region_subtract (region, inner_region);
cairo_region_destroy (inner_region);
gdk_window_shape_combine_region (window,
region,
0, 0);
cairo_region_destroy (region);
/* This should piss off gtk a bit, but we don't want to raise
* above the tab popup. So, instead of calling gtk_widget_show,
* we manually set the window as mapped and then manually map it
* with gdk functions.
*/
gtk_widget_set_mapped (popup->outline_window, TRUE);
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
gboolean fm_clipboard_paste_files(GtkWidget* dest_widget, FmPath* dest_dir)
{
GdkDisplay* dpy = dest_widget ? gtk_widget_get_display(dest_widget) : gdk_display_get_default();
GtkClipboard* clip = gtk_clipboard_get_for_display(dpy, GDK_SELECTION_CLIPBOARD);
FmPathList* files;
char** uris, **uri;
GdkAtom atom;
int type = 0;
GdkAtom *avail_targets;
int n, i;
/* get all available targets currently in the clipboard. */
if( !gtk_clipboard_wait_for_targets(clip, &avail_targets, &n) )
return FALSE;
/* check gnome and xfce compatible format first */
atom = gdk_atom_intern_static_string(targets[GNOME_COPIED_FILES-1].target);
for(i = 0; i < n; ++i)
{
if(avail_targets[i] == atom)
{
type = GNOME_COPIED_FILES;
break;
}
}
if( 0 == type ) /* x-special/gnome-copied-files is not found. */
{
/* check uri-list */
atom = gdk_atom_intern_static_string(targets[URI_LIST-1].target);
for(i = 0; i < n; ++i)
{
if(avail_targets[i] == atom)
{
type = URI_LIST;
break;
}
}
if( 0 == type ) /* text/uri-list is not found. */
{
/* finally, fallback to UTF-8 string */
atom = gdk_atom_intern_static_string(targets[UTF8_STRING-1].target);
for(i = 0; i < n; ++i)
{
if(avail_targets[i] == atom)
{
type = UTF8_STRING;
break;
}
}
}
}
g_free(avail_targets);
if( type )
{
GtkSelectionData* data = gtk_clipboard_wait_for_contents(clip, atom);
char* pdata = (char*)data->data;
/* FIXME: is it safe to assume the clipboard data is null-terminalted?
* According to the source code in gtkselection.c, gtk+ seems to
* includes an extra byte at the end of GtkSelectionData::data, so
* this should be safe. */
pdata[data->length] = '\0'; /* make sure the data is null-terminated. */
is_cut = FALSE;
switch(type)
{
case GNOME_COPIED_FILES:
is_cut = g_str_has_prefix(pdata, "cut\n");
while(*pdata && *pdata != '\n')
++pdata;
++pdata;
/* the following parts is actually a uri-list, so don't break here. */
case URI_LIST:
uris = g_uri_list_extract_uris(pdata);
if( type != GNOME_COPIED_FILES )
{
/* if we're not handling x-special/gnome-copied-files, check
* if information from KDE is available. */
is_cut = check_kde_curselection(clip);
}
break;
case UTF8_STRING:
/* FIXME: how should we treat UTF-8 strings? URIs or filenames? */
uris = g_uri_list_extract_uris(pdata);
break;
}
gtk_selection_data_free(data);
if(uris)
{
files = fm_path_list_new_from_uris((const char **)uris);
g_strfreev(uris);
if( is_cut )
fm_move_files(files, dest_dir);
else
fm_copy_files(files, dest_dir);
fm_list_unref(files);
return TRUE;
}
}
return FALSE;
}
nsresult nsPluginNativeWindowGtk::CreateXEmbedWindow(bool aEnableXtFocus) {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkDisplay *display = gdk_display_get_default();
GdkWindow *parent_win = gdk_x11_window_lookup_for_display(display, GetWindow());
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// enable/disable focus event handlers,
// see plugin_window_filter_func() for details
g_object_set_data(G_OBJECT(mSocketWidget), "enable-xt-focus", (void *)aEnableXtFocus);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), nullptr);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), nullptr);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = nullptr;
gdk_window_get_user_data(parent_win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// The GtkSocket has a visible window, but the plugin's XEmbed plug will
// cover this window. Normally GtkSockets let the X server paint their
// background and this would happen immediately (before the plug is
// created). Setting the background to None prevents the server from
// painting this window, avoiding flicker.
// TODO GTK3
#if (MOZ_WIDGET_GTK == 2)
gdk_window_set_back_pixmap(gtk_widget_get_window(mSocketWidget), nullptr, FALSE);
#endif
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget)));
// Fill out the ws_info structure.
// (The windowless case is done in nsPluginFrame.cpp.)
GdkWindow *gdkWindow = gdk_x11_window_lookup_for_display(display, GetWindow());
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
#if (MOZ_WIDGET_GTK == 2)
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.depth = gdkVisual->depth;
#else
mWsInfo.colormap = None;
GdkVisual* gdkVisual = gdk_window_get_visual(gdkWindow);
mWsInfo.depth = gdk_visual_get_depth(gdkVisual);
#endif
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
return NS_OK;
}
MetaTabPopup*
meta_ui_tab_popup_new (const MetaTabEntry *entries,
int screen_number,
int entry_count,
int width,
gboolean outline)
{
MetaTabPopup *popup;
int i, left, right, top, bottom;
int height;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *align;
GList *tmp;
GtkWidget *frame;
int max_label_width; /* the actual max width of the labels we create */
AtkObject *obj;
GdkScreen *screen;
int screen_width;
popup = g_new (MetaTabPopup, 1);
popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
screen = gdk_display_get_screen (gdk_display_get_default (),
screen_number);
gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
screen);
gtk_widget_set_app_paintable (popup->outline_window, TRUE);
gtk_widget_realize (popup->outline_window);
g_signal_connect (G_OBJECT (popup->outline_window), "draw",
G_CALLBACK (outline_window_draw), popup);
popup->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup->window),
screen);
gtk_window_set_position (GTK_WINDOW (popup->window),
GTK_WIN_POS_CENTER_ALWAYS);
/* enable resizing, to get never-shrink behavior */
gtk_window_set_resizable (GTK_WINDOW (popup->window),
TRUE);
popup->current = NULL;
popup->entries = NULL;
popup->current_selected_entry = NULL;
popup->outline = outline;
screen_width = gdk_screen_get_width (screen);
for (i = 0; i < entry_count; ++i)
{
TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
popup->entries = g_list_prepend (popup->entries, new_entry);
}
popup->entries = g_list_reverse (popup->entries);
g_assert (width > 0);
height = i / width;
if (i % width)
height += 1;
table = gtk_table_new (height, width, FALSE);
vbox = gtk_vbox_new (FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_set_border_width (GTK_CONTAINER (table), 1);
gtk_container_add (GTK_CONTAINER (popup->window),
frame);
gtk_container_add (GTK_CONTAINER (frame),
vbox);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (align),
table);
popup->label = gtk_label_new ("");
/* Set the accessible role of the label to a status bar so it
* will emit name changed events that can be used by screen
* readers.
*/
obj = gtk_widget_get_accessible (popup->label);
atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3);
gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);
max_label_width = 0;
top = 0;
bottom = 1;
tmp = popup->entries;
while (tmp && top < height)
{
left = 0;
right = 1;
while (tmp && left < width)
{
GtkWidget *image;
GtkRequisition req;
TabEntry *te;
te = tmp->data;
if (te->blank)
{
/* just stick a widget here to avoid special cases */
image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
}
else if (outline)
{
if (te->dimmed_icon)
{
image = selectable_image_new (te->dimmed_icon);
}
else
{
image = selectable_image_new (te->icon);
}
gtk_misc_set_padding (GTK_MISC (image),
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
}
else
{
image = selectable_workspace_new ((MetaWorkspace *) te->key);
}
te->widget = image;
gtk_table_attach (GTK_TABLE (table),
te->widget,
left, right, top, bottom,
0, 0,
0, 0);
/* Efficiency rules! */
gtk_label_set_markup (GTK_LABEL (popup->label),
te->title);
gtk_widget_size_request (popup->label, &req);
max_label_width = MAX (max_label_width, req.width);
tmp = tmp->next;
++left;
++right;
}
++top;
++bottom;
}
/* remove all the temporary text */
gtk_label_set_text (GTK_LABEL (popup->label), "");
/* Make it so that we ellipsize if the text is too long */
gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
/* Limit the window size to no bigger than screen_width/4 */
if (max_label_width>(screen_width/4))
{
max_label_width = screen_width/4;
}
max_label_width += 20; /* add random padding */
gtk_window_set_default_size (GTK_WINDOW (popup->window),
max_label_width,
-1);
return popup;
}
void Pasteboard::clear()
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_clear(clipboard);
}
/**
* gdk_cursor_new:
* @cursor_type: cursor to create
*
* Creates a new cursor from the set of builtin cursors for the default display.
* See gdk_cursor_new_for_display().
*
* To make the cursor invisible, use %GDK_BLANK_CURSOR.
*
* Returns: a new #GdkCursor
*
* Deprecated: 3.16: Use gdk_cursor_new_for_display() instead.
*/
GdkCursor*
gdk_cursor_new (GdkCursorType cursor_type)
{
return gdk_cursor_new_for_display (gdk_display_get_default (), cursor_type);
}
void
action_menu_map (WnckWindow *win,
long button,
Time time)
{
GdkDisplay *gdkdisplay;
GdkScreen *screen;
gdkdisplay = gdk_display_get_default ();
screen = gdk_display_get_default_screen (gdkdisplay);
if (action_menu)
{
if (action_menu_mapped)
{
gtk_widget_destroy (action_menu);
return;
}
else
gtk_widget_destroy (action_menu);
}
switch (wnck_window_get_window_type (win)) {
case WNCK_WINDOW_DESKTOP:
case WNCK_WINDOW_DOCK:
/* don't allow window action */
return;
case WNCK_WINDOW_NORMAL:
case WNCK_WINDOW_DIALOG:
case WNCK_WINDOW_TOOLBAR:
case WNCK_WINDOW_MENU:
case WNCK_WINDOW_UTILITY:
case WNCK_WINDOW_SPLASHSCREEN:
/* allow window action menu */
break;
}
action_menu = wnck_action_menu_new (win);
g_object_ref_sink (action_menu);
gtk_menu_set_screen (GTK_MENU (action_menu), screen);
g_signal_connect (G_OBJECT (action_menu), "destroy",
G_CALLBACK (action_menu_destroyed), NULL);
g_signal_connect (G_OBJECT (action_menu), "unmap",
G_CALLBACK (action_menu_unmap), NULL);
gtk_widget_show (action_menu);
if (!button || button == 1)
{
gtk_menu_popup (GTK_MENU (action_menu),
NULL, NULL,
position_action_menu, (gpointer) win,
button,
time);
}
else
{
gtk_menu_popup (GTK_MENU (action_menu),
NULL, NULL,
NULL, NULL,
button,
time);
}
action_menu_mapped = TRUE;
}
/**
* matecomponent_plug_construct:
* @plug: The #MateComponentPlug.
* @socket_id: the XID of the socket's window.
*
* Finish the creation of a #MateComponentPlug widget. This function
* will generally only be used by classes deriving
* from #MateComponentPlug.
*/
void
matecomponent_plug_construct (MateComponentPlug *plug, guint32 socket_id)
{
matecomponent_plug_construct_full (plug, gdk_display_get_default (), socket_id);
}
//nfalg 0:sh 1:mirsoft 2: cit 3:vm 4：配置网络 7：其他，不带有是和否的提示消息， 11： 带有是和否的提示消息,这里
void SYMsgDialog(int nflag, char *msg)
{
if (showSyMsgDlg == 1)
return;
showSyMsgDlg = 1;
builder = gtk_builder_new();
GError *error1 = NULL;
gtk_builder_add_from_file (builder, "SYthrdMsgDlg.glade", &error1);
window = gtk_builder_get_object(builder, "window_symsg");
GObject * label_thrdtext;
label_thrdtext = gtk_builder_get_object(builder, "label_thrdtext");
labeltext = (GtkLabel *)label_thrdtext;
if (nflag == 7 || nflag == 11 || nflag == 4)
gtk_label_set_text(GTK_LABEL(label_thrdtext), msg);
else if (nflag == 0)
{
gtk_label_set_text(GTK_LABEL(label_thrdtext), "正在连接，请稍后 ... ");
}
//绘制控件
/*----- CSS ----------- */
GtkCssProvider *provider;
GdkDisplay *display;
GdkScreen *screen;
/*-----------------------*/
/* ----------------- CSS ----------------------------------------------------------------------------------------------*/
provider = gtk_css_provider_new ();
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gsize bytes_written, bytes_read;
GError *error = 0;
gtk_css_provider_load_from_path (provider,
g_filename_to_utf8(g_symsgcss, strlen(g_symsgcss), &bytes_read, &bytes_written, &error),
NULL);
//gtk_css_provider_load_from_path (provider, home, NULL);
g_object_unref (provider);
/* --------------------------------------------------------------------------------------------------------------------*/
GObject * btnsymsg_close;
btnsymsg_close = gtk_builder_get_object(builder, "btnsymsg_close");
g_signal_connect(GTK_BUTTON(btnsymsg_close), "clicked", G_CALLBACK(close_button_clicked), NULL);
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
if (nflag == 0 || nflag == 1)
ShenCloud_login();
//if (nflag == 4)
// SaveSysNetwork();
//ok-cancel btn
GObject * btn_OK;
GObject * btn_Cancel;
btn_OK = gtk_builder_get_object(builder, "btn_OK");
btn_Cancel = gtk_builder_get_object(builder, "btn_Cancel");
gtk_button_set_label(GTK_BUTTON(btn_OK), "是");
gtk_button_set_label(GTK_BUTTON(btn_Cancel), "否");
if (nflag == 11)
{
gtk_widget_set_visible(GTK_WIDGET(btn_OK), TRUE);
gtk_widget_set_visible(GTK_WIDGET(btn_Cancel), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(btn_OK), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(btn_Cancel), TRUE);
}else
{
gtk_widget_set_visible(GTK_WIDGET(btn_OK), FALSE);
gtk_widget_set_visible(GTK_WIDGET(btn_Cancel), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(btn_OK), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(btn_Cancel), FALSE);
}
g_signal_connect(GTK_BUTTON(btn_OK), "clicked", G_CALLBACK(OK_button_clicked), NULL);
g_signal_connect(GTK_BUTTON(btn_Cancel), "clicked", G_CALLBACK(Cancel_button_clicked), NULL);
gtk_main ();
g_object_unref (G_OBJECT (builder));
showSyMsgDlg = 0;
}
/**
* gdk_window_at_pointer:
* @win_x: (out) (allow-none): return location for origin of the window under the pointer
* @win_y: (out) (allow-none): return location for origin of the window under the pointer
*
* Obtains the window underneath the mouse pointer, returning the
* location of that window in @win_x, @win_y. Returns %NULL if the
* window under the mouse pointer is not known to GDK (if the window
* belongs to another application and a #GdkWindow hasn’t been created
* for it with gdk_window_foreign_new())
*
* NOTE: For multihead-aware widgets or applications use
* gdk_display_get_window_at_pointer() instead.
*
* Return value: (transfer none): window under the mouse pointer
*
* Deprecated: 3.0: Use gdk_device_get_window_at_position() instead.
**/
GdkWindow*
gdk_window_at_pointer (gint *win_x,
gint *win_y)
{
return gdk_display_get_window_at_pointer (gdk_display_get_default (), win_x, win_y);
}
void Sys_GetCursorPos( GtkWindow* window, int *x, int *y ){
gdk_display_get_pointer( gdk_display_get_default(), 0, x, y, 0 );
}
/**
* gdk_pointer_is_grabbed:
*
* Returns %TRUE if the pointer on the default display is currently
* grabbed by this application.
*
* Note that this does not take the inmplicit pointer grab on button
* presses into account.
*
* Return value: %TRUE if the pointer is currently grabbed by this application.
*
* Deprecated: 3.0: Use gdk_display_device_is_grabbed() instead.
**/
gboolean
gdk_pointer_is_grabbed (void)
{
return gdk_display_pointer_is_grabbed (gdk_display_get_default ());
}
void Sys_SetCursorPos( GtkWindow* window, int x, int y ){
GdkScreen *screen;
gdk_display_get_pointer( gdk_display_get_default(), &screen, 0, 0, 0 );
gdk_display_warp_pointer( gdk_display_get_default(), screen, x, y );
}
/**
* gdk_keymap_get_default:
*
* Returns the #GdkKeymap attached to the default display.
*
* Returns: (transfer none): the #GdkKeymap attached to the default display.
*/
GdkKeymap*
gdk_keymap_get_default (void)
{
return gdk_keymap_get_for_display (gdk_display_get_default ());
}
GdkFilterReturn
event_filter_func (GdkXEvent *gdkxevent,
GdkEvent *event,
gpointer data)
{
GdkDisplay *gdkdisplay;
XEvent *xevent = gdkxevent;
gulong xid = 0;
Window select = 0;
gdkdisplay = gdk_display_get_default ();
switch (xevent->type) {
case CreateNotify:
{
if (!wnck_window_get (xevent->xcreatewindow.window))
{
GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window);
if (toplevel)
{
gdk_window_set_events (toplevel,
gdk_window_get_events (toplevel) |
GDK_PROPERTY_CHANGE_MASK);
/* check if the window is a switcher and update accordingly */
if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select))
update_switcher_window (xevent->xcreatewindow.window, select);
}
}
}
break;
case ButtonPress:
case ButtonRelease:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xbutton.window));
break;
case EnterNotify:
case LeaveNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xcrossing.window));
break;
case MotionNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xmotion.window));
break;
case PropertyNotify:
if (xevent->xproperty.atom == frame_input_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_input_window_atom, &frame))
add_frame_window (win, frame, FALSE);
else
remove_frame_window (win);
}
}
}
if (xevent->xproperty.atom == frame_output_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_output_window_atom, &frame))
add_frame_window (win, frame, TRUE);
else
remove_frame_window (win);
}
}
}
else if (xevent->xproperty.atom == compiz_shadow_info_atom ||
xevent->xproperty.atom == compiz_shadow_color_atom)
{
GdkScreen *g_screen = gdk_display_get_default_screen (gdkdisplay);
Window root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen));
WnckScreen *screen;
screen = wnck_screen_get_for_root (root);
if (screen)
{
if (gwd_process_decor_shadow_property_update ())
decorations_changed (screen);
}
}
else if (xevent->xproperty.atom == mwm_hints_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
gboolean decorated = FALSE;
/* Only decorations that are actually bound to windows can be decorated
* ignore cases where a broken application which shouldn't be decorated
* sets the decoration hint */
if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE) && d->win)
decorated = TRUE;
if (decorated != d->decorated)
{
d->decorated = decorated;
if (decorated)
{
d->context = NULL;
d->width = d->height = 0;
d->frame = gwd_get_decor_frame (get_frame_type (win));
update_window_decoration_state (win);
update_window_decoration_actions (win);
update_window_decoration_icon (win);
request_update_window_decoration_size (win);
update_event_windows (win);
}
else
{
remove_frame_window (win);
}
}
}
}
else if (xevent->xproperty.atom == select_window_atom)
{
Window select;
if (get_window_prop (xevent->xproperty.window, select_window_atom, &select))
update_switcher_window (xevent->xproperty.window, select);
}
break;
case DestroyNotify:
g_hash_table_remove (frame_table,
GINT_TO_POINTER (xevent->xproperty.window));
break;
case ClientMessage:
if (xevent->xclient.message_type == toolkit_action_atom)
{
long action;
action = xevent->xclient.data.l[0];
if (action == toolkit_action_window_menu_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
action_menu_map (win,
xevent->xclient.data.l[2],
xevent->xclient.data.l[1]);
}
}
else if (action == toolkit_action_force_quit_dialog_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
if (xevent->xclient.data.l[2])
show_force_quit_dialog (win,
xevent->xclient.data.l[1]);
else
hide_force_quit_dialog (win);
}
}
}
else if (xevent->xclient.message_type == decor_request_atom)
{
WnckWindow *win = wnck_window_get (xevent->xclient.window);
if (win)
update_window_decoration_size (win);
}
default:
break;
}
if (xid)
{
WnckWindow *win;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
if (d->decorated)
{
gint i, j;
event_callback cb = NULL;
Window w = xevent->xany.window;
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j)
if (d->event_windows[i][j].window == w)
cb = d->event_windows[i][j].callback;
if (!cb)
{
for (i = 0; i < BUTTON_NUM; ++i)
if (d->button_windows[i].window == w)
cb = d->button_windows[i].callback;
}
if (cb)
{
decor_event gtkwd_event;
decor_event_type gtkwd_type;
gtkwd_event.window = w;
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
if (xevent->type == ButtonPress)
gtkwd_type = GButtonPress;
else
gtkwd_type = GButtonRelease;
gtkwd_event.button = xevent->xbutton.button;
gtkwd_event.x = xevent->xbutton.x;
gtkwd_event.y = xevent->xbutton.y;
gtkwd_event.x_root = xevent->xbutton.x_root;
gtkwd_event.y_root = xevent->xbutton.y_root;
gtkwd_event.time = xevent->xbutton.time;
break;
case EnterNotify:
case LeaveNotify:
if (xevent->type == EnterNotify)
gtkwd_type = GEnterNotify;
else
gtkwd_type = GLeaveNotify;
gtkwd_event.x = xevent->xcrossing.x;
gtkwd_event.y = xevent->xcrossing.y;
gtkwd_event.x_root = xevent->xcrossing.x_root;
gtkwd_event.y_root = xevent->xcrossing.y_root;
gtkwd_event.time = xevent->xcrossing.time;
break;
default:
cb = NULL;
break;
}
if (cb)
(*cb) (win, >kwd_event, gtkwd_type);
}
}
}
}
return GDK_FILTER_CONTINUE;
}
static gchar*
passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
gchar *the_passphrase = NULL;
GtkWidget *vbox;
GtkWidget *confirm_box;
GtkWidget *window;
GtkWidget *pass_entry;
GtkWidget *ok_button;
GtkWidget *cancel_button;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
gtk_widget_set_size_request(window, 450, -1);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(passphrase_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(passphrase_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
manage_window_set_transient(GTK_WINDOW(window));
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
if (uid_hint || pass_hint) {
GtkWidget *label;
label = create_description (uid_hint, pass_hint, prev_bad);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
}
pass_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0);
gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE);
gtk_widget_grab_focus(pass_entry);
gtkut_stock_button_set_create(&confirm_box, &ok_button, GTK_STOCK_OK,
&cancel_button, GTK_STOCK_CANCEL,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(pass_entry), "activate",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(passphrase_cancel_cb), NULL);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
if (grab_all)
gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_widget_show_all(window);
if (grab_all) {
/* make sure that window is viewable
* FIXME: this is still not enough */
gtk_widget_show_now(window);
gdk_flush();
#ifdef GDK_WINDOWING_X11
gdk_x11_display_grab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
if (gdk_pointer_grab(window->window, TRUE, 0,
window->window, NULL, GDK_CURRENT_TIME)) {
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab mouse\n");
gtk_widget_destroy(window);
return NULL;
}
if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
gdk_display_pointer_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab keyboard\n");
gtk_widget_destroy(window);
return NULL;
}
}
gtk_main();
if (grab_all) {
gdk_display_keyboard_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
gdk_flush();
}
manage_window_focus_out(window, NULL, NULL);
if (pass_ack) {
const gchar *entry_text;
entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL);
if (!the_passphrase)
the_passphrase = g_strdup(entry_text);
}
gtk_widget_destroy(window);
return the_passphrase;
}
int
main (int argc, char **argv)
{
GdkDisplay *display = NULL;
int estatus;
char *child_argv[] = { LIBEXECDIR "/gnome-session-check-accelerated-helper", NULL };
Window rootwin;
glong is_accelerated;
GError *error = NULL;
gtk_init (NULL, NULL);
display = gdk_display_get_default ();
rootwin = gdk_x11_get_default_root_xwindow ();
is_accelerated_atom = gdk_x11_get_xatom_by_name_for_display (display, "_GNOME_SESSION_ACCELERATED");
{
Atom type;
gint format;
gulong nitems;
gulong bytes_after;
guchar *data;
read:
gdk_x11_display_error_trap_push (display);
XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), rootwin,
is_accelerated_atom,
0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems,
&bytes_after, &data);
gdk_x11_display_error_trap_pop_ignored (display);
if (type == XA_CARDINAL) {
glong *is_accelerated_ptr = (glong*) data;
if (*is_accelerated_ptr == ACCEL_CHECK_RUNNING) {
/* Test in progress, wait */
if (wait_for_property_notify ())
goto read;
/* else fall through and do the check ourselves */
} else {
return (*is_accelerated_ptr == 0 ? 1 : 0);
}
}
}
/* We don't have the property or it's the wrong type.
* Try to compute it now.
*/
/* First indicate that a test is in progress */
is_accelerated = ACCEL_CHECK_RUNNING;
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
rootwin,
is_accelerated_atom,
XA_CARDINAL, 32, PropModeReplace, (guchar *) &is_accelerated, 1);
gdk_display_sync (display);
estatus = 1;
if (!g_spawn_sync (NULL, (char**)child_argv, NULL, 0,
NULL, NULL, NULL, NULL, &estatus, &error)) {
is_accelerated = FALSE;
g_printerr ("gnome-session-check-accelerated: Failed to run helper: %s\n", error->message);
g_clear_error (&error);
} else {
is_accelerated = (estatus == 0);
if (!is_accelerated)
g_printerr ("gnome-session-check-accelerated: Helper exited with code %d\n", estatus);
}
if (is_accelerated) {
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
rootwin,
is_accelerated_atom,
XA_CARDINAL, 32, PropModeReplace, (guchar *) &is_accelerated, 1);
}
gdk_display_sync (display);
return is_accelerated ? 0 : 1;
}
gdk_window_get_pointer (GdkWindow_val(window), &x, &y, NULL);
ret = alloc_small (2, 0);
Field(ret, 0) = Val_int(x);
Field(ret, 1) = Val_int(y);
return ret;
}
/* Cursor */
Make_Val_final_pointer_ext (GdkCursor, _new, Ignore, gdk_cursor_unref, 20)
ML_1 (gdk_cursor_new, GdkCursorType_val, Val_GdkCursor_new)
ML_6 (gdk_cursor_new_from_pixmap, GdkPixmap_val, GdkPixmap_val,
GdkColor_val, GdkColor_val, Int_val, Int_val, Val_GdkCursor_new)
ML_bc6 (ml_gdk_cursor_new_from_pixmap)
#ifdef HASGTK24
ML_3 (gdk_cursor_new_from_pixbuf, Insert(gdk_display_get_default ())
GdkPixbuf_val, Int_val, Int_val, Val_GdkCursor_new)
#else
Unsupported_24(gdk_cursor_new_from_pixbuf)
#endif
#ifdef HASGTK28
ML_1 (gdk_cursor_get_image, GdkCursor_val, Val_GdkPixbuf_new)
#else
Unsupported_28(gdk_cursor_get_image)
#endif
/* Display */
#ifdef HASGTK22
ML_0 (gdk_display_get_default, Val_GdkDisplay)
CAMLprim value ml_gdk_display_get_window_at_pointer (value display)
{
void
caja_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri, *uri_scheme;
GList *locations, *l;
GFile *location;
CajaFile *file;
gboolean result;
GError *error;
GdkDisplay *display;
GdkAppLaunchContext *launch_context;
CajaIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next)
{
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location))
{
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
if (parent_window != NULL) {
display = gtk_widget_get_display (GTK_WIDGET (parent_window));
} else {
display = gdk_display_get_default ();
}
launch_context = gdk_display_get_app_launch_context (display);
if (parent_window != NULL) {
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
}
file = caja_file_get_by_uri (uris->data);
icon = caja_file_get_icon (file, 48, 0);
caja_file_unref (file);
if (icon)
{
gdk_app_launch_context_set_icon_name (launch_context,
caja_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
result = g_desktop_app_info_launch_uris_as_manager (G_DESKTOP_APP_INFO (application),
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL,
gather_pid_callback, application,
&error);
g_object_unref (launch_context);
if (!result)
{
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_SUPPORTED)
{
uri_scheme = g_uri_parse_scheme (uris->data);
application_cannot_open_location (application,
file,
uri_scheme,
parent_window);
g_free (uri_scheme);
}
else
{
#ifdef NEW_MIME_COMPLETE
caja_program_chooser_show_invalid_message
(MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window);
#else
g_warning ("Cannot open app: %s\n", error->message);
#endif
}
g_error_free (error);
}
else
{
for (l = uris; l != NULL; l = l->next)
{
file = caja_file_get_by_uri (l->data);
caja_recent_add_file (file, application);
caja_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}
static gboolean
egg_desktop_file_launchv (EggDesktopFile *desktop_file,
GSList *documents, va_list args,
GError **error)
{
EggDesktopFileLaunchOption option;
GSList *translated_documents = NULL, *docs = NULL;
char *command, **argv;
int argc, i, screen_num;
gboolean success, current_success;
GdkDisplay *display;
char *startup_id;
GPtrArray *env = NULL;
char **variables = NULL;
GdkScreen *screen = NULL;
int workspace = -1;
const char *directory = NULL;
guint32 launch_time = (guint32)-1;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH;
GSpawnChildSetupFunc setup_func = NULL;
gpointer setup_data = NULL;
GPid *ret_pid = NULL;
int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL;
char **ret_startup_id = NULL;
if (documents && desktop_file->document_code == 0)
{
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE,
_("Application does not accept documents on command line"));
return FALSE;
}
/* Read the options: technically it's incorrect for the caller to
* NULL-terminate the list of options (rather than 0-terminating
* it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED,
* it's more consistent with other glib/gtk methods, and it will
* work as long as sizeof (int) <= sizeof (NULL), and NULL is
* represented as 0. (Which is true everywhere we care about.)
*/
while ((option = va_arg (args, EggDesktopFileLaunchOption)))
{
switch (option)
{
case EGG_DESKTOP_FILE_LAUNCH_CLEARENV:
if (env)
g_ptr_array_free (env, TRUE);
env = g_ptr_array_new ();
break;
case EGG_DESKTOP_FILE_LAUNCH_PUTENV:
variables = va_arg (args, char **);
for (i = 0; variables[i]; i++)
env = array_putenv (env, variables[i]);
break;
case EGG_DESKTOP_FILE_LAUNCH_SCREEN:
screen = va_arg (args, GdkScreen *);
break;
case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE:
workspace = va_arg (args, int);
break;
case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY:
directory = va_arg (args, const char *);
break;
case EGG_DESKTOP_FILE_LAUNCH_TIME:
launch_time = va_arg (args, guint32);
break;
case EGG_DESKTOP_FILE_LAUNCH_FLAGS:
flags |= va_arg (args, GSpawnFlags);
/* Make sure they didn't set any flags that don't make sense. */
flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO;
break;
case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC:
setup_func = va_arg (args, GSpawnChildSetupFunc);
setup_data = va_arg (args, gpointer);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID:
ret_pid = va_arg (args, GPid *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE:
ret_stdin = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE:
ret_stdout = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE:
ret_stderr = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID:
ret_startup_id = va_arg (args, char **);
break;
default:
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION,
_("Unrecognized launch option: %d"),
GPOINTER_TO_INT (option));
success = FALSE;
goto out;
}
}
if (screen)
{
char *display_name = gdk_screen_make_display_name (screen);
char *display_env = g_strdup_printf ("DISPLAY=%s", display_name);
env = array_putenv (env, display_env);
g_free (display_name);
g_free (display_env);
display = gdk_screen_get_display (screen);
}
else
{
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
}
screen_num = gdk_screen_get_number (screen);
translated_documents = translate_document_list (desktop_file, documents);
docs = translated_documents;
success = FALSE;
do
{
command = parse_exec (desktop_file, &docs, error);
if (!command)
goto out;
if (!g_shell_parse_argv (command, &argc, &argv, error))
{
g_free (command);
goto out;
}
g_free (command);
startup_id = start_startup_notification (display, desktop_file,
argv[0], screen_num,
workspace, launch_time);
if (startup_id)
{
char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",
startup_id);
env = array_putenv (env, startup_id_env);
g_free (startup_id_env);
}
if (env != NULL)
g_ptr_array_add (env, NULL);
current_success =
g_spawn_async_with_pipes (directory,
argv,
env ? (char **)(env->pdata) : NULL,
flags,
setup_func, setup_data,
ret_pid,
ret_stdin, ret_stdout, ret_stderr,
error);
g_strfreev (argv);
if (startup_id)
{
if (current_success)
{
set_startup_notification_timeout (display, startup_id);
if (ret_startup_id)
*ret_startup_id = startup_id;
else
g_free (startup_id);
}
else
g_free (startup_id);
}
else if (ret_startup_id)
*ret_startup_id = NULL;
if (current_success)
{
/* If we successfully launch any instances of the app, make
* sure we return TRUE and don't set @error.
*/
success = TRUE;
error = NULL;
/* Also, only set the output params on the first one */
ret_pid = NULL;
ret_stdin = ret_stdout = ret_stderr = NULL;
ret_startup_id = NULL;
}
}
while (docs && current_success);
out:
if (env)
{
g_ptr_array_foreach (env, (GFunc)g_free, NULL);
g_ptr_array_free (env, TRUE);
}
free_document_list (translated_documents);
return success;
}
/**
* matecomponent_plug_new:
* @socket_id: the XID of the socket's window.
*
* Create a new plug widget inside the #GtkSocket identified
* by @socket_id.
*
* Returns: the new #MateComponentPlug widget.
*/
GtkWidget*
matecomponent_plug_new (guint32 socket_id)
{
return matecomponent_plug_new_for_display
(gdk_display_get_default (), socket_id);
}
int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win )
{
GdkWindow *window = NULL;
if (win)
window = gtk_widget_get_window(win->GetHandle());
switch (index)
{
case wxSYS_BORDER_X:
case wxSYS_BORDER_Y:
case wxSYS_EDGE_X:
case wxSYS_EDGE_Y:
case wxSYS_FRAMESIZE_X:
case wxSYS_FRAMESIZE_Y:
if (win)
{
wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
if (!tlw)
return GetBorderWidth(index, win);
else if (window)
{
// Get the frame extents from the windowmanager.
// In most cases the top extent is the titlebar, so we use the bottom extent
// for the heights.
int right, bottom;
if (wxGetFrameExtents(window, NULL, &right, NULL, &bottom))
{
switch (index)
{
case wxSYS_BORDER_X:
case wxSYS_EDGE_X:
case wxSYS_FRAMESIZE_X:
return right; // width of right extent
default:
return bottom; // height of bottom extent
}
}
}
}
return -1; // no window specified
case wxSYS_CURSOR_X:
case wxSYS_CURSOR_Y:
return gdk_display_get_default_cursor_size(
window ? gdk_window_get_display(window)
: gdk_display_get_default());
case wxSYS_DCLICK_X:
case wxSYS_DCLICK_Y:
gint dclick_distance;
g_object_get(GetSettingsForWindowScreen(window),
"gtk-double-click-distance", &dclick_distance, NULL);
return dclick_distance * 2;
case wxSYS_DCLICK_MSEC:
gint dclick;
g_object_get(GetSettingsForWindowScreen(window),
"gtk-double-click-time", &dclick, NULL);
return dclick;
case wxSYS_DRAG_X:
case wxSYS_DRAG_Y:
gint drag_threshold;
g_object_get(GetSettingsForWindowScreen(window),
"gtk-dnd-drag-threshold", &drag_threshold, NULL);
// The correct thing here would be to double the value
// since that is what the API wants. But the values
// are much bigger under GNOME than under Windows and
// just seem to much in many cases to be useful.
// drag_threshold *= 2;
return drag_threshold;
case wxSYS_ICON_X:
case wxSYS_ICON_Y:
return 32;
case wxSYS_SCREEN_X:
if (window)
return gdk_screen_get_width(gdk_window_get_screen(window));
else
return gdk_screen_width();
case wxSYS_SCREEN_Y:
if (window)
return gdk_screen_get_height(gdk_window_get_screen(window));
else
return gdk_screen_height();
case wxSYS_HSCROLL_Y:
case wxSYS_VSCROLL_X:
return 15;
case wxSYS_CAPTION_Y:
if (!window)
// No realized window specified, and no implementation for that case yet.
return -1;
wxASSERT_MSG( wxDynamicCast(win, wxTopLevelWindow),
wxT("Asking for caption height of a non toplevel window") );
// Get the height of the top windowmanager border.
// This is the titlebar in most cases. The titlebar might be elsewhere, and
// we could check which is the thickest wm border to decide on which side the
// titlebar is, but this might lead to interesting behaviours in used code.
// Reconsider when we have a way to report to the user on which side it is.
{
int top;
if (wxGetFrameExtents(window, NULL, NULL, &top, NULL))
{
return top; // top frame extent
}
}
// Try a default approach without a window pointer, if possible
// ...
return -1;
case wxSYS_PENWINDOWS_PRESENT:
// No MS Windows for Pen computing extension available in X11 based gtk+.
return 0;
default:
return -1; // metric is unknown
}
}
static void
decor_update_meta_window_property (decor_t *d,
MetaTheme *theme,
MetaFrameFlags flags,
Region top,
Region bottom,
Region left,
Region right)
{
long *data;
Display *xdisplay =
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
gint nQuad;
decor_extents_t win_extents, frame_win_extents;
decor_extents_t max_win_extents, frame_max_win_extents;
decor_quad_t quads[N_QUADS_MAX];
unsigned int nOffset = 1;
unsigned int frame_type = populate_frame_type (d);
unsigned int frame_state = populate_frame_state (d);
unsigned int frame_actions = populate_frame_actions (d);
gint w, lh, rh;
gint top_stretch_offset;
gint bottom_stretch_offset;
gint left_stretch_offset;
gint right_stretch_offset;
gint mutter_draggable_border_width = 0;
win_extents = frame_win_extents = d->frame->win_extents;
max_win_extents = frame_max_win_extents = d->frame->max_win_extents;
g_object_get (settings, "draggable-border-width", &mutter_draggable_border_width, NULL);
/* Add the invisible grab area padding, but only for
* pixmap type decorations */
if (!d->frame_window)
{
if (flags & META_FRAME_ALLOWS_HORIZONTAL_RESIZE)
{
frame_win_extents.left += mutter_draggable_border_width;
frame_win_extents.right += mutter_draggable_border_width;
frame_max_win_extents.left += mutter_draggable_border_width;
frame_max_win_extents.right += mutter_draggable_border_width;
}
if (flags & META_FRAME_ALLOWS_VERTICAL_RESIZE)
{
frame_win_extents.bottom += mutter_draggable_border_width;
frame_win_extents.top += mutter_draggable_border_width;
frame_max_win_extents.bottom += mutter_draggable_border_width;
frame_max_win_extents.top += mutter_draggable_border_width;
}
}
w = d->border_layout.top.x2 - d->border_layout.top.x1 -
d->context->left_space - d->context->right_space;
if (d->border_layout.rotation)
lh = d->border_layout.left.x2 - d->border_layout.left.x1;
else
lh = d->border_layout.left.y2 - d->border_layout.left.y1;
if (d->border_layout.rotation)
rh = d->border_layout.right.x2 - d->border_layout.right.x1;
else
rh = d->border_layout.right.y2 - d->border_layout.right.y1;
left_stretch_offset = lh / 2;
right_stretch_offset = rh / 2;
top_stretch_offset = w - d->button_width - 1;
bottom_stretch_offset = (d->border_layout.bottom.x2 -
d->border_layout.bottom.x1 -
d->context->left_space -
d->context->right_space) / 2;
nQuad = decor_set_lXrXtXbX_window_quads (quads, d->context,
&d->border_layout,
left_stretch_offset,
right_stretch_offset,
top_stretch_offset,
bottom_stretch_offset);
win_extents.top += d->frame->titlebar_height;
frame_win_extents.top += d->frame->titlebar_height;
max_win_extents.top += d->frame->max_titlebar_height;
frame_max_win_extents.top += d->frame->max_titlebar_height;
if (d->frame_window)
{
data = decor_alloc_property (nOffset, WINDOW_DECORATION_TYPE_WINDOW);
decor_gen_window_property (data, nOffset - 1, &win_extents, &max_win_extents, 20, 20,
frame_type, frame_state, frame_actions);
}
else
{
data = decor_alloc_property (nOffset, WINDOW_DECORATION_TYPE_PIXMAP);
decor_quads_to_property (data, nOffset - 1, cairo_xlib_surface_get_drawable (d->surface),
&frame_win_extents, &win_extents,
&frame_max_win_extents, &max_win_extents,
ICON_SPACE + d->button_width,
0,
quads, nQuad, frame_type, frame_state, frame_actions);
}
gdk_error_trap_push ();
XChangeProperty (xdisplay, d->prop_xid,
win_decor_atom,
XA_INTEGER,
32, PropModeReplace, (guchar *) data,
PROP_HEADER_SIZE + BASE_PROP_SIZE + QUAD_PROP_SIZE * N_QUADS_MAX);
gdk_display_sync (gdk_display_get_default ());
gdk_error_trap_pop_ignored ();
free (data);
decor_update_blur_property (d,
w, lh,
top, top_stretch_offset,
bottom, bottom_stretch_offset,
left, left_stretch_offset,
right, right_stretch_offset);
}