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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 1998-2002 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 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29
  30 #include <glib/gprintf.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <limits.h>
  34 #include <io.h>
  35
  36 #include "gdk.h"
  37 #include "gdkregion-generic.h"
  38 #include "gdkkeysyms.h"
  39 #include "gdkinternals.h"
  40 #include "gdkintl.h"
  41 #include "gdkprivate-win32.h"
  42 #include "gdkinput-win32.h"
  43
  44 #include <objbase.h>
  45
  46 #include <imm.h>
  47
  48 static gboolean gdk_synchronize = FALSE;
  49
  50 static gboolean dummy;
  51
  52 const GOptionEntry _gdk_windowing_args[] = {
  53   { "sync", 0, 0, G_OPTION_ARG_NONE, &gdk_synchronize,
  54     /* Description of --sync in --help output */              N_("Don't batch GDI requests"), NULL },
  55   { "no-wintab", 0, 0, G_OPTION_ARG_NONE, &_gdk_input_ignore_wintab,
  56     /* Description of --no-wintab in --help output */         N_("Don't use the Wintab API for tablet support"), NULL },
  57   { "ignore-wintab", 0, 0, G_OPTION_ARG_NONE, &_gdk_input_ignore_wintab,
  58     /* Description of --ignore-wintab in --help output */     N_("Same as --no-wintab"), NULL },
  59   { "use-wintab", 0, 0, G_OPTION_ARG_NONE, &dummy,
  60     /* Description of --use-wintab in --help output */     N_("Do use the Wintab API [default]"), NULL },
  61   { "max-colors", 0, 0, G_OPTION_ARG_INT, &_gdk_max_colors,
  62     /* Description of --max-colors=COLORS in --help output */ N_("Size of the palette in 8 bit mode"),
  63     /* Placeholder in --max-colors=COLORS in --help output */ N_("COLORS") },
  64   { NULL }
  65 };
  66
  67 int __stdcall
  68 DllMain (HINSTANCE hinstDLL,
  69          DWORD     dwReason,
  70          LPVOID    reserved)
  71 {
  72   _gdk_dll_hinstance = hinstDLL;
  73
  74   return TRUE;
  75 }
  76
  77 void
  78 _gdk_windowing_init (void)
  79 {
  80   gchar buf[10];
  81
  82   if (getenv ("GDK_IGNORE_WINTAB") != NULL)
  83     _gdk_input_ignore_wintab = TRUE;
  84   else if (getenv ("GDK_USE_WINTAB") != NULL)
  85     _gdk_input_ignore_wintab = FALSE;
  86
  87   if (gdk_synchronize)
  88     GdiSetBatchLimit (1);
  89
  90   _gdk_app_hmodule = GetModuleHandle (NULL);
  91   _gdk_display_hdc = CreateDC ("DISPLAY", NULL, NULL, NULL);
  92   _gdk_input_locale = GetKeyboardLayout (0);
  93   _gdk_input_locale_is_ime = ImmIsIME (_gdk_input_locale);
  94   GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
  95                  LOCALE_IDEFAULTANSICODEPAGE,
  96                  buf, sizeof (buf));
  97   _gdk_input_codepage = atoi (buf);
  98   GDK_NOTE (EVENTS, g_print ("input_locale:%p, codepage:%d\n",
  99                              _gdk_input_locale, _gdk_input_codepage));
 100
 101   CoInitialize (NULL);
 102
 103   _cf_utf8_string = RegisterClipboardFormat ("UTF8_STRING");
 104   _cf_image_bmp = RegisterClipboardFormat ("image/bmp");
 105
 106   _gdk_selection_property = gdk_atom_intern ("GDK_SELECTION", FALSE);
 107   _wm_transient_for = gdk_atom_intern ("WM_TRANSIENT_FOR", FALSE);
 108   _targets = gdk_atom_intern ("TARGETS", FALSE);
 109   _save_targets = gdk_atom_intern ("SAVE_TARGETS", FALSE);
 110   _utf8_string = gdk_atom_intern ("UTF8_STRING", FALSE);
 111   _text = gdk_atom_intern ("TEXT", FALSE);
 112   _compound_text = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
 113   _text_uri_list = gdk_atom_intern ("text/uri-list", FALSE);
 114   _image_bmp = gdk_atom_intern ("image/bmp", FALSE);
 115
 116   _local_dnd = gdk_atom_intern ("LocalDndSelection", FALSE);
 117   _gdk_win32_dropfiles = gdk_atom_intern ("DROPFILES_DND", FALSE);
 118   _gdk_ole2_dnd = gdk_atom_intern ("OLE2_DND", FALSE);
 119
 120   _gdk_win32_selection_init ();
 121 }
 122
 123 void
 124 _gdk_win32_api_failed (const gchar *where,
 125                       gint         line,
 126                       const gchar *api)
 127 {
 128   gchar *msg = g_win32_error_message (GetLastError ());
 129   g_warning ("%s:%d: %s failed: %s", where, line, api, msg);
 130   g_free (msg);
 131 }
 132
 133 void
 134 _gdk_other_api_failed (const gchar *where,
 135                       gint         line,
 136                       const gchar *api)
 137 {
 138   g_warning ("%s:%d: %s failed", where, line, api);
 139 }
 140
 141 void
 142 gdk_set_use_xshm (gboolean use_xshm)
 143 {
 144   /* Always on */
 145 }
 146
 147 gboolean
 148 gdk_get_use_xshm (void)
 149 {
 150   return TRUE;
 151 }
 152
 153 gint
 154 gdk_screen_get_width (GdkScreen *screen)
 155 {
 156   return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->width;
 157 }
 158
 159 gint
 160 gdk_screen_get_height (GdkScreen *screen)
 161 {
 162   return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->height;
 163 }
 164 gint
 165 gdk_screen_get_width_mm (GdkScreen *screen)
 166 {
 167   return (double) gdk_screen_get_width (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSX) * 25.4;
 168 }
 169
 170 gint
 171 gdk_screen_get_height_mm (GdkScreen *screen)
 172 {
 173   return (double) gdk_screen_get_height (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSY) * 25.4;
 174 }
 175
 176 void
 177 _gdk_windowing_display_set_sm_client_id (GdkDisplay  *display,
 178                                          const gchar *sm_client_id)
 179 {
 180   g_warning("gdk_set_sm_client_id %s", sm_client_id ? sm_client_id : "NULL");
 181 }
 182
 183 void
 184 gdk_display_beep (GdkDisplay *display)
 185 {
 186   g_return_if_fail (display == gdk_display_get_default());
 187   Beep(1000, 50);
 188 }
 189
 190 void
 191 _gdk_windowing_exit (void)
 192 {
 193   _gdk_win32_dnd_exit ();
 194   CoUninitialize ();
 195   DeleteDC (_gdk_display_hdc);
 196   _gdk_display_hdc = NULL;
 197 }
 198
 199 gchar *
 200 gdk_get_display (void)
 201 {
 202   return g_strdup (gdk_display_get_name (gdk_display_get_default ()));
 203 }
 204
 205 void
 206 gdk_error_trap_push (void)
 207 {
 208 }
 209
 210 gint
 211 gdk_error_trap_pop (void)
 212 {
 213   return 0;
 214 }
 215
 216 void
 217 gdk_notify_startup_complete (void)
 218 {
 219 }
 220
 221 void
 222 gdk_notify_startup_complete_with_id (const gchar* startup_id)
 223 {
 224 }
 225
 226 void
 227 gdk_window_set_startup_id (GdkWindow   *window,
 228                            const gchar *startup_id)
 229 {
 230 }
 231
 232 #ifdef G_ENABLE_DEBUG
 233
 234 /*
 235  * Like g_strdup_printf, but to a static buffer. Return value does not
 236  * have to be g_free()d. The buffer is of bounded size and reused
 237  * cyclically. Thus the return value is valid only until that part of
 238  * the buffer happens to get reused. This doesn't matter as this
 239  * function's return value is used in debugging output right after the call,
 240  * and the return value isn't used after that.
 241  */
 242 static gchar *
 243 static_printf (const gchar *format,
 244                ...)
 245 {
 246   static gchar buf[10000];
 247   gchar *msg;
 248   static gchar *bufp = buf;
 249   gchar *retval;
 250   va_list args;
 251
 252   va_start (args, format);
 253   msg = g_strdup_vprintf (format, args);
 254   va_end (args);
 255
 256   g_assert (strlen (msg) < sizeof (buf));
 257
 258   if (bufp + strlen (msg) + 1 > buf + sizeof (buf))
 259     bufp = buf;
 260   retval = bufp;
 261
 262   strcpy (bufp, msg);
 263   bufp += strlen (msg) + 1;
 264   g_free (msg);
 265
 266   return retval;
 267 }
 268
 269 gchar *
 270 _gdk_win32_color_to_string (const GdkColor *color)
 271 {
 272   return static_printf ("(%.04x,%.04x,%.04x):%.06x",
 273                         color->red, color->green,
 274                         color->blue, color->pixel);
 275 }
 276
 277 void
 278 _gdk_win32_print_paletteentries (const PALETTEENTRY *pep,
 279                                 const int           nentries)
 280 {
 281   char buf[20];
 282   int i;
 283
 284   for (i = 0; i < nentries; i++)
 285     g_print ("  %3d %02x:  %02x %02x %02x%s\n",
 286              i, i,
 287              pep[i].peRed, pep[i].peGreen, pep[i].peBlue,
 288              (pep[i].peFlags == 0 ? "" :
 289               (pep[i].peFlags == PC_EXPLICIT ? " PC_EXPLICIT" :
 290                (pep[i].peFlags == PC_NOCOLLAPSE ? " PC_NOCOLLAPSE" :
 291                 (pep[i].peFlags == PC_RESERVED ? " PC_RESERVED" :
 292                  (g_sprintf (buf, " %d", pep[i].peFlags), buf))))));
 293 }
 294
 295 void
 296 _gdk_win32_print_system_palette (void)
 297 {
 298   PALETTEENTRY *pe;
 299   int k;
 300
 301   k = GetSystemPaletteEntries (_gdk_display_hdc, 0, 0, NULL);
 302   pe = g_new (PALETTEENTRY, k);
 303   k = GetSystemPaletteEntries (_gdk_display_hdc, 0, k, pe);
 304
 305   if (!k)
 306     g_print ("GetSystemPaletteEntries failed: %s\n",
 307              g_win32_error_message (GetLastError ()));
 308   else
 309     {
 310       g_print ("System palette: %d entries\n", k);
 311       _gdk_win32_print_paletteentries (pe, k);
 312     }
 313   g_free (pe);
 314 }
 315
 316 static gint
 317 palette_size (HPALETTE hpal)
 318 {
 319   WORD npal = 0;
 320
 321   if (!GetObject (hpal, sizeof (npal), &npal))
 322     WIN32_GDI_FAILED ("GetObject (HPALETTE)");
 323
 324   return npal;
 325 }
 326
 327 void
 328 _gdk_win32_print_hpalette (HPALETTE hpal)
 329 {
 330   PALETTEENTRY *pe;
 331   gint n, npal;
 332
 333   npal = palette_size (hpal);
 334   pe = g_new (PALETTEENTRY, npal);
 335   n = GetPaletteEntries (hpal, 0, npal, pe);
 336
 337   if (!n)
 338     g_print ("HPALETTE %p: GetPaletteEntries failed: %s\n",
 339              hpal, g_win32_error_message (GetLastError ()));
 340   else
 341     {
 342       g_print ("HPALETTE %p: %d (%d) entries\n", hpal, n, npal);
 343       _gdk_win32_print_paletteentries (pe, n);
 344     }
 345   g_free (pe);
 346 }
 347
 348 void
 349 _gdk_win32_print_dc (HDC hdc)
 350 {
 351   HGDIOBJ obj;
 352   LOGBRUSH logbrush;
 353   EXTLOGPEN extlogpen;
 354   HRGN hrgn;
 355   RECT rect;
 356   int flag;
 357
 358   g_print ("%p:\n", hdc);
 359   obj = GetCurrentObject (hdc, OBJ_BRUSH);
 360   GetObject (obj, sizeof (LOGBRUSH), &logbrush);
 361   g_print ("brush: %s color=%06lx hatch=%p\n",
 362            _gdk_win32_lbstyle_to_string (logbrush.lbStyle),
 363            logbrush.lbColor, (gpointer) logbrush.lbHatch);
 364   obj = GetCurrentObject (hdc, OBJ_PEN);
 365   GetObject (obj, sizeof (EXTLOGPEN), &extlogpen);
 366   g_print ("pen: %s %s %s %s w=%d %s\n",
 367            _gdk_win32_pstype_to_string (extlogpen.elpPenStyle),
 368            _gdk_win32_psstyle_to_string (extlogpen.elpPenStyle),
 369            _gdk_win32_psendcap_to_string (extlogpen.elpPenStyle),
 370            _gdk_win32_psjoin_to_string (extlogpen.elpPenStyle),
 371            (int) extlogpen.elpWidth,
 372            _gdk_win32_lbstyle_to_string (extlogpen.elpBrushStyle));
 373   g_print ("rop2: %s textcolor=%06lx\n",
 374            _gdk_win32_rop2_to_string (GetROP2 (hdc)),
 375            GetTextColor (hdc));
 376   hrgn = CreateRectRgn (0, 0, 0, 0);
 377   if ((flag = GetClipRgn (hdc, hrgn)) == -1)
 378     WIN32_API_FAILED ("GetClipRgn");
 379   else if (flag == 0)
 380     g_print ("no clip region\n");
 381   else if (flag == 1)
 382     {
 383       GetRgnBox (hrgn, &rect);
 384       g_print ("clip region: %p bbox: %s\n",
 385                hrgn, _gdk_win32_rect_to_string (&rect));
 386     }
 387   DeleteObject (hrgn);
 388 }
 389
 390 gchar *
 391 _gdk_win32_cap_style_to_string (GdkCapStyle cap_style)
 392 {
 393   switch (cap_style)
 394     {
 395 #define CASE(x) case GDK_CAP_##x: return #x
 396     CASE (NOT_LAST);
 397     CASE (BUTT);
 398     CASE (ROUND);
 399     CASE (PROJECTING);
 400 #undef CASE
 401     default: return static_printf ("illegal_%d", cap_style);
 402     }
 403   /* NOTREACHED */
 404   return NULL;
 405 }
 406
 407 gchar *
 408 _gdk_win32_fill_style_to_string (GdkFill fill)
 409 {
 410   switch (fill)
 411     {
 412 #define CASE(x) case GDK_##x: return #x
 413     CASE (SOLID);
 414     CASE (TILED);
 415     CASE (STIPPLED);
 416     CASE (OPAQUE_STIPPLED);
 417 #undef CASE
 418     default: return static_printf ("illegal_%d", fill);
 419     }
 420   /* NOTREACHED */
 421   return NULL;
 422 }
 423
 424 gchar *
 425 _gdk_win32_function_to_string (GdkFunction function)
 426 {
 427   switch (function)
 428     {
 429 #define CASE(x) case GDK_##x: return #x
 430     CASE (COPY);
 431     CASE (INVERT);
 432     CASE (XOR);
 433     CASE (CLEAR);
 434     CASE (AND);
 435     CASE (AND_REVERSE);
 436     CASE (AND_INVERT);
 437     CASE (NOOP);
 438     CASE (OR);
 439     CASE (EQUIV);
 440     CASE (OR_REVERSE);
 441     CASE (COPY_INVERT);
 442     CASE (OR_INVERT);
 443     CASE (NAND);
 444     CASE (SET);
 445 #undef CASE
 446     default: return static_printf ("illegal_%d", function);
 447     }
 448   /* NOTREACHED */
 449   return NULL;
 450 }
 451
 452 gchar *
 453 _gdk_win32_join_style_to_string (GdkJoinStyle join_style)
 454 {
 455   switch (join_style)
 456     {
 457 #define CASE(x) case GDK_JOIN_##x: return #x
 458     CASE (MITER);
 459     CASE (ROUND);
 460     CASE (BEVEL);
 461 #undef CASE
 462     default: return static_printf ("illegal_%d", join_style);
 463     }
 464   /* NOTREACHED */
 465   return NULL;
 466 }
 467
 468 gchar *
 469 _gdk_win32_line_style_to_string (GdkLineStyle line_style)
 470 {
 471   switch (line_style)
 472     {
 473 #define CASE(x) case GDK_LINE_##x: return #x
 474     CASE(SOLID);
 475     CASE(ON_OFF_DASH);
 476     CASE(DOUBLE_DASH);
 477 #undef CASE
 478     default: return static_printf ("illegal_%d", line_style);
 479     }
 480   /* NOTREACHED */
 481   return NULL;
 482 }
 483
 484 gchar *
 485 _gdk_win32_gcvalues_mask_to_string (GdkGCValuesMask mask)
 486 {
 487   gchar buf[400];
 488   gchar *bufp = buf;
 489   gchar *s = "";
 490
 491   buf[0] = '\0';
 492
 493 #define BIT(x)                                          \
 494   if (mask & GDK_GC_##x)                                \
 495     (bufp += g_sprintf (bufp, "%s" #x, s), s = "|")
 496
 497   BIT (FOREGROUND);
 498   BIT (BACKGROUND);
 499   BIT (FONT);
 500   BIT (FUNCTION);
 501   BIT (FILL);
 502   BIT (TILE);
 503   BIT (STIPPLE);
 504   BIT (CLIP_MASK);
 505   BIT (SUBWINDOW);
 506   BIT (TS_X_ORIGIN);
 507   BIT (TS_Y_ORIGIN);
 508   BIT (CLIP_X_ORIGIN);
 509   BIT (CLIP_Y_ORIGIN);
 510   BIT (EXPOSURES);
 511   BIT (LINE_WIDTH);
 512   BIT (LINE_STYLE);
 513   BIT (CAP_STYLE);
 514   BIT (JOIN_STYLE);
 515 #undef BIT
 516
 517   return static_printf ("%s", buf);
 518 }
 519
 520 gchar *
 521 _gdk_win32_window_state_to_string (GdkWindowState state)
 522 {
 523   gchar buf[100];
 524   gchar *bufp = buf;
 525   gchar *s = "";
 526
 527   buf[0] = '\0';
 528
 529 #define BIT(x)                                          \
 530   if (state & GDK_WINDOW_STATE_ ## x)                   \
 531     (bufp += sprintf (bufp, "%s" #x, s), s = "|")
 532
 533   /* For clarity, also show the complement of WITHDRAWN, i.e. "MAPPED" */
 534   if (!(state & GDK_WINDOW_STATE_WITHDRAWN))
 535     (bufp += sprintf (bufp, "MAPPED"), s = "|");
 536
 537   BIT (WITHDRAWN);
 538   BIT (ICONIFIED);
 539   BIT (MAXIMIZED);
 540   BIT (STICKY);
 541 #undef BIT
 542
 543   return static_printf ("%s", buf);
 544 }
 545
 546 gchar *
 547 _gdk_win32_window_style_to_string (LONG style)
 548 {
 549   gchar buf[1000];
 550   gchar *bufp = buf;
 551   gchar *s = "";
 552
 553   buf[0] = '\0';
 554
 555 #define BIT(x)                                          \
 556   if (style & WS_ ## x)                                 \
 557     (bufp += sprintf (bufp, "%s" #x, s), s = "|")
 558
 559   /* Note that many of the WS_* macros are in face several bits.
 560    * Handle just the individual bits here. Sort as in w32api's
 561    * winuser.h.
 562    */
 563   BIT (BORDER);
 564   BIT (CHILD);
 565   BIT (CLIPCHILDREN);
 566   BIT (CLIPSIBLINGS);
 567   BIT (DISABLED);
 568   BIT (DLGFRAME);
 569   BIT (GROUP);
 570   BIT (HSCROLL);
 571   BIT (ICONIC);
 572   BIT (MAXIMIZE);
 573   BIT (MAXIMIZEBOX);
 574   BIT (MINIMIZE);
 575   BIT (MINIMIZEBOX);
 576   BIT (POPUP);
 577   BIT (SIZEBOX);
 578   BIT (SYSMENU);
 579   BIT (TABSTOP);
 580   BIT (THICKFRAME);
 581   BIT (VISIBLE);
 582   BIT (VSCROLL);
 583 #undef BIT
 584
 585   return static_printf ("%s", buf);
 586 }
 587
 588 gchar *
 589 _gdk_win32_window_exstyle_to_string (LONG style)
 590 {
 591   gchar buf[1000];
 592   gchar *bufp = buf;
 593   gchar *s = "";
 594
 595   buf[0] = '\0';
 596
 597 #define BIT(x)                                          \
 598   if (style & WS_EX_ ## x)                              \
 599     (bufp += sprintf (bufp, "%s" #x, s), s = "|")
 600
 601   /* Note that many of the WS_EX_* macros are in face several bits.
 602    * Handle just the individual bits here. Sort as in w32api's
 603    * winuser.h.
 604    */
 605   BIT (ACCEPTFILES);
 606   BIT (APPWINDOW);
 607   BIT (CLIENTEDGE);
 608   BIT (COMPOSITED);
 609   BIT (CONTEXTHELP);
 610   BIT (CONTROLPARENT);
 611   BIT (DLGMODALFRAME);
 612   BIT (LAYERED);
 613   BIT (LAYOUTRTL);
 614   BIT (LEFTSCROLLBAR);
 615   BIT (MDICHILD);
 616   BIT (NOACTIVATE);
 617   BIT (NOINHERITLAYOUT);
 618   BIT (NOPARENTNOTIFY);
 619   BIT (RIGHT);
 620   BIT (RTLREADING);
 621   BIT (STATICEDGE);
 622   BIT (TOOLWINDOW);
 623   BIT (TOPMOST);
 624   BIT (TRANSPARENT);
 625   BIT (WINDOWEDGE);
 626 #undef BIT
 627
 628   return static_printf ("%s", buf);
 629 }
 630
 631 gchar *
 632 _gdk_win32_window_pos_bits_to_string (UINT flags)
 633 {
 634   gchar buf[1000];
 635   gchar *bufp = buf;
 636   gchar *s = "";
 637
 638   buf[0] = '\0';
 639
 640 #define BIT(x)                                          \
 641   if (flags & SWP_ ## x)                                \
 642     (bufp += sprintf (bufp, "%s" #x, s), s = "|")
 643
 644   BIT (DRAWFRAME);
 645   BIT (FRAMECHANGED);
 646   BIT (HIDEWINDOW);
 647   BIT (NOACTIVATE);
 648   BIT (NOCOPYBITS);
 649   BIT (NOMOVE);
 650   BIT (NOSIZE);
 651   BIT (NOREDRAW);
 652   BIT (NOZORDER);
 653   BIT (SHOWWINDOW);
 654   BIT (NOOWNERZORDER);
 655   BIT (NOSENDCHANGING);
 656   BIT (DEFERERASE);
 657   BIT (ASYNCWINDOWPOS);
 658 #undef BIT
 659
 660   return static_printf ("%s", buf);
 661 }
 662
 663 gchar *
 664 _gdk_win32_rop2_to_string (int rop2)
 665 {
 666   switch (rop2)
 667     {
 668 #define CASE(x) case R2_##x: return #x
 669       CASE (BLACK);
 670       CASE (COPYPEN);
 671       CASE (MASKNOTPEN);
 672       CASE (MASKPEN);
 673       CASE (MASKPENNOT);
 674       CASE (MERGENOTPEN);
 675       CASE (MERGEPEN);
 676       CASE (MERGEPENNOT);
 677       CASE (NOP);
 678       CASE (NOT);
 679       CASE (NOTCOPYPEN);
 680       CASE (NOTMASKPEN);
 681       CASE (NOTMERGEPEN);
 682       CASE (NOTXORPEN);
 683       CASE (WHITE);
 684       CASE (XORPEN);
 685 #undef CASE
 686     default: return static_printf ("illegal_%x", rop2);
 687     }
 688   /* NOTREACHED */
 689   return NULL;
 690 }
 691
 692 gchar *
 693 _gdk_win32_lbstyle_to_string (UINT brush_style)
 694 {
 695   switch (brush_style)
 696     {
 697 #define CASE(x) case BS_##x: return #x
 698       CASE (DIBPATTERN);
 699       CASE (DIBPATTERNPT);
 700       CASE (HATCHED);
 701       CASE (HOLLOW);
 702       CASE (PATTERN);
 703       CASE (SOLID);
 704 #undef CASE
 705     default: return static_printf ("illegal_%d", brush_style);
 706     }
 707   /* NOTREACHED */
 708   return NULL;
 709 }
 710
 711 gchar *
 712 _gdk_win32_pstype_to_string (DWORD pen_style)
 713 {
 714   switch (pen_style & PS_TYPE_MASK)
 715     {
 716     case PS_GEOMETRIC: return "GEOMETRIC";
 717     case PS_COSMETIC: return "COSMETIC";
 718     default: return static_printf ("illegal_%d", pen_style & PS_TYPE_MASK);
 719     }
 720   /* NOTREACHED */
 721   return NULL;
 722 }
 723
 724 gchar *
 725 _gdk_win32_psstyle_to_string (DWORD pen_style)
 726 {
 727   switch (pen_style & PS_STYLE_MASK)
 728     {
 729 #define CASE(x) case PS_##x: return #x
 730       CASE (ALTERNATE);
 731       CASE (SOLID);
 732       CASE (DASH);
 733       CASE (DOT);
 734       CASE (DASHDOT);
 735       CASE (DASHDOTDOT);
 736       CASE (NULL);
 737       CASE (USERSTYLE);
 738       CASE (INSIDEFRAME);
 739 #undef CASE
 740     default: return static_printf ("illegal_%d", pen_style & PS_STYLE_MASK);
 741     }
 742   /* NOTREACHED */
 743   return NULL;
 744 }
 745
 746 gchar *
 747 _gdk_win32_psendcap_to_string (DWORD pen_style)
 748 {
 749   switch (pen_style & PS_ENDCAP_MASK)
 750     {
 751 #define CASE(x) case PS_ENDCAP_##x: return #x
 752       CASE (ROUND);
 753       CASE (SQUARE);
 754       CASE (FLAT);
 755 #undef CASE
 756     default: return static_printf ("illegal_%d", pen_style & PS_ENDCAP_MASK);
 757     }
 758   /* NOTREACHED */
 759   return NULL;
 760 }
 761
 762 gchar *
 763 _gdk_win32_psjoin_to_string (DWORD pen_style)
 764 {
 765   switch (pen_style & PS_JOIN_MASK)
 766     {
 767 #define CASE(x) case PS_JOIN_##x: return #x
 768       CASE (ROUND);
 769       CASE (BEVEL);
 770       CASE (MITER);
 771 #undef CASE
 772     default: return static_printf ("illegal_%d", pen_style & PS_JOIN_MASK);
 773     }
 774   /* NOTREACHED */
 775   return NULL;
 776 }
 777
 778 gchar *
 779 _gdk_win32_message_to_string (UINT msg)
 780 {
 781   switch (msg)
 782     {
 783 #define CASE(x) case x: return #x
 784       CASE (WM_NULL);
 785       CASE (WM_CREATE);
 786       CASE (WM_DESTROY);
 787       CASE (WM_MOVE);
 788       CASE (WM_SIZE);
 789       CASE (WM_ACTIVATE);
 790       CASE (WM_SETFOCUS);
 791       CASE (WM_KILLFOCUS);
 792       CASE (WM_ENABLE);
 793       CASE (WM_SETREDRAW);
 794       CASE (WM_SETTEXT);
 795       CASE (WM_GETTEXT);
 796       CASE (WM_GETTEXTLENGTH);
 797       CASE (WM_PAINT);
 798       CASE (WM_CLOSE);
 799       CASE (WM_QUERYENDSESSION);
 800       CASE (WM_QUERYOPEN);
 801       CASE (WM_ENDSESSION);
 802       CASE (WM_QUIT);
 803       CASE (WM_ERASEBKGND);
 804       CASE (WM_SYSCOLORCHANGE);
 805       CASE (WM_SHOWWINDOW);
 806       CASE (WM_WININICHANGE);
 807       CASE (WM_DEVMODECHANGE);
 808       CASE (WM_ACTIVATEAPP);
 809       CASE (WM_FONTCHANGE);
 810       CASE (WM_TIMECHANGE);
 811       CASE (WM_CANCELMODE);
 812       CASE (WM_SETCURSOR);
 813       CASE (WM_MOUSEACTIVATE);
 814       CASE (WM_CHILDACTIVATE);
 815       CASE (WM_QUEUESYNC);
 816       CASE (WM_GETMINMAXINFO);
 817       CASE (WM_PAINTICON);
 818       CASE (WM_ICONERASEBKGND);
 819       CASE (WM_NEXTDLGCTL);
 820       CASE (WM_SPOOLERSTATUS);
 821       CASE (WM_DRAWITEM);
 822       CASE (WM_MEASUREITEM);
 823       CASE (WM_DELETEITEM);
 824       CASE (WM_VKEYTOITEM);
 825       CASE (WM_CHARTOITEM);
 826       CASE (WM_SETFONT);
 827       CASE (WM_GETFONT);
 828       CASE (WM_SETHOTKEY);
 829       CASE (WM_GETHOTKEY);
 830       CASE (WM_QUERYDRAGICON);
 831       CASE (WM_COMPAREITEM);
 832       CASE (WM_GETOBJECT);
 833       CASE (WM_COMPACTING);
 834       CASE (WM_WINDOWPOSCHANGING);
 835       CASE (WM_WINDOWPOSCHANGED);
 836       CASE (WM_POWER);
 837       CASE (WM_COPYDATA);
 838       CASE (WM_CANCELJOURNAL);
 839       CASE (WM_NOTIFY);
 840       CASE (WM_INPUTLANGCHANGEREQUEST);
 841       CASE (WM_INPUTLANGCHANGE);
 842       CASE (WM_TCARD);
 843       CASE (WM_HELP);
 844       CASE (WM_USERCHANGED);
 845       CASE (WM_NOTIFYFORMAT);
 846       CASE (WM_CONTEXTMENU);
 847       CASE (WM_STYLECHANGING);
 848       CASE (WM_STYLECHANGED);
 849       CASE (WM_DISPLAYCHANGE);
 850       CASE (WM_GETICON);
 851       CASE (WM_SETICON);
 852       CASE (WM_NCCREATE);
 853       CASE (WM_NCDESTROY);
 854       CASE (WM_NCCALCSIZE);
 855       CASE (WM_NCHITTEST);
 856       CASE (WM_NCPAINT);
 857       CASE (WM_NCACTIVATE);
 858       CASE (WM_GETDLGCODE);
 859       CASE (WM_SYNCPAINT);
 860       CASE (WM_NCMOUSEMOVE);
 861       CASE (WM_NCLBUTTONDOWN);
 862       CASE (WM_NCLBUTTONUP);
 863       CASE (WM_NCLBUTTONDBLCLK);
 864       CASE (WM_NCRBUTTONDOWN);
 865       CASE (WM_NCRBUTTONUP);
 866       CASE (WM_NCRBUTTONDBLCLK);
 867       CASE (WM_NCMBUTTONDOWN);
 868       CASE (WM_NCMBUTTONUP);
 869       CASE (WM_NCMBUTTONDBLCLK);
 870       CASE (WM_NCXBUTTONDOWN);
 871       CASE (WM_NCXBUTTONUP);
 872       CASE (WM_NCXBUTTONDBLCLK);
 873       CASE (WM_KEYDOWN);
 874       CASE (WM_KEYUP);
 875       CASE (WM_CHAR);
 876       CASE (WM_DEADCHAR);
 877       CASE (WM_SYSKEYDOWN);
 878       CASE (WM_SYSKEYUP);
 879       CASE (WM_SYSCHAR);
 880       CASE (WM_SYSDEADCHAR);
 881       CASE (WM_KEYLAST);
 882       CASE (WM_IME_STARTCOMPOSITION);
 883       CASE (WM_IME_ENDCOMPOSITION);
 884       CASE (WM_IME_COMPOSITION);
 885       CASE (WM_INITDIALOG);
 886       CASE (WM_COMMAND);
 887       CASE (WM_SYSCOMMAND);
 888       CASE (WM_TIMER);
 889       CASE (WM_HSCROLL);
 890       CASE (WM_VSCROLL);
 891       CASE (WM_INITMENU);
 892       CASE (WM_INITMENUPOPUP);
 893       CASE (WM_MENUSELECT);
 894       CASE (WM_MENUCHAR);
 895       CASE (WM_ENTERIDLE);
 896       CASE (WM_MENURBUTTONUP);
 897       CASE (WM_MENUDRAG);
 898       CASE (WM_MENUGETOBJECT);
 899       CASE (WM_UNINITMENUPOPUP);
 900       CASE (WM_MENUCOMMAND);
 901       CASE (WM_CHANGEUISTATE);
 902       CASE (WM_UPDATEUISTATE);
 903       CASE (WM_QUERYUISTATE);
 904       CASE (WM_CTLCOLORMSGBOX);
 905       CASE (WM_CTLCOLOREDIT);
 906       CASE (WM_CTLCOLORLISTBOX);
 907       CASE (WM_CTLCOLORBTN);
 908       CASE (WM_CTLCOLORDLG);
 909       CASE (WM_CTLCOLORSCROLLBAR);
 910       CASE (WM_CTLCOLORSTATIC);
 911       CASE (WM_MOUSEMOVE);
 912       CASE (WM_LBUTTONDOWN);
 913       CASE (WM_LBUTTONUP);
 914       CASE (WM_LBUTTONDBLCLK);
 915       CASE (WM_RBUTTONDOWN);
 916       CASE (WM_RBUTTONUP);
 917       CASE (WM_RBUTTONDBLCLK);
 918       CASE (WM_MBUTTONDOWN);
 919       CASE (WM_MBUTTONUP);
 920       CASE (WM_MBUTTONDBLCLK);
 921       CASE (WM_MOUSEWHEEL);
 922       CASE (WM_XBUTTONDOWN);
 923       CASE (WM_XBUTTONUP);
 924       CASE (WM_XBUTTONDBLCLK);
 925       CASE (WM_PARENTNOTIFY);
 926       CASE (WM_ENTERMENULOOP);
 927       CASE (WM_EXITMENULOOP);
 928       CASE (WM_NEXTMENU);
 929       CASE (WM_SIZING);
 930       CASE (WM_CAPTURECHANGED);
 931       CASE (WM_MOVING);
 932       CASE (WM_POWERBROADCAST);
 933       CASE (WM_DEVICECHANGE);
 934       CASE (WM_MDICREATE);
 935       CASE (WM_MDIDESTROY);
 936       CASE (WM_MDIACTIVATE);
 937       CASE (WM_MDIRESTORE);
 938       CASE (WM_MDINEXT);
 939       CASE (WM_MDIMAXIMIZE);
 940       CASE (WM_MDITILE);
 941       CASE (WM_MDICASCADE);
 942       CASE (WM_MDIICONARRANGE);
 943       CASE (WM_MDIGETACTIVE);
 944       CASE (WM_MDISETMENU);
 945       CASE (WM_ENTERSIZEMOVE);
 946       CASE (WM_EXITSIZEMOVE);
 947       CASE (WM_DROPFILES);
 948       CASE (WM_MDIREFRESHMENU);
 949       CASE (WM_IME_SETCONTEXT);
 950       CASE (WM_IME_NOTIFY);
 951       CASE (WM_IME_CONTROL);
 952       CASE (WM_IME_COMPOSITIONFULL);
 953       CASE (WM_IME_SELECT);
 954       CASE (WM_IME_CHAR);
 955       CASE (WM_IME_REQUEST);
 956       CASE (WM_IME_KEYDOWN);
 957       CASE (WM_IME_KEYUP);
 958       CASE (WM_MOUSEHOVER);
 959       CASE (WM_MOUSELEAVE);
 960       CASE (WM_NCMOUSEHOVER);
 961       CASE (WM_NCMOUSELEAVE);
 962       CASE (WM_CUT);
 963       CASE (WM_COPY);
 964       CASE (WM_PASTE);
 965       CASE (WM_CLEAR);
 966       CASE (WM_UNDO);
 967       CASE (WM_RENDERFORMAT);
 968       CASE (WM_RENDERALLFORMATS);
 969       CASE (WM_DESTROYCLIPBOARD);
 970       CASE (WM_DRAWCLIPBOARD);
 971       CASE (WM_PAINTCLIPBOARD);
 972       CASE (WM_VSCROLLCLIPBOARD);
 973       CASE (WM_SIZECLIPBOARD);
 974       CASE (WM_ASKCBFORMATNAME);
 975       CASE (WM_CHANGECBCHAIN);
 976       CASE (WM_HSCROLLCLIPBOARD);
 977       CASE (WM_QUERYNEWPALETTE);
 978       CASE (WM_PALETTEISCHANGING);
 979       CASE (WM_PALETTECHANGED);
 980       CASE (WM_HOTKEY);
 981       CASE (WM_PRINT);
 982       CASE (WM_PRINTCLIENT);
 983       CASE (WM_APPCOMMAND);
 984       CASE (WM_HANDHELDFIRST);
 985       CASE (WM_HANDHELDLAST);
 986       CASE (WM_AFXFIRST);
 987       CASE (WM_AFXLAST);
 988       CASE (WM_PENWINFIRST);
 989       CASE (WM_PENWINLAST);
 990       CASE (WM_APP);
 991       CASE (WT_PACKET);
 992       CASE (WT_CSRCHANGE);
 993       CASE (WT_PROXIMITY);
 994 #undef CASE
 995     default:
 996       if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST)
 997         return static_printf ("WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST);
 998       else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST)
 999         return static_printf ("WM_AFXFIRST+%d", msg - WM_AFXFIRST);
1000       else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST)
1001         return static_printf ("WM_PENWINFIRST+%d", msg - WM_PENWINFIRST);
1002       else if (msg >= WM_USER && msg <= 0x7FFF)
1003         return static_printf ("WM_USER+%d", msg - WM_USER);
1004       else if (msg >= 0xC000 && msg <= 0xFFFF)
1005         return static_printf ("reg-%#x", msg);
1006       else
1007         return static_printf ("unk-%#x", msg);
1008     }
1009   /* NOTREACHED */
1010   return NULL;
1011 }
1012
1013 gchar *
1014 _gdk_win32_key_to_string (LONG lParam)
1015 {
1016   char buf[100];
1017   gchar *keyname_utf8;
1018
1019   if (GetKeyNameText (lParam, buf, sizeof (buf)) &&
1020       (keyname_utf8 = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL)) != NULL)
1021     {
1022       gchar *retval = static_printf ("%s", keyname_utf8);
1023
1024       g_free (keyname_utf8);
1025
1026       return retval;
1027     }
1028
1029   return static_printf ("unk-%#lx", lParam);
1030 }
1031
1032 gchar *
1033 _gdk_win32_cf_to_string (UINT format)
1034 {
1035   char buf[100];
1036
1037   switch (format)
1038     {
1039 #define CASE(x) case CF_##x: return "CF_" #x
1040       CASE (BITMAP);
1041       CASE (DIB);
1042 #ifdef CF_DIBV5
1043       CASE (DIBV5);
1044 #endif
1045       CASE (DIF);
1046       CASE (DSPBITMAP);
1047       CASE (DSPENHMETAFILE);
1048       CASE (DSPMETAFILEPICT);
1049       CASE (DSPTEXT);
1050       CASE (ENHMETAFILE);
1051       CASE (HDROP);
1052       CASE (LOCALE);
1053       CASE (METAFILEPICT);
1054       CASE (OEMTEXT);
1055       CASE (OWNERDISPLAY);
1056       CASE (PALETTE);
1057       CASE (PENDATA);
1058       CASE (RIFF);
1059       CASE (SYLK);
1060       CASE (TEXT);
1061       CASE (WAVE);
1062       CASE (TIFF);
1063       CASE (UNICODETEXT);
1064     default:
1065       if (format >= CF_GDIOBJFIRST &&
1066           format <= CF_GDIOBJLAST)
1067         return static_printf ("CF_GDIOBJ%d", format - CF_GDIOBJFIRST);
1068       if (format >= CF_PRIVATEFIRST &&
1069           format <= CF_PRIVATELAST)
1070         return static_printf ("CF_PRIVATE%d", format - CF_PRIVATEFIRST);
1071       if (GetClipboardFormatName (format, buf, sizeof (buf)))
1072         return static_printf ("'%s'", buf);
1073       else
1074         return static_printf ("unk-%#lx", format);
1075     }
1076 }
1077
1078 gchar *
1079 _gdk_win32_data_to_string (const guchar *data,
1080                            int           nbytes)
1081 {
1082   GString *s = g_string_new ("");
1083   int i;
1084   gchar *retval;
1085
1086   for (i = 0; i < nbytes; i++)
1087     if (data[i] >=' ' && data[i] <= '~')
1088       g_string_append_printf (s, "%c  ", data[i]);
1089     else
1090       g_string_append_printf (s, "%02X ", data[i]);
1091
1092   retval = static_printf ("%s", s->str);
1093   g_string_free (s, TRUE);
1094
1095   return retval;
1096 }
1097
1098 gchar *
1099 _gdk_win32_rect_to_string (const RECT *rect)
1100 {
1101   return static_printf ("%ldx%ld@%+ld%+ld",
1102                         (rect->right - rect->left), (rect->bottom - rect->top),
1103                         rect->left, rect->top);
1104 }
1105
1106 gchar *
1107 _gdk_win32_gdkrectangle_to_string (const GdkRectangle *rect)
1108 {
1109   return static_printf ("%dx%d@%+d%+d",
1110                         rect->width, rect->height,
1111                         rect->x, rect->y);
1112 }
1113
1114 gchar *
1115 _gdk_win32_gdkregion_to_string (const GdkRegion *rgn)
1116 {
1117   return static_printf ("%dx%d@%+d%+d",
1118                         (rgn->extents.x2 - rgn->extents.x1),
1119                         (rgn->extents.y2 - rgn->extents.y1),
1120                         rgn->extents.x1, rgn->extents.y1);
1121 }
1122
1123 gchar *
1124 _gdk_win32_drawable_description (GdkDrawable *d)
1125 {
1126   gint width, height, depth;
1127
1128   gdk_drawable_get_size (d, &width, &height);
1129   depth = gdk_drawable_get_depth (d);
1130
1131   return static_printf ("%s:%p:%dx%dx%d",
1132                         G_OBJECT_TYPE_NAME (d),
1133                         GDK_DRAWABLE_HANDLE (d),
1134                         width, height, depth);
1135 }
1136
1137 #endif /* G_ENABLE_DEBUG */