/* similar to what we have in libgimp/gimpui.c */
void
gimp_window_set_transient_for (GtkWindow *window,
guint32 parent_ID)
{
/* Cross-process transient-for is broken in gdk/win32 <= 2.10.6. It
* causes hangs, at least when used as by the gimp and script-fu
* processes. In some newer GTK+ version it will be fixed to be a
* no-op. If it eventually is fixed to actually work, change this to
* a run-time check of GTK+ version. Remember to change also the
* function with the same name in libgimp/gimpui.c
*/
#ifndef GDK_WINDOWING_WIN32
GdkWindow *parent;
parent = gdk_window_foreign_new_for_display (gdk_display_get_default (),
parent_ID);
if (! parent)
return;
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_transient_for (GTK_WIDGET (window)->window, parent);
g_signal_connect_object (window, "realize",
G_CALLBACK (gimp_window_transient_realized),
parent, 0);
g_object_unref (parent);
#endif
}
/* From X Window System Interaction */
static VALUE
gdkwin_foreign_new(int argc, VALUE *argv, VALUE self)
{
VALUE arg[2];
GdkWindow * win = NULL;
rb_scan_args(argc, argv, "11", &arg[0], &arg[1]);
switch(argc)
{
case 1:
win = gdk_window_foreign_new(RVAL2GDKNATIVEWINDOW(arg[0]));
break;
case 2:
#if GTK_CHECK_VERSION(2,2,0)
win = gdk_window_foreign_new_for_display(RVAL2GOBJ(arg[0]),
RVAL2GDKNATIVEWINDOW(arg[1]));
#else
win = gdk_window_foreign_new(NUM2UINT(arg[1]));
rb_warn("Not supported in GTK+-2.0.x.");
#endif
break;
}
if (win == NULL)
return Qnil;
else {
return GOBJ2RVAL(win);
}
}
void start_recording(GtkWidget *widget, gpointer data) {
GdkNativeWindow native;
GdkDisplay *display;
GdkRectangle rect;
if(is_recording)
return;
screen = gtk_widget_get_screen(widget);
if (screen == NULL) {
screen = gdk_screen_get_default ();
}
native = select_window(screen);
display = gdk_screen_get_display (screen);
window = gdk_window_foreign_new_for_display (display, native);
gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width, &rect.height);
/* creating flv und screenVideo instances */
flv = newFLVStream(FLVVERSION_1, FLVFLAG_VIDEO);
video = newScreenVideo(rect.width, rect.height, 64);
printf("video width: %i, height: %i\n", rect.width, rect.height);
/* capture timer */
g_timeout_add ( 1000 / FRAMERATE, next_capture, NULL);
is_recording = 1;
}
/* From X Window System Interaction */
static VALUE
rg_s_foreign_new(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE arg[2];
GdkWindow * win = NULL;
rb_scan_args(argc, argv, "11", &arg[0], &arg[1]);
switch(argc)
{
case 1:
win = gdk_window_foreign_new(RVAL2GDKNATIVEWINDOW(arg[0]));
break;
case 2:
win = gdk_window_foreign_new_for_display(RVAL2GOBJ(arg[0]),
RVAL2GDKNATIVEWINDOW(arg[1]));
break;
default:
break;
}
if (win == NULL)
return Qnil;
else {
return GOBJ2RVAL(win);
}
}
static void really_make_transient(GtkWidget *window, ALLEGRO_DISPLAY_XGLX *glx)
{
GdkDisplay *gdk = gdk_drawable_get_display(GDK_DRAWABLE(window->window));
GdkWindow *parent = gdk_window_lookup_for_display(gdk, glx->window);
if (!parent)
parent = gdk_window_foreign_new_for_display(gdk, glx->window);
gdk_window_set_transient_for(window->window, parent);
}
/**
* mcm_window_set_parent_xid:
**/
static void
mcm_window_set_parent_xid (GtkWindow *window, guint32 xid)
{
GdkDisplay *display;
GdkWindow *parent_window;
GdkWindow *our_window;
display = gdk_display_get_default ();
parent_window = gdk_window_foreign_new_for_display (display, xid);
our_window = gtk_widget_get_window (GTK_WIDGET (window));
/* set this above our parent */
gtk_window_set_modal (window, TRUE);
gdk_window_set_transient_for (our_window, parent_window);
}
/**
* gimp_ui_get_progress_window:
*
* Returns the #GdkWindow of the window this plug-in's progress bar is
* shown in. Use it to make plug-in dialogs transient to this window
* as explained with gdk_window_set_transient_for().
*
* You shouldn't have to call this function directly. Use
* gimp_window_set_transient() instead.
*
* Return value: A reference to a #GdkWindow or %NULL. You should
* unref the window using g_object_unref() as soon as
* you don't need it any longer.
*
* Since: GIMP 2.4
*/
GdkWindow *
gimp_ui_get_progress_window (void)
{
#ifndef GDK_NATIVE_WINDOW_POINTER
GdkNativeWindow window;
g_return_val_if_fail (gimp_ui_initialized, NULL);
window = gimp_progress_get_window_handle ();
if (window)
return gdk_window_foreign_new_for_display (gdk_display_get_default (),
window);
#endif
return NULL;
}
/**
* gpk_window_set_parent_xid:
**/
gboolean
gpk_window_set_parent_xid (GtkWindow *window, guint32 xid)
{
GdkDisplay *display;
GdkWindow *parent_window;
GdkWindow *our_window;
g_return_val_if_fail (xid != 0, FALSE);
display = gdk_display_get_default ();
parent_window = gdk_window_foreign_new_for_display (display, xid);
our_window = gtk_widget_get_window (GTK_WIDGET (window));
/* set this above our parent */
gtk_window_set_modal (window, TRUE);
gdk_window_set_transient_for (our_window, parent_window);
return TRUE;
}
static void
impl_MateComponent_Canvas_Component_realize (PortableServer_Servant servant,
const CORBA_char *window,
CORBA_Environment *ev)
{
Gcc *gcc = GCC (matecomponent_object_from_servant (servant));
MateCanvasItem *item = MATE_CANVAS_ITEM (gcc->priv->item);
GdkWindow *gdk_window = gdk_window_foreign_new_for_display
(gtk_widget_get_display (GTK_WIDGET (item->canvas)),
matecomponent_control_x11_from_window_id (window));
if (gdk_window == NULL) {
g_warning ("Invalid window id passed='%s'", window);
return;
}
item->canvas->layout.bin_window = gdk_window;
ICLASS (item)->realize (item);
}
static gint32
shoot (GdkScreen *screen)
{
GdkDisplay *display;
GdkWindow *window;
GdkPixbuf *screenshot;
GdkRegion *shape = NULL;
GdkRectangle rect;
GdkRectangle screen_rect;
gchar *name = NULL;
gint32 image;
gint screen_x;
gint screen_y;
gint x, y;
/* use default screen if we are running non-interactively */
if (screen == NULL)
screen = gdk_screen_get_default ();
display = gdk_screen_get_display (screen);
screen_rect.x = 0;
screen_rect.y = 0;
screen_rect.width = gdk_screen_get_width (screen);
screen_rect.height = gdk_screen_get_height (screen);
if (shootvals.shoot_type == SHOOT_REGION)
{
rect.x = MIN (shootvals.x1, shootvals.x2);
rect.y = MIN (shootvals.y1, shootvals.y2);
rect.width = ABS (shootvals.x2 - shootvals.x1);
rect.height = ABS (shootvals.y2 - shootvals.y1);
}
else
{
if (shootvals.shoot_type == SHOOT_ROOT)
{
window = gdk_screen_get_root_window (screen);
}
else
{
window = gdk_window_foreign_new_for_display (display,
shootvals.window_id);
}
if (! window)
{
g_message (_("Specified window not found"));
return -1;
}
gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width, &rect.height);
gdk_window_get_origin (window, &x, &y);
rect.x = x;
rect.y = y;
}
if (! gdk_rectangle_intersect (&rect, &screen_rect, &rect))
return -1;
window = gdk_screen_get_root_window (screen);
gdk_window_get_origin (window, &screen_x, &screen_y);
screenshot = gdk_pixbuf_get_from_drawable (NULL, window, NULL,
rect.x - screen_x,
rect.y - screen_y,
0, 0, rect.width, rect.height);
gdk_display_beep (display);
gdk_flush ();
if (! screenshot)
{
g_message (_("There was an error taking the screenshot."));
return -1;
}
if (shootvals.shoot_type == SHOOT_WINDOW)
{
name = window_get_title (display, shootvals.window_id);
shape = window_get_shape (screen, shootvals.window_id);
if (shape)
gdk_region_offset (shape, x - rect.x, y - rect.y);
}
image = create_image (screenshot, shape, name);
g_object_unref (screenshot);
if (shape)
gdk_region_destroy (shape);
g_free (name);
return image;
}
GwyRemote*
gwy_remote_get(void)
{
GwyRemote *remote;
GdkWindow *root;
Display *xdisplay;
Window xroot, xparent, *xchildren;
Atom role_xatom;
guint nchildren;
gint i;
remote = g_new0(GwyRemote, 1);
remote->display = gdk_display_get_default();
g_object_ref(remote->display);
root = gdk_screen_get_root_window(gdk_screen_get_default());
xdisplay = gdk_x11_display_get_xdisplay(remote->display);
if (!XQueryTree(xdisplay, GDK_WINDOW_XID(root),
&xroot, &xparent, &xchildren, &nchildren)
|| !nchildren
|| !xchildren) {
gwy_remote_free(remote);
return NULL;
}
role_xatom = gdk_x11_get_xatom_by_name_for_display(remote->display,
"WM_WINDOW_ROLE");
for (i = nchildren-1; !remote->toolbox && i >= 0; i--) {
Window xwindow;
Atom ret_type_xatom;
gint ret_format;
gulong bytes_after, nitems;
guchar *data;
/*
* The XmuClientWindow() function finds a window at or below the
* specified window, that has a WM_STATE property. If such a
* window is found, it is returned; otherwise the argument window
* is returned.
*/
xwindow = XmuClientWindow(xdisplay, xchildren[i]);
if (XGetWindowProperty(xdisplay, xwindow,
role_xatom, 0, 32, FALSE, XA_STRING,
&ret_type_xatom, &ret_format,
&nitems, &bytes_after, &data) == Success
&& ret_type_xatom) {
if (gwy_strequal(data, GWY_TOOLBOX_WM_ROLE)) {
remote->winid = xwindow;
remote->toolbox
= gdk_window_foreign_new_for_display(remote->display,
remote->winid);
g_object_ref(remote->toolbox);
}
XFree(data);
}
}
XFree(xchildren);
if (!remote->winid) {
gwy_remote_free(remote);
remote = NULL;
}
return remote;
}
GdkWindow *
gimp_remote_find_toolbox (GdkDisplay *display,
GdkScreen *screen)
{
GdkWindow *result = NULL;
Display *xdisplay;
Window root, parent;
Window *children;
Atom role_atom;
Atom string_atom;
guint nchildren;
gint i;
GdkWindow *root_window = gdk_screen_get_root_window (screen);
xdisplay = gdk_x11_display_get_xdisplay (display);
role_atom = XInternAtom (xdisplay, "WM_WINDOW_ROLE", TRUE);
string_atom = XInternAtom (xdisplay, "STRING", TRUE);
if (role_atom == None || string_atom == None)
return NULL;
if (XQueryTree (xdisplay, GDK_WINDOW_XID (root_window),
&root, &parent, &children, &nchildren) == 0)
return NULL;
if (! (children && nchildren))
return NULL;
for (i = nchildren - 1; i >= 0; i--)
{
Window window;
Atom ret_type;
gint ret_format;
gulong bytes_after;
gulong nitems;
guchar *data;
/* The XmuClientWindow() function finds a window at or below the
* specified window, that has a WM_STATE property. If such a
* window is found, it is returned; otherwise the argument window
* is returned.
*/
window = XmuClientWindow (xdisplay, children[i]);
/* We are searching for the GIMP toolbox: Its WM_WINDOW_ROLE Property
* (as set by gtk_window_set_role ()) has the value "gimp-toolbox".
* This is pretty reliable, since it ask for a special property,
* explicitly set by GIMP. See below... :-)
*/
if (XGetWindowProperty (xdisplay, window,
role_atom,
0, 32,
FALSE,
string_atom,
&ret_type, &ret_format, &nitems, &bytes_after,
&data) == Success && ret_type)
{
if (nitems > 11 &&
strcmp ((const gchar *) data, "gimp-toolbox") == 0)
{
XFree (data);
result = gdk_window_foreign_new_for_display (display, window);
break;
}
XFree (data);
}
}
XFree (children);
return result;
}
/**
* matecomponent_control_set_transient_for:
* @control: a control with associated control frame
* @window: a window upon which to set the transient window.
*
* Attempts to make the @window transient for the toplevel
* of any associated controlframe the MateComponentControl may have.
**/
void
matecomponent_control_set_transient_for (MateComponentControl *control,
GtkWindow *window,
CORBA_Environment *opt_ev)
{
CORBA_char *id;
GdkDisplay *display;
GdkWindow *win;
GdkNativeWindow window_id;
CORBA_Environment *ev = NULL, tmp_ev;
MateComponent_ControlFrame frame;
gpointer local_win;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (MATECOMPONENT_IS_CONTROL (control));
/* FIXME: special case the local case !
* we can only do this if set_transient is virtualized
* and thus we can catch it in MateComponentSocket and chain up
* again if we are embedded inside an embedded thing. */
frame = control->priv->frame;
if (frame == CORBA_OBJECT_NIL)
return;
if (opt_ev)
ev = opt_ev;
else {
CORBA_exception_init (&tmp_ev);
ev = &tmp_ev;
}
id = MateComponent_ControlFrame_getToplevelId (frame, ev);
g_return_if_fail (!MATECOMPONENT_EX (ev) && id != NULL);
window_id = matecomponent_control_x11_from_window_id (id);
#ifdef TRANSIENT_DEBUG
g_warning ("Got id '%s' -> %d", id, window_id);
#endif
CORBA_free (id);
display = gtk_widget_get_display (GTK_WIDGET (window));
#if defined (GDK_WINDOWING_X11)
local_win = gdk_xid_table_lookup_for_display (display, window_id);
#elif defined (GDK_WINDOWING_WIN32)
local_win = gdk_win32_handle_table_lookup (window_id);
#endif
if (local_win == NULL)
win = gdk_window_foreign_new_for_display (display, window_id);
else {
win = GDK_WINDOW (local_win);
g_object_ref (win);
}
g_return_if_fail (win != NULL);
window_set_transient_for_gdk (window, win);
if (!opt_ev)
CORBA_exception_free (&tmp_ev);
}
