Pileus Git - ~andy/gtk/blob - gdk/win32/gdkdisplay-win32.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 2002 Hans Breuer
   3  * Copyright (C) 2003 Tor Lillqvist
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include "gdk.h"
  23 #include "gdkprivate-win32.h"
  24
  25 #define HAVE_MONITOR_INFO
  26
  27 #if defined(_MSC_VER) && (WINVER < 0x500) && (WINVER > 0x0400)
  28 #include <multimon.h>
  29 #elif defined(_MSC_VER) && (WINVER <= 0x0400)
  30 #undef HAVE_MONITOR_INFO
  31 #endif
  32
  33 #ifdef HAVE_MONITOR_INFO
  34 typedef BOOL (WINAPI *t_EnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
  35 typedef BOOL (WINAPI *t_GetMonitorInfoA)(HMONITOR, LPMONITORINFO);
  36
  37 static t_EnumDisplayMonitors p_EnumDisplayMonitors = NULL;
  38 static t_GetMonitorInfoA p_GetMonitorInfoA = NULL;
  39 #endif
  40
  41 void
  42 _gdk_windowing_set_default_display (GdkDisplay *display)
  43 {
  44   g_assert (_gdk_display == display);
  45 }
  46
  47 #ifdef HAVE_MONITOR_INFO
  48 static BOOL CALLBACK
  49 count_monitor (HMONITOR hmonitor,
  50                HDC      hdc,
  51                LPRECT   rect,
  52                LPARAM   data)
  53 {
  54   gint *n = (gint *) data;
  55
  56   (*n)++;
  57
  58   return TRUE;
  59 }
  60
  61 static BOOL CALLBACK
  62 enum_monitor (HMONITOR hmonitor,
  63               HDC      hdc,
  64               LPRECT   rect,
  65               LPARAM   data)
  66 {
  67   MONITORINFOEX monitor_info;
  68
  69   gint *index = (gint *) data;
  70   GdkRectangle *monitor;
  71
  72   g_assert (*index < _gdk_num_monitors);
  73
  74   monitor = _gdk_monitors + *index;
  75
  76   monitor_info.cbSize = sizeof (MONITORINFOEX);
  77   (*p_GetMonitorInfoA) (hmonitor, (MONITORINFO *) &monitor_info);
  78
  79 #ifndef MONITORINFOF_PRIMARY
  80 #define MONITORINFOF_PRIMARY 1
  81 #endif
  82
  83   monitor->x = monitor_info.rcMonitor.left;
  84   monitor->y = monitor_info.rcMonitor.top;
  85   monitor->width = monitor_info.rcMonitor.right - monitor_info.rcMonitor.left;
  86   monitor->height = monitor_info.rcMonitor.bottom - monitor_info.rcMonitor.top;
  87
  88   if (monitor_info.dwFlags & MONITORINFOF_PRIMARY &&
  89       *index != 0)
  90     {
  91       /* Put primary monitor at index 0, just in case somebody needs
  92        * to know which one is the primary.
  93        */
  94       GdkRectangle temp = *monitor;
  95       *monitor = _gdk_monitors[0];
  96       _gdk_monitors[0] = temp;
  97     }
  98
  99   (*index)++;
 100
 101   return TRUE;
 102 }
 103 #endif /* HAVE_MONITOR_INFO */
 104
 105 void
 106 _gdk_monitor_init (void)
 107 {
 108 #ifdef HAVE_MONITOR_INFO
 109   static HMODULE user32 = NULL;
 110
 111   if (user32 == NULL)
 112     {
 113       user32 = GetModuleHandle ("user32.dll");
 114
 115       g_assert (user32 != NULL);
 116
 117       p_EnumDisplayMonitors = (t_EnumDisplayMonitors) GetProcAddress (user32, "EnumDisplayMonitors");
 118       p_GetMonitorInfoA = (t_GetMonitorInfoA) GetProcAddress (user32, "GetMonitorInfoA");
 119     }
 120
 121   if (p_EnumDisplayMonitors != NULL && p_GetMonitorInfoA != NULL)
 122     {
 123       gint i, index;
 124
 125       _gdk_num_monitors = 0;
 126
 127       (*p_EnumDisplayMonitors) (NULL, NULL, count_monitor, (LPARAM) &_gdk_num_monitors);
 128
 129       _gdk_monitors = g_renew (GdkRectangle, _gdk_monitors, _gdk_num_monitors);
 130
 131       index = 0;
 132       (*p_EnumDisplayMonitors) (NULL, NULL, enum_monitor, (LPARAM) &index);
 133
 134       _gdk_offset_x = G_MININT;
 135       _gdk_offset_y = G_MININT;
 136
 137       /* Calculate offset */
 138       for (i = 0; i < _gdk_num_monitors; i++)
 139         {
 140           _gdk_offset_x = MAX (_gdk_offset_x, -_gdk_monitors[i].x);
 141           _gdk_offset_y = MAX (_gdk_offset_y, -_gdk_monitors[i].y);
 142         }
 143       GDK_NOTE (MISC, g_print ("Multi-monitor offset: (%d,%d)\n",
 144                                _gdk_offset_x, _gdk_offset_y));
 145
 146       /* Translate monitor coords into GDK coordinate space */
 147       for (i = 0; i < _gdk_num_monitors; i++)
 148         {
 149           _gdk_monitors[i].x += _gdk_offset_x;
 150           _gdk_monitors[i].y += _gdk_offset_y;
 151           GDK_NOTE (MISC, g_print ("Monitor %d: %dx%d@%+d%+d\n",
 152                                    i, _gdk_monitors[i].width,
 153                                    _gdk_monitors[i].height,
 154                                    _gdk_monitors[i].x, _gdk_monitors[i].y));
 155         }
 156     }
 157   else
 158 #endif /* HAVE_MONITOR_INFO */
 159     {
 160       unsigned int width, height;
 161
 162       _gdk_num_monitors = 1;
 163       _gdk_monitors = g_renew (GdkRectangle, _gdk_monitors, 1);
 164
 165       width = GetSystemMetrics (SM_CXSCREEN);
 166       height = GetSystemMetrics (SM_CYSCREEN);
 167
 168       _gdk_monitors[0].x = 0;
 169       _gdk_monitors[0].y = 0;
 170       _gdk_monitors[0].width = width;
 171       _gdk_monitors[0].height = height;
 172       _gdk_offset_x = 0;
 173       _gdk_offset_y = 0;
 174     }
 175
 176 }
 177
 178 GdkDisplay *
 179 gdk_display_open (const gchar *display_name)
 180 {
 181   if (_gdk_display != NULL)
 182     return NULL; /* single display only */
 183
 184   _gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
 185   _gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
 186
 187   _gdk_monitor_init ();
 188   _gdk_visual_init ();
 189   gdk_screen_set_default_colormap (_gdk_screen,
 190                                    gdk_screen_get_system_colormap (_gdk_screen));
 191   _gdk_windowing_window_init ();
 192   _gdk_windowing_image_init ();
 193   _gdk_events_init ();
 194   _gdk_input_init (_gdk_display);
 195   _gdk_dnd_init ();
 196
 197   g_signal_emit_by_name (gdk_display_manager_get (),
 198                          "display_opened", _gdk_display);
 199
 200   return _gdk_display;
 201 }
 202
 203 G_CONST_RETURN gchar *
 204 gdk_display_get_name (GdkDisplay *display)
 205 {
 206   return gdk_get_display_arg_name ();
 207 }
 208
 209 gint
 210 gdk_display_get_n_screens (GdkDisplay *display)
 211 {
 212   return 1;
 213 }
 214
 215 GdkScreen *
 216 gdk_display_get_screen (GdkDisplay *display,
 217                         gint        screen_num)
 218 {
 219   return _gdk_screen;
 220 }
 221
 222 GdkScreen *
 223 gdk_display_get_default_screen (GdkDisplay *display)
 224 {
 225   return _gdk_screen;
 226 }
 227
 228 GdkWindow *
 229 gdk_display_get_default_group (GdkDisplay *display)
 230 {
 231   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 232
 233   g_warning ("gdk_display_get_default_group not yet implemented");
 234
 235   return NULL;
 236 }
 237
 238 gboolean
 239 gdk_display_supports_selection_notification (GdkDisplay *display)
 240 {
 241   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 242
 243   return TRUE;
 244 }
 245
 246 static HWND _hwnd_next_viewer = NULL;
 247
 248 /*
 249  * maybe this should be integrated with the default message loop - or maybe not ;-)
 250  */
 251 static LRESULT CALLBACK
 252 _win32_on_clipboard_change (HWND   hwnd,
 253                             UINT   message,
 254                             WPARAM wparam,
 255                             LPARAM lparam)
 256 {
 257   switch (message)
 258     {
 259     case WM_DESTROY : /* remove us from chain */
 260       {
 261         ChangeClipboardChain (hwnd, _hwnd_next_viewer);
 262         return 0;
 263       }
 264     case WM_CHANGECBCHAIN :
 265       {
 266         HWND hwndRemove = (HWND) wparam; /* handle of window being removed */
 267         HWND hwndNext   = (HWND) lparam; /* handle of next window in chain */
 268         if (hwndRemove == _hwnd_next_viewer)
 269           _hwnd_next_viewer = hwndNext == hwnd ? NULL : hwndNext;
 270         return 0;
 271       }
 272     case WM_DRAWCLIPBOARD :
 273       {
 274         /* Create the appropriate gdk events */
 275
 276 #ifdef G_ENABLE_DEBUG
 277         if ((_gdk_debug_flags & GDK_DEBUG_DND) &&
 278             OpenClipboard (hwnd))
 279           {
 280             HWND hwndOwner = GetClipboardOwner ();
 281             UINT nFormat = 0;
 282
 283             g_print ("WM_DRAWCLIPBOARD: owner:%p formats: ", hwndOwner);
 284             for (; 0 != (nFormat = EnumClipboardFormats (nFormat));)
 285               {
 286                 char sFormat[80];
 287                 if (GetClipboardFormatName (nFormat, sFormat, G_N_ELEMENTS (sFormat)) > 0)
 288                   g_print ("%s ", sFormat);
 289               }
 290             g_print ("\n");
 291             CloseClipboard ();
 292           }
 293 #endif
 294         /* XXX: generate the apropriate GdkEventOwnerChange ... */
 295
 296         /* don't break the chain */
 297         return PostMessage (_hwnd_next_viewer, message, wparam, lparam);
 298       }
 299     default :
 300       return DefWindowProc (hwnd, message, wparam, lparam);
 301     }
 302 }
 303
 304 /*
 305  * Creates a hidden window and adds it to the clipboard chain
 306  */
 307 HWND
 308 _gdk_win32_register_clipboard_notification (void)
 309 {
 310   WNDCLASS wclass;
 311   HWND     hwnd;
 312   ATOM     klass;
 313
 314   memset (&wclass, 0, sizeof(WNDCLASS));
 315   wclass.lpszClassName = "GdkClipboardNotification";
 316   wclass.lpfnWndProc   = _win32_on_clipboard_change;
 317   wclass.hInstance     = _gdk_app_hmodule;
 318
 319   klass = RegisterClass (&wclass);
 320   if (!klass)
 321     return NULL;
 322
 323   hwnd = CreateWindow (MAKEINTRESOURCE(klass),
 324                        NULL, WS_POPUP,
 325                        0, 0, 0, 0, NULL, NULL,
 326                        _gdk_app_hmodule, NULL);
 327   if (!hwnd)
 328     {
 329       UnregisterClass (MAKEINTRESOURCE(klass), _gdk_app_hmodule);
 330       return NULL;
 331     }
 332   _hwnd_next_viewer = SetClipboardViewer (hwnd);
 333   return hwnd;
 334 }
 335
 336 /*
 337  * The whole function would only make sense if the gdk/win32 clipboard
 338  * model is rewritten to do delayed rendering. Currently this is only
 339  * testcode and as noted in
 340  * http://mail.gnome.org/archives/gtk-devel-list/2004-May/msg00113.html
 341  * probably not worth bothering ;)
 342  */
 343 gboolean
 344 gdk_display_request_selection_notification (GdkDisplay *display,
 345                                             GdkAtom     selection)
 346
 347 {
 348   static HWND hwndViewer = NULL;
 349   gboolean ret = FALSE;
 350
 351   GDK_NOTE (DND,
 352             g_print ("gdk_display_request_selection_notification (..., %s)",
 353                      gdk_atom_name (selection)));
 354
 355   if (GDK_SELECTION_CLIPBOARD == selection)
 356     {
 357       if (!hwndViewer)
 358         {
 359           hwndViewer = _gdk_win32_register_clipboard_notification ();
 360           GDK_NOTE (DND, g_print (" registered"));
 361         }
 362       ret = (hwndViewer != NULL);
 363     }
 364   else if (GDK_SELECTION_PRIMARY == selection)
 365     {
 366       /* seems to work by default ? */
 367       GDK_NOTE (DND, g_print (" by default"));
 368       ret = TRUE;
 369     }
 370   GDK_NOTE (DND, g_print (" -> %s\n", ret ? "TRUE" : "FALSE"));
 371   return ret;
 372 }
 373
 374 gboolean
 375 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
 376 {
 377   return FALSE;
 378 }
 379
 380 void
 381 gdk_display_store_clipboard (GdkDisplay *display,
 382                              GdkWindow  *clipboard_window,
 383                              guint32     time_,
 384                              GdkAtom    *targets,
 385                              gint        n_targets)
 386 {
 387   /* XXX: implement it (or maybe not as long as we don't support delayed rendering?) */
 388 }