← Back to branch summary

~ubuntu-branches/debian/sid/cheese/sid

« back to all changes in this revision

Viewing changes to libcheese/cheese-flash.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2011-07-17 21:04:16 UTC
  • mfrom: (15.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110717210416-nt5qi659qei7a2yy
Tags: 3.0.1-2
* debian/control.in:
  - Change gir1.2-cheese-3.0 Section to libs
  - Make library packages depend against cheese-common package
  - Make cheese package recommends against hicolor-icon-theme
  - Move gst Dependency to libcheese package
* debian/patches/0002-fix-linking.patch: Add missing library to fix linking
* debian/watch:
  - Switch to .bz2 tarballs.
  - Bump version to 3

Show diffs side-by-side

added added

removed removed

Lines of Context:
libcheese/cheese-flash.c
27
27
#include <cheese-camera.h>
28
28
#include "cheese-flash.h"
29
29
 
 
30
#ifdef GDK_WINDOWING_X11
 
31
#include <X11/Xproto.h>
 
32
#include <X11/Xlib.h>
 
33
#include <X11/Xutil.h>
 
34
#include <X11/Xatom.h>
 
35
#include <gdk/gdkx.h>
 
36
#endif /* GDK_WINDOWING_X11 */
 
37
 
30
38
enum
31
39
{
32
40
  PROP_0,
57
65
  guint fade_timeout_tag;
58
66
} CheeseFlashPrivate;
59
67
 
60
 
static gboolean
61
 
cheese_flash_window_expose_event_cb (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
62
 
{
63
 
  cairo_t *cr;
64
 
 
65
 
  cr = gdk_cairo_create (gtk_widget_get_window (widget));
66
 
  cairo_set_source_rgb (cr, 1, 1, 1);
67
 
  cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height);
 
68
/* Copy-pasted from totem/src/backend/video-utils.c
 
69
 * Waiting on GTK+ bug:
 
70
 * https://bugzilla.gnome.org/show_bug.cgi?id=523574 */
 
71
#ifdef GDK_WINDOWING_X11
 
72
static int
 
73
get_current_desktop (GdkScreen *screen)
 
74
{
 
75
        Display *display;
 
76
        Window win;
 
77
        Atom current_desktop, type;
 
78
        int format;
 
79
        unsigned long n_items, bytes_after;
 
80
        unsigned char *data_return = NULL;
 
81
        int workspace = 0;
 
82
 
 
83
        display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
 
84
        win = XRootWindow (display, GDK_SCREEN_XNUMBER (screen));
 
85
 
 
86
        current_desktop = XInternAtom (display, "_NET_CURRENT_DESKTOP", True);
 
87
 
 
88
        XGetWindowProperty (display,
 
89
                            win,
 
90
                            current_desktop,
 
91
                            0, G_MAXLONG,
 
92
                            False, XA_CARDINAL,
 
93
                            &type, &format, &n_items, &bytes_after,
 
94
                            &data_return);
 
95
 
 
96
        if (type == XA_CARDINAL && format == 32 && n_items > 0)
 
97
                workspace = (int) data_return[0];
 
98
        if (data_return)
 
99
                XFree (data_return);
 
100
 
 
101
        return workspace;
 
102
}
 
103
 
 
104
static gboolean
 
105
get_work_area (GdkScreen      *screen,
 
106
               GdkRectangle   *rect)
 
107
{
 
108
        Atom            workarea;
 
109
        Atom            type;
 
110
        Window          win;
 
111
        int             format;
 
112
        gulong          num;
 
113
        gulong          leftovers;
 
114
        gulong          max_len = 4 * 32;
 
115
        guchar         *ret_workarea;
 
116
        long           *workareas;
 
117
        int             result;
 
118
        int             disp_screen;
 
119
        int             desktop;
 
120
        Display        *display;
 
121
 
 
122
        display = GDK_DISPLAY_XDISPLAY (gdk_screen_get_display (screen));
 
123
        workarea = XInternAtom (display, "_NET_WORKAREA", True);
 
124
 
 
125
        disp_screen = GDK_SCREEN_XNUMBER (screen);
 
126
 
 
127
        /* Defaults in case of error */
 
128
        rect->x = 0;
 
129
        rect->y = 0;
 
130
        rect->width = gdk_screen_get_width (screen);
 
131
        rect->height = gdk_screen_get_height (screen);
 
132
 
 
133
        if (workarea == None)
 
134
                return FALSE;
 
135
 
 
136
        win = XRootWindow (display, disp_screen);
 
137
        result = XGetWindowProperty (display,
 
138
                                     win,
 
139
                                     workarea,
 
140
                                     0,
 
141
                                     max_len,
 
142
                                     False,
 
143
                                     AnyPropertyType,
 
144
                                     &type,
 
145
                                     &format,
 
146
                                     &num,
 
147
                                     &leftovers,
 
148
                                     &ret_workarea);
 
149
 
 
150
        if (result != Success
 
151
            || type == None
 
152
            || format == 0
 
153
            || leftovers
 
154
            || num % 4) {
 
155
                return FALSE;
 
156
        }
 
157
 
 
158
        desktop = get_current_desktop (screen);
 
159
 
 
160
        workareas = (long *) ret_workarea;
 
161
        rect->x = workareas[desktop * 4];
 
162
        rect->y = workareas[desktop * 4 + 1];
 
163
        rect->width = workareas[desktop * 4 + 2];
 
164
        rect->height = workareas[desktop * 4 + 3];
 
165
 
 
166
        XFree (ret_workarea);
 
167
 
 
168
        return TRUE;
 
169
}
 
170
#endif /* GDK_WINDOWING_X11 */
 
171
 
 
172
static gboolean
 
173
cheese_flash_window_draw_event_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data)
 
174
{
68
175
  cairo_fill (cr);
69
 
  cairo_destroy (cr);
70
 
 
71
176
  return TRUE;
72
177
}
73
178
 
75
180
cheese_flash_init (CheeseFlash *self)
76
181
{
77
182
  CheeseFlashPrivate *priv = CHEESE_FLASH_GET_PRIVATE (self);
78
 
 
 
183
  cairo_region_t *input_region;
79
184
  GtkWindow *window;
80
185
 
81
186
  priv->flash_timeout_tag = 0;
95
200
 
96
201
  /* Don't consume input */
97
202
  gtk_widget_realize (GTK_WIDGET (window));
98
 
  GdkRegion *input_region;
99
 
  input_region = gdk_region_new ();
 
203
  input_region = cairo_region_create ();
100
204
  gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0);
101
 
  gdk_region_destroy (input_region);
 
205
  cairo_region_destroy (input_region);
102
206
 
103
 
  g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (cheese_flash_window_expose_event_cb), NULL);
 
207
  g_signal_connect (G_OBJECT (window), "draw", G_CALLBACK (cheese_flash_window_draw_event_cb), NULL);
104
208
  priv->window = window;
105
209
}
106
210
 
235
339
  parent  = gtk_widget_get_toplevel (flash_priv->parent);
236
340
  screen  = gtk_widget_get_screen (parent);
237
341
  monitor = gdk_screen_get_monitor_at_window (screen,
238
 
                                              gtk_widget_get_window (parent));
 
342
                                              gtk_widget_get_window (parent));
239
343
  gdk_screen_get_monitor_geometry (screen, monitor, &rect);
 
344
#ifdef GDK_WINDOWING_X11
 
345
  {
 
346
    GdkRectangle area, dest;
 
347
    get_work_area (screen, &area);
 
348
    if (gdk_rectangle_intersect (&area, &rect, &dest))
 
349
      rect = dest;
 
350
  }
 
351
#endif /* GDK_WINDOWING_X11 */
240
352
  gtk_window_set_transient_for (GTK_WINDOW (flash_window), GTK_WINDOW (parent));
241
353
  gtk_window_resize (flash_window, rect.width, rect.height);
242
354
  gtk_window_move (flash_window, rect.x, rect.y);