Pileus Git - ~andy/gtk/blob - gdk/gdkdisplayprivate.h

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2010 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef __GDK_DISPLAY_PRIVATE_H__
  19 #define __GDK_DISPLAY_PRIVATE_H__
  20
  21 #include "gdkdisplay.h"
  22 #include "gdkwindow.h"
  23 #include "gdkcursor.h"
  24
  25 G_BEGIN_DECLS
  26
  27 #define GDK_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY, GdkDisplayClass))
  28 #define GDK_IS_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY))
  29 #define GDK_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY, GdkDisplayClass))
  30
  31
  32 typedef struct _GdkDisplayClass GdkDisplayClass;
  33
  34 /* Tracks information about the keyboard grab on this display */
  35 typedef struct
  36 {
  37   GdkWindow *window;
  38   GdkWindow *native_window;
  39   gulong serial;
  40   gboolean owner_events;
  41   guint32 time;
  42 } GdkKeyboardGrabInfo;
  43
  44 /* Tracks information about the pointer grab on this display */
  45 typedef struct
  46 {
  47   GdkWindow *window;
  48   GdkWindow *native_window;
  49   gulong serial_start;
  50   gulong serial_end; /* exclusive, i.e. not active on serial_end */
  51   guint event_mask;
  52   guint32 time;
  53   GdkGrabOwnership ownership;
  54
  55   guint activated : 1;
  56   guint implicit_ungrab : 1;
  57   guint owner_events : 1;
  58   guint implicit : 1;
  59 } GdkDeviceGrabInfo;
  60
  61 /* Tracks information about a touch implicit grab on this display */
  62 typedef struct
  63 {
  64   GdkDevice *device;
  65   GdkEventSequence *sequence;
  66
  67   GdkWindow *window;
  68   GdkWindow *native_window;
  69   gulong serial;
  70   guint event_mask;
  71   guint32 time;
  72 } GdkTouchGrabInfo;
  73
  74 /* Tracks information about which window and position the pointer last was in.
  75  * This is useful when we need to synthesize events later.
  76  * Note that we track toplevel_under_pointer using enter/leave events,
  77  * so in the case of a grab, either with owner_events==FALSE or with the
  78  * pointer in no clients window the x/y coordinates may actually be outside
  79  * the window.
  80  */
  81 typedef struct
  82 {
  83   GdkWindow *toplevel_under_pointer; /* toplevel window containing the pointer, */
  84                                      /* tracked via native events */
  85   GdkWindow *window_under_pointer;   /* window that last got a normal enter event */
  86   gdouble toplevel_x, toplevel_y;
  87   guint32 state;
  88   guint32 button;
  89   GdkDevice *last_slave;
  90   guint need_touch_press_enter : 1;
  91 } GdkPointerWindowInfo;
  92
  93 typedef struct
  94 {
  95   guint32 button_click_time[2]; /* last 2 button click times */
  96   GdkWindow *button_window[2];  /* last 2 windows to receive button presses */
  97   gint button_number[2];        /* last 2 buttons to be pressed */
  98   gint button_x[2];             /* last 2 button click positions */
  99   gint button_y[2];
 100 } GdkMultipleClickInfo;
 101
 102 struct _GdkDisplay
 103 {
 104   GObject parent_instance;
 105
 106   GList *queued_events;
 107   GList *queued_tail;
 108
 109   /* Information for determining if the latest button click
 110    * is part of a double-click or triple-click
 111    */
 112   GHashTable *multiple_click_info;
 113   guint double_click_time;  /* Maximum time between clicks in msecs */
 114   GdkDevice *core_pointer;  /* Core pointer device */
 115
 116   guint event_pause_count;       /* How many times events are blocked */
 117
 118   guint closed             : 1;  /* Whether this display has been closed */
 119   guint flushing_events    : 1;  /* Inside gdk_display_flush_events */
 120
 121   GArray *touch_implicit_grabs;
 122   GHashTable *device_grabs;
 123   GHashTable *motion_hint_info;
 124   GdkDeviceManager *device_manager;
 125
 126   GHashTable *pointers_info;  /* GdkPointerWindowInfo for each device */
 127   guint32 last_event_time;    /* Last reported event time from server */
 128
 129   guint double_click_distance;   /* Maximum distance between clicks in pixels */
 130 };
 131
 132 struct _GdkDisplayClass
 133 {
 134   GObjectClass parent_class;
 135
 136   GType window_type;          /* type for native windows for this display, set in class_init */
 137
 138   const gchar *              (*get_name)           (GdkDisplay *display);
 139   gint                       (*get_n_screens)      (GdkDisplay *display);
 140   GdkScreen *                (*get_screen)         (GdkDisplay *display,
 141                                                     gint        screen_num);
 142   GdkScreen *                (*get_default_screen) (GdkDisplay *display);
 143   void                       (*beep)               (GdkDisplay *display);
 144   void                       (*sync)               (GdkDisplay *display);
 145   void                       (*flush)              (GdkDisplay *display);
 146   gboolean                   (*has_pending)        (GdkDisplay *display);
 147   void                       (*queue_events)       (GdkDisplay *display);
 148   GdkWindow *                (*get_default_group)  (GdkDisplay *display);
 149   gboolean                   (*supports_selection_notification) (GdkDisplay *display);
 150   gboolean                   (*request_selection_notification)  (GdkDisplay *display,
 151                                                                  GdkAtom     selection);
 152   gboolean                   (*supports_shapes)       (GdkDisplay *display);
 153   gboolean                   (*supports_input_shapes) (GdkDisplay *display);
 154   gboolean                   (*supports_composite)    (GdkDisplay *display);
 155   gboolean                   (*supports_cursor_alpha) (GdkDisplay *display);
 156   gboolean                   (*supports_cursor_color) (GdkDisplay *display);
 157
 158   gboolean                   (*supports_clipboard_persistence)  (GdkDisplay *display);
 159   void                       (*store_clipboard)    (GdkDisplay    *display,
 160                                                     GdkWindow     *clipboard_window,
 161                                                     guint32        time_,
 162                                                     const GdkAtom *targets,
 163                                                     gint           n_targets);
 164
 165   void                       (*get_default_cursor_size) (GdkDisplay *display,
 166                                                          guint      *width,
 167                                                          guint      *height);
 168   void                       (*get_maximal_cursor_size) (GdkDisplay *display,
 169                                                          guint      *width,
 170                                                          guint      *height);
 171   GdkCursor *                (*get_cursor_for_type)     (GdkDisplay    *display,
 172                                                          GdkCursorType  type);
 173   GdkCursor *                (*get_cursor_for_name)     (GdkDisplay    *display,
 174                                                          const gchar   *name);
 175   GdkCursor *                (*get_cursor_for_pixbuf)   (GdkDisplay    *display,
 176                                                          GdkPixbuf     *pixbuf,
 177                                                          gint           x,
 178                                                          gint           y);
 179
 180   GList *                    (*list_devices)       (GdkDisplay *display);
 181   GdkAppLaunchContext *      (*get_app_launch_context) (GdkDisplay *display);
 182
 183   void                       (*before_process_all_updates) (GdkDisplay *display);
 184   void                       (*after_process_all_updates)  (GdkDisplay *display);
 185
 186   gulong                     (*get_next_serial) (GdkDisplay *display);
 187
 188   void                       (*notify_startup_complete) (GdkDisplay  *display,
 189                                                          const gchar *startup_id);
 190   void                       (*event_data_copy) (GdkDisplay     *display,
 191                                                  const GdkEvent *event,
 192                                                  GdkEvent       *new_event);
 193   void                       (*event_data_free) (GdkDisplay     *display,
 194                                                  GdkEvent       *event);
 195   void                       (*create_window_impl) (GdkDisplay    *display,
 196                                                     GdkWindow     *window,
 197                                                     GdkWindow     *real_parent,
 198                                                     GdkScreen     *screen,
 199                                                     GdkEventMask   event_mask,
 200                                                     GdkWindowAttr *attributes,
 201                                                     gint           attributes_mask);
 202
 203   GdkKeymap *                (*get_keymap)         (GdkDisplay    *display);
 204   void                       (*push_error_trap)    (GdkDisplay    *display);
 205   gint                       (*pop_error_trap)     (GdkDisplay    *display,
 206                                                     gboolean       ignore);
 207
 208   GdkWindow *                (*get_selection_owner) (GdkDisplay   *display,
 209                                                      GdkAtom       selection);
 210   gboolean                   (*set_selection_owner) (GdkDisplay   *display,
 211                                                      GdkWindow    *owner,
 212                                                      GdkAtom       selection,
 213                                                      guint32       time,
 214                                                      gboolean      send_event);
 215   void                       (*send_selection_notify) (GdkDisplay *dispay,
 216                                                        GdkWindow        *requestor,
 217                                                        GdkAtom          selection,
 218                                                        GdkAtom          target,
 219                                                        GdkAtom          property,
 220                                                        guint32          time);
 221   gint                       (*get_selection_property) (GdkDisplay  *display,
 222                                                         GdkWindow   *requestor,
 223                                                         guchar     **data,
 224                                                         GdkAtom     *type,
 225                                                         gint        *format);
 226   void                       (*convert_selection)      (GdkDisplay  *display,
 227                                                         GdkWindow   *requestor,
 228                                                         GdkAtom      selection,
 229                                                         GdkAtom      target,
 230                                                         guint32      time);
 231
 232   gint                   (*text_property_to_utf8_list) (GdkDisplay     *display,
 233                                                         GdkAtom         encoding,
 234                                                         gint            format,
 235                                                         const guchar   *text,
 236                                                         gint            length,
 237                                                         gchar        ***list);
 238   gchar *                (*utf8_to_string_target)      (GdkDisplay     *display,
 239                                                         const gchar    *text);
 240
 241   /* Signals */
 242   void (*closed) (GdkDisplay *display,
 243                   gboolean    is_error);
 244 };
 245
 246
 247 typedef void (* GdkDisplayPointerInfoForeach) (GdkDisplay           *display,
 248                                                GdkDevice            *device,
 249                                                GdkPointerWindowInfo *device_info,
 250                                                gpointer              user_data);
 251
 252 void                _gdk_display_device_grab_update   (GdkDisplay *display,
 253                                                        GdkDevice  *device,
 254                                                        GdkDevice  *source_device,
 255                                                        gulong      current_serial);
 256 GdkDeviceGrabInfo * _gdk_display_get_last_device_grab (GdkDisplay *display,
 257                                                        GdkDevice  *device);
 258 GdkDeviceGrabInfo * _gdk_display_add_device_grab      (GdkDisplay       *display,
 259                                                        GdkDevice        *device,
 260                                                        GdkWindow        *window,
 261                                                        GdkWindow        *native_window,
 262                                                        GdkGrabOwnership  grab_ownership,
 263                                                        gboolean          owner_events,
 264                                                        GdkEventMask      event_mask,
 265                                                        gulong            serial_start,
 266                                                        guint32           time,
 267                                                        gboolean          implicit);
 268 GdkDeviceGrabInfo * _gdk_display_has_device_grab      (GdkDisplay       *display,
 269                                                        GdkDevice        *device,
 270                                                        gulong            serial);
 271 gboolean            _gdk_display_end_device_grab      (GdkDisplay       *display,
 272                                                        GdkDevice        *device,
 273                                                        gulong            serial,
 274                                                        GdkWindow        *if_child,
 275                                                        gboolean          implicit);
 276 gboolean            _gdk_display_check_grab_ownership (GdkDisplay       *display,
 277                                                        GdkDevice        *device,
 278                                                        gulong            serial);
 279 void                _gdk_display_add_touch_grab       (GdkDisplay       *display,
 280                                                        GdkDevice        *device,
 281                                                        GdkEventSequence *sequence,
 282                                                        GdkWindow        *window,
 283                                                        GdkWindow        *native_window,
 284                                                        GdkEventMask      event_mask,
 285                                                        unsigned long     serial_start,
 286                                                        guint32           time);
 287 GdkTouchGrabInfo *  _gdk_display_has_touch_grab       (GdkDisplay       *display,
 288                                                        GdkDevice        *device,
 289                                                        GdkEventSequence *sequence,
 290                                                        gulong            serial);
 291 gboolean            _gdk_display_end_touch_grab       (GdkDisplay       *display,
 292                                                        GdkDevice        *device,
 293                                                        GdkEventSequence *sequence);
 294 void                _gdk_display_enable_motion_hints  (GdkDisplay       *display,
 295                                                        GdkDevice        *device);
 296 GdkPointerWindowInfo * _gdk_display_get_pointer_info  (GdkDisplay       *display,
 297                                                        GdkDevice        *device);
 298 void                _gdk_display_pointer_info_foreach (GdkDisplay       *display,
 299                                                        GdkDisplayPointerInfoForeach func,
 300                                                        gpointer          user_data);
 301 gulong              _gdk_display_get_next_serial      (GdkDisplay       *display);
 302 void                _gdk_display_pause_events         (GdkDisplay       *display);
 303 void                _gdk_display_unpause_events       (GdkDisplay       *display);
 304 void                _gdk_display_flush_events         (GdkDisplay       *display);
 305 void                _gdk_display_event_data_copy      (GdkDisplay       *display,
 306                                                        const GdkEvent   *event,
 307                                                        GdkEvent         *new_event);
 308 void                _gdk_display_event_data_free      (GdkDisplay       *display,
 309                                                        GdkEvent         *event);
 310 void                _gdk_display_create_window_impl   (GdkDisplay       *display,
 311                                                        GdkWindow        *window,
 312                                                        GdkWindow        *real_parent,
 313                                                        GdkScreen        *screen,
 314                                                        GdkEventMask      event_mask,
 315                                                        GdkWindowAttr    *attributes,
 316                                                        gint              attributes_mask);
 317 GdkWindow *         _gdk_display_create_window        (GdkDisplay       *display);
 318
 319 G_END_DECLS
 320
 321 #endif  /* __GDK_DISPLAY_PRIVATE_H__ */