Logo ROOT   6.10/09
Reference Guide
TGWin32.cxx
Go to the documentation of this file.
1 // @(#)root/win32gdk:$Id$
2 // Author: Rene Brun, Olivier Couet, Fons Rademakers, Valeri Onuchin, Bertrand Bellenot 27/11/01
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /// \defgroup win32 Win32 backend
13 /// \brief Interface to Windows graphics.
14 /// \ingroup GraphicsBackends
15 
16 /** \class TGWin32
17 \ingroup win32
18 This class is the basic interface to the Win32 graphics system.
19 It is an implementation of the abstract TVirtualX class.
20 
21 This code was initially developed in the context of HIGZ and PAW
22 by Olivier Couet (package X11INT).
23 */
24 
25 #include <ft2build.h>
26 #include FT_FREETYPE_H
27 #include FT_GLYPH_H
28 #include "TGWin32.h"
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <ctype.h>
33 #include <limits.h>
34 #include <process.h>
35 #include <wchar.h>
36 #include "gdk/gdkkeysyms.h"
37 #include "xatom.h"
38 #include <winuser.h>
39 
40 #include "TROOT.h"
41 #include "TApplication.h"
42 #include "TColor.h"
43 #include "TPoint.h"
44 #include "TMath.h"
45 #include "TStorage.h"
46 #include "TStyle.h"
47 #include "TSystem.h"
48 #include "TGFrame.h"
49 #include "TError.h"
50 #include "TException.h"
51 #include "TClassTable.h"
52 #include "KeySymbols.h"
53 #include "TWinNTSystem.h"
54 #include "TGWin32VirtualXProxy.h"
56 #include "TWin32SplashThread.h"
57 #include "TString.h"
58 #include "TObjString.h"
59 #include "TObjArray.h"
60 #include "TExMap.h"
61 #include "TEnv.h"
62 #include "RStipples.h"
63 #include "TEnv.h"
64 
65 // DND protocol version
66 #define XDND_PROTOCOL_VERSION 5
67 #ifndef IDC_HAND
68 #define IDC_HAND MAKEINTRESOURCE(32649)
69 #endif
70 
71 extern "C" {
72 void gdk_win32_draw_rectangle (GdkDrawable *drawable,
73  GdkGC *gc,
74  gint filled,
75  gint x,
76  gint y,
77  gint width,
78  gint height);
79 void gdk_win32_draw_arc (GdkDrawable *drawable,
80  GdkGC *gc,
81  gint filled,
82  gint x,
83  gint y,
84  gint width,
85  gint height,
86  gint angle1,
87  gint angle2);
88 void gdk_win32_draw_polygon (GdkDrawable *drawable,
89  GdkGC *gc,
90  gint filled,
91  GdkPoint *points,
92  gint npoints);
93 void gdk_win32_draw_text (GdkDrawable *drawable,
94  GdkFont *font,
95  GdkGC *gc,
96  gint x,
97  gint y,
98  const gchar *text,
99  gint text_length);
100 void gdk_win32_draw_points (GdkDrawable *drawable,
101  GdkGC *gc,
102  GdkPoint *points,
103  gint npoints);
104 void gdk_win32_draw_segments (GdkDrawable *drawable,
105  GdkGC *gc,
106  GdkSegment *segs,
107  gint nsegs);
108 void gdk_win32_draw_lines (GdkDrawable *drawable,
109  GdkGC *gc,
110  GdkPoint *points,
111  gint npoints);
112 
113 };
114 
115 //////////// internal classes & structures (very private) ////////////////
116 
117 struct XWindow_t {
118  Int_t open; // 1 if the window is open, 0 if not
119  Int_t double_buffer; // 1 if the double buffer is on, 0 if not
120  Int_t ispixmap; // 1 if pixmap, 0 if not
121  GdkDrawable *drawing; // drawing area, equal to window or buffer
122  GdkDrawable *window; // win32 window
123  GdkDrawable *buffer; // pixmap used for double buffer
124  UInt_t width; // width of the window
125  UInt_t height; // height of the window
126  Int_t clip; // 1 if the clipping is on
127  Int_t xclip; // x coordinate of the clipping rectangle
128  Int_t yclip; // y coordinate of the clipping rectangle
129  UInt_t wclip; // width of the clipping rectangle
130  UInt_t hclip; // height of the clipping rectangle
131  ULong_t *new_colors; // new image colors (after processing)
132  Int_t ncolors; // number of different colors
133 };
134 
135 
136 /////////////////////////////////// globals //////////////////////////////////
138 
139 namespace {
140 /////////////////////////////////// globals //////////////////////////////////
141 
142 GdkAtom gClipboardAtom = GDK_NONE;
143 static XWindow_t *gCws; // gCws: pointer to the current window
144 static XWindow_t *gTws; // gTws: temporary pointer
145 
146 //
147 // gColors[0] : background also used for b/w screen
148 // gColors[1] : foreground also used for b/w screen
149 // gColors[2..kMAXCOL-1]: colors which can be set by SetColor
150 //
151 const Int_t kBIGGEST_RGB_VALUE = 65535;
152 //const Int_t kMAXCOL = 1000;
153 //static struct {
154 // Int_t defined;
155 // GdkColor color;
156 //} gColors[kMAXCOL];
157 
158 //
159 // Primitives Graphic Contexts global for all windows
160 //
161 const int kMAXGC = 7;
162 static GdkGC *gGClist[kMAXGC];
163 static GdkGC *gGCline; // = gGClist[0]; // PolyLines
164 static GdkGC *gGCmark; // = gGClist[1]; // PolyMarker
165 static GdkGC *gGCfill; // = gGClist[2]; // Fill areas
166 static GdkGC *gGCtext; // = gGClist[3]; // Text
167 static GdkGC *gGCinvt; // = gGClist[4]; // Inverse text
168 static GdkGC *gGCdash; // = gGClist[5]; // Dashed lines
169 static GdkGC *gGCpxmp; // = gGClist[6]; // Pixmap management
170 
171 static GdkGC *gGCecho; // Input echo
172 
173 static Int_t gFillHollow; // Flag if fill style is hollow
174 static GdkPixmap *gFillPattern; // Fill pattern
175 
176 //
177 // Text management
178 //
179 static char *gTextFont = "arial.ttf"; // Current font
180 
181 //
182 // Markers
183 //
184 const Int_t kMAXMK = 100;
185 static struct {
186  int type;
187  int n;
188  GdkPoint xy[kMAXMK];
189 } gMarker; // Point list to draw marker
190 
191 //
192 // Keep style values for line GdkGC
193 //
194 static int gLineStyle = GDK_LINE_SOLID;
195 static int gCapStyle = GDK_CAP_BUTT;
196 static int gJoinStyle = GDK_JOIN_MITER;
197 static char gDashList[10];
198 static int gDashLength = 0;
199 static int gDashOffset = 0;
200 static int gDashSize = 0;
201 
202 //
203 // Event masks
204 //
205 static ULong_t gMouseMask =
206  GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK
207  | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK
208  | GDK_KEY_RELEASE_MASK;
209 static ULong_t gKeybdMask =
210  GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK |
211  GDK_LEAVE_NOTIFY_MASK;
212 
213 //
214 // Data to create an invisible cursor
215 //
216 const char null_cursor_bits[] = {
217  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
219  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
220 };
221 static GdkCursor *gNullCursor;
222 
223 static bool gdk_initialized = false;
224 
225 //---- MWM Hints stuff
226 
227 struct MWMHintsProperty_t {
228  Handle_t fFlags;
229  Handle_t fFunctions;
230  Handle_t fDecorations;
231  Int_t fInputMode;
232 };
233 
234 //---- hints
235 
236 const ULong_t kMWMHintsFunctions = BIT(0);
237 const ULong_t kMWMHintsDecorations = BIT(1);
238 const ULong_t kMWMHintsInputMode = BIT(2);
239 
242 
243 
244 //---- Key symbol mapping
245 
246 struct KeySymbolMap_t {
247  KeySym fXKeySym;
248  EKeySym fKeySym;
249 };
250 
251 static char *keyCodeToString[] = {
252  "", /* 0x000 */
253  "", /* 0x001, VK_LBUTTON */
254  "", /* 0x002, VK_RBUTTON */
255  "", /* 0x003, VK_CANCEL */
256  "", /* 0x004, VK_MBUTTON */
257  "", /* 0x005 */
258  "", /* 0x006 */
259  "", /* 0x007 */
260  "\015", /* 0x008, VK_BACK */
261  "\t", /* 0x009, VK_TAB */
262  "", /* 0x00A */
263  "", /* 0x00B */
264  "", /* 0x00C, VK_CLEAR */
265  "\r", /* 0x00D, VK_RETURN */
266  "", /* 0x00E */
267  "", /* 0x00F */
268  "", /* 0x010, VK_SHIFT */
269  "", /* 0x011, VK_CONTROL */
270  "", /* 0x012, VK_MENU */
271  "", /* 0x013, VK_PAUSE */
272  "", /* 0x014, VK_CAPITAL */
273  "", /* 0x015, VK_KANA */
274  "", /* 0x016 */
275  "", /* 0x017 */
276  "", /* 0x018 */
277  "", /* 0x019, VK_KANJI */
278  "", /* 0x01A */
279  "", /* 0x01B, VK_ESCAPE */
280  "", /* 0x01C, VK_CONVERT */
281  "", /* 0x01D, VK_NONCONVERT */
282  "", /* 0x01E */
283  "", /* 0x01F */
284  " ", /* 0x020, VK_SPACE */
285  "", /* 0x021, VK_PRIOR */
286  "", /* 0x022, VK_NEXT */
287  "", /* 0x023, VK_END */
288  "", /* 0x024, VK_HOME */
289  "", /* 0x025, VK_LEFT */
290  "", /* 0x026, VK_UP */
291  "", /* 0x027, VK_RIGHT */
292  "", /* 0x028, VK_DOWN */
293  "", /* 0x029, VK_SELECT */
294  "", /* 0x02A, VK_PRINT */
295  "", /* 0x02B, VK_EXECUTE */
296  "", /* 0x02C, VK_SNAPSHOT */
297  "", /* 0x02D, VK_INSERT */
298  "\037", /* 0x02E, VK_DELETE */
299  "", /* 0x02F, VK_HELP */
300 };
301 
302 //---- Mapping table of all non-trivial mappings (the ASCII keys map
303 //---- one to one so are not included)
304 
305 static KeySymbolMap_t gKeyMap[] = {
306  {GDK_Escape, kKey_Escape},
307  {GDK_Tab, kKey_Tab},
308 #ifndef GDK_ISO_Left_Tab
309  {0xFE20, kKey_Backtab},
310 #else
311  {GDK_ISO_Left_Tab, kKey_Backtab},
312 #endif
313  {GDK_BackSpace, kKey_Backspace},
314  {GDK_Return, kKey_Return},
315  {GDK_Insert, kKey_Insert},
316  {GDK_Delete, kKey_Delete},
317  {GDK_Clear, kKey_Delete},
318  {GDK_Pause, kKey_Pause},
319  {GDK_Print, kKey_Print},
320  {0x1005FF60, kKey_SysReq}, // hardcoded Sun SysReq
321  {0x1007ff00, kKey_SysReq}, // hardcoded X386 SysReq
322  {GDK_Home, kKey_Home}, // cursor movement
323  {GDK_End, kKey_End},
324  {GDK_Left, kKey_Left},
325  {GDK_Up, kKey_Up},
326  {GDK_Right, kKey_Right},
327  {GDK_Down, kKey_Down},
328  {GDK_Prior, kKey_Prior},
329  {GDK_Next, kKey_Next},
330  {GDK_Shift_L, kKey_Shift}, // modifiers
331  {GDK_Shift_R, kKey_Shift},
332  {GDK_Shift_Lock, kKey_Shift},
333  {GDK_Control_L, kKey_Control},
334  {GDK_Control_R, kKey_Control},
335  {GDK_Meta_L, kKey_Meta},
336  {GDK_Meta_R, kKey_Meta},
337  {GDK_Alt_L, kKey_Alt},
338  {GDK_Alt_R, kKey_Alt},
339  {GDK_Caps_Lock, kKey_CapsLock},
340  {GDK_Num_Lock, kKey_NumLock},
341  {GDK_Scroll_Lock, kKey_ScrollLock},
342  {GDK_KP_Space, kKey_Space}, // numeric keypad
343  {GDK_KP_Tab, kKey_Tab},
344  {GDK_KP_Enter, kKey_Enter},
345  {GDK_KP_Equal, kKey_Equal},
346  {GDK_KP_Multiply, kKey_Asterisk},
347  {GDK_KP_Add, kKey_Plus},
348  {GDK_KP_Separator, kKey_Comma},
349  {GDK_KP_Subtract, kKey_Minus},
350  {GDK_KP_Decimal, kKey_Period},
351  {GDK_KP_Divide, kKey_Slash},
352  {0, (EKeySym) 0}
353 };
354 
355 
356 /////////////////////static auxilary functions /////////////////////////////////
357 ////////////////////////////////////////////////////////////////////////////////
358 
359 static Int_t _lookup_string(Event_t * event, char *buf, Int_t buflen)
360 {
361  int i;
362  int n = event->fUser[1];
363  if (n > 0) {
364  for (i = 0; i < n; i++) {
365  buf[i] = event->fUser[2 + i];
366  }
367  buf[n] = 0;
368  } else {
369  buf[0] = 0;
370  }
371  if (event->fCode <= 0x20) {
372  strncpy(buf, keyCodeToString[event->fCode], buflen - 1);
373  }
374  return n;
375 }
376 
377 ////////////////////////////////////////////////////////////////////////////////
378 
379 inline void SplitLong(Long_t ll, Long_t & i1, Long_t & i2)
380 {
381  union {
382  Long_t l;
383  Int_t i[2];
384  } conv;
385 
386  conv.l = 0L;
387  conv.i[0] = 0;
388  conv.i[1] = 0;
389 
390  conv.l = ll;
391  i1 = conv.i[0];
392  i2 = conv.i[1];
393 }
394 
395 ////////////////////////////////////////////////////////////////////////////////
396 
397 inline void AsmLong(Long_t i1, Long_t i2, Long_t & ll)
398 {
399  union {
400  Long_t l;
401  Int_t i[2];
402  } conv;
403 
404  conv.i[0] = (Int_t) i1;
405  conv.i[1] = (Int_t) i2;
406  ll = conv.l;
407 }
408 
409 ////////////////////////////////////////////////////////////////////////////////
410 /// Make sure the child window is visible.
411 
412 static BOOL CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam)
413 {
414  ::ShowWindow(hwndChild, SW_SHOWNORMAL);
415  GdkWindow *child = gdk_window_lookup(hwndChild);
416  if (child)
417  ((GdkWindowPrivate *) child)->mapped = TRUE;
418  return TRUE;
419 }
420 
421 ////////////////////////////////////////////////////////////////////////////////
422 
423 static void _ChangeProperty(HWND w, char *np, char *dp, int n, Atom_t type)
424 {
425  HGLOBAL hMem;
426  char *p;
427 
428  hMem = ::GetProp(w, np);
429  if (hMem != NULL) {
430  ::GlobalFree(hMem);
431  }
432  hMem = ::GlobalAlloc(GHND, n + sizeof(Atom_t));
433  p = (char *) ::GlobalLock(hMem);
434  memcpy(p, &type, sizeof(Atom_t));
435  memcpy(p + sizeof(Atom_t), dp, n);
436  ::GlobalUnlock(hMem);
437  ::SetProp(w, np, hMem);
438  ::GlobalFree(hMem);
439 }
440 
441 ////////////////////////////////////////////////////////////////////////////////
442 ///
443 
444 static void W32ChangeProperty(HWND w, Atom_t property, Atom_t type,
445  int format, int mode, const unsigned char *data,
446  int nelements)
447 {
448  char *atomName;
449  char buffer[256];
450  int len;
451  char propName[32];
452 
453  if (mode == GDK_PROP_MODE_REPLACE || mode == GDK_PROP_MODE_PREPEND) {
454  len = (int) ::GlobalGetAtomName(property, buffer, sizeof(buffer));
455  if ((atomName = (char *) malloc(len + 1)) == NULL) {
456  return;
457  } else {
458  strcpy(atomName, buffer);
459  }
460  sprintf(propName, "#0x%0.4x", atomName);
461  _ChangeProperty(w, propName, (char *) data, nelements, type);
462  free(atomName);
463  }
464 }
465 
466 ////////////////////////////////////////////////////////////////////////////////
467 ///
468 
469 static int _GetWindowProperty(GdkWindow * id, Atom_t property, Long_t long_offset,
470  Long_t long_length, Bool_t delete_it, Atom_t req_type,
471  Atom_t * actual_type_return,
472  Int_t * actual_format_return, ULong_t * nitems_return,
473  ULong_t * bytes_after_return, UChar_t ** prop_return)
474 {
475  if (!id) return 0;
476 
477  char *data, *destPtr;
478  char propName[32];
479  HGLOBAL handle;
480  HWND w;
481 
482  w = (HWND) GDK_DRAWABLE_XID(id);
483 
484  if (::IsClipboardFormatAvailable(CF_TEXT) && ::OpenClipboard(NULL)) {
485  handle = ::GetClipboardData(CF_TEXT);
486  if (handle != NULL) {
487  data = (char *) ::GlobalLock(handle);
488  *nitems_return = strlen(data);
489  *prop_return = (UChar_t *) malloc(*nitems_return + 1);
490  destPtr = (char *) *prop_return;
491  while (*data != '\0') {
492  if (*data != '\r') {
493  *destPtr = *data;
494  destPtr++;
495  }
496  data++;
497  }
498  *destPtr = '\0';
499  ::GlobalUnlock(handle);
500  *actual_type_return = XA_STRING;
501  *bytes_after_return = 0;
502  }
503  ::CloseClipboard();
504  return 1;
505  }
506  if (delete_it) {
507  ::RemoveProp(w, propName);
508  }
509  return 1;
510 }
511 
512 ////////////////////////////////////////////////////////////////////////////////
513 ///
514 
515 static ULong_t GetPixelImage(Drawable_t id, Int_t x, Int_t y)
516 {
517  if (!id) return 0;
518 
519  GdkImage *image = (GdkImage *)id;
520  ULong_t pixel;
521 
522  if (image->depth == 1) {
523  pixel = (((char *) image->mem)[y * image->bpl + (x >> 3)] & (1 << (7 - (x & 0x7)))) != 0;
524  } else {
525  UChar_t *pixelp = (UChar_t *) image->mem + y * image->bpl + x * image->bpp;
526  switch (image->bpp) {
527  case 1:
528  pixel = *pixelp;
529  break;
530  // Windows is always LSB, no need to check image->byte_order.
531  case 2:
532  pixel = pixelp[0] | (pixelp[1] << 8);
533  break;
534  case 3:
535  pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
536  break;
537  case 4:
538  pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
539  break;
540  }
541  }
542  return pixel;
543 }
544 
545 ////////////////////////////////////////////////////////////////////////////////
546 /// Collect in orgcolors all different original image colors.
547 
548 static void CollectImageColors(ULong_t pixel, ULong_t * &orgcolors,
549  Int_t & ncolors, Int_t & maxcolors)
550 {
551  if (maxcolors == 0) {
552  ncolors = 0;
553  maxcolors = 100;
554  orgcolors = (ULong_t*) ::operator new(maxcolors*sizeof(ULong_t));
555  }
556 
557  for (int i = 0; i < ncolors; i++) {
558  if (pixel == orgcolors[i]) return;
559  }
560  if (ncolors >= maxcolors) {
561  orgcolors = (ULong_t *) TStorage::ReAlloc(orgcolors,
562  maxcolors * 2 *
563  sizeof(ULong_t),
564  maxcolors *
565  sizeof(ULong_t));
566  maxcolors *= 2;
567  }
568  orgcolors[ncolors++] = pixel;
569 }
570 
571 ////////////////////////////////////////////////////////////////////////////////
572 /// debug function for printing event mask
573 
574 static char *EventMask2String(UInt_t evmask)
575 {
576  static char bfr[500];
577  char *p = bfr;
578 
579  *p = '\0';
580 #define BITmask(x) \
581  if (evmask & k##x##Mask) \
582  p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
583  BITmask(Exposure);
584  BITmask(PointerMotion);
585  BITmask(ButtonMotion);
586  BITmask(ButtonPress);
587  BITmask(ButtonRelease);
588  BITmask(KeyPress);
589  BITmask(KeyRelease);
590  BITmask(EnterWindow);
591  BITmask(LeaveWindow);
592  BITmask(FocusChange);
593  BITmask(StructureNotify);
594 #undef BITmask
595 
596  return bfr;
597 }
598 
599 ///////////////////////////////////////////////////////////////////////////////
600 class TGWin32MainThread {
601 
602 public:
603  void *fHandle; // handle of server (aka command) thread
604  DWORD fId; // id of server (aka command) thread
605  static LPCRITICAL_SECTION fCritSec; // general mutex
606  static LPCRITICAL_SECTION fMessageMutex; // message queue mutex
607 
608  TGWin32MainThread();
609  ~TGWin32MainThread();
610  static void LockMSG();
611  static void UnlockMSG();
612 };
613 
614 TGWin32MainThread *gMainThread = 0;
615 LPCRITICAL_SECTION TGWin32MainThread::fCritSec = 0;
616 LPCRITICAL_SECTION TGWin32MainThread::fMessageMutex = 0;
617 
618 
619 ////////////////////////////////////////////////////////////////////////////////
620 /// dtor
621 
622 TGWin32MainThread::~TGWin32MainThread()
623 {
624  if (fCritSec) {
625  ::LeaveCriticalSection(fCritSec);
626  ::DeleteCriticalSection(fCritSec);
627  delete fCritSec;
628  }
629  fCritSec = 0;
630 
631  if (fMessageMutex) {
632  ::LeaveCriticalSection(fMessageMutex);
633  ::DeleteCriticalSection(fMessageMutex);
634  delete fMessageMutex;
635  }
636  fMessageMutex = 0;
637 
638  if(fHandle) {
639  ::PostThreadMessage(fId, WM_QUIT, 0, 0);
640  ::CloseHandle(fHandle);
641  }
642  fHandle = 0;
643 }
644 
645 ////////////////////////////////////////////////////////////////////////////////
646 /// lock message queue
647 
648 void TGWin32MainThread::LockMSG()
649 {
650  if (fMessageMutex) ::EnterCriticalSection(fMessageMutex);
651 }
652 
653 ////////////////////////////////////////////////////////////////////////////////
654 /// unlock message queue
655 
656 void TGWin32MainThread::UnlockMSG()
657 {
658  if (fMessageMutex) ::LeaveCriticalSection(fMessageMutex);
659 }
660 
661 ///////////////////////////////////////////////////////////////////////////////
662 class TGWin32RefreshTimer : public TTimer {
663 
664 public:
665  TGWin32RefreshTimer() : TTimer(10, kTRUE) { if (gSystem) gSystem->AddTimer(this); }
666  ~TGWin32RefreshTimer() { if (gSystem) gSystem->RemoveTimer(this); }
667  Bool_t Notify()
668  {
669  Reset();
670  MSG msg;
671 
672  while (::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE)) {
673  ::PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE);
674  if (!gVirtualX)
675  Sleep(200); // avoid start-up race
676  if (gVirtualX)
677  ((TGWin32*)gVirtualX)->GUIThreadMessageFunc(&msg);
678  }
679  return kFALSE;
680  }
681 };
682 /*
683 ////////////////////////////////////////////////////////////////////////////////
684 /// thread for processing windows messages (aka Main/Server thread)
685 
686 static DWORD WINAPI MessageProcessingLoop(void *p)
687 {
688  MSG msg;
689  Int_t erret;
690  Bool_t endLoop = kFALSE;
691  TGWin32RefreshTimer *refersh = 0;
692 
693  // force to create message queue
694  ::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
695 
696  // periodically we refresh windows
697  // Don't create refresh timer if the application has been created inside PVSS
698  if (gApplication) {
699  TString arg = gSystem->BaseName(gApplication->Argv(0));
700  if (!arg.Contains("PVSS"))
701  refersh = new TGWin32RefreshTimer();
702  }
703 
704  while (!endLoop) {
705  erret = ::GetMessage(&msg, NULL, NULL, NULL);
706  if (erret <= 0) endLoop = kTRUE;
707  endLoop = MessageProcessingFunc(&msg);
708  }
709 
710  TGWin32::Instance()->CloseDisplay();
711  if (refersh)
712  delete refersh;
713 
714  // exit thread
715  if (erret == -1) {
716  erret = ::GetLastError();
717  Error("MsgLoop", "Error in GetMessage");
718  ::ExitThread(-1);
719  } else {
720  ::ExitThread(0);
721  }
722  return 0;
723 }
724 */
725 
726 Bool_t GUIThreadMessageWrapper(MSG* msg)
727 {
728  // Static wrapper for handling GUI messages.
729  // Forwards from TWinNTSystem's GUIThreadMessageProcessingLoop()
730  // to TGWin32::GUIThreadMessageFunc()
731 
732  return ((TGWin32*)gVirtualX)->GUIThreadMessageFunc(msg);
733 }
734 
735 ////////////////////////////////////////////////////////////////////////////////
736 /// constructor
737 
738 TGWin32MainThread::TGWin32MainThread()
739 {
740  fCritSec = new CRITICAL_SECTION;
741  ::InitializeCriticalSection(fCritSec);
742  fMessageMutex = new CRITICAL_SECTION;
743  ::InitializeCriticalSection(fMessageMutex);
744  fHandle = ((TWinNTSystem*)gSystem)->GetGUIThreadHandle();
745  fId = ((TWinNTSystem*)gSystem)->GetGUIThreadId();
746  ((TWinNTSystem*)gSystem)->SetGUIThreadMsgHandler(GUIThreadMessageWrapper);
747 }
748 
749 } // unnamed namespace
750 
751 ///////////////////////// TGWin32 implementation ///////////////////////////////
753 
754 ////////////////////////////////////////////////////////////////////////////////
755 /// Default constructor.
756 
757 TGWin32::TGWin32(): fRefreshTimer(0)
758 {
759  fScreenNumber = 0;
760  fWindows = 0;
761  fColors = 0;
762 }
763 
764 ////////////////////////////////////////////////////////////////////////////////
765 /// Normal Constructor.
766 
767 TGWin32::TGWin32(const char *name, const char *title) : TVirtualX(name,title), fRefreshTimer(0)
768 {
769  fScreenNumber = 0;
772  fTextAlignH = 1;
773  fTextAlignV = 1;
774  fTextAlign = 7;
775  fTextMagnitude = 1;
776  fCharacterUpX = 1;
777  fCharacterUpY = 1;
778  fDrawMode = kCopy;
779  fWindows = 0;
780  fMaxNumberOfWindows = 10;
781  fXEvent = 0;
788 
789  fWindows = (XWindow_t*) TStorage::Alloc(fMaxNumberOfWindows*sizeof(XWindow_t));
790  for (int i = 0; i < fMaxNumberOfWindows; i++) fWindows[i].open = 0;
791 
792  fColors = new TExMap;
793 
794  if (gApplication) {
796  if (!arg.Contains("PVSS"))
797  fRefreshTimer = new TGWin32RefreshTimer();
798  } else {
799  fRefreshTimer = new TGWin32RefreshTimer();
800  }
801 
802  // initialize GUI thread and proxy objects
803  if (!gROOT->IsBatch() && !gMainThread) {
804  gMainThread = new TGWin32MainThread();
805  TGWin32ProxyBase::fgMainThreadId = ::GetCurrentThreadId(); // gMainThread->fId;
808 #ifdef OLD_THREAD_IMPLEMENTATION
809  gPtr2Interpreter = &TGWin32InterpreterProxy::ProxyObject;
810 #endif
811  }
812 }
813 
814 ////////////////////////////////////////////////////////////////////////////////
815 /// destructor.
816 
818 {
819  CloseDisplay();
820  if (fRefreshTimer)
821  delete fRefreshTimer;
822  if (!fColors) return;
823  Long64_t key, value;
824  TExMapIter it(fColors);
825  while (it.Next(key, value)) {
826  XColor_t *col = (XColor_t *) value;
827  delete col;
828  }
829  delete fColors;
830 }
831 
832 ////////////////////////////////////////////////////////////////////////////////
833 /// Windows timer handling events while moving/resizing windows
834 
835 VOID CALLBACK MyTimerProc(HWND hwnd, UINT message, UINT idTimer, DWORD dwTime)
836 {
838  //gVirtualX->UpdateWindow(1); // cause problems with OpenGL in pad...
839 }
840 
841 ////////////////////////////////////////////////////////////////////////////////
842 /// Message processing function for the GUI thread.
843 /// Kicks in once TGWin32 becomes active, and "replaces" the dummy one
844 /// in TWinNTSystem; see TWinNTSystem.cxx's GUIThreadMessageProcessingLoop().
845 
847 {
848  Bool_t ret = kFALSE;
849  static Int_t m_timer = 0;
850 
851  if ( (msg->message == WM_NCLBUTTONDOWN) ) {
852  if (m_timer == 0)
853  m_timer = SetTimer(NULL, 1, 20, (TIMERPROC) MyTimerProc);
854  }
855  else if (msg->message == WM_NCMOUSELEAVE ) {
856  if (m_timer) {
857  KillTimer(NULL, m_timer);
858  }
859  m_timer = 0;
860  }
861 
862  if (msg->message == TGWin32ProxyBase::fgPostMessageId) {
863  if (msg->wParam) {
864  TGWin32ProxyBase *proxy = (TGWin32ProxyBase*)msg->wParam;
865  proxy->ExecuteCallBack(kTRUE);
866  } else {
867  ret = kTRUE;
868  }
869  } else if (msg->message == TGWin32ProxyBase::fgPingMessageId) {
871  } else {
872  //if ( (msg->message >= WM_NCMOUSEMOVE) &&
873  // (msg->message <= WM_NCMBUTTONDBLCLK) ) {
874  // TGWin32ProxyBase::GlobalLock();
875  //}
876  TGWin32MainThread::LockMSG();
877  TranslateMessage(msg);
878  DispatchMessage(msg);
879  TGWin32MainThread::UnlockMSG();
880  }
881  return ret;
882 }
883 
884 ////////////////////////////////////////////////////////////////////////////////
885 /// returns kTRUE if we are inside cmd/server thread
886 
888 {
889 #ifdef OLD_THREAD_IMPLEMENTATION
890  return ((::GetCurrentThreadId() == TGWin32ProxyBase::fgMainThreadId) ||
891  (::GetCurrentThreadId() == TGWin32ProxyBase::fgUserThreadId));
892 #else
893  return kTRUE;
894 #endif
895 }
896 
897 ////////////////////////////////////////////////////////////////////////////////
898 /// close display (terminate server/gMainThread thread)
899 
901 {
902  // disable any processing while exiting
904 
905  // terminate server thread
906  gPtr2VirtualX = 0;
907 #if ROOT_VERSION_CODE < ROOT_VERSION(6,00,00)
908  gPtr2Interpreter = 0;
909 #endif
911  // Following the change in revision 47611,
912  // gInterpreter is a read-only variable but its value
913  // is overridden by gPtr2Interpreter when it is not null.
914  // gInterpreter = TGWin32InterpreterProxy::RealObject();
915 
916  // The lock above does not work, so at least
917  // minimize the risk
918  TGWin32MainThread *delThread = gMainThread;
919  if (gMainThread) {
920  gMainThread = 0;
921  delete delThread;
922  }
923 
925 
926  // terminate ROOT logo splash thread
927  TWin32SplashThread *delSplash = gSplash;
928  if (gSplash) {
929  gSplash = 0;
930  delete delSplash;
931  }
932 
934  fWindows = 0;
935 
936  if (fXEvent) gdk_event_free((GdkEvent*)fXEvent);
937 
939 
940  gROOT->SetBatch(kTRUE); // no GUI is possible
941 }
942 
943 ////////////////////////////////////////////////////////////////////////////////
944 ///
945 
947 {
948  if (gMainThread && gMainThread->fCritSec) ::EnterCriticalSection(gMainThread->fCritSec);
949 }
950 
951 ////////////////////////////////////////////////////////////////////////////////
952 ///
953 
955 {
956  if (gMainThread && gMainThread->fCritSec) ::LeaveCriticalSection(gMainThread->fCritSec);
957 }
958 
959 ////////////////////////////////////////////////////////////////////////////////
960 /// Initialize Win32 system. Returns kFALSE in case of failure.
961 
962 Bool_t TGWin32::Init(void *display)
963 {
964  if (!gdk_initialized) {
965  if (!gdk_init_check(NULL, NULL)) return kFALSE;
966  gdk_initialized = true;
967  }
968 
969  if (!gClipboardAtom) {
970  gClipboardAtom = gdk_atom_intern("CLIPBOARD", kFALSE);
971  }
972 
973  return kTRUE;
974 }
975 
976 ////////////////////////////////////////////////////////////////////////////////
977 /// Open the display. Return -1 if the opening fails, 0 when ok.
978 
979 Int_t TGWin32::OpenDisplay(const char *dpyName)
980 {
981  GdkPixmap *pixmp1, *pixmp2;
982  GdkColor fore, back;
983  GdkColor color;
984  GdkGCValues gcvals;
985  int i;
986 
987  if (!Init((void*)dpyName)) {
988  return -1;
989  }
990 
991  if (gDebug <= 4) {
993  } else {
994  gdk_debug_level = 0;
995  }
996 
997  fore.red = fore.green = fore.blue = 0;
998  back.red = back.green = back.blue = 0;
999  color.red = color.green = color.blue = 0;
1000 
1001  fScreenNumber = 0; //DefaultScreen(fDisplay);
1002  fVisual = gdk_visual_get_best();
1003  fColormap = gdk_colormap_get_system();
1004  fDepth = gdk_visual_get_best_depth();
1005 
1006  GetColor(1).fDefined = kTRUE; // default foreground
1007  gdk_color_black((GdkColormap *)fColormap, &GetColor(1).color);
1008 
1009  GetColor(0).fDefined = kTRUE; // default background
1010  gdk_color_white((GdkColormap *)fColormap, &GetColor(0).color);
1011 
1012  // Create primitives graphic contexts
1013  for (i = 0; i < kMAXGC; i++) {
1014  gGClist[i] = gdk_gc_new(GDK_ROOT_PARENT());
1015  gdk_gc_set_foreground(gGClist[i], &GetColor(1).color);
1016  gdk_gc_set_background(gGClist[i], &GetColor(0).color);
1017  }
1018 
1019  gGCline = gGClist[0]; // PolyLines
1020  gGCmark = gGClist[1]; // PolyMarker
1021  gGCfill = gGClist[2]; // Fill areas
1022  gGCtext = gGClist[3]; // Text
1023  gGCinvt = gGClist[4]; // Inverse text
1024  gGCdash = gGClist[5]; // Dashed lines
1025  gGCpxmp = gGClist[6]; // Pixmap management
1026 
1027  gdk_gc_get_values(gGCtext, &gcvals);
1028  gdk_gc_set_foreground(gGCinvt, &gcvals.background);
1029  gdk_gc_set_background(gGCinvt, &gcvals.foreground);
1030 
1031  // Create input echo graphic context
1032  GdkGCValues echov;
1033  gdk_color_black(fColormap, &echov.foreground); // = BlackPixel(fDisplay, fScreenNumber);
1034  gdk_color_white(fColormap, &echov.background); // = WhitePixel(fDisplay, fScreenNumber);
1035  echov.function = GDK_INVERT;
1036  echov.subwindow_mode = GDK_CLIP_BY_CHILDREN;
1037  gGCecho =
1038  gdk_gc_new_with_values((GdkWindow *) GDK_ROOT_PARENT(), &echov,
1039  (GdkGCValuesMask) (GDK_GC_FOREGROUND |
1040  GDK_GC_BACKGROUND |
1041  GDK_GC_FUNCTION |
1042  GDK_GC_SUBWINDOW));
1043  // Create a null cursor
1044  pixmp1 = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
1045  (const char *)null_cursor_bits, 16,16);
1046 
1047  pixmp2 = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
1048  (const char *)null_cursor_bits, 16, 16);
1049 
1050  gNullCursor = gdk_cursor_new_from_pixmap((GdkDrawable *)pixmp1, (GdkDrawable *)pixmp2,
1051  &fore, &back, 0, 0);
1052  // Create cursors
1053  if (gEnv->GetValue("Win32.UseSysPointers", 0)) {
1055  fCursors[kBottomLeft] = gdk_syscursor_new((ULong_t)IDC_SIZENESW);
1056  fCursors[kBottomRight] = gdk_syscursor_new((ULong_t)IDC_SIZENWSE);
1057  fCursors[kTopLeft] = gdk_syscursor_new((ULong_t)IDC_SIZENWSE);
1058  fCursors[kTopRight] = gdk_syscursor_new((ULong_t)IDC_SIZENESW);
1059  fCursors[kBottomSide] = gdk_syscursor_new((ULong_t)IDC_SIZENS);
1060  fCursors[kLeftSide] = gdk_syscursor_new((ULong_t)IDC_SIZEWE);
1061  fCursors[kTopSide] = gdk_syscursor_new((ULong_t)IDC_SIZENS);
1062  fCursors[kRightSide] = gdk_syscursor_new((ULong_t)IDC_SIZEWE);
1063  fCursors[kMove] = gdk_syscursor_new((ULong_t)IDC_SIZEALL);
1064  fCursors[kCross] =gdk_syscursor_new((ULong_t)IDC_CROSS);
1065  fCursors[kArrowHor] = gdk_syscursor_new((ULong_t)IDC_SIZEWE);
1066  fCursors[kArrowVer] = gdk_syscursor_new((ULong_t)IDC_SIZENS);
1067  fCursors[kHand] = gdk_syscursor_new((ULong_t)IDC_HAND);
1068  fCursors[kPointer] = gdk_syscursor_new((ULong_t)IDC_ARROW);
1069  fCursors[kCaret] = gdk_syscursor_new((ULong_t)IDC_IBEAM);
1070  fCursors[kWatch] = gdk_syscursor_new((ULong_t)IDC_WAIT);
1071  fCursors[kNoDrop] = gdk_syscursor_new((ULong_t)IDC_NO);
1072  }
1073  else {
1075  fCursors[kBottomLeft] = gdk_cursor_new(GDK_BOTTOM_LEFT_CORNER);
1076  fCursors[kBottomRight] = gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER);
1077  fCursors[kTopLeft] = gdk_cursor_new(GDK_TOP_LEFT_CORNER);
1078  fCursors[kTopRight] = gdk_cursor_new(GDK_TOP_RIGHT_CORNER);
1079  fCursors[kBottomSide] = gdk_cursor_new(GDK_BOTTOM_SIDE);
1080  fCursors[kLeftSide] = gdk_cursor_new(GDK_LEFT_SIDE);
1081  fCursors[kTopSide] = gdk_cursor_new(GDK_TOP_SIDE);
1082  fCursors[kRightSide] = gdk_cursor_new(GDK_RIGHT_SIDE);
1083  fCursors[kMove] = gdk_cursor_new(GDK_FLEUR);
1084  fCursors[kCross] =gdk_cursor_new(GDK_CROSSHAIR);
1085  fCursors[kArrowHor] = gdk_cursor_new(GDK_SB_H_DOUBLE_ARROW);
1086  fCursors[kArrowVer] = gdk_cursor_new(GDK_SB_V_DOUBLE_ARROW);
1087  fCursors[kHand] = gdk_cursor_new(GDK_HAND2);
1088  fCursors[kPointer] = gdk_cursor_new(GDK_LEFT_PTR);
1089  fCursors[kCaret] = gdk_cursor_new(GDK_XTERM);
1090  //fCursors[kWatch] = gdk_cursor_new(GDK_WATCH);
1091  fCursors[kWatch] = gdk_cursor_new(GDK_BUSY);
1092  fCursors[kNoDrop] = gdk_cursor_new(GDK_PIRATE);
1093  }
1094  fCursors[kRotate] = gdk_cursor_new(GDK_EXCHANGE);
1095  fCursors[kArrowRight] = gdk_cursor_new(GDK_ARROW);
1096 
1097  // Setup color information
1099 
1100  if ( gdk_visual_get_best_type() == GDK_VISUAL_TRUE_COLOR) {
1101  int i;
1102  for (i = 0; i < int(sizeof(fVisual->blue_mask)*kBitsPerByte); i++) {
1103  if (fBlueShift == -1 && ((fVisual->blue_mask >> i) & 1)) {
1104  fBlueShift = i;
1105  }
1106  if ((fVisual->blue_mask >> i) == 1) {
1107  fBlueDiv = sizeof(UShort_t)*kBitsPerByte - i - 1 + fBlueShift;
1108  break;
1109  }
1110  }
1111  for (i = 0; i < int(sizeof(fVisual->green_mask)*kBitsPerByte); i++) {
1112  if (fGreenShift == -1 && ((fVisual->green_mask >> i) & 1)) {
1113  fGreenShift = i;
1114  }
1115  if ((fVisual->green_mask >> i) == 1) {
1116  fGreenDiv = sizeof(UShort_t)*kBitsPerByte - i - 1 + fGreenShift;
1117  break;
1118  }
1119  }
1120  for (i = 0; i < int(sizeof(fVisual->red_mask)*kBitsPerByte); i++) {
1121  if (fRedShift == -1 && ((fVisual->red_mask >> i) & 1)) {
1122  fRedShift = i;
1123  }
1124  if ((fVisual->red_mask >> i) == 1) {
1125  fRedDiv = sizeof(UShort_t)*kBitsPerByte - i - 1 + fRedShift;
1126  break;
1127  }
1128  }
1129  }
1130 
1131  SetName("Win32TTF");
1132  SetTitle("ROOT interface to Win32 with TrueType fonts");
1133 
1134  if (!TTF::IsInitialized()) TTF::Init();
1135 
1136  if (fDepth > 8) {
1138  } else {
1140  }
1141 
1143  fHasTTFonts = kTRUE;
1144  return 0;
1145 }
1146 
1147 ////////////////////////////////////////////////////////////////////////////////
1148 /// Allocate color in colormap. If we are on an <= 8 plane machine
1149 /// we will use XAllocColor. If we are on a >= 15 (15, 16 or 24) plane
1150 /// true color machine we will calculate the pixel value using:
1151 /// for 15 and 16 bit true colors have 6 bits precision per color however
1152 /// only the 5 most significant bits are used in the color index.
1153 /// Except for 16 bits where green uses all 6 bits. I.e.:
1154 /// 15 bits = rrrrrgggggbbbbb
1155 /// 16 bits = rrrrrggggggbbbbb
1156 /// for 24 bits each r, g and b are represented by 8 bits.
1157 ///
1158 /// Since all colors are set with a max of 65535 (16 bits) per r, g, b
1159 /// we just right shift them by 10, 11 and 10 bits for 16 planes, and
1160 /// (10, 10, 10 for 15 planes) and by 8 bits for 24 planes.
1161 /// Returns kFALSE in case color allocation failed.
1162 
1163 Bool_t TGWin32::AllocColor(GdkColormap *cmap, GdkColor *color)
1164 {
1165  if (fRedDiv == -1) {
1166  if ( gdk_color_alloc((GdkColormap *)cmap, (GdkColor *)color) ) return kTRUE;
1167  } else {
1168  color->pixel = (color->red >> fRedDiv) << fRedShift |
1169  (color->green >> fGreenDiv) << fGreenShift |
1170  (color->blue >> fBlueDiv) << fBlueShift;
1171  return kTRUE;
1172  }
1173 
1174  return kFALSE;
1175 }
1176 
1177 ////////////////////////////////////////////////////////////////////////////////
1178 /// Returns the current RGB value for the pixel in the XColor structure.
1179 
1180 void TGWin32::QueryColors(GdkColormap *cmap, GdkColor *color, Int_t ncolors)
1181 {
1182  ULong_t r, g, b;
1183 
1184  if (fRedDiv == -1) {
1185  GdkColorContext *cc = gdk_color_context_new(gdk_visual_get_system(), cmap);
1186  gdk_color_context_query_colors(cc, color, ncolors);
1187  gdk_color_context_free(cc);
1188  } else {
1189  for (Int_t i = 0; i < ncolors; i++) {
1190  r = (color[i].pixel & fVisual->red_mask) >> fRedShift;
1191  color[i].red = UShort_t(r*kBIGGEST_RGB_VALUE/(fVisual->red_mask >> fRedShift));
1192 
1193  g = (color[i].pixel & fVisual->green_mask) >> fGreenShift;
1194  color[i].green = UShort_t(g*kBIGGEST_RGB_VALUE/(fVisual->green_mask >> fGreenShift));
1195 
1196  b = (color[i].pixel & fVisual->blue_mask) >> fBlueShift;
1197  color[i].blue = UShort_t(b*kBIGGEST_RGB_VALUE/(fVisual->blue_mask >> fBlueShift));
1198  }
1199  }
1200 }
1201 
1202 ////////////////////////////////////////////////////////////////////////////////
1203 /// Compute alignment variables. The alignment is done on the horizontal string
1204 /// then the rotation is applied on the alignment variables.
1205 /// SetRotation and LayoutGlyphs should have been called before.
1206 
1207 void TGWin32::Align(void)
1208 {
1209  EAlign align = (EAlign) fTextAlign;
1210 
1211  // vertical alignment
1212  if (align == kTLeft || align == kTCenter || align == kTRight) {
1213  fAlign.y = TTF::GetAscent();
1214  } else if (align == kMLeft || align == kMCenter || align == kMRight) {
1215  fAlign.y = TTF::GetAscent()/2;
1216  } else {
1217  fAlign.y = 0;
1218  }
1219  // horizontal alignment
1220  if (align == kTRight || align == kMRight || align == kBRight) {
1221  fAlign.x = TTF::GetWidth();
1222  } else if (align == kTCenter || align == kMCenter || align == kBCenter) {
1223  fAlign.x = TTF::GetWidth()/2;
1224  } else {
1225  fAlign.x = 0;
1226  }
1227 
1228  FT_Vector_Transform(&fAlign, TTF::GetRotMatrix());
1229  fAlign.x = fAlign.x >> 6;
1230  fAlign.y = fAlign.y >> 6;
1231 }
1232 
1233 ////////////////////////////////////////////////////////////////////////////////
1234 /// Draw FT_Bitmap bitmap to xim image at position bx,by using specified
1235 /// foreground color.
1236 
1237 void TGWin32::DrawImage(FT_Bitmap *source, ULong_t fore, ULong_t back,
1238  GdkImage *xim, Int_t bx, Int_t by)
1239 {
1240  UChar_t d = 0, *s = source->buffer;
1241 
1242  if (TTF::GetSmoothing()) {
1243 
1244  static GdkColor col[5];
1245  GdkColor *bcol = 0, *bc;
1246  Int_t x, y;
1247 
1248  // background kClear, i.e. transparent, we take as background color
1249  // the average of the rgb values of all pixels covered by this character
1250  if (back == (ULong_t) -1 && (UInt_t)source->width) {
1251  ULong_t r, g, b;
1252  Int_t dots, dotcnt;
1253  const Int_t maxdots = 50000;
1254 
1255  dots = Int_t(source->width * source->rows);
1256  dots = dots > maxdots ? maxdots : dots;
1257  bcol = new GdkColor[dots];
1258  if (!bcol) return;
1259 
1260  bc = bcol;
1261  dotcnt = 0;
1262  for (y = 0; y < (int) source->rows; y++) {
1263  for (x = 0; x < (int) source->width; x++, bc++) {
1264  bc->pixel = GetPixelImage((Drawable_t)xim, bx + x, by + y);
1265  if (++dotcnt >= maxdots) break;
1266  }
1267  }
1268  QueryColors(fColormap, bcol, dots);
1269  r = g = b = 0;
1270  bc = bcol;
1271  dotcnt = 0;
1272  for (y = 0; y < (int) source->rows; y++) {
1273  for (x = 0; x < (int) source->width; x++, bc++) {
1274  r += bc->red;
1275  g += bc->green;
1276  b += bc->blue;
1277  if (++dotcnt >= maxdots) break;
1278  }
1279  }
1280  if (dots != 0) {
1281  r /= dots;
1282  g /= dots;
1283  b /= dots;
1284  }
1285  bc = &col[0];
1286  if (bc->red == r && bc->green == g && bc->blue == b) {
1287  bc->pixel = back;
1288  } else {
1289  bc->pixel = ~back;
1290  bc->red = (UShort_t) r;
1291  bc->green = (UShort_t) g;
1292  bc->blue = (UShort_t) b;
1293  }
1294  }
1295  delete [] bcol;
1296 
1297  // if fore or background have changed from previous character
1298  // recalculate the 3 smooting colors (interpolation between fore-
1299  // and background colors)
1300  if (fore != col[4].pixel || back != col[0].pixel) {
1301  col[4].pixel = fore;
1302  if (back != (ULong_t) -1) {
1303  col[3].pixel = back;
1304  QueryColors(fColormap, &col[3], 2);
1305  col[0] = col[3];
1306  } else {
1307  QueryColors(fColormap, &col[4], 1);
1308  }
1309 
1310  // interpolate between fore and backgound colors
1311  for (x = 3; x > 0; x--) {
1312  col[x].red = (col[4].red *x + col[0].red *(4-x)) /4;
1313  col[x].green = (col[4].green*x + col[0].green*(4-x)) /4;
1314  col[x].blue = (col[4].blue *x + col[0].blue *(4-x)) /4;
1315  if (!AllocColor(fColormap, &col[x])) {
1316  Warning("DrawImage", "cannot allocate smoothing color");
1317  col[x].pixel = col[x+1].pixel;
1318  }
1319  }
1320  }
1321 
1322  // put smoothed character, character pixmap values are an index
1323  // into the 5 colors used for aliasing (4 = foreground, 0 = background)
1324  for (y = 0; y < (int) source->rows; y++) {
1325  for (x = 0; x < (int) source->width; x++) {
1326  d = *s++ & 0xff;
1327  d = ((d + 10) * 5) / 256;
1328  if (d > 4) d = 4;
1329  if (d && x < (int) source->width) {
1330  ULong_t p = col[d].pixel;
1331  PutPixel((Drawable_t)xim, bx + x, by + y, p);
1332  }
1333  }
1334  }
1335  } else {
1336  // no smoothing, just put character using foreground color
1337  UChar_t* row=s;
1338  for (int y = 0; y < (int) source->rows; y++) {
1339  int n = 0;
1340  s = row;
1341  for (int x = 0; x < (int) source->width; x++) {
1342  if (n == 0) d = *s++;
1343  if (TESTBIT(d,7-n)) {
1344  PutPixel((Drawable_t)xim, bx + x, by + y, fore);
1345  }
1346  if (++n == (int) kBitsPerByte) n = 0;
1347  }
1348  row += source->pitch;
1349  }
1350  }
1351 }
1352 
1353 ////////////////////////////////////////////////////////////////////////////////
1354 /// Draw text using TrueType fonts. If TrueType fonts are not available the
1355 /// text is drawn with TGWin32::DrawText.
1356 
1358  const char *text, ETextMode mode)
1359 {
1360  if (!TTF::IsInitialized()) TTF::Init();
1361  TTF::SetRotationMatrix(angle);
1362  TTF::PrepareString(text);
1364  Align();
1365  RenderString(x, y, mode);
1366 }
1367 
1368 ////////////////////////////////////////////////////////////////////////////////
1369 /// Draw text using TrueType fonts. If TrueType fonts are not available the
1370 /// text is drawn with TGWin32::DrawText.
1371 
1373  const wchar_t *text, ETextMode mode)
1374 {
1375  if (!TTF::IsInitialized()) TTF::Init();
1376  TTF::SetRotationMatrix(angle);
1377  TTF::PrepareString(text);
1379  Align();
1380  RenderString(x, y, mode);
1381 }
1382 
1383 ////////////////////////////////////////////////////////////////////////////////
1384 /// Get the background of the current window in an XImage.
1385 
1387 {
1388  Window_t cws = GetCurrentWindow();
1389  UInt_t width;
1390  UInt_t height;
1391  Int_t xy;
1392  gVirtualX->GetWindowSize(cws, xy, xy, width, height);
1393 
1394  if (x < 0) {
1395  w += x;
1396  x = 0;
1397  }
1398  if (y < 0) {
1399  h += y;
1400  y = 0;
1401  }
1402 
1403  if (x+w > width) w = width - x;
1404  if (y+h > height) h = height - y;
1405 
1406  return gdk_image_get((GdkDrawable*)cws, x, y, w, h);
1407 }
1408 
1409 ////////////////////////////////////////////////////////////////////////////////
1410 /// Test if there is really something to render
1411 
1413 {
1414  Window_t cws = GetCurrentWindow();
1415  UInt_t width;
1416  UInt_t height;
1417  Int_t xy;
1418  gVirtualX->GetWindowSize(cws, xy, xy, width, height);
1419 
1420  // If w or h is 0, very likely the string is only blank characters
1421  if ((int)w == 0 || (int)h == 0) return kFALSE;
1422 
1423  // If string falls outside window, there is probably no need to draw it.
1424  if (x + (int)w <= 0 || x >= (int)width) return kFALSE;
1425  if (y + (int)h <= 0 || y >= (int)height) return kFALSE;
1426 
1427  return kTRUE;
1428 }
1429 
1430 ////////////////////////////////////////////////////////////////////////////////
1431 /// Perform the string rendering in the pad.
1432 /// LayoutGlyphs should have been called before.
1433 
1435 {
1436  TTF::TTGlyph* glyph = TTF::GetGlyphs();
1437  GdkGCValues gcvals;
1438 
1439  // compute the size and position of the XImage that will contain the text
1440  Int_t Xoff = 0; if (TTF::GetBox().xMin < 0) Xoff = -TTF::GetBox().xMin;
1441  Int_t Yoff = 0; if (TTF::GetBox().yMin < 0) Yoff = -TTF::GetBox().yMin;
1442  Int_t w = TTF::GetBox().xMax + Xoff;
1443  Int_t h = TTF::GetBox().yMax + Yoff;
1444  Int_t x1 = x-Xoff-fAlign.x;
1445  Int_t y1 = y+Yoff+fAlign.y-h;
1446 
1447  if (!IsVisible(x1, y1, w, h)) {
1448  return;
1449  }
1450 
1451  // create the XImage that will contain the text
1452  UInt_t depth = fDepth;
1453  GdkImage *xim = gdk_image_new(GDK_IMAGE_SHARED, gdk_visual_get_best(), w, h);
1454 
1455  // use malloc since Xlib will use free() in XDestroyImage
1456 // xim->data = (char *) malloc(xim->bytes_per_line * h);
1457 // memset(xim->data, 0, xim->bytes_per_line * h);
1458 
1459  ULong_t pixel;
1460  ULong_t bg;
1461 
1462  gdk_gc_get_values((GdkGC*)GetGC(3), &gcvals);
1463 
1464  // get the background
1465  if (mode == kClear) {
1466  // if mode == kClear we need to get an image of the background
1467  GdkImage *bim = GetBackground(x1, y1, w, h);
1468  if (!bim) {
1469  Error("DrawText", "error getting background image");
1470  return;
1471  }
1472 
1473  // and copy it into the text image
1474  Int_t xo = 0, yo = 0;
1475  if (x1 < 0) xo = -x1;
1476  if (y1 < 0) yo = -y1;
1477 
1478  for (int yp = 0; yp < (int) bim->height; yp++) {
1479  for (int xp = 0; xp < (int) bim->width; xp++) {
1480  pixel = GetPixelImage((Drawable_t)bim, xp, yp);
1481  PutPixel((Drawable_t)xim, xo+xp, yo+yp, pixel);
1482  }
1483  }
1484 
1485  gdk_image_unref((GdkImage *)bim);
1486 
1487  bg = (ULong_t) -1;
1488  } else {
1489  // if mode == kOpaque its simple, we just draw the background
1490 
1491  GdkImage *bim = GetBackground(x1, y1, w, h);
1492  if (!bim) {
1493  pixel = gcvals.background.pixel;
1494  } else {
1495  pixel = GetPixelImage((Drawable_t)bim, 0, 0);
1496  }
1497  Int_t xo = 0, yo = 0;
1498  if (x1 < 0) xo = -x1;
1499  if (y1 < 0) yo = -y1;
1500 
1501  for (int yp = 0; yp < h; yp++) {
1502  for (int xp = 0; xp < (int) w; xp++) {
1503  PutPixel((Drawable_t)xim, xo+xp, yo+yp, pixel);
1504  }
1505  }
1506  if (bim) {
1507  gdk_image_unref((GdkImage *)bim);
1508  bg = (ULong_t) -1;
1509  } else {
1510  bg = pixel;
1511  }
1512  }
1513 
1514  // paint the glyphs in the XImage
1515  glyph = TTF::GetGlyphs();
1516  for (int n = 0; n < TTF::GetNumGlyphs(); n++, glyph++) {
1517  if (FT_Glyph_To_Bitmap(&glyph->fImage,
1518  TTF::GetSmoothing() ? ft_render_mode_normal
1519  : ft_render_mode_mono,
1520  0, 1 )) continue;
1521  FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph->fImage;
1522  FT_Bitmap* source = &bitmap->bitmap;
1523  Int_t bx, by;
1524 
1525  bx = bitmap->left+Xoff;
1526  by = h - bitmap->top-Yoff;
1527  DrawImage(source, gcvals.foreground.pixel, bg, xim, bx, by);
1528  }
1529 
1530  // put the Ximage on the screen
1531  Window_t cws = GetCurrentWindow();
1532  gdk_draw_image((GdkDrawable *)cws, GetGC(6), xim, 0, 0, x1, y1, w, h);
1533 
1534  gdk_image_unref(xim);
1535 }
1536 
1537 ////////////////////////////////////////////////////////////////////////////////
1538 /// Set specified font.
1539 
1541 {
1542  fTextFont = fontnumber;
1543  TTF::SetTextFont(fontnumber);
1544 }
1545 
1546 ////////////////////////////////////////////////////////////////////////////////
1547 /// Set text font to specified name.
1548 /// mode : loading flag
1549 /// mode=0 : search if the font exist (kCheck)
1550 /// mode=1 : search the font and load it if it exists (kLoad)
1551 /// font : font name
1552 ///
1553 /// Set text font to specified name. This function returns 0 if
1554 /// the specified font is found, 1 if not.
1555 
1557 {
1558  return TTF::SetTextFont(fontname);
1559 }
1560 
1561 ////////////////////////////////////////////////////////////////////////////////
1562 /// Set current text size.
1563 
1565 {
1566  fTextSize = textsize;
1567  TTF::SetTextSize(textsize);
1568 }
1569 
1570 ////////////////////////////////////////////////////////////////////////////////
1571 /// Clear current window.
1572 
1574 {
1575  if (!fWindows) return;
1576 
1577  if (!gCws->ispixmap && !gCws->double_buffer) {
1578  gdk_window_set_background(gCws->drawing, (GdkColor *) & GetColor(0).color);
1579  gdk_window_clear(gCws->drawing);
1580  GdiFlush();
1581  } else {
1582  SetColor(gGCpxmp, 0);
1583  gdk_win32_draw_rectangle(gCws->drawing, gGCpxmp, 1,
1584  0, 0, gCws->width, gCws->height);
1585  SetColor(gGCpxmp, 1);
1586  }
1587 }
1588 
1589 ////////////////////////////////////////////////////////////////////////////////
1590 /// Delete current pixmap.
1591 
1593 {
1594  CloseWindow1();
1595 }
1596 
1597 ////////////////////////////////////////////////////////////////////////////////
1598 /// Delete current window.
1599 
1601 {
1602  CloseWindow1();
1603 }
1604 
1605 ////////////////////////////////////////////////////////////////////////////////
1606 /// Delete current window.
1607 
1609 {
1610  int wid;
1611 
1612  if (gCws->ispixmap) {
1613  gdk_pixmap_unref(gCws->window);
1614  } else {
1615  gdk_window_destroy(gCws->window, kTRUE);
1616  }
1617 
1618  if (gCws->buffer) {
1619  gdk_pixmap_unref(gCws->buffer);
1620  }
1621  if (gCws->new_colors) {
1622  gdk_colormap_free_colors((GdkColormap *) fColormap,
1623  (GdkColor *)gCws->new_colors, gCws->ncolors);
1624 
1625  delete [] gCws->new_colors;
1626  gCws->new_colors = 0;
1627  }
1628 
1629  GdiFlush();
1630  gCws->open = 0;
1631 
1632  if (!fWindows) return;
1633 
1634  // make first window in list the current window
1635  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
1636  if (fWindows[wid].open) {
1637  gCws = &fWindows[wid];
1638  return;
1639  }
1640  }
1641  gCws = 0;
1642 }
1643 
1644 ////////////////////////////////////////////////////////////////////////////////
1645 /// Copy the pixmap wid at the position xpos, ypos in the current window.
1646 
1647 void TGWin32::CopyPixmap(int wid, int xpos, int ypos)
1648 {
1649  if (!fWindows) return;
1650 
1651  gTws = &fWindows[wid];
1652  gdk_window_copy_area(gCws->drawing, gGCpxmp, xpos, ypos, gTws->drawing,
1653  0, 0, gTws->width, gTws->height);
1654  GdiFlush();
1655 }
1656 
1657 ////////////////////////////////////////////////////////////////////////////////
1658 /// Draw a box.
1659 /// mode=0 hollow (kHollow)
1660 /// mode=1 solid (kSolid)
1661 
1662 void TGWin32::DrawBox(int x1, int y1, int x2, int y2, EBoxMode mode)
1663 {
1664  if (!fWindows) return;
1665 
1666  Int_t x = TMath::Min(x1, x2);
1667  Int_t y = TMath::Min(y1, y2);
1668  Int_t w = TMath::Abs(x2 - x1);
1669  Int_t h = TMath::Abs(y2 - y1);
1670 
1671  switch (mode) {
1672 
1673  case kHollow:
1676  gdk_win32_draw_rectangle(gCws->drawing, gGCline, 0, x, y, w, h);
1677  break;
1678 
1679  case kFilled:
1682  gdk_win32_draw_rectangle(gCws->drawing, gGCfill, 1, x, y, w, h);
1683  break;
1684 
1685  default:
1686  break;
1687  }
1688 }
1689 
1690 ////////////////////////////////////////////////////////////////////////////////
1691 /// Draw a cell array.
1692 /// x1,y1 : left down corner
1693 /// x2,y2 : right up corner
1694 /// nx,ny : array size
1695 /// ic : array
1696 ///
1697 /// Draw a cell array. The drawing is done with the pixel presicion
1698 /// if (X2-X1)/NX (or Y) is not a exact pixel number the position of
1699 /// the top rigth corner may be wrong.
1700 
1702  Int_t nx, Int_t ny, Int_t *ic)
1703 {
1704  int i, j, icol, ix, iy, w, h, current_icol;
1705 
1706  if (!fWindows) return;
1707 
1708  current_icol = -1;
1709  w = TMath::Max((x2 - x1) / (nx), 1);
1710  h = TMath::Max((y1 - y2) / (ny), 1);
1711  ix = x1;
1712 
1715 
1716  for (i = 0; i < nx; i++) {
1717  iy = y1 - h;
1718  for (j = 0; j < ny; j++) {
1719  icol = ic[i + (nx * j)];
1720  if (icol != current_icol) {
1721  gdk_gc_set_foreground(gGCfill, (GdkColor *) & GetColor(icol).color);
1722  current_icol = icol;
1723  }
1724 
1725  gdk_win32_draw_rectangle(gCws->drawing, gGCfill, kTRUE, ix, iy, w, h);
1726  iy = iy - h;
1727  }
1728  ix = ix + w;
1729  }
1730 }
1731 
1732 ////////////////////////////////////////////////////////////////////////////////
1733 /// Fill area described by polygon.
1734 /// n : number of points
1735 /// xy(2,n) : list of points
1736 
1738 {
1739  int i;
1740  static int lastn = 0;
1741  static GdkPoint *xy = 0;
1742 
1743  if (!fWindows) return;
1744 
1747 
1748  if (lastn!=n) {
1749  delete [] (GdkPoint *)xy;
1750  xy = new GdkPoint[n];
1751  lastn = n;
1752  }
1753  for (i = 0; i < n; i++) {
1754  xy[i].x = xyt[i].fX;
1755  xy[i].y = xyt[i].fY;
1756  }
1757 
1758  if (gFillHollow) {
1759  gdk_win32_draw_lines(gCws->drawing, gGCfill, xy, n);
1760  } else {
1761  gdk_win32_draw_polygon(gCws->drawing, gGCfill, 1, xy, n);
1762  }
1763 }
1764 
1765 ////////////////////////////////////////////////////////////////////////////////
1766 /// Draw a line.
1767 /// x1,y1 : begin of line
1768 /// x2,y2 : end of line
1769 
1770 void TGWin32::DrawLine(int x1, int y1, int x2, int y2)
1771 {
1772  if (!fWindows) return;
1773 
1776 
1777  if (gLineStyle == GDK_LINE_SOLID) {
1778  gdk_draw_line(gCws->drawing, gGCline, x1, y1, x2, y2);
1779  } else {
1780  int i;
1781  gint8 dashes[32];
1782  for (i = 0; i < gDashSize; i++) {
1783  dashes[i] = (gint8) gDashList[i];
1784  }
1785  for (i = gDashSize; i < 32; i++) {
1786  dashes[i] = (gint8) 0;
1787  }
1788  gdk_gc_set_dashes(gGCdash, gDashOffset, dashes, gDashSize);
1789  gdk_draw_line(gCws->drawing, gGCdash, x1, y1, x2, y2);
1790  }
1791 }
1792 
1793 ////////////////////////////////////////////////////////////////////////////////
1794 /// Draw a line through all points.
1795 /// n : number of points
1796 /// xy : list of points
1797 
1799 {
1800  int i;
1801 
1802  if (!fWindows) return;
1803 
1804  Point_t *xy = new Point_t[n];
1805 
1806  for (i = 0; i < n; i++) {
1807  xy[i].fX = xyt[i].fX;
1808  xy[i].fY = xyt[i].fY;
1809  }
1810 
1813 
1814  if (n > 1) {
1815  if (gLineStyle == GDK_LINE_SOLID) {
1816  gdk_win32_draw_lines(gCws->drawing, gGCline, (GdkPoint *)xy, n);
1817  } else {
1818  int i;
1819  gint8 dashes[32];
1820 
1821  for (i = 0; i < gDashSize; i++) {
1822  dashes[i] = (gint8) gDashList[i];
1823  }
1824  for (i = gDashSize; i < 32; i++) {
1825  dashes[i] = (gint8) 0;
1826  }
1827 
1828  gdk_gc_set_dashes(gGCdash, gDashOffset, dashes, gDashSize);
1829  gdk_win32_draw_lines(gCws->drawing, (GdkGC*)gGCdash, (GdkPoint *)xy, n);
1830 
1831  // calculate length of line to update dash offset
1832  for (i = 1; i < n; i++) {
1833  int dx = xy[i].fX - xy[i - 1].fX;
1834  int dy = xy[i].fY - xy[i - 1].fY;
1835 
1836  if (dx < 0) dx = -dx;
1837  if (dy < 0) dy = -dy;
1838  gDashOffset += dx > dy ? dx : dy;
1839  }
1841  }
1842  } else {
1843  gdk_win32_draw_points( gCws->drawing, gLineStyle == GDK_LINE_SOLID ?
1844  gGCline : gGCdash, (GdkPoint *)xy,1);
1845  }
1846  delete [] xy;
1847 }
1848 
1849 ////////////////////////////////////////////////////////////////////////////////
1850 /// Draw n markers with the current attributes at position x, y.
1851 /// n : number of markers to draw
1852 /// xy : x,y coordinates of markers
1853 
1855 {
1856  int i;
1857  static int lastn = 0;
1858  static GdkPoint *xy = 0;
1859 
1860  if (!fWindows) return;
1861 
1864 
1865  if (lastn!=n) {
1866  delete [] (GdkPoint *)xy;
1867  xy = new GdkPoint[n];
1868  lastn = n;
1869  }
1870 
1871  for (i = 0; i < n; i++) {
1872  xy[i].x = xyt[i].fX;
1873  xy[i].y = xyt[i].fY;
1874  }
1875 
1876  if (gMarker.n <= 0) {
1877  gdk_win32_draw_points(gCws->drawing, gGCmark, xy, n);
1878  } else {
1879  int r = gMarker.n / 2;
1880  int m;
1881 
1882  for (m = 0; m < n; m++) {
1883  int hollow = 0;
1884  switch (gMarker.type) {
1885  int i;
1886 
1887  case 0: // hollow circle
1888  gdk_win32_draw_arc(gCws->drawing, gGCmark, kFALSE, xy[m].x-r, xy[m].y-r,
1889  gMarker.n, gMarker.n, 0, 23040);
1890  break;
1891 
1892  case 1: // filled circle
1893  gdk_win32_draw_arc(gCws->drawing, gGCmark, kTRUE, xy[m].x-r, xy[m].y-r,
1894  gMarker.n, gMarker.n, 0, 23040);
1895  break;
1896 
1897  case 2: // hollow polygon
1898  hollow = 1;
1899  case 3: // filled polygon
1900  for (i = 0; i < gMarker.n; i++) {
1901  gMarker.xy[i].x += xy[m].x;
1902  gMarker.xy[i].y += xy[m].y;
1903  }
1904  if (hollow) {
1905  gdk_win32_draw_lines(gCws->drawing, gGCmark, (GdkPoint *)gMarker.xy, gMarker.n);
1906  } else {
1907  gdk_win32_draw_polygon(gCws->drawing, gGCmark, 1, (GdkPoint *)gMarker.xy, gMarker.n);
1908  }
1909  for (i = 0; i < gMarker.n; i++) {
1910  gMarker.xy[i].x -= xy[m].x;
1911  gMarker.xy[i].y -= xy[m].y;
1912  }
1913  break;
1914 
1915  case 4: // segmented line
1916  for (i = 0; i < gMarker.n; i += 2) {
1917  gdk_draw_line(gCws->drawing, gGCmark,
1918  xy[m].x + gMarker.xy[i].x,
1919  xy[m].y + gMarker.xy[i].y,
1920  xy[m].x + gMarker.xy[i + 1].x,
1921  xy[m].y + gMarker.xy[i + 1].y);
1922  }
1923  break;
1924  }
1925  }
1926  }
1927 }
1928 
1929 ////////////////////////////////////////////////////////////////////////////////
1930 /// Return character up vector.
1931 
1933 {
1934  chupx = fCharacterUpX;
1935  chupy = fCharacterUpY;
1936 }
1937 
1938 ////////////////////////////////////////////////////////////////////////////////
1939 /// Return reference to internal color structure associated
1940 /// to color index cid.
1941 
1943 {
1944  XColor_t *col = (XColor_t*) fColors->GetValue(cid);
1945  if (!col) {
1946  col = new XColor_t;
1947  fColors->Add(cid, (Long_t) col);
1948  }
1949  return *col;
1950 }
1951 
1952 ////////////////////////////////////////////////////////////////////////////////
1953 /// Return current window pointer. Protected method used by TGWin32TTF.
1954 
1956 {
1957  return (Window_t)(gCws ? gCws->drawing : 0);
1958 }
1959 
1960 ////////////////////////////////////////////////////////////////////////////////
1961 /// Return desired Graphics Context ("which" maps directly on gGCList[]).
1962 /// Protected method used by TGWin32TTF.
1963 
1964 GdkGC *TGWin32::GetGC(Int_t which) const
1965 {
1966  if (which >= kMAXGC || which < 0) {
1967  Error("GetGC", "trying to get illegal GdkGC (which = %d)", which);
1968  return 0;
1969  }
1970 
1971  return gGClist[which];
1972 }
1973 
1974 ////////////////////////////////////////////////////////////////////////////////
1975 /// Query the double buffer value for the window wid.
1976 
1978 {
1979  if (!fWindows) return 0;
1980 
1981  gTws = &fWindows[wid];
1982 
1983  if (!gTws->open) {
1984  return -1;
1985  } else {
1986  return gTws->double_buffer;
1987  }
1988 }
1989 
1990 ////////////////////////////////////////////////////////////////////////////////
1991 /// Return position and size of window wid.
1992 /// wid : window identifier
1993 /// x,y : window position (output)
1994 /// w,h : window size (output)
1995 /// if wid < 0 the size of the display is returned
1996 
1997 void TGWin32::GetGeometry(int wid, int &x, int &y, unsigned int &w,
1998  unsigned int &h)
1999 {
2000  if (!fWindows) return;
2001 
2002  if (wid < 0) {
2003  x = 0;
2004  y = 0;
2005 
2006  w = gdk_screen_width();
2007  h = gdk_screen_height();
2008  } else {
2009  int depth;
2010  int width, height;
2011 
2012  gTws = &fWindows[wid];
2013  gdk_window_get_geometry((GdkDrawable *) gTws->window, &x, &y,
2014  &width, &height, &depth);
2015 
2016  gdk_window_get_deskrelative_origin((GdkDrawable *) gTws->window, &x, &y);
2017 
2018  if (width > 0 && height > 0) {
2019  gTws->width = width;
2020  gTws->height = height;
2021  }
2022  w = gTws->width;
2023  h = gTws->height;
2024  }
2025 }
2026 
2027 ////////////////////////////////////////////////////////////////////////////////
2028 /// Return hostname on which the display is opened.
2029 
2030 const char *TGWin32::DisplayName(const char *dpyName)
2031 {
2032  return "localhost"; //return gdk_get_display();
2033 }
2034 
2035 ////////////////////////////////////////////////////////////////////////////////
2036 /// Get maximum number of planes.
2037 
2038 void TGWin32::GetPlanes(int &nplanes)
2039 {
2040  nplanes = gdk_visual_get_best_depth();
2041 }
2042 
2043 ////////////////////////////////////////////////////////////////////////////////
2044 /// Get rgb values for color "index".
2045 
2046 void TGWin32::GetRGB(int index, float &r, float &g, float &b)
2047 {
2048  if (index == 0) {
2049  r = g = b = 1.0;
2050  } else if (index == 1) {
2051  r = g = b = 0.0;
2052  } else {
2053  XColor_t &col = GetColor(index);
2054  r = ((float) col.color.red) / ((float) kBIGGEST_RGB_VALUE);
2055  g = ((float) col.color.green) / ((float) kBIGGEST_RGB_VALUE);
2056  b = ((float) col.color.blue) / ((float) kBIGGEST_RGB_VALUE);
2057  }
2058 }
2059 
2060 ////////////////////////////////////////////////////////////////////////////////
2061 /// Return the size of a character string.
2062 /// iw : text width
2063 /// ih : text height
2064 /// mess : message
2065 
2066 void TGWin32::GetTextExtent(unsigned int &w, unsigned int &h, char *mess)
2067 {
2070  TTF::GetTextExtent(w, h, mess);
2071 }
2072 
2073 ////////////////////////////////////////////////////////////////////////////////
2074 /// Return the X11 window identifier.
2075 /// wid : Workstation identifier (input)
2076 
2078 {
2079  if (!fWindows) return 0;
2080  return (Window_t) fWindows[wid].window;
2081 }
2082 
2083 ////////////////////////////////////////////////////////////////////////////////
2084 /// Move the window wid.
2085 /// wid : GdkWindow identifier.
2086 /// x : x new window position
2087 /// y : y new window position
2088 
2089 void TGWin32::MoveWindow(int wid, int x, int y)
2090 {
2091  if (!fWindows) return;
2092 
2093  gTws = &fWindows[wid];
2094  if (!gTws->open) return;
2095 
2096  gdk_window_move((GdkDrawable *) gTws->window, x, y);
2097 }
2098 
2099 ////////////////////////////////////////////////////////////////////////////////
2100 /// Open a new pixmap.
2101 /// w,h : Width and height of the pixmap.
2102 
2103 Int_t TGWin32::OpenPixmap(unsigned int w, unsigned int h)
2104 {
2105  int wval, hval;
2106  int i, wid;
2107  int ww, hh, depth;
2108  wval = w;
2109  hval = h;
2110 
2111  // Select next free window number
2112  again:
2113  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
2114  if (!fWindows[wid].open) {
2115  fWindows[wid].open = 1;
2116  gCws = &fWindows[wid];
2117  break;
2118  }
2119  }
2120  if (wid == fMaxNumberOfWindows) {
2121  int newsize = fMaxNumberOfWindows + 10;
2122  fWindows = (XWindow_t *) TStorage::ReAlloc(fWindows,
2123  newsize * sizeof(XWindow_t),
2124  fMaxNumberOfWindows *
2125  sizeof(XWindow_t));
2126 
2127  for (i = fMaxNumberOfWindows; i < newsize; i++) fWindows[i].open = 0;
2128  fMaxNumberOfWindows = newsize;
2129  goto again;
2130  }
2131 
2132  depth =gdk_visual_get_best_depth();
2133  gCws->window = (GdkPixmap *) gdk_pixmap_new(GDK_ROOT_PARENT(),wval,hval,depth);
2134  gdk_drawable_get_size((GdkDrawable *) gCws->window, &ww, &hh);
2135 
2136  for (i = 0; i < kMAXGC; i++) {
2137  gdk_gc_set_clip_mask((GdkGC *) gGClist[i], (GdkDrawable *)None);
2138  }
2139 
2140  SetColor(gGCpxmp, 0);
2141  gdk_win32_draw_rectangle(gCws->window,(GdkGC *)gGCpxmp, kTRUE,
2142  0, 0, ww, hh);
2143  SetColor(gGCpxmp, 1);
2144 
2145  // Initialise the window structure
2146  gCws->drawing = gCws->window;
2147  gCws->buffer = 0;
2148  gCws->double_buffer = 0;
2149  gCws->ispixmap = 1;
2150  gCws->clip = 0;
2151  gCws->width = wval;
2152  gCws->height = hval;
2153  gCws->new_colors = 0;
2154 
2155  return wid;
2156 }
2157 
2158 ////////////////////////////////////////////////////////////////////////////////
2159 /// Open window and return window number.
2160 /// Return -1 if window initialization fails.
2161 
2163 {
2164  GdkWindowAttr attributes;
2165  unsigned long attr_mask = 0;
2166  int wid;
2167  int xval, yval;
2168  int wval, hval, depth;
2169 
2170  GdkWindow *wind = (GdkWindow *) win;
2171 
2172  gdk_window_get_geometry(wind, &xval, &yval, &wval, &hval, &depth);
2173 
2174  // Select next free window number
2175 
2176  again:
2177  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
2178  if (!fWindows[wid].open) {
2179  fWindows[wid].open = 1;
2180  fWindows[wid].double_buffer = 0;
2181  gCws = &fWindows[wid];
2182  break;
2183  }
2184  }
2185 
2186  if (wid == fMaxNumberOfWindows) {
2187  int newsize = fMaxNumberOfWindows + 10;
2188  fWindows =
2189  (XWindow_t *) TStorage::ReAlloc(fWindows,
2190  newsize * sizeof(XWindow_t),
2191  fMaxNumberOfWindows *
2192  sizeof(XWindow_t));
2193 
2194  for (int i = fMaxNumberOfWindows; i < newsize; i++) {
2195  fWindows[i].open = 0;
2196  }
2197 
2198  fMaxNumberOfWindows = newsize;
2199  goto again;
2200  }
2201  // Create window
2202  attributes.wclass = GDK_INPUT_OUTPUT;
2203  attributes.event_mask = 0L; //GDK_ALL_EVENTS_MASK;
2204  attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
2205  GDK_PROPERTY_CHANGE_MASK;
2206 // GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
2207  if (xval >= 0) {
2208  attributes.x = xval;
2209  } else {
2210  attributes.x = -1.0 * xval;
2211  }
2212 
2213  if (yval >= 0) {
2214  attributes.y = yval;
2215  } else {
2216  attributes.y = -1.0 * yval;
2217  }
2218  attributes.width = wval;
2219  attributes.height = hval;
2220  attributes.colormap = gdk_colormap_get_system();
2221  attributes.visual = gdk_window_get_visual(wind);
2222  attributes.override_redirect = TRUE;
2223 
2224  if ((attributes.y > 0) && (attributes.x > 0)) {
2225  attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP |
2226  GDK_WA_WMCLASS | GDK_WA_NOREDIR;
2227  } else {
2228  attr_mask = GDK_WA_COLORMAP | GDK_WA_WMCLASS | GDK_WA_NOREDIR;
2229  }
2230 
2231  if (attributes.visual != NULL) {
2232  attr_mask |= GDK_WA_VISUAL;
2233  }
2234  attributes.window_type = GDK_WINDOW_CHILD;
2235  gCws->window = gdk_window_new(wind, &attributes, attr_mask);
2236  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)gCws->window);
2237  ::ShowWindow(window, SW_SHOWNORMAL);
2238  ::ShowWindow(window, SW_RESTORE);
2239  ::BringWindowToTop(window);
2240 
2241  if (!fUseSysPointers) {
2242  ::SetClassLong(window, GCL_HCURSOR,
2243  (LONG)GDK_CURSOR_XID(fCursors[kPointer]));
2244  }
2245 
2246  // Initialise the window structure
2247 
2248  gCws->drawing = gCws->window;
2249  gCws->buffer = 0;
2250  gCws->double_buffer = 0;
2251  gCws->ispixmap = 0;
2252  gCws->clip = 0;
2253  gCws->width = wval;
2254  gCws->height = hval;
2255  gCws->new_colors = 0;
2256 
2257  return wid;
2258 }
2259 
2260 ////////////////////////////////////////////////////////////////////////////////
2261 /// Query pointer position.
2262 /// ix : X coordinate of pointer
2263 /// iy : Y coordinate of pointer
2264 /// (both coordinates are relative to the origin of the root window)
2265 
2266 void TGWin32::QueryPointer(int &ix, int &iy)
2267 {
2268  //GdkModifierType mask;
2269  //GdkWindow *retw = gdk_window_get_pointer((GdkWindow *) gCws->window,
2270  // &ix, &iy, &mask);
2271  POINT cpt;
2272  GetCursorPos(&cpt);
2273  ix = cpt.x;
2274  iy = cpt.y;
2275 }
2276 
2277 ////////////////////////////////////////////////////////////////////////////////
2278 /// Remove the pixmap pix.
2279 
2280 void TGWin32::RemovePixmap(GdkDrawable *pix)
2281 {
2282  gdk_pixmap_unref((GdkPixmap *)pix);
2283 }
2284 
2285 ////////////////////////////////////////////////////////////////////////////////
2286 /// Request Locator position.
2287 /// x,y : cursor position at moment of button press (output)
2288 /// ctyp : cursor type (input)
2289 /// ctyp=1 tracking cross
2290 /// ctyp=2 cross-hair
2291 /// ctyp=3 rubber circle
2292 /// ctyp=4 rubber band
2293 /// ctyp=5 rubber rectangle
2294 ///
2295 /// mode : input mode
2296 /// mode=0 request
2297 /// mode=1 sample
2298 ///
2299 /// Request locator:
2300 /// return button number 1 = left is pressed
2301 /// 2 = middle is pressed
2302 /// 3 = right is pressed
2303 /// in sample mode:
2304 /// 11 = left is released
2305 /// 12 = middle is released
2306 /// 13 = right is released
2307 /// -1 = nothing is pressed or released
2308 /// -2 = leave the window
2309 /// else = keycode (keyboard is pressed)
2310 
2312 {
2313  static int xloc = 0;
2314  static int yloc = 0;
2315  static int xlocp = 0;
2316  static int ylocp = 0;
2317  static GdkCursor *cursor = NULL;
2318  Int_t xtmp, ytmp;
2319 
2320  GdkEvent *event;
2321  int button_press;
2322  int radius;
2323 
2324  // Change the cursor shape
2325  if (cursor == NULL) {
2326  if (ctyp > 1) {
2327  gdk_window_set_cursor((GdkWindow *)gCws->window, (GdkCursor *)gNullCursor);
2328  gdk_gc_set_foreground((GdkGC *) gGCecho, &GetColor(0).color);
2329  } else {
2330  if (fUseSysPointers)
2331  cursor = gdk_syscursor_new((ULong_t)IDC_CROSS);
2332  else
2333  cursor = gdk_cursor_new((GdkCursorType)GDK_CROSSHAIR);
2334  gdk_window_set_cursor((GdkWindow *)gCws->window, (GdkCursor *)cursor);
2335  }
2336  }
2337 
2338  // Event loop
2339  button_press = 0;
2340 
2341  // Set max response time to 2 minutes to avoid timeout
2342  // in TGWin32ProxyBase::ForwardCallBack during RequestLocator
2344  while (button_press == 0) {
2345  event = gdk_event_get();
2346 
2347  switch (ctyp) {
2348 
2349  case 1:
2350  break;
2351 
2352  case 2:
2353  gdk_draw_line(gCws->window, gGCecho, xloc, 0, xloc, gCws->height);
2354  gdk_draw_line(gCws->window, gGCecho, 0, yloc, gCws->width, yloc);
2355  break;
2356 
2357  case 3:
2358  radius = (int) TMath::Sqrt((double)((xloc - xlocp) * (xloc - xlocp) +
2359  (yloc - ylocp) * (yloc - ylocp)));
2360 
2362  xlocp - radius, ylocp - radius,
2363  2 * radius, 2 * radius, 0, 23040);
2364  break;
2365 
2366  case 4:
2367  gdk_draw_line(gCws->window, gGCecho, xlocp, ylocp, xloc, yloc);
2368  break;
2369 
2370  case 5:
2372  TMath::Min(xlocp, xloc), TMath::Min(ylocp, yloc),
2373  TMath::Abs(xloc - xlocp), TMath::Abs(yloc - ylocp));
2374  break;
2375 
2376  default:
2377  break;
2378  }
2379 
2380  xloc = event->button.x;
2381  yloc = event->button.y;
2382 
2383  switch (event->type) {
2384 
2385  case GDK_LEAVE_NOTIFY:
2386  if (mode == 0) {
2387  while (1) {
2388  event = gdk_event_get();
2389 
2390  if (event->type == GDK_ENTER_NOTIFY) {
2391  gdk_event_free(event);
2392  break;
2393  }
2394  gdk_event_free(event);
2395  }
2396  } else {
2397  button_press = -2;
2398  }
2399  break;
2400 
2401  case GDK_BUTTON_PRESS:
2402  button_press = event->button.button;
2403  xlocp = event->button.x;
2404  ylocp = event->button.y;
2405  gdk_cursor_unref(cursor);
2406  cursor = 0;
2407  break;
2408 
2409  case GDK_BUTTON_RELEASE:
2410  if (mode == 1) {
2411  button_press = 10 + event->button.button;
2412  xlocp = event->button.x;
2413  ylocp = event->button.y;
2414  }
2415  break;
2416 
2417  case GDK_KEY_PRESS:
2418  if (mode == 1) {
2419  button_press = event->key.keyval;
2420  xlocp = event->button.x;
2421  ylocp = event->button.y;
2422  }
2423  break;
2424 
2425  case GDK_KEY_RELEASE:
2426  if (mode == 1) {
2427  button_press = -1 * (int)(event->key.keyval);
2428  xlocp = event->button.x;
2429  ylocp = event->button.y;
2430  }
2431  break;
2432 
2433  default:
2434  break;
2435  }
2436 
2437  xtmp = event->button.x;
2438  ytmp = event->button.y;
2439 
2440  gdk_event_free(event);
2441 
2442  if (mode == 1) {
2443  if (button_press == 0) {
2444  button_press = -1;
2445  }
2446  break;
2447  }
2448  }
2450 
2451  x = xtmp;
2452  y = ytmp;
2453 
2454  return button_press;
2455 }
2456 
2457 ////////////////////////////////////////////////////////////////////////////////
2458 /// Request a string.
2459 /// x,y : position where text is displayed
2460 /// text : text displayed (input), edited text (output)
2461 ///
2462 /// Request string:
2463 /// text is displayed and can be edited with Emacs-like keybinding
2464 /// return termination code (0 for ESC, 1 for RETURN)
2465 
2467 {
2468  static GdkCursor *cursor = NULL;
2469  static int percent = 0; // bell volume
2470  static GdkWindow *CurWnd;
2471  HWND focuswindow;
2472  GdkEvent *event;
2473  KeySym keysym;
2474  int key = -1;
2475  int len_text = strlen(text);
2476  int nt; // defined length of text
2477  int pt; // cursor position in text
2478 
2479  CurWnd = (GdkWindow *)gCws->window;
2480  // change the cursor shape
2481  if (cursor == NULL) {
2482  if (fUseSysPointers)
2483  cursor = gdk_syscursor_new((ULong_t)IDC_HELP);
2484  else
2485  cursor = gdk_cursor_new((GdkCursorType)GDK_QUESTION_ARROW);
2486  }
2487  if (cursor != 0) {
2488  gdk_window_set_cursor(CurWnd, cursor);
2489  }
2490  for (nt = len_text; nt > 0 && text[nt - 1] == ' '; nt--);
2491 
2492  pt = nt;
2493  focuswindow = ::SetFocus((HWND)GDK_DRAWABLE_XID(CurWnd));
2494 
2495  // Set max response time to 2 minutes to avoid timeout
2496  // in TGWin32ProxyBase::ForwardCallBack during RequestString
2500  do {
2501  char tmp[2];
2502  char keybuf[8];
2503  char nbytes;
2504  UInt_t dx, ddx, h;
2505  int i;
2506 
2507  if (EventsPending()) {
2508  event = gdk_event_get();
2509  } else {
2511  ::SleepEx(10, kTRUE);
2512  continue;
2513  }
2514 
2515  DrawText(x, y, 0.0, 1.0, text, kOpaque);
2516  TTF::GetTextExtent(dx, h, text);
2517  DrawText(x+dx, y, 0.0, 1.0, " ", kOpaque);
2518 
2519  if (pt == 0) {
2520  dx = 0;
2521  } else {
2522  char *stmp = new char[pt+1];
2523  strncpy(stmp, text, pt);
2524  stmp[pt] = '\0';
2525  TTF::GetTextExtent(ddx, h, stmp);
2526  dx = ddx;
2527  delete[] stmp;
2528  }
2529 
2530  if (pt < len_text) {
2531  tmp[0] = text[pt];
2532  tmp[1] = '\0';
2533  DrawText(x+dx, y, 0.0, 1.0, tmp, kOpaque);
2534  } else {
2535  DrawText(x+dx, y, 0.0, 1.0, " ", kOpaque);
2536  }
2537 
2538  if (event != NULL) {
2539  switch (event->type) {
2540  case GDK_BUTTON_PRESS:
2541  case GDK_ENTER_NOTIFY:
2542  focuswindow = ::SetFocus((HWND)GDK_DRAWABLE_XID(CurWnd));
2543  break;
2544 
2545  case GDK_LEAVE_NOTIFY:
2546  ::SetFocus(focuswindow);
2547  break;
2548  case GDK_KEY_PRESS:
2549  nbytes = event->key.length;
2550  for (i = 0; i < nbytes; i++) {
2551  keybuf[i] = event->key.string[i];
2552  }
2553  keysym = event->key.keyval;
2554  switch (keysym) { // map cursor keys
2555  case GDK_BackSpace:
2556  keybuf[0] = 0x08; // backspace
2557  nbytes = 1;
2558  break;
2559  case GDK_Return:
2560  keybuf[0] = 0x0d; // return
2561  nbytes = 1;
2562  break;
2563  case GDK_Delete:
2564  keybuf[0] = 0x7f; // del
2565  nbytes = 1;
2566  break;
2567  case GDK_Escape:
2568  keybuf[0] = 0x1b; // esc
2569  nbytes = 1;
2570  break;
2571  case GDK_Home:
2572  keybuf[0] = 0x01; // home
2573  nbytes = 1;
2574  break;
2575  case GDK_Left:
2576  keybuf[0] = 0x02; // backward
2577  nbytes = 1;
2578  break;
2579  case GDK_Right:
2580  keybuf[0] = 0x06; // forward
2581  nbytes = 1;
2582  break;
2583  case GDK_End:
2584  keybuf[0] = 0x05; // end
2585  nbytes = 1;
2586  break;
2587  }
2588  if (nbytes == 1) {
2589  if (isascii(keybuf[0]) && isprint(keybuf[0])) {
2590  // insert character
2591  if (nt < len_text) {
2592  nt++;
2593  }
2594  for (i = nt - 1; i > pt; i--) {
2595  text[i] = text[i - 1];
2596  }
2597  if (pt < len_text) {
2598  text[pt] = keybuf[0];
2599  pt++;
2600  }
2601  } else {
2602  switch (keybuf[0]) {
2603  // Emacs-like editing keys
2604 
2605  case 0x08: //'\010': // backspace
2606  case 0x7f: //'\177': // delete
2607  // delete backward
2608  if (pt > 0) {
2609  for (i = pt; i < nt; i++) {
2610  text[i - 1] = text[i];
2611  }
2612  text[nt - 1] = ' ';
2613  nt--;
2614  pt--;
2615  }
2616  break;
2617  case 0x01: //'\001': // ^A
2618  // beginning of line
2619  pt = 0;
2620  break;
2621  case 0x02: //'\002': // ^B
2622  // move backward
2623  if (pt > 0) {
2624  pt--;
2625  }
2626  break;
2627  case 0x04: //'\004': // ^D
2628  // delete forward
2629  if (pt > 0) {
2630  for (i = pt; i < nt; i++) {
2631  text[i - 1] = text[i];
2632  }
2633  text[nt - 1] = ' ';
2634  pt--;
2635  }
2636  break;
2637  case 0x05: //'\005': // ^E
2638  // end of line
2639  pt = nt;
2640  break;
2641 
2642  case 0x06: //'\006': // ^F
2643  // move forward
2644  if (pt < nt) {
2645  pt++;
2646  }
2647  break;
2648  case 0x0b: //'\013': // ^K
2649  // delete to end of line
2650  for (i = pt; i < nt; i++)
2651  text[i] = ' ';
2652  nt = pt;
2653  break;
2654  case 0x14: //'\024': // ^T
2655  // transpose
2656  if (pt > 0) {
2657  char c = text[pt];
2658  text[pt] = text[pt - 1];
2659  text[pt - 1] = c;
2660  }
2661  break;
2662  case 0x0A: //'\012': // newline
2663  case 0x0D: //'\015': // return
2664  key = 1;
2665  break;
2666  case 0x1B: //'\033': // escape
2667  key = 0;
2668  break;
2669 
2670  default:
2671  gSystem->Beep();
2672  break;
2673  }
2674  }
2675  }
2676  default:
2677  SetInputFocus((Window_t)gCws->window);
2678  break;
2679  }
2680  gdk_event_free(event);
2681  }
2682  } while (key < 0);
2684  ::SetFocus(focuswindow);
2685  SetInputFocus((Window_t)CurWnd);
2686 
2687  gdk_window_set_cursor(CurWnd, (GdkCursor *)fCursors[kPointer]);
2688  if (cursor != 0) {
2689  gdk_cursor_unref(cursor);
2690  cursor = 0;
2691  }
2692 
2693  return key;
2694 }
2695 
2696 ////////////////////////////////////////////////////////////////////////////////
2697 /// Rescale the window wid.
2698 /// wid : GdkWindow identifier
2699 /// w : Width
2700 /// h : Heigth
2701 
2702 void TGWin32::RescaleWindow(int wid, unsigned int w, unsigned int h)
2703 {
2704  int i;
2705 
2706  if (!fWindows) return;
2707 
2708  gTws = &fWindows[wid];
2709  if (!gTws->open)
2710  return;
2711 
2712  // don't do anything when size did not change
2713  if (gTws->width == w && gTws->height == h)
2714  return;
2715 
2716  gdk_window_resize((GdkWindow *) gTws->window, w, h);
2717 
2718  if (gTws->buffer) {
2719  // don't free and recreate pixmap when new pixmap is smaller
2720  if (gTws->width < w || gTws->height < h) {
2721  gdk_pixmap_unref(gTws->buffer);
2722  gTws->buffer = gdk_pixmap_new(GDK_ROOT_PARENT(), // NULL,
2723  w, h, gdk_visual_get_best_depth());
2724  }
2725  for (i = 0; i < kMAXGC; i++) {
2726  gdk_gc_set_clip_mask(gGClist[i], None);
2727  }
2728  SetColor(gGCpxmp, 0);
2729  gdk_win32_draw_rectangle(gTws->buffer, gGCpxmp, 1, 0, 0, w, h);
2730  SetColor(gGCpxmp, 1);
2731 
2732  if (gTws->double_buffer) gTws->drawing = gTws->buffer;
2733  }
2734  gTws->width = w;
2735  gTws->height = h;
2736 }
2737 
2738 ////////////////////////////////////////////////////////////////////////////////
2739 /// Resize a pixmap.
2740 /// wid : pixmap to be resized
2741 /// w,h : Width and height of the pixmap
2742 
2743 int TGWin32::ResizePixmap(int wid, unsigned int w, unsigned int h)
2744 {
2745  int wval, hval;
2746  int i;
2747  int ww, hh, depth;
2748  wval = w;
2749  hval = h;
2750 
2751  if (!fWindows) return 0;
2752 
2753  gTws = &fWindows[wid];
2754 
2755  // don't do anything when size did not change
2756  // if (gTws->width == wval && gTws->height == hval) return 0;
2757 
2758  // due to round-off errors in TPad::Resize() we might get +/- 1 pixel
2759  // change, in those cases don't resize pixmap
2760  if (gTws->width >= wval - 1 && gTws->width <= wval + 1 &&
2761  gTws->height >= hval - 1 && gTws->height <= hval + 1)
2762  return 0;
2763 
2764  // don't free and recreate pixmap when new pixmap is smaller
2765  if (gTws->width < wval || gTws->height < hval) {
2766  gdk_pixmap_unref((GdkPixmap *)gTws->window);
2767  depth = gdk_visual_get_best_depth();
2768  gTws->window = gdk_pixmap_new(GDK_ROOT_PARENT(), wval, hval, depth);
2769  }
2770 
2771  gdk_drawable_get_size(gTws->window, &ww, &hh);
2772 
2773  for (i = 0; i < kMAXGC; i++) {
2774  gdk_gc_set_clip_mask((GdkGC *) gGClist[i], (GdkDrawable *)None);
2775  }
2776 
2777  SetColor(gGCpxmp, 0);
2778  gdk_win32_draw_rectangle(gTws->window,(GdkGC *)gGCpxmp, kTRUE, 0, 0, ww, hh);
2779  SetColor(gGCpxmp, 1);
2780 
2781  // Initialise the window structure
2782  gTws->drawing = gTws->window;
2783  gTws->width = wval;
2784  gTws->height = hval;
2785  return 1;
2786 }
2787 
2788 ////////////////////////////////////////////////////////////////////////////////
2789 /// Resize the current window if necessary.
2790 
2792 {
2793  int i;
2794  int xval = 0, yval = 0;
2795  GdkWindow *win, *root = NULL;
2796  int wval = 0, hval = 0, depth = 0;
2797 
2798  if (!fWindows) return;
2799 
2800  gTws = &fWindows[wid];
2801 
2802  win = (GdkWindow *) gTws->window;
2803  gdk_window_get_geometry(win, &xval, &yval,
2804  &wval, &hval, &depth);
2805 
2806  // don't do anything when size did not change
2807  if (gTws->width == wval && gTws->height == hval) {
2808  return;
2809  }
2810 
2811  gdk_window_resize((GdkWindow *) gTws->window, wval, hval);
2812 
2813  if (gTws->buffer) {
2814  if (gTws->width < wval || gTws->height < hval) {
2815  gdk_pixmap_unref((GdkPixmap *)gTws->buffer);
2816  depth = gdk_visual_get_best_depth();
2817  gTws->buffer = (GdkPixmap *) gdk_pixmap_new(GDK_ROOT_PARENT(),
2818  wval, hval, depth);
2819  }
2820 
2821  for (i = 0; i < kMAXGC; i++) {
2822  gdk_gc_set_clip_mask((GdkGC *) gGClist[i], (GdkDrawable *)None);
2823  }
2824 
2825  SetColor(gGCpxmp, 0);
2826  gdk_win32_draw_rectangle(gTws->buffer,(GdkGC *)gGCpxmp, kTRUE, 0, 0, wval, hval);
2827 
2828  SetColor(gGCpxmp, 1);
2829 
2830  if (gTws->double_buffer) gTws->drawing = gTws->buffer;
2831  }
2832 
2833  gTws->width = wval;
2834  gTws->height = hval;
2835 }
2836 
2837 ////////////////////////////////////////////////////////////////////////////////
2838 /// Select window to which subsequent output is directed.
2839 
2841 {
2842  int i;
2843  GdkRectangle rect;
2844 
2845  if (!fWindows || wid < 0 || wid >= fMaxNumberOfWindows || !fWindows[wid].open) {
2846  return;
2847  }
2848 
2849  gCws = &fWindows[wid];
2850 
2851  if (gCws->clip && !gCws->ispixmap && !gCws->double_buffer) {
2852  rect.x = gCws->xclip;
2853  rect.y = gCws->yclip;
2854  rect.width = gCws->wclip;
2855  rect.height = gCws->hclip;
2856 
2857  for (i = 0; i < kMAXGC; i++) {
2858  gdk_gc_set_clip_rectangle((GdkGC *) gGClist[i], &rect);
2859  }
2860  } else {
2861  for (i = 0; i < kMAXGC; i++) {
2862  gdk_gc_set_clip_mask((GdkGC *) gGClist[i], (GdkDrawable *)None);
2863  }
2864  }
2865 }
2866 
2867 ////////////////////////////////////////////////////////////////////////////////
2868 /// Set character up vector.
2869 
2871 {
2872  if (chupx == fCharacterUpX && chupy == fCharacterUpY) return;
2873 
2874  if (chupx == 0 && chupy == 0) {
2875  fTextAngle = 0;
2876  } else if (chupx == 0 && chupy == 1) {
2877  fTextAngle = 0;
2878  } else if (chupx == -1 && chupy == 0) {
2879  fTextAngle = 90;
2880  } else if (chupx == 0 && chupy == -1) {
2881  fTextAngle = 180;
2882  } else if (chupx == 1 && chupy == 0) {
2883  fTextAngle = 270;
2884  } else {
2885  fTextAngle =
2886  ((TMath::
2887  ACos(chupx / TMath::Sqrt(chupx * chupx + chupy * chupy)) *
2888  180.) / 3.14159) - 90;
2889  if (chupy < 0) fTextAngle = 180 - fTextAngle;
2890  if (TMath::Abs(fTextAngle) <= 0.01) fTextAngle = 0;
2891  }
2892  fCharacterUpX = chupx;
2893  fCharacterUpY = chupy;
2894 }
2895 
2896 ////////////////////////////////////////////////////////////////////////////////
2897 /// Turn off the clipping for the window wid.
2898 
2899 void TGWin32::SetClipOFF(int wid)
2900 {
2901  if (!fWindows) return;
2902 
2903  gTws = &fWindows[wid];
2904  gTws->clip = 0;
2905 
2906  for (int i = 0; i < kMAXGC; i++) {
2907  gdk_gc_set_clip_mask((GdkGC *) gGClist[i], (GdkDrawable *)None);
2908  }
2909 }
2910 
2911 ////////////////////////////////////////////////////////////////////////////////
2912 /// Set clipping region for the window wid.
2913 /// wid : GdkWindow indentifier
2914 /// x,y : origin of clipping rectangle
2915 /// w,h : size of clipping rectangle;
2916 
2917 void TGWin32::SetClipRegion(int wid, int x, int y, unsigned int w,
2918  unsigned int h)
2919 {
2920  if (!fWindows) return;
2921 
2922  gTws = &fWindows[wid];
2923  gTws->xclip = x;
2924  gTws->yclip = y;
2925  gTws->wclip = w;
2926  gTws->hclip = h;
2927  gTws->clip = 1;
2928  GdkRectangle rect;
2929 
2930  if (gTws->clip && !gTws->ispixmap && !gTws->double_buffer) {
2931  rect.x = gTws->xclip;
2932  rect.y = gTws->yclip;
2933  rect.width = gTws->wclip;
2934  rect.height = gTws->hclip;
2935 
2936  for (int i = 0; i < kMAXGC; i++) {
2937  gdk_gc_set_clip_rectangle((GdkGC *)gGClist[i], &rect);
2938  }
2939  }
2940 }
2941 
2942 ////////////////////////////////////////////////////////////////////////////////
2943 /// Return pixel value associated to specified ROOT color number.
2944 
2946 {
2947  TColor *color = gROOT->GetColor(ci);
2948  if (color)
2949  SetRGB(ci, color->GetRed(), color->GetGreen(), color->GetBlue());
2950  XColor_t &col = GetColor(ci);
2951  return col.color.pixel;
2952 }
2953 
2954 ////////////////////////////////////////////////////////////////////////////////
2955 /// Set the foreground color in GdkGC.
2956 
2957 void TGWin32::SetColor(GdkGC *gc, int ci)
2958 {
2959  GdkGCValues gcvals;
2960  GdkColor color;
2961 
2962  if (ci<=0) ci = 10; //white
2963 
2964  TColor *clr = gROOT->GetColor(ci);
2965  if (clr)
2966  SetRGB(ci, clr->GetRed(), clr->GetGreen(), clr->GetBlue());
2967 
2968  XColor_t &col = GetColor(ci);
2969  if (fColormap && !col.fDefined) {
2970  col = GetColor(0);
2971  } else if (!fColormap && (ci < 0 || ci > 1)) {
2972  col = GetColor(0);
2973  }
2974 
2975  if (fDrawMode == kXor) {
2976  gdk_gc_get_values(gc, &gcvals);
2977 
2978  color.pixel = col.color.pixel ^ gcvals.background.pixel;
2979  color.red = GetRValue(color.pixel);
2980  color.green = GetGValue(color.pixel);
2981  color.blue = GetBValue(color.pixel);
2982  gdk_gc_set_foreground(gc, &color);
2983 
2984  } else {
2985  gdk_gc_set_foreground(gc, &col.color);
2986 
2987  // make sure that foreground and background are different
2988  gdk_gc_get_values(gc, &gcvals);
2989 
2990  if (gcvals.foreground.pixel != gcvals.background.pixel) {
2991  gdk_gc_set_background(gc, &GetColor(!ci).color);
2992  }
2993  }
2994 }
2995 
2996 ////////////////////////////////////////////////////////////////////////////////
2997 /// Set the cursor.
2998 
2999 void TGWin32::SetCursor(int wid, ECursor cursor)
3000 {
3001  if (!fWindows) return;
3002 
3003  gTws = &fWindows[wid];
3004  gdk_window_set_cursor((GdkWindow *)gTws->window, (GdkCursor *)fCursors[cursor]);
3005 }
3006 
3007 ////////////////////////////////////////////////////////////////////////////////
3008 /// Set the specified cursor.
3009 
3011 {
3012  if (!id) return;
3013 
3014  static GdkWindow *lid = 0;
3015  static GdkCursor *lcur = 0;
3016 
3017  if ((lid == (GdkWindow *)id) && (lcur==(GdkCursor *)curid)) return;
3018  lid = (GdkWindow *)id;
3019  lcur = (GdkCursor *)curid;
3020 
3021  gdk_window_set_cursor((GdkWindow *) id, (GdkCursor *)curid);
3022 }
3023 
3024 ////////////////////////////////////////////////////////////////////////////////
3025 /// Set the double buffer on/off on window wid.
3026 /// wid : GdkWindow identifier.
3027 /// 999 means all the opened windows.
3028 /// mode : 1 double buffer is on
3029 /// 0 double buffer is off
3030 
3031 void TGWin32::SetDoubleBuffer(int wid, int mode)
3032 {
3033  if (!fWindows) return;
3034 
3035  if (wid == 999) {
3036  for (int i = 0; i < fMaxNumberOfWindows; i++) {
3037  gTws = &fWindows[i];
3038  if (gTws->open) {
3039  switch (mode) {
3040  case 1:
3042  break;
3043  default:
3045  break;
3046  }
3047  }
3048  }
3049  } else {
3050  gTws = &fWindows[wid];
3051  if (!gTws->open) return;
3052 
3053  switch (mode) {
3054  case 1:
3056  return;
3057  default:
3059  return;
3060  }
3061  }
3062 }
3063 
3064 ////////////////////////////////////////////////////////////////////////////////
3065 /// Turn double buffer mode off.
3066 
3068 {
3069  if (!gTws->double_buffer) return;
3070  gTws->double_buffer = 0;
3071  gTws->drawing = gTws->window;
3072 }
3073 
3074 ////////////////////////////////////////////////////////////////////////////////
3075 /// Turn double buffer mode on.
3076 
3078 {
3079  if (!fWindows || gTws->double_buffer || gTws->ispixmap) return;
3080 
3081  if (!gTws->buffer) {
3082  gTws->buffer = gdk_pixmap_new(GDK_ROOT_PARENT(), //NULL,
3083  gTws->width, gTws->height,
3084  gdk_visual_get_best_depth());
3085  SetColor(gGCpxmp, 0);
3086  gdk_win32_draw_rectangle(gTws->buffer, gGCpxmp, 1, 0, 0, gTws->width,
3087  gTws->height);
3088  SetColor(gGCpxmp, 1);
3089  }
3090  for (int i = 0; i < kMAXGC; i++) {
3091  gdk_gc_set_clip_mask(gGClist[i], None);
3092  }
3093  gTws->double_buffer = 1;
3094  gTws->drawing = gTws->buffer;
3095 }
3096 
3097 ////////////////////////////////////////////////////////////////////////////////
3098 /// Set the drawing mode.
3099 /// mode : drawing mode
3100 /// mode=1 copy
3101 /// mode=2 xor
3102 /// mode=3 invert
3103 /// mode=4 set the suitable mode for cursor echo according to
3104 /// the vendor
3105 
3107 {
3108  int i;
3109 
3110  switch (mode) {
3111  case kCopy:
3112  for (i = 0; i < kMAXGC; i++) {
3113  gdk_gc_set_function(gGClist[i], GDK_COPY);
3114  }
3115  break;
3116 
3117  case kXor:
3118  for (i = 0; i < kMAXGC; i++) {
3119  gdk_gc_set_function(gGClist[i], GDK_XOR);
3120  }
3121  break;
3122 
3123  case kInvert:
3124  for (i = 0; i < kMAXGC; i++) {
3125  gdk_gc_set_function(gGClist[i], GDK_INVERT);
3126  }
3127  break;
3128  }
3129  fDrawMode = mode;
3130 }
3131 
3132 ////////////////////////////////////////////////////////////////////////////////
3133 /// Set color index for fill areas.
3134 
3136 {
3137  Int_t indx = Int_t(cindex);
3138 
3139  if (!gStyle->GetFillColor() && cindex > 1) {
3140  indx = 0;
3141  }
3142 
3143  fFillColor = indx;
3145 }
3146 
3147 ////////////////////////////////////////////////////////////////////////////////
3148 ///
3149 
3151 {
3152  if (fFillColor >= 0) {
3154  }
3155 
3156  // invalidate fill pattern
3157  if (gFillPattern != NULL) {
3158  gdk_pixmap_unref(gFillPattern);
3159  gFillPattern = NULL;
3160  }
3162 }
3163 
3164 ////////////////////////////////////////////////////////////////////////////////
3165 /// Set fill area style.
3166 /// fstyle : compound fill area interior style
3167 /// fstyle = 1000*interiorstyle + styleindex
3168 
3170 {
3171  if (fFillStyle==fstyle) return;
3172 
3173  fFillStyle = fstyle;
3175 }
3176 
3177 ////////////////////////////////////////////////////////////////////////////////
3178 /// Set fill area style index.
3179 
3181 {
3182  static int current_fasi = 0;
3183 
3184  Int_t style = fFillStyle / 1000;
3185  Int_t fasi = fFillStyle % 1000;
3186 
3187  switch (style) {
3188 
3189  case 1: // solid
3190  gFillHollow = 0;
3191  gdk_gc_set_fill(gGCfill, GDK_SOLID);
3192  break;
3193 
3194  case 2: // pattern
3195  gFillHollow = 1;
3196  break;
3197 
3198  case 3: // hatch
3199  gFillHollow = 0;
3200  gdk_gc_set_fill(gGCfill, GDK_STIPPLED);
3201 
3202  if (fasi != current_fasi) {
3203  if (gFillPattern != NULL) {
3204  gdk_pixmap_unref(gFillPattern);
3205  gFillPattern = NULL;
3206  }
3207  int stn = (fasi >= 1 && fasi <=25) ? fasi : 2;
3208  gFillPattern = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
3209  (const char *)gStipples[stn], 16, 16);
3210  gdk_gc_set_stipple(gGCfill, gFillPattern);
3211  current_fasi = fasi;
3212  }
3213  break;
3214 
3215  default:
3216  gFillHollow = 1;
3217  }
3218 
3220 }
3221 
3222 ////////////////////////////////////////////////////////////////////////////////
3223 /// Set input on or off.
3224 
3225 void TGWin32::SetInput(int inp)
3226 {
3227  EnableWindow((HWND) GDK_DRAWABLE_XID(gCws->window), inp);
3228 }
3229 
3230 ////////////////////////////////////////////////////////////////////////////////
3231 /// Set color index for lines.
3232 
3234 {
3235  if ((cindex < 0) || (cindex==fLineColor)) return;
3236 
3237  fLineColor = cindex;
3239 }
3240 
3241 ////////////////////////////////////////////////////////////////////////////////
3242 ///
3243 
3245 {
3249 }
3250 
3251 ////////////////////////////////////////////////////////////////////////////////
3252 /// Set line type.
3253 /// n : length of dash list
3254 /// dash(n) : dash segment lengths
3255 ///
3256 /// if n <= 0 use solid lines
3257 /// if n > 0 use dashed lines described by DASH(N)
3258 /// e.g. N=4,DASH=(6,3,1,3) gives a dashed-dotted line with dash length 6
3259 /// and a gap of 7 between dashes
3260 
3261 void TGWin32::SetLineType(int n, int *dash)
3262 {
3263  if (n <= 0) {
3264  gLineStyle = GDK_LINE_SOLID;
3265  gdk_gc_set_line_attributes(gGCline, fLineWidth,
3266  (GdkLineStyle)gLineStyle,
3267  (GdkCapStyle) gCapStyle,
3268  (GdkJoinStyle) gJoinStyle);
3269  } else {
3270  int i;
3271  gDashSize = TMath::Min((int)sizeof(gDashList),n);
3272  gDashLength = 0;
3273  for (i = 0; i < gDashSize; i++) {
3274  gDashList[i] = dash[i];
3275  gDashLength += gDashList[i];
3276  }
3277  gDashOffset = 0;
3278  gLineStyle = GDK_LINE_ON_OFF_DASH;
3279  gdk_gc_set_line_attributes(gGCdash, fLineWidth,
3280  (GdkLineStyle) gLineStyle,
3281  (GdkCapStyle) gCapStyle,
3282  (GdkJoinStyle) gJoinStyle);
3283  }
3284  fPenModified = kFALSE;
3285 }
3286 
3287 ////////////////////////////////////////////////////////////////////////////////
3288 /// Set line style.
3289 
3291 {
3292  if (fLineStyle == lstyle) return;
3293 
3294  fLineStyle = lstyle;
3295  fPenModified = kTRUE;
3296 }
3297 
3298 ////////////////////////////////////////////////////////////////////////////////
3299 /// Update line style
3300 
3302 {
3303  static Int_t dashed[2] = { 3, 3 };
3304  static Int_t dotted[2] = { 1, 2 };
3305  static Int_t dasheddotted[4] = { 3, 4, 1, 4 };
3306 
3307  if (fLineStyle <= 1) {
3308  SetLineType(0, 0);
3309  } else if (fLineStyle == 2) {
3310  SetLineType(2, dashed);
3311  } else if (fLineStyle == 3) {
3312  SetLineType(2, dotted);
3313  } else if (fLineStyle == 4) {
3314  SetLineType(4, dasheddotted);
3315  } else {
3317  TObjArray *tokens = st.Tokenize(" ");
3318  Int_t nt;
3319  nt = tokens->GetEntries();
3320  Int_t *linestyle = new Int_t[nt];
3321  for (Int_t j = 0; j<nt; j++) {
3322  Int_t it;
3323  sscanf(((TObjString*)tokens->At(j))->GetName(), "%d", &it);
3324  linestyle[j] = (Int_t)(it/4);
3325  }
3326  SetLineType(nt,linestyle);
3327  delete [] linestyle;
3328  delete tokens;
3329  }
3330  fPenModified = kFALSE;
3331 }
3332 
3333 ////////////////////////////////////////////////////////////////////////////////
3334 /// Set line width.
3335 /// width : line width in pixels
3336 
3338 {
3339  if ((fLineWidth==width) || (width<0)) return;
3340 
3341  if (width == 1) {
3342  fLineWidth = 0;
3343  } else {
3344  fLineWidth = width;
3345  }
3346 
3347  fPenModified = kTRUE;
3348 }
3349 
3350 ////////////////////////////////////////////////////////////////////////////////
3351 /// Set color index for markers.
3352 
3354 {
3355  if ((cindex<0) || (cindex==fMarkerColor)) return;
3356  fMarkerColor = cindex;
3358 }
3359 
3360 ////////////////////////////////////////////////////////////////////////////////
3361 ///
3362 
3364 {
3367 }
3368 
3369 ////////////////////////////////////////////////////////////////////////////////
3370 /// Set marker size index.
3371 /// msize : marker scale factor
3372 
3374 {
3375  if ((msize==fMarkerSize) || (msize<0)) return;
3376 
3377  fMarkerSize = msize;
3379 }
3380 
3381 ////////////////////////////////////////////////////////////////////////////////
3382 /// Set marker type.
3383 /// type : marker type
3384 /// n : length of marker description
3385 /// xy : list of points describing marker shape
3386 ///
3387 /// if n == 0 marker is a single point
3388 /// if TYPE == 0 marker is hollow circle of diameter N
3389 /// if TYPE == 1 marker is filled circle of diameter N
3390 /// if TYPE == 2 marker is a hollow polygon describe by line XY
3391 /// if TYPE == 3 marker is a filled polygon describe by line XY
3392 /// if TYPE == 4 marker is described by segmented line XY
3393 /// e.g. TYPE=4,N=4,XY=(-3,0,3,0,0,-3,0,3) sets a plus shape of 7x7 pixels
3394 
3395 void TGWin32::SetMarkerType(int type, int n, GdkPoint * xy)
3396 {
3397  gMarker.type = type;
3398  gMarker.n = n < kMAXMK ? n : kMAXMK;
3399  if (gMarker.type >= 2) {
3400  for (int i = 0; i < gMarker.n; i++) {
3401  gMarker.xy[i] = xy[i];
3402  }
3403  }
3404 }
3405 
3406 ////////////////////////////////////////////////////////////////////////////////
3407 /// Set marker style.
3408 
3410 {
3411  if ((fMarkerStyle==markerstyle) || (markerstyle >= 35)) return;
3412  fMarkerStyle = TMath::Abs(markerstyle);
3414 }
3415 
3416 ////////////////////////////////////////////////////////////////////////////////
3417 ///
3418 
3420 {
3421  static GdkPoint shape[30];
3422 
3423  Int_t im = Int_t(4 * fMarkerSize + 0.5);
3424 
3425  if (fMarkerStyle == 2) {
3426  // + shaped marker
3427  shape[0].x = -im;
3428  shape[0].y = 0;
3429  shape[1].x = im;
3430  shape[1].y = 0;
3431  shape[2].x = 0;
3432  shape[2].y = -im;
3433  shape[3].x = 0;
3434  shape[3].y = im;
3435  SetMarkerType(4, 4, shape);
3436  } else if (fMarkerStyle == 3 || fMarkerStyle == 31) {
3437  // * shaped marker
3438  shape[0].x = -im;
3439  shape[0].y = 0;
3440  shape[1].x = im;
3441  shape[1].y = 0;
3442  shape[2].x = 0;
3443  shape[2].y = -im;
3444  shape[3].x = 0;
3445  shape[3].y = im;
3446  im = Int_t(0.707 * Float_t(im) + 0.5);
3447  shape[4].x = -im;
3448  shape[4].y = -im;
3449  shape[5].x = im;
3450  shape[5].y = im;
3451  shape[6].x = -im;
3452  shape[6].y = im;
3453  shape[7].x = im;
3454  shape[7].y = -im;
3455  SetMarkerType(4, 8, shape);
3456  } else if (fMarkerStyle == 4 || fMarkerStyle == 24) {
3457  // O shaped marker
3458  SetMarkerType(0, im * 2, shape);
3459  } else if (fMarkerStyle == 5) {
3460  // X shaped marker
3461  im = Int_t(0.707 * Float_t(im) + 0.5);
3462  shape[0].x = -im;
3463  shape[0].y = -im;
3464  shape[1].x = im;
3465  shape[1].y = im;
3466  shape[2].x = -im;
3467  shape[2].y = im;
3468  shape[3].x = im;
3469  shape[3].y = -im;
3470  SetMarkerType(4, 4, shape);
3471  } else if (fMarkerStyle == 6) {
3472  // + shaped marker (with 1 pixel)
3473  shape[0].x = -1;
3474  shape[0].y = 0;
3475  shape[1].x = 1;
3476  shape[1].y = 0;
3477  shape[2].x = 0;
3478  shape[2].y = -1;
3479  shape[3].x = 0;
3480  shape[3].y = 1;
3481  SetMarkerType(4, 4, shape);
3482  } else if (fMarkerStyle == 7) {
3483  // . shaped marker (with 9 pixel)
3484  shape[0].x = -1;
3485  shape[0].y = 1;
3486  shape[1].x = 1;
3487  shape[1].y = 1;
3488  shape[2].x = -1;
3489  shape[2].y = 0;
3490  shape[3].x = 1;
3491  shape[3].y = 0;
3492  shape[4].x = -1;
3493  shape[4].y = -1;
3494  shape[5].x = 1;
3495  shape[5].y = -1;
3496  SetMarkerType(4, 6, shape);
3497  } else if (fMarkerStyle == 8 || fMarkerStyle == 20) {
3498  // O shaped marker (filled)
3499  SetMarkerType(1, im * 2, shape);
3500  } else if (fMarkerStyle == 21) {
3501  // full square
3502  shape[0].x = -im;
3503  shape[0].y = -im;
3504  shape[1].x = im;
3505  shape[1].y = -im;
3506  shape[2].x = im;
3507  shape[2].y = im;
3508  shape[3].x = -im;
3509  shape[3].y = im;
3510  shape[4].x = -im;
3511  shape[4].y = -im;
3512  SetMarkerType(3, 5, shape);
3513  } else if (fMarkerStyle == 22) {
3514  // full triangle up
3515  shape[0].x = -im;
3516  shape[0].y = im;
3517  shape[1].x = im;
3518  shape[1].y = im;
3519  shape[2].x = 0;
3520  shape[2].y = -im;
3521  shape[3].x = -im;
3522  shape[3].y = im;
3523  SetMarkerType(3, 4, shape);
3524  } else if (fMarkerStyle == 23) {
3525  // full triangle down
3526  shape[0].x = 0;
3527  shape[0].y = im;
3528  shape[1].x = im;
3529  shape[1].y = -im;
3530  shape[2].x = -im;
3531  shape[2].y = -im;
3532  shape[3].x = 0;
3533  shape[3].y = im;
3534  SetMarkerType(3, 4, shape);
3535  } else if (fMarkerStyle == 25) {
3536  // open square
3537  shape[0].x = -im;
3538  shape[0].y = -im;
3539  shape[1].x = im;
3540  shape[1].y = -im;
3541  shape[2].x = im;
3542  shape[2].y = im;
3543  shape[3].x = -im;
3544  shape[3].y = im;
3545  shape[4].x = -im;
3546  shape[4].y = -im;
3547  SetMarkerType(2, 5, shape);
3548  } else if (fMarkerStyle == 26) {
3549  // open triangle up
3550  shape[0].x = -im;
3551  shape[0].y = im;
3552  shape[1].x = im;
3553  shape[1].y = im;
3554  shape[2].x = 0;
3555  shape[2].y = -im;
3556  shape[3].x = -im;
3557  shape[3].y = im;
3558  SetMarkerType(2, 4, shape);
3559  } else if (fMarkerStyle == 27) {
3560  // open losange
3561  Int_t imx = Int_t(2.66 * fMarkerSize + 0.5);
3562  shape[0].x = -imx;
3563  shape[0].y = 0;
3564  shape[1].x = 0;
3565  shape[1].y = -im;
3566  shape[2].x = imx;
3567  shape[2].y = 0;
3568  shape[3].x = 0;
3569  shape[3].y = im;
3570  shape[4].x = -imx;
3571  shape[4].y = 0;
3572  SetMarkerType(2, 5, shape);
3573  } else if (fMarkerStyle == 28) {
3574  // open cross
3575  Int_t imx = Int_t(1.33 * fMarkerSize + 0.5);
3576  shape[0].x = -im;
3577  shape[0].y = -imx;
3578  shape[1].x = -imx;
3579  shape[1].y = -imx;
3580  shape[2].x = -imx;
3581  shape[2].y = -im;
3582  shape[3].x = imx;
3583  shape[3].y = -im;
3584  shape[4].x = imx;
3585  shape[4].y = -imx;
3586  shape[5].x = im;
3587  shape[5].y = -imx;
3588  shape[6].x = im;
3589  shape[6].y = imx;
3590  shape[7].x = imx;
3591  shape[7].y = imx;
3592  shape[8].x = imx;
3593  shape[8].y = im;
3594  shape[9].x = -imx;
3595  shape[9].y = im;
3596  shape[10].x = -imx;
3597  shape[10].y = imx;
3598  shape[11].x = -im;
3599  shape[11].y = imx;
3600  shape[12].x = -im;
3601  shape[12].y = -imx;
3602  SetMarkerType(2, 13, shape);
3603  } else if (fMarkerStyle == 29) {
3604  // full star pentagone
3605  Int_t im1 = Int_t(0.66 * fMarkerSize + 0.5);
3606  Int_t im2 = Int_t(2.00 * fMarkerSize + 0.5);
3607  Int_t im3 = Int_t(2.66 * fMarkerSize + 0.5);
3608  Int_t im4 = Int_t(1.33 * fMarkerSize + 0.5);
3609  shape[0].x = -im;
3610  shape[0].y = im4;
3611  shape[1].x = -im2;
3612  shape[1].y = -im1;
3613  shape[2].x = -im3;
3614  shape[2].y = -im;
3615  shape[3].x = 0;
3616  shape[3].y = -im2;
3617  shape[4].x = im3;
3618  shape[4].y = -im;
3619  shape[5].x = im2;
3620  shape[5].y = -im1;
3621  shape[6].x = im;
3622  shape[6].y = im4;
3623  shape[7].x = im4;
3624  shape[7].y = im4;
3625  shape[8].x = 0;
3626  shape[8].y = im;
3627  shape[9].x = -im4;
3628  shape[9].y = im4;
3629  shape[10].x = -im;
3630  shape[10].y = im4;
3631  SetMarkerType(3, 11, shape);
3632  } else if (fMarkerStyle == 30) {
3633  // open star pentagone
3634  Int_t im1 = Int_t(0.66 * fMarkerSize + 0.5);
3635  Int_t im2 = Int_t(2.00 * fMarkerSize + 0.5);
3636  Int_t im3 = Int_t(2.66 * fMarkerSize + 0.5);
3637  Int_t im4 = Int_t(1.33 * fMarkerSize + 0.5);
3638  shape[0].x = -im;
3639  shape[0].y = im4;
3640  shape[1].x = -im2;
3641  shape[1].y = -im1;
3642  shape[2].x = -im3;
3643  shape[2].y = -im;
3644  shape[3].x = 0;
3645  shape[3].y = -im2;
3646  shape[4].x = im3;
3647  shape[4].y = -im;
3648  shape[5].x = im2;
3649  shape[5].y = -im1;
3650  shape[6].x = im;
3651  shape[6].y = im4;
3652  shape[7].x = im4;
3653  shape[7].y = im4;
3654  shape[8].x = 0;
3655  shape[8].y = im;
3656  shape[9].x = -im4;
3657  shape[9].y = im4;
3658  shape[10].x = -im;
3659  shape[10].y = im4;
3660  SetMarkerType(2, 11, shape);
3661  } else if (fMarkerStyle == 32) {
3662  // open triangle down
3663  shape[0].x = 0; shape[0].y = im;
3664  shape[1].x = im; shape[1].y = -im;
3665  shape[2].x = -im; shape[2].y = -im;
3666  shape[3].x = 0; shape[3].y = im;
3667  SetMarkerType(2,4,shape);
3668  } else if (fMarkerStyle == 33) {
3669  // full losange
3670  Int_t imx = Int_t(2.66*fMarkerSize + 0.5);
3671  shape[0].x =-imx; shape[0].y = 0;
3672  shape[1].x = 0; shape[1].y = -im;
3673  shape[2].x = imx; shape[2].y = 0;
3674  shape[3].x = 0; shape[3].y = im;
3675  shape[4].x =-imx; shape[4].y = 0;
3676  SetMarkerType(3,5,shape);
3677  } else if (fMarkerStyle == 34) {
3678  // full cross
3679  Int_t imx = Int_t(1.33*fMarkerSize + 0.5);
3680  shape[0].x = -im; shape[0].y =-imx;
3681  shape[1].x =-imx; shape[1].y =-imx;
3682  shape[2].x =-imx; shape[2].y = -im;
3683  shape[3].x = imx; shape[3].y = -im;
3684  shape[4].x = imx; shape[4].y =-imx;
3685  shape[5].x = im; shape[5].y =-imx;
3686  shape[6].x = im; shape[6].y = imx;
3687  shape[7].x = imx; shape[7].y = imx;
3688  shape[8].x = imx; shape[8].y = im;
3689  shape[9].x =-imx; shape[9].y = im;
3690  shape[10].x=-imx; shape[10].y= imx;
3691  shape[11].x= -im; shape[11].y= imx;
3692  shape[12].x= -im; shape[12].y=-imx;
3693  SetMarkerType(3,13,shape);
3694  } else if (markerstyle == 35) {
3695  // square with diagonal cross
3696  shape[0].x = -im; shape[0].y = -im;
3697  shape[1].x = im; shape[1].y = -im;
3698  shape[2].x = im; shape[2].y = im;
3699  shape[3].x = -im; shape[3].y = im;
3700  shape[4].x = -im; shape[4].y = -im;
3701  shape[5].x = im; shape[5].y = im;
3702  shape[6].x = -im; shape[6].y = im;
3703  shape[7].x = im; shape[7].y = -im;
3704  SetMarkerType(2,8,shape);
3705  } else if (markerstyle == 36) {
3706  // diamond with cross
3707  shape[0].x =-im; shape[0].y = 0;
3708  shape[1].x = 0; shape[1].y = -im;
3709  shape[2].x = im; shape[2].y = 0;
3710  shape[3].x = 0; shape[3].y = im;
3711  shape[4].x =-im; shape[4].y = 0;
3712  shape[5].x = im; shape[5].y = 0;
3713  shape[6].x = 0; shape[6].y = im;
3714  shape[7].x = 0; shape[7].y =-im;
3715  SetMarkerType(2,8,shape);
3716  } else if (markerstyle == 37) {
3717  // open three triangles
3718  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3719  shape[0].x = 0; shape[0].y = 0;
3720  shape[1].x =-im2; shape[1].y = im;
3721  shape[2].x = -im; shape[2].y = 0;
3722  shape[3].x = 0; shape[3].y = 0;
3723  shape[4].x =-im2; shape[4].y = -im;
3724  shape[5].x = im2; shape[5].y = -im;
3725  shape[6].x = 0; shape[6].y = 0;
3726  shape[7].x = im; shape[7].y = 0;
3727  shape[8].x = im2; shape[8].y = im;
3728  shape[9].x = 0; shape[9].y = 0;
3729  SetMarkerType(2,10,shape);
3730  } else if (markerstyle == 38) {
3731  // + shaped marker with octagon
3732  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3733  shape[0].x = -im; shape[0].y = 0;
3734  shape[1].x = -im; shape[1].y =-im2;
3735  shape[2].x =-im2; shape[2].y =-im;
3736  shape[3].x = im2; shape[3].y = -im;
3737  shape[4].x = im; shape[4].y =-im2;
3738  shape[5].x = im; shape[5].y = im2;
3739  shape[6].x = im2; shape[6].y = im;
3740  shape[7].x =-im2; shape[7].y = im;
3741  shape[8].x = -im; shape[8].y = im2;
3742  shape[9].x = -im; shape[9].y = 0;
3743  shape[10].x = im; shape[10].y = 0;
3744  shape[11].x = 0; shape[11].y = 0;
3745  shape[12].x = 0; shape[12].y = -im;
3746  shape[13].x = 0; shape[13].y = im;
3747  shape[14].x = 0; shape[14].y = 0;
3748  SetMarkerType(2,15,shape);
3749  } else if (markerstyle == 39) {
3750  // filled three triangles
3751  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3752  shape[0].x = 0; shape[0].y = 0;
3753  shape[1].x =-im2; shape[1].y = im;
3754  shape[2].x = -im; shape[2].y = 0;
3755  shape[3].x = 0; shape[3].y = 0;
3756  shape[4].x =-im2; shape[4].y = -im;
3757  shape[5].x = im2; shape[5].y = -im;
3758  shape[6].x = 0; shape[6].y = 0;
3759  shape[7].x = im; shape[7].y = 0;
3760  shape[8].x = im2; shape[8].y = im;
3761  SetMarkerType(3,9,shape);
3762  } else if (markerstyle == 40) {
3763  // four open triangles X
3764  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3765  shape[0].x = 0; shape[0].y = 0;
3766  shape[1].x = im2; shape[1].y = im;
3767  shape[2].x = im; shape[2].y = im2;
3768  shape[3].x = 0; shape[3].y = 0;
3769  shape[4].x = im; shape[4].y = -im2;
3770  shape[5].x = im2; shape[5].y = -im;
3771  shape[6].x = 0; shape[6].y = 0;
3772  shape[7].x = -im2; shape[7].y = -im;
3773  shape[8].x = -im; shape[8].y = -im2;
3774  shape[9].x = 0; shape[9].y = 0;
3775  shape[10].x = -im; shape[10].y = im2;
3776  shape[11].x = -im2; shape[11].y = im;
3777  shape[12].x = 0; shape[12].y = 0;
3778  SetMarkerType(2,13,shape);
3779  } else if (markerstyle == 41) {
3780  // four filled triangles X
3781  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3782  shape[0].x = 0; shape[0].y = 0;
3783  shape[1].x = im2; shape[1].y = im;
3784  shape[2].x = im; shape[2].y = im2;
3785  shape[3].x = 0; shape[3].y = 0;
3786  shape[4].x = im; shape[4].y = -im2;
3787  shape[5].x = im2; shape[5].y = -im;
3788  shape[6].x = 0; shape[6].y = 0;
3789  shape[7].x = -im2; shape[7].y = -im;
3790  shape[8].x = -im; shape[8].y = -im2;
3791  shape[9].x = 0; shape[9].y = 0;
3792  shape[10].x = -im; shape[10].y = im2;
3793  shape[11].x = -im2; shape[11].y = im;
3794  shape[12].x = 0; shape[12].y = 0;
3795  SetMarkerType(3,13,shape);
3796  } else if (markerstyle == 42) {
3797  // open double diamonds
3798  Int_t imx = Int_t(fMarkerSize + 0.5);
3799  shape[0].x= 0; shape[0].y= im;
3800  shape[1].x= -imx; shape[1].y= imx;
3801  shape[2].x = -im; shape[2].y = 0;
3802  shape[3].x = -imx; shape[3].y = -imx;
3803  shape[4].x = 0; shape[4].y = -im;
3804  shape[5].x = imx; shape[5].y = -imx;
3805  shape[6].x = im; shape[6].y = 0;
3806  shape[7].x= imx; shape[7].y= imx;
3807  shape[8].x= 0; shape[8].y= im;
3808  SetMarkerType(2,9,shape);
3809  } else if (markerstyle == 43) {
3810  // filled double diamonds
3811  Int_t imx = Int_t(fMarkerSize + 0.5);
3812  shape[0].x = 0; shape[0].y = im;
3813  shape[1].x = -imx; shape[1].y = imx;
3814  shape[2].x = -im; shape[2].y = 0;
3815  shape[3].x = -imx; shape[3].y = -imx;
3816  shape[4].x = 0; shape[4].y = -im;
3817  shape[5].x = imx; shape[5].y = -imx;
3818  shape[6].x = im; shape[6].y = 0;
3819  shape[7].x = imx; shape[7].y = imx;
3820  shape[8].x = 0; shape[8].y = im;
3821  SetMarkerType(3,9,shape);
3822  } else if (markerstyle == 44) {
3823  // open four triangles plus
3824  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3825  shape[0].x = 0; shape[0].y = 0;
3826  shape[1].x = im2; shape[1].y = im;
3827  shape[2].x = -im2; shape[2].y = im;
3828  shape[3].x = im2; shape[3].y = -im;
3829  shape[4].x = -im2; shape[4].y = -im;
3830  shape[5].x = 0; shape[5].y = 0;
3831  shape[6].x = im; shape[6].y = im2;
3832  shape[7].x = im; shape[7].y = -im2;
3833  shape[8].x = -im; shape[8].y = im2;
3834  shape[9].x = -im; shape[9].y = -im2;
3835  shape[10].x = 0; shape[10].y = 0;
3836  SetMarkerType(2,11,shape);
3837  } else if (markerstyle == 45) {
3838  // filled four triangles plus
3839  Int_t im0 = Int_t(0.4*fMarkerSize + 0.5);
3840  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3841  shape[0].x = im0; shape[0].y = im0;
3842  shape[1].x = im2; shape[1].y = im;
3843  shape[2].x = -im2; shape[2].y = im;
3844  shape[3].x = -im0; shape[3].y = im0;
3845  shape[4].x = -im; shape[4].y = im2;
3846  shape[5].x = -im; shape[5].y = -im2;
3847  shape[6].x = -im0; shape[6].y = -im0;
3848  shape[7].x = -im2; shape[7].y = -im;
3849  shape[8].x = im2; shape[8].y = -im;
3850  shape[9].x = im0; shape[9].y = -im0;
3851  shape[10].x = im; shape[10].y = -im2;
3852  shape[11].x = im; shape[11].y = im2;
3853  shape[12].x = im0; shape[12].y = im0;
3854  SetMarkerType(3,13,shape);
3855  } else if (markerstyle == 46) {
3856  // open four triangles X
3857  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3858  shape[0].x = 0; shape[0].y = im2;
3859  shape[1].x = -im2; shape[1].y = im;
3860  shape[2].x = -im; shape[2].y = im2;
3861  shape[3].x = -im2; shape[3].y = 0;
3862  shape[4].x = -im; shape[4].y = -im2;
3863  shape[5].x = -im2; shape[5].y = -im;
3864  shape[6].x = 0; shape[6].y = -im2;
3865  shape[7].x = im2; shape[7].y = -im;
3866  shape[8].x = im; shape[8].y = -im2;
3867  shape[9].x = im2; shape[9].y = 0;
3868  shape[10].x = im; shape[10].y = im2;
3869  shape[11].x = im2; shape[11].y = im;
3870  shape[12].x = 0; shape[12].y = im2;
3871  SetMarkerType(2,13,shape);
3872  } else if (markerstyle == 47) {
3873  // filled four triangles X
3874  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3875  shape[0].x = 0; shape[0].y = im2;
3876  shape[1].x = -im2; shape[1].y = im;
3877  shape[2].x = -im; shape[2].y = im2;
3878  shape[3].x = -im2; shape[3].y = 0;
3879  shape[4].x = -im; shape[4].y = -im2;
3880  shape[5].x = -im2; shape[5].y = -im;
3881  shape[6].x = 0; shape[6].y = -im2;
3882  shape[7].x = im2; shape[7].y = -im;
3883  shape[8].x = im; shape[8].y = -im2;
3884  shape[9].x = im2; shape[9].y = 0;
3885  shape[10].x = im; shape[10].y = im2;
3886  shape[11].x = im2; shape[11].y = im;
3887  shape[12].x = 0; shape[12].y = im2;
3888  SetMarkerType(3,13,shape);
3889  } else if (markerstyle == 48) {
3890  // four filled squares X
3891  Int_t im2 = Int_t(2.0*fMarkerSize + 0.5);
3892  shape[0].x = 0; shape[0].y = im2*1.005;
3893  shape[1].x = -im2; shape[1].y = im;
3894  shape[2].x = -im; shape[2].y = im2;
3895  shape[3].x = -im2; shape[3].y = 0;
3896  shape[4].x = -im; shape[4].y = -im2;
3897  shape[5].x = -im2; shape[5].y = -im;
3898  shape[6].x = 0; shape[6].y = -im2;
3899  shape[7].x = im2; shape[7].y = -im;
3900  shape[8].x = im; shape[8].y = -im2;
3901  shape[9].x = im2; shape[9].y = 0;
3902  shape[10].x = im; shape[10].y = im2;
3903  shape[11].x = im2; shape[11].y = im;
3904  shape[12].x = 0; shape[12].y = im2*0.995;
3905  shape[13].x = im2*0.995; shape[13].y = 0;
3906  shape[14].x = 0; shape[14].y = -im2*0.995;
3907  shape[15].x = -im2*0.995; shape[15].y = 0;
3908  shape[16].x = 0; shape[16].y = im2*0.995;
3909  SetMarkerType(3,16,shape);
3910  } else if (markerstyle == 49) {
3911  // four filled squares plus
3912  Int_t imx = Int_t(1.33*fMarkerSize + 0.5);
3913  shape[0].x =-imx; shape[0].y =-imx*1.005;
3914  shape[1].x =-imx; shape[1].y = -im;
3915  shape[2].x = imx; shape[2].y = -im;
3916  shape[3].x = imx; shape[3].y =-imx;
3917  shape[4].x = im; shape[4].y =-imx;
3918  shape[5].x = im; shape[5].y = imx;
3919  shape[6].x = imx; shape[6].y = imx;
3920  shape[7].x = imx; shape[7].y = im;
3921  shape[8].x =-imx; shape[8].y = im;
3922  shape[9].x =-imx; shape[9].y = imx;
3923  shape[10].x = -im; shape[10].y = imx;
3924  shape[11].x = -im; shape[11].y =-imx;
3925  shape[12].x =-imx; shape[12].y =-imx*0.995;
3926  shape[13].x =-imx; shape[13].y = imx;
3927  shape[14].x = imx; shape[14].y = imx;
3928  shape[15].x = imx; shape[15].y =-imx;
3929  shape[16].x =-imx; shape[16].y =-imx*1.005;
3930  SetMarkerType(3,17,shape);
3931  } else {
3932  // single dot
3933  SetMarkerType(0, 0, shape);
3934  }
3936 }
3937 
3938 ////////////////////////////////////////////////////////////////////////////////
3939 /// Set opacity of a window. This image manipulation routine works
3940 /// by adding to a percent amount of neutral to each pixels RGB.
3941 /// Since it requires quite some additional color map entries is it
3942 /// only supported on displays with more than > 8 color planes (> 256
3943 /// colors)
3944 
3946 {
3947  Int_t depth = gdk_visual_get_best_depth();
3948 
3949  if (depth <= 8) return;
3950  if (percent == 0) return;
3951 
3952  // if 100 percent then just make white
3953  ULong_t *orgcolors = 0, *tmpc = 0;
3954  Int_t maxcolors = 0, ncolors, ntmpc = 0;
3955 
3956  // save previous allocated colors, delete at end when not used anymore
3957  if (gCws->new_colors) {
3958  tmpc = gCws->new_colors;
3959  ntmpc = gCws->ncolors;
3960  }
3961  // get pixmap from server as image
3962  GdkImage *image = gdk_image_get((GdkDrawable*)gCws->drawing, 0, 0,
3963  gCws->width, gCws->height);
3964 
3965  // collect different image colors
3966  int x, y;
3967  for (y = 0; y < (int) gCws->height; y++) {
3968  for (x = 0; x < (int) gCws->width; x++) {
3969  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
3970  CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
3971  }
3972  }
3973  if (ncolors == 0) {
3974  gdk_image_unref(image);
3975  ::operator delete(orgcolors);
3976  return;
3977  }
3978  // create opaque counter parts
3979  MakeOpaqueColors(percent, orgcolors, ncolors);
3980 
3981  // put opaque colors in image
3982  for (y = 0; y < (int) gCws->height; y++) {
3983  for (x = 0; x < (int) gCws->width; x++) {
3984  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
3985  Int_t idx = FindColor(pixel, orgcolors, ncolors);
3986  PutPixel((Drawable_t)image, x, y, gCws->new_colors[idx]);
3987  }
3988  }
3989 
3990  // put image back in pixmap on server
3991  gdk_draw_image(gCws->drawing, gGCpxmp, (GdkImage *)image,
3992  0, 0, 0, 0, gCws->width, gCws->height);
3993  GdiFlush();
3994 
3995  // clean up
3996  if (tmpc) {
3997  gdk_colors_free((GdkColormap *)fColormap, tmpc, ntmpc, 0);
3998  delete[]tmpc;
3999  }
4000  gdk_image_unref(image);
4001  ::operator delete(orgcolors);
4002 }
4003 
4004 ////////////////////////////////////////////////////////////////////////////////
4005 /// Get RGB values for orgcolors, add percent neutral to the RGB and
4006 /// allocate new_colors.
4007 
4008 void TGWin32::MakeOpaqueColors(Int_t percent, ULong_t *orgcolors, Int_t ncolors)
4009 {
4010  Int_t ret;
4011  if (ncolors <= 0) return;
4012  GdkColor *xcol = new GdkColor[ncolors];
4013 
4014  int i;
4015  for (i = 0; i < ncolors; i++) {
4016  xcol[i].pixel = orgcolors[i];
4017  xcol[i].red = xcol[i].green = xcol[i].blue = 0;
4018  }
4019 
4020  GdkColorContext *cc;
4021  cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)fColormap);
4022  gdk_color_context_query_colors(cc, xcol, ncolors);
4023  gdk_color_context_free(cc);
4024 
4025  UShort_t add = percent * kBIGGEST_RGB_VALUE / 100;
4026 
4027  Int_t val;
4028  for (i = 0; i < ncolors; i++) {
4029  val = xcol[i].red + add;
4030  if (val > kBIGGEST_RGB_VALUE) {
4031  val = kBIGGEST_RGB_VALUE;
4032  }
4033  xcol[i].red = (UShort_t) val;
4034  val = xcol[i].green + add;
4035  if (val > kBIGGEST_RGB_VALUE) {
4036  val = kBIGGEST_RGB_VALUE;
4037  }
4038  xcol[i].green = (UShort_t) val;
4039  val = xcol[i].blue + add;
4040  if (val > kBIGGEST_RGB_VALUE) {
4041  val = kBIGGEST_RGB_VALUE;
4042  }
4043  xcol[i].blue = (UShort_t) val;
4044 
4045  ret = gdk_color_alloc((GdkColormap *)fColormap, &xcol[i]);
4046 
4047  if (!ret) {
4048  Warning("MakeOpaqueColors",
4049  "failed to allocate color %hd, %hd, %hd", xcol[i].red,
4050  xcol[i].green, xcol[i].blue);
4051  // assumes that in case of failure xcol[i].pixel is not changed
4052  }
4053  }
4054 
4055  gCws->new_colors = new ULong_t[ncolors];
4056  gCws->ncolors = ncolors;
4057 
4058  for (i = 0; i < ncolors; i++) {
4059  gCws->new_colors[i] = xcol[i].pixel;
4060  }
4061 
4062  delete []xcol;
4063 }
4064 
4065 ////////////////////////////////////////////////////////////////////////////////
4066 /// Returns index in orgcolors (and new_colors) for pixel.
4067 
4068 Int_t TGWin32::FindColor(ULong_t pixel, ULong_t * orgcolors, Int_t ncolors)
4069 {
4070  for (int i = 0; i < ncolors; i++) {
4071  if (pixel == orgcolors[i]) return i;
4072  }
4073  Error("FindColor", "did not find color, should never happen!");
4074 
4075  return 0;
4076 }
4077 
4078 ////////////////////////////////////////////////////////////////////////////////
4079 /// Set color intensities for given color index.
4080 /// cindex : color index
4081 /// r,g,b : red, green, blue intensities between 0.0 and 1.0
4082 
4083 void TGWin32::SetRGB(int cindex, float r, float g, float b)
4084 {
4085  GdkColor xcol;
4086 
4087  if (fColormap && cindex >= 0) {
4088  xcol.red = (unsigned short) (r * kBIGGEST_RGB_VALUE);
4089  xcol.green = (unsigned short) (g * kBIGGEST_RGB_VALUE);
4090  xcol.blue = (unsigned short) (b * kBIGGEST_RGB_VALUE);
4091  xcol.pixel = RGB(xcol.red, xcol.green, xcol.blue);
4092 
4093  XColor_t &col = GetColor(cindex);
4094  if (col.fDefined) {
4095  // if color is already defined with same rgb just return
4096  if (col.color.red == xcol.red && col.color.green == xcol.green &&
4097  col.color.blue == xcol.blue)
4098  return;
4099  col.fDefined = kFALSE;
4100  gdk_colormap_free_colors((GdkColormap *) fColormap,
4101  (GdkColor *)&col, 1);
4102  }
4103 
4104  Int_t ret = gdk_colormap_alloc_color(fColormap, &xcol, 1, 1);
4105  if (ret != 0) {
4106  col.fDefined = kTRUE;
4107  col.color.pixel = xcol.pixel;
4108  col.color.red = xcol.red;
4109  col.color.green = xcol.green;
4110  col.color.blue = xcol.blue;
4111  }
4112  }
4113 }
4114 
4115 ////////////////////////////////////////////////////////////////////////////////
4116 /// Set text alignment.
4117 /// txalh : horizontal text alignment
4118 /// txalv : vertical text alignment
4119 
4121 {
4122  static Short_t current = 0;
4123  if (talign==current) return;
4124  current = talign;
4125 
4126  Int_t txalh = talign / 10;
4127  Int_t txalv = talign % 10;
4128  fTextAlignH = txalh;
4129  fTextAlignV = txalv;
4130 
4131  switch (txalh) {
4132 
4133  case 0:
4134  case 1:
4135  switch (txalv) { //left
4136  case 1:
4137  fTextAlign = 7; //bottom
4138  break;
4139  case 2:
4140  fTextAlign = 4; //center
4141  break;
4142  case 3:
4143  fTextAlign = 1; //top
4144  break;
4145  }
4146  break;
4147  case 2:
4148  switch (txalv) { //center
4149  case 1:
4150  fTextAlign = 8; //bottom
4151  break;
4152  case 2:
4153  fTextAlign = 5; //center
4154  break;
4155  case 3:
4156  fTextAlign = 2; //top
4157  break;
4158  }
4159  break;
4160  case 3:
4161  switch (txalv) { //right
4162  case 1:
4163  fTextAlign = 9; //bottom
4164  break;
4165  case 2:
4166  fTextAlign = 6; //center
4167  break;
4168  case 3:
4169  fTextAlign = 3; //top
4170  break;
4171  }
4172  break;
4173  }
4175 }
4176 
4177 ////////////////////////////////////////////////////////////////////////////////
4178 /// Set color index for text.
4179 
4181 {
4182  static Int_t current = 0;
4183  GdkGCValues values;
4184  if ((cindex < 0) || (Int_t(cindex)==current)) return;
4185 
4186  TAttText::SetTextColor(cindex);
4187 
4188  SetColor(gGCtext, Int_t(cindex));
4189  gdk_gc_get_values(gGCtext, &values);
4190  gdk_gc_set_foreground(gGCinvt, &values.background);
4191  gdk_gc_set_background(gGCinvt, &values.foreground);
4192  gdk_gc_set_background(gGCtext, (GdkColor *) & GetColor(0).color);
4193  current = Int_t(cindex);
4194 }
4195 
4196 ////////////////////////////////////////////////////////////////////////////////
4197 
4198 void TGWin32::Sync(int mode)
4199 {
4200 }
4201 
4202 ////////////////////////////////////////////////////////////////////////////////
4203 /// Update display.
4204 /// mode : (1) update
4205 /// (0) sync
4206 ///
4207 /// Synchronise client and server once (not permanent).
4208 /// Copy the pixmap gCws->drawing on the window gCws->window
4209 /// if the double buffer is on.
4210 
4212 {
4213  if (gCws && gCws->double_buffer) {
4214  gdk_window_copy_area(gCws->window, gGCpxmp, 0, 0,
4215  gCws->drawing, 0, 0, gCws->width, gCws->height);
4216  }
4217  Update(mode);
4218 }
4219 
4220 ////////////////////////////////////////////////////////////////////////////////
4221 /// Set pointer position.
4222 /// ix : New X coordinate of pointer
4223 /// iy : New Y coordinate of pointer
4224 /// Coordinates are relative to the origin of the window id
4225 /// or to the origin of the current window if id == 0.
4226 
4227 void TGWin32::Warp(int ix, int iy, Window_t id)
4228 {
4229  if (!id) return;
4230 
4231  POINT cpt, tmp;
4232  HWND dw;
4233  if (!id)
4234  dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)gCws->window);
4235  else
4236  dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)id);
4237  GetCursorPos(&cpt);
4238  tmp.x = ix > 0 ? ix : cpt.x;
4239  tmp.y = iy > 0 ? iy : cpt.y;
4240  ClientToScreen(dw, &tmp);
4241  SetCursorPos(tmp.x, tmp.y);
4242 }
4243 
4244 ////////////////////////////////////////////////////////////////////////////////
4245 /// Write the pixmap wid in the bitmap file pxname.
4246 /// wid : Pixmap address
4247 /// w,h : Width and height of the pixmap.
4248 /// lenname : pixmap name length
4249 /// pxname : pixmap name
4250 
4251 void TGWin32::WritePixmap(int wid, unsigned int w, unsigned int h,
4252  char *pxname)
4253 {
4254  int wval, hval;
4255  wval = w;
4256  hval = h;
4257 
4258  if (!fWindows) return;
4259  gTws = &fWindows[wid];
4260 // XWriteBitmapFile(fDisplay,pxname,(Pixmap)gTws->drawing,wval,hval,-1,-1);
4261 }
4262 
4263 
4264 //
4265 // Functions for GIFencode()
4266 //
4267 
4268 static FILE *gGifFile; // output unit used WriteGIF and PutByte
4269 static GdkImage *gGifImage = 0; // image used in WriteGIF and GetPixel
4270 
4271 extern "C" {
4272  int GIFquantize(UInt_t width, UInt_t height, Int_t * ncol, Byte_t * red,
4273  Byte_t * green, Byte_t * blue, Byte_t * outputBuf,
4274  Byte_t * outputCmap);
4275  long GIFencode(int Width, int Height, Int_t Ncol, Byte_t R[],
4276  Byte_t G[], Byte_t B[], Byte_t ScLine[],
4277  void (*get_scline) (int, int, Byte_t *),
4278  void (*pb) (Byte_t));
4279  int GIFdecode(Byte_t * GIFarr, Byte_t * PIXarr, int *Width, int *Height,
4280  int *Ncols, Byte_t * R, Byte_t * G, Byte_t * B);
4281  int GIFinfo(Byte_t * GIFarr, int *Width, int *Height, int *Ncols);
4282 }
4283 
4284 
4285 ////////////////////////////////////////////////////////////////////////////////
4286 /// Get pixels in line y and put in array scline.
4287 
4288 static void GetPixel(int y, int width, Byte_t * scline)
4289 {
4290  for (int i = 0; i < width; i++) {
4291  scline[i] = Byte_t(GetPixelImage((Drawable_t)gGifImage, i, y));
4292  }
4293 }
4294 
4295 ////////////////////////////////////////////////////////////////////////////////
4296 /// Put byte b in output stream.
4297 
4298 static void PutByte(Byte_t b)
4299 {
4300  if (ferror(gGifFile) == 0) fputc(b, gGifFile);
4301 }
4302 
4303 ////////////////////////////////////////////////////////////////////////////////
4304 /// Returns in R G B the ncol colors of the palette used by the image.
4305 /// The image pixels are changed to index values in these R G B arrays.
4306 /// This produces a colormap with only the used colors (so even on displays
4307 /// with more than 8 planes we will be able to create GIF's when the image
4308 /// contains no more than 256 different colors). If it does contain more
4309 /// colors we will have to use GIFquantize to reduce the number of colors.
4310 /// The R G B arrays must be deleted by the caller.
4311 
4312 void TGWin32::ImgPickPalette(GdkImage * image, Int_t & ncol, Int_t * &R,
4313  Int_t * &G, Int_t * &B)
4314 {
4315  ULong_t *orgcolors = 0;
4316  Int_t maxcolors = 0, ncolors;
4317 
4318  // collect different image colors
4319  int x, y;
4320  for (x = 0; x < (int) gCws->width; x++) {
4321  for (y = 0; y < (int) gCws->height; y++) {
4322  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
4323  CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
4324  }
4325  }
4326 
4327  // get RGB values belonging to pixels
4328  GdkColor *xcol = new GdkColor[ncolors];
4329 
4330  int i;
4331  for (i = 0; i < ncolors; i++) {
4332  xcol[i].pixel = orgcolors[i];
4333 // xcol[i].red = xcol[i].green = xcol[i].blue = 0;
4334  xcol[i].red = GetRValue(xcol[i].pixel);
4335  xcol[i].green = GetGValue(xcol[i].pixel);
4336  xcol[i].blue = GetBValue(xcol[i].pixel);
4337  }
4338 
4339  GdkColorContext *cc;
4340  cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)fColormap);
4341  gdk_color_context_query_colors(cc, xcol, ncolors);
4342  gdk_color_context_free(cc);
4343 
4344  // create RGB arrays and store RGB's for each color and set number of colors
4345  // (space must be delete by caller)
4346  R = new Int_t[ncolors];
4347  G = new Int_t[ncolors];
4348  B = new Int_t[ncolors];
4349 
4350  for (i = 0; i < ncolors; i++) {
4351  R[i] = xcol[i].red;
4352  G[i] = xcol[i].green;
4353  B[i] = xcol[i].blue;
4354  }
4355  ncol = ncolors;
4356 
4357  // update image with indices (pixels) into the new RGB colormap
4358  for (x = 0; x < (int) gCws->width; x++) {
4359  for (y = 0; y < (int) gCws->height; y++) {
4360  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
4361  Int_t idx = FindColor(pixel, orgcolors, ncolors);
4362  PutPixel((Drawable_t)image, x, y, idx);
4363  }
4364  }
4365 
4366  // cleanup
4367  delete[]xcol;
4368  ::operator delete(orgcolors);
4369 }
4370 
4371 ////////////////////////////////////////////////////////////////////////////////
4372 /// Writes the current window into GIF file.
4373 
4375 {
4376  Byte_t scline[2000], r[256], b[256], g[256];
4377  Int_t *R, *G, *B;
4378  Int_t ncol, maxcol, i;
4379 
4380  if (gGifImage) {
4381  gdk_image_unref((GdkImage *)gGifImage);
4382  }
4383 
4384  gGifImage = gdk_image_get((GdkDrawable*)gCws->drawing, 0, 0,
4385  gCws->width, gCws->height);
4386 
4387  ImgPickPalette(gGifImage, ncol, R, G, B);
4388 
4389  if (ncol > 256) {
4390  //GIFquantize(...);
4391  Error("WriteGIF",
4392  "can not create GIF of image containing more than 256 colors");
4393  delete[]R;
4394  delete[]G;
4395  delete[]B;
4396  return 0;
4397  }
4398 
4399  maxcol = 0;
4400  for (i = 0; i < ncol; i++) {
4401  if (maxcol < R[i]) maxcol = R[i];
4402  if (maxcol < G[i]) maxcol = G[i];
4403  if (maxcol < B[i]) maxcol = B[i];
4404  r[i] = 0;
4405  g[i] = 0;
4406  b[i] = 0;
4407  }
4408  if (maxcol != 0) {
4409  for (i = 0; i < ncol; i++) {
4410  r[i] = R[i] * 255 / maxcol;
4411  g[i] = G[i] * 255 / maxcol;
4412  b[i] = B[i] * 255 / maxcol;
4413  }
4414  }
4415 
4416  gGifFile = fopen(name, "wb");
4417 
4418  if (gGifFile) {
4419  GIFencode(gCws->width, gCws->height,
4420  ncol, r, g, b, scline, ::GetPixel, PutByte);
4421  fclose(gGifFile);
4422  i = 1;
4423  } else {
4424  Error("WriteGIF","cannot write file: %s",name);
4425  i = 0;
4426  }
4427  delete[]R;
4428  delete[]G;
4429  delete[]B;
4430 
4431  return i;
4432 }
4433 
4434 ////////////////////////////////////////////////////////////////////////////////
4435 /// Draw image.
4436 
4437 void TGWin32::PutImage(int offset, int itran, int x0, int y0, int nx,
4438  int ny, int xmin, int ymin, int xmax, int ymax,
4439  unsigned char *image, Drawable_t wid)
4440 {
4441  const int MAX_SEGMENT = 20;
4442  int i, n, x, y, xcur, x1, x2, y1, y2;
4443  unsigned char *jimg, *jbase, icol;
4444  int nlines[256];
4445  GdkSegment lines[256][MAX_SEGMENT];
4446  GdkDrawable *id;
4447 
4448  if (wid) {
4449  id = (GdkDrawable*)wid;
4450  } else {
4451  id = gCws->drawing;
4452  }
4453 
4454  for (i = 0; i < 256; i++) nlines[i] = 0;
4455 
4456  x1 = x0 + xmin;
4457  y1 = y0 + ny - ymax - 1;
4458  x2 = x0 + xmax;
4459  y2 = y0 + ny - ymin - 1;
4460  jbase = image + (ymin - 1) * nx + xmin;
4461 
4462  for (y = y2; y >= y1; y--) {
4463  xcur = x1;
4464  jbase += nx;
4465  for (jimg = jbase, icol = *jimg++, x = x1 + 1; x <= x2; jimg++, x++) {
4466  if (icol != *jimg) {
4467  if (icol != itran) {
4468  n = nlines[icol]++;
4469  lines[icol][n].x1 = xcur;
4470  lines[icol][n].y1 = y;
4471  lines[icol][n].x2 = x - 1;
4472  lines[icol][n].y2 = y;
4473  if (nlines[icol] == MAX_SEGMENT) {
4474  SetColor(gGCline, (int) icol + offset);
4475  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4476  (GdkSegment *) &lines[icol][0], MAX_SEGMENT);
4477  nlines[icol] = 0;
4478  }
4479  }
4480  icol = *jimg;
4481  xcur = x;
4482  }
4483  }
4484  if (icol != itran) {
4485  n = nlines[icol]++;
4486  lines[icol][n].x1 = xcur;
4487  lines[icol][n].y1 = y;
4488  lines[icol][n].x2 = x - 1;
4489  lines[icol][n].y2 = y;
4490  if (nlines[icol] == MAX_SEGMENT) {
4491  SetColor(gGCline, (int) icol + offset);
4492  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4493  (GdkSegment *)&lines[icol][0], MAX_SEGMENT);
4494  nlines[icol] = 0;
4495  }
4496  }
4497  }
4498 
4499  for (i = 0; i < 256; i++) {
4500  if (nlines[i] != 0) {
4501  SetColor(gGCline, i + offset);
4502  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4503  (GdkSegment *)&lines[icol][0], nlines[i]);
4504  }
4505  }
4506 }
4507 
4508 ////////////////////////////////////////////////////////////////////////////////
4509 /// If id is NULL - loads the specified gif file at position [x0,y0] in the
4510 /// current window. Otherwise creates pixmap from gif file
4511 
4512 Pixmap_t TGWin32::ReadGIF(int x0, int y0, const char *file, Window_t id)
4513 {
4514  FILE *fd;
4515  Seek_t filesize;
4516  unsigned char *GIFarr, *PIXarr, R[256], G[256], B[256], *j1, *j2, icol;
4517  int i, j, k, width, height, ncolor, irep, offset;
4518  float rr, gg, bb;
4519  Pixmap_t pic = 0;
4520 
4521  fd = fopen(file, "r+b");
4522  if (!fd) {
4523  Error("ReadGIF", "unable to open GIF file");
4524  return pic;
4525  }
4526 
4527  fseek(fd, 0L, 2);
4528  filesize = Seek_t(ftell(fd));
4529  fseek(fd, 0L, 0);
4530 
4531  if (!(GIFarr = (unsigned char *) calloc(filesize + 256, 1))) {
4532  fclose(fd);
4533  Error("ReadGIF", "unable to allocate array for gif");
4534  return pic;
4535  }
4536 
4537  if (fread(GIFarr, filesize, 1, fd) != 1) {
4538  fclose(fd);
4539  Error("ReadGIF", "GIF file read failed");
4540  return pic;
4541  }
4542  fclose(fd);
4543 
4544  irep = GIFinfo(GIFarr, &width, &height, &ncolor);
4545  if (irep != 0) {
4546  return pic;
4547  }
4548 
4549  if (!(PIXarr = (unsigned char *) calloc((width * height), 1))) {
4550  Error("ReadGIF", "unable to allocate array for image");
4551  return pic;
4552  }
4553 
4554  irep = GIFdecode(GIFarr, PIXarr, &width, &height, &ncolor, R, G, B);
4555  if (irep != 0) {
4556  return pic;
4557  }
4558  // S E T P A L E T T E
4559 
4560  offset = 8;
4561 
4562  for (i = 0; i < ncolor; i++) {
4563  rr = R[i] / 255.;
4564  gg = G[i] / 255.;
4565  bb = B[i] / 255.;
4566  j = i + offset;
4567  SetRGB(j, rr, gg, bb);
4568  }
4569 
4570  // O U T P U T I M A G E
4571 
4572  for (i = 1; i <= height / 2; i++) {
4573  j1 = PIXarr + (i - 1) * width;
4574  j2 = PIXarr + (height - i) * width;
4575  for (k = 0; k < width; k++) {
4576  icol = *j1;
4577  *j1++ = *j2;
4578  *j2++ = icol;
4579  }
4580  }
4581 
4582  if (id) pic = CreatePixmap(id, width, height);
4583  PutImage(offset, -1, x0, y0, width, height, 0, 0, width-1, height-1, PIXarr, pic);
4584 
4585  if (pic) return pic;
4586  else if (gCws->drawing) return (Pixmap_t)gCws->drawing;
4587  else return 0;
4588 }
4589 
4590 //////////////////////////// GWin32Gui //////////////////////////////////////////
4591 ////////////////////////////////////////////////////////////////////////////////
4592 /// Map window on screen.
4593 
4595 {
4596  if (!id) return;
4597 
4598  gdk_window_show((GdkWindow *)id);
4599  if ((GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_TEMP) &&
4600  (GetParent(id) == GetDefaultRootWindow())) {
4601  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4602  ::SetForegroundWindow(window);
4603  }
4604 }
4605 
4606 ////////////////////////////////////////////////////////////////////////////////
4607 ///
4608 
4610 {
4611  if (!id) return;
4612 
4613  EnumChildWindows((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
4614  EnumChildProc, (LPARAM) NULL);
4615 }
4616 
4617 ////////////////////////////////////////////////////////////////////////////////
4618 /// Map window on screen and put on top of all windows.
4619 
4621 {
4622  if (!id) return;
4623 
4624  HWND hwnd = ::GetForegroundWindow();
4625  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4626  gdk_window_show((GdkWindow *)id);
4627  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_TEMP) {
4628  ::BringWindowToTop(window);
4629  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_CHILD)
4630  ::SetForegroundWindow(window);
4631  }
4632 
4633  if (gConsoleWindow && (hwnd == (HWND)gConsoleWindow)) {
4634  RECT r1, r2, r3;
4635  ::GetWindowRect((HWND)gConsoleWindow, &r1);
4636  HWND fore = ::GetForegroundWindow();
4637  ::GetWindowRect(fore, &r2);
4638  if (!::IntersectRect(&r3, &r2, &r1)) {
4639  ::SetForegroundWindow((HWND)gConsoleWindow);
4640  }
4641  }
4642 }
4643 
4644 ////////////////////////////////////////////////////////////////////////////////
4645 /// Unmap window from screen.
4646 
4648 {
4649  if (!id) return;
4650 
4651  gdk_window_hide((GdkWindow *) id);
4652 }
4653 
4654 ////////////////////////////////////////////////////////////////////////////////
4655 /// Destroy window.
4656 
4658 {
4659  if (!id) return;
4660 
4661  // we need to unmap the window before to destroy it, in order to properly
4662  // receive kUnmapNotify needed by gClient->WaitForUnmap()...
4663  gdk_window_hide((GdkWindow *) id);
4664  gdk_window_destroy((GdkDrawable *) id, kTRUE);
4665 }
4666 
4667 ////////////////////////////////////////////////////////////////////////////////
4668 /// Destroy all internal subwindows
4669 
4671 {
4672  if (!id) return;
4673 
4674  gdk_window_destroy((GdkDrawable *) id, kFALSE);
4675 }
4676 
4677 ////////////////////////////////////////////////////////////////////////////////
4678 /// Put window on top of window stack.
4679 
4681 {
4682  if (!id) return;
4683 
4684  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4685  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) == GDK_WINDOW_TEMP) {
4686  ::SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0,
4687  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4688  }
4689  else {
4690  ::BringWindowToTop(window);
4691  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_CHILD)
4692  ::SetForegroundWindow(window);
4693  }
4694 }
4695 
4696 ////////////////////////////////////////////////////////////////////////////////
4697 /// Lower window so it lays below all its siblings.
4698 
4700 {
4701  if (!id) return;
4702 
4703  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4704  ::SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0,
4705  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4706 }
4707 
4708 ////////////////////////////////////////////////////////////////////////////////
4709 /// Move a window.
4710 
4712 {
4713  if (!id) return;
4714 
4715  gdk_window_move((GdkDrawable *) id, x, y);
4716 }
4717 
4718 ////////////////////////////////////////////////////////////////////////////////
4719 /// Move and resize a window.
4720 
4722  UInt_t h)
4723 {
4724  if (!id) return;
4725 
4726  gdk_window_move_resize((GdkWindow *) id, x, y, w, h);
4727 }
4728 
4729 ////////////////////////////////////////////////////////////////////////////////
4730 /// Resize the window.
4731 
4733 {
4734  if (!id) return;
4735 
4736  // protect against potential negative values
4737  if (w >= (UInt_t)INT_MAX || h >= (UInt_t)INT_MAX)
4738  return;
4739  gdk_window_resize((GdkWindow *) id, w, h);
4740 }
4741 
4742 ////////////////////////////////////////////////////////////////////////////////
4743 /// Iconify the window.
4744 
4746 {
4747  if (!id) return;
4748 
4749  gdk_window_lower((GdkWindow *) id);
4750  ::CloseWindow((HWND)GDK_DRAWABLE_XID((GdkWindow *)id));
4751 }
4752 
4753 ////////////////////////////////////////////////////////////////////////////////
4754 /// Reparent window, make pid the new parent and position the window at
4755 /// position (x,y) in new parent.
4756 
4758 {
4759  if (!id) return;
4760 
4761  gdk_window_reparent((GdkWindow *)id, (GdkWindow *)pid, x, y);
4762 }
4763 
4764 ////////////////////////////////////////////////////////////////////////////////
4765 /// Set the window background color.
4766 
4768 {
4769  if (!id) return;
4770 
4771  GdkColor back;
4772  back.pixel = color;
4773  back.red = GetRValue(color);
4774  back.green = GetGValue(color);
4775  back.blue = GetBValue(color);
4776 
4777  gdk_window_set_background((GdkWindow *) id, &back);
4778 }
4779 
4780 ////////////////////////////////////////////////////////////////////////////////
4781 /// Set pixmap as window background.
4782 
4784 {
4785  if (!id) return;
4786 
4787  gdk_window_set_back_pixmap((GdkWindow *) id, (GdkPixmap *) pxm, 0);
4788 }
4789 
4790 ////////////////////////////////////////////////////////////////////////////////
4791 /// Return handle to newly created gdk window.
4792 
4794  UInt_t w, UInt_t h, UInt_t border,
4795  Int_t depth, UInt_t clss,
4796  void *visual, SetWindowAttributes_t * attr,
4797  UInt_t wtype)
4798 {
4799  GdkWindowAttr xattr;
4800  GdkWindow *newWin;
4801  GdkColor background_color;
4802  ULong_t xmask = 0;
4803 
4804  if (attr) {
4805  MapSetWindowAttributes(attr, xmask, xattr);
4806  xattr.window_type = GDK_WINDOW_CHILD;
4807  if (wtype & kMainFrame) {
4808  xattr.window_type = GDK_WINDOW_TOPLEVEL;
4809  }
4810  if (wtype & kTransientFrame) {
4811  xattr.window_type = GDK_WINDOW_DIALOG;
4812  }
4813  if (wtype & kTempFrame) {
4814  xattr.window_type = GDK_WINDOW_TEMP;
4815  }
4816  newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4817  } else {
4818  xattr.width = w;
4819  xattr.height = h;
4820  xattr.wclass = GDK_INPUT_OUTPUT;
4821  xattr.event_mask = 0L; //GDK_ALL_EVENTS_MASK;
4822  xattr.event_mask |= GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
4823  GDK_PROPERTY_CHANGE_MASK;
4824 // GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
4825  if (x >= 0) {
4826  xattr.x = x;
4827  } else {
4828  xattr.x = -1.0 * x;
4829  }
4830  if (y >= 0) {
4831  xattr.y = y;
4832  } else {
4833  xattr.y = -1.0 * y;
4834  }
4835  xattr.colormap = gdk_colormap_get_system();
4836  xattr.cursor = NULL;
4837  xattr.override_redirect = TRUE;
4838  if ((xattr.y > 0) && (xattr.x > 0)) {
4839  xmask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP |
4840  GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4841  } else {
4842  xmask = GDK_WA_COLORMAP | GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4843  }
4844  if (visual != NULL) {
4845  xattr.visual = (GdkVisual *) visual;
4846  xmask |= GDK_WA_VISUAL;
4847  } else {
4848  xattr.visual = gdk_visual_get_system();
4849  xmask |= GDK_WA_VISUAL;
4850  }
4851  xattr.window_type = GDK_WINDOW_CHILD;
4852  if (wtype & kMainFrame) {
4853  xattr.window_type = GDK_WINDOW_TOPLEVEL;
4854  }
4855  if (wtype & kTransientFrame) {
4856  xattr.window_type = GDK_WINDOW_DIALOG;
4857  }
4858  if (wtype & kTempFrame) {
4859  xattr.window_type = GDK_WINDOW_TEMP;
4860  }
4861  newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4862  gdk_window_set_events(newWin, (GdkEventMask) 0L);
4863  }
4864  if (border > 0) {
4865  gdk_window_set_decorations(newWin,
4866  (GdkWMDecoration) GDK_DECOR_BORDER);
4867  }
4868  if (attr) {
4869  if ((attr->fMask & kWABackPixmap)) {
4870  if (attr->fBackgroundPixmap == kNone) {
4871  gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 0);
4872  } else if (attr->fBackgroundPixmap == kParentRelative) {
4873  gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 1);
4874  } else {
4875  gdk_window_set_back_pixmap(newWin,
4876  (GdkPixmap *) attr->
4877  fBackgroundPixmap, 0);
4878  }
4879  }
4880  if ((attr->fMask & kWABackPixel)) {
4881  background_color.pixel = attr->fBackgroundPixel;
4882  background_color.red = GetRValue(attr->fBackgroundPixel);
4883  background_color.green = GetGValue(attr->fBackgroundPixel);
4884  background_color.blue = GetBValue(attr->fBackgroundPixel);
4885  gdk_window_set_background(newWin, &background_color);
4886  }
4887  }
4888  if (!fUseSysPointers) {
4889  ::SetClassLong((HWND)GDK_DRAWABLE_XID(newWin), GCL_HCURSOR,
4890  (LONG)GDK_CURSOR_XID(fCursors[kPointer]));
4891  }
4892  return (Window_t) newWin;
4893 }
4894 
4895 ////////////////////////////////////////////////////////////////////////////////
4896 /// Map event mask to or from gdk.
4897 
4898 void TGWin32::MapEventMask(UInt_t & emask, UInt_t & xemask, Bool_t tox)
4899 {
4900  if (tox) {
4901  Long_t lxemask = 0L;
4902  if ((emask & kKeyPressMask)) {
4903  lxemask |= GDK_KEY_PRESS_MASK;
4904  }
4905  if ((emask & kKeyReleaseMask)) {
4906  lxemask |= GDK_KEY_RELEASE_MASK;
4907  }
4908  if ((emask & kButtonPressMask)) {
4909  lxemask |= GDK_BUTTON_PRESS_MASK;
4910  }
4911  if ((emask & kButtonReleaseMask)) {
4912  lxemask |= GDK_BUTTON_RELEASE_MASK;
4913  }
4914  if ((emask & kPointerMotionMask)) {
4915  lxemask |= GDK_POINTER_MOTION_MASK;
4916  }
4917  if ((emask & kButtonMotionMask)) {
4918  lxemask |= GDK_BUTTON_MOTION_MASK;
4919  }
4920  if ((emask & kExposureMask)) {
4921  lxemask |= GDK_EXPOSURE_MASK;
4922  }
4923  if ((emask & kStructureNotifyMask)) {
4924  lxemask |= GDK_STRUCTURE_MASK;
4925  }
4926  if ((emask & kEnterWindowMask)) {
4927  lxemask |= GDK_ENTER_NOTIFY_MASK;
4928  }
4929  if ((emask & kLeaveWindowMask)) {
4930  lxemask |= GDK_LEAVE_NOTIFY_MASK;
4931  }
4932  if ((emask & kFocusChangeMask)) {
4933  lxemask |= GDK_FOCUS_CHANGE_MASK;
4934  }
4935  xemask = (UInt_t) lxemask;
4936  } else {
4937  emask = 0;
4938  if ((xemask & GDK_KEY_PRESS_MASK)) {
4939  emask |= kKeyPressMask;
4940  }
4941  if ((xemask & GDK_KEY_RELEASE_MASK)) {
4942  emask |= kKeyReleaseMask;
4943  }
4944  if ((xemask & GDK_BUTTON_PRESS_MASK)) {
4945  emask |= kButtonPressMask;
4946  }
4947  if ((xemask & GDK_BUTTON_RELEASE_MASK)) {
4948  emask |= kButtonReleaseMask;
4949  }
4950  if ((xemask & GDK_POINTER_MOTION_MASK)) {
4951  emask |= kPointerMotionMask;
4952  }
4953  if ((xemask & GDK_BUTTON_MOTION_MASK)) {
4954  emask |= kButtonMotionMask;
4955  }
4956  if ((xemask & GDK_EXPOSURE_MASK)) {
4957  emask |= kExposureMask;
4958  }
4959  if ((xemask & GDK_STRUCTURE_MASK)) {
4960  emask |= kStructureNotifyMask;
4961  }
4962  if ((xemask & GDK_ENTER_NOTIFY_MASK)) {
4963  emask |= kEnterWindowMask;
4964  }
4965  if ((xemask & GDK_LEAVE_NOTIFY_MASK)) {
4966  emask |= kLeaveWindowMask;
4967  }
4968  if ((xemask & GDK_FOCUS_CHANGE_MASK)) {
4969  emask |= kFocusChangeMask;
4970  }
4971  }
4972 }
4973 
4974 ////////////////////////////////////////////////////////////////////////////////
4975 /// Map a SetWindowAttributes_t to a GdkWindowAttr structure.
4976 
4978  ULong_t & xmask,
4979  GdkWindowAttr & xattr)
4980 {
4981  Mask_t mask = attr->fMask;
4982  xmask = 0;
4983 
4984  if ((mask & kWAOverrideRedirect)) {
4985  xmask |= GDK_WA_NOREDIR;
4986  xattr.override_redirect = attr->fOverrideRedirect;
4987  }
4988  if ((mask & kWAEventMask)) {
4989  UInt_t xmsk, msk = (UInt_t) attr->fEventMask;
4990  MapEventMask(msk, xmsk, kTRUE);
4991  xattr.event_mask = xmsk;
4992  }
4993  if ((mask & kWAColormap)) {
4994  xmask |= GDK_WA_COLORMAP;
4995  xattr.colormap = (GdkColormap *) attr->fColormap;
4996  }
4997  if ((mask & kWACursor)) {
4998  xmask |= GDK_WA_CURSOR;
4999  if (attr->fCursor != kNone) {
5000  xattr.cursor = (GdkCursor *) attr->fCursor;
5001  }
5002  }
5003  xattr.wclass = GDK_INPUT_OUTPUT;
5004 }
5005 
5006 ////////////////////////////////////////////////////////////////////////////////
5007 /// Map a GCValues_t to a XCGValues structure if tox is true. Map
5008 /// the other way in case tox is false.
5009 
5011  ULong_t & xmask, GdkGCValues & xgval, Bool_t tox)
5012 {
5013  if (tox) {
5014  // map GCValues_t to XGCValues
5015  Mask_t mask = gval.fMask;
5016  xmask = 0;
5017 
5018  if ((mask & kGCFunction)) {
5019  xmask |= GDK_GC_FUNCTION;
5020  switch (gval.fFunction) {
5021  case kGXclear:
5022  xgval.function = GDK_CLEAR;
5023  break;
5024  case kGXand:
5025  xgval.function = GDK_AND;
5026  break;
5027  case kGXandReverse:
5028  xgval.function = GDK_AND_REVERSE;
5029  break;
5030  case kGXcopy:
5031  xgval.function = GDK_COPY;
5032  break;
5033  case kGXandInverted:
5034  xgval.function = GDK_AND_INVERT;
5035  break;
5036  case kGXnoop:
5037  xgval.function = GDK_NOOP;
5038  break;
5039  case kGXxor:
5040  xgval.function = GDK_XOR;
5041  break;
5042  case kGXor:
5043  xgval.function = GDK_OR;
5044  break;
5045  case kGXequiv:
5046  xgval.function = GDK_EQUIV;
5047  break;
5048  case kGXinvert:
5049  xgval.function = GDK_INVERT;
5050  break;
5051  case kGXorReverse:
5052  xgval.function = GDK_OR_REVERSE;
5053  break;
5054  case kGXcopyInverted:
5055  xgval.function = GDK_COPY_INVERT;
5056  break;
5057  case kGXorInverted:
5058  xgval.function = GDK_OR_INVERT;
5059  break;
5060  case kGXnand:
5061  xgval.function = GDK_NAND;
5062  break;
5063  case kGXset:
5064  xgval.function = GDK_SET;
5065  break;
5066  }
5067  }
5068  if (mask & kGCSubwindowMode) {
5069  xmask |= GDK_GC_SUBWINDOW;
5070  if (gval.fSubwindowMode == kIncludeInferiors) {
5071  xgval.subwindow_mode = GDK_INCLUDE_INFERIORS;
5072  } else {
5073  xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN;
5074  }
5075  }
5076  if (mask & kGCForeground) {
5077  xmask |= GDK_GC_FOREGROUND;
5078  xgval.foreground.pixel = gval.fForeground;
5079  xgval.foreground.red = GetRValue(gval.fForeground);
5080  xgval.foreground.green = GetGValue(gval.fForeground);
5081  xgval.foreground.blue = GetBValue(gval.fForeground);
5082  }
5083  if (mask & kGCBackground) {
5084  xmask |= GDK_GC_BACKGROUND;
5085  xgval.background.pixel = gval.fBackground;
5086  xgval.background.red = GetRValue(gval.fBackground);
5087  xgval.background.green = GetGValue(gval.fBackground);
5088  xgval.background.blue = GetBValue(gval.fBackground);
5089  }
5090  if (mask & kGCLineWidth) {
5091  xmask |= GDK_GC_LINE_WIDTH;
5092  xgval.line_width = gval.fLineWidth;
5093  }
5094  if (mask & kGCLineStyle) {
5095  xmask |= GDK_GC_LINE_STYLE;
5096  xgval.line_style = (GdkLineStyle) gval.fLineStyle; // ident mapping
5097  }
5098  if (mask & kGCCapStyle) {
5099  xmask |= GDK_GC_CAP_STYLE;
5100  xgval.cap_style = (GdkCapStyle) gval.fCapStyle; // ident mapping
5101  }
5102  if (mask & kGCJoinStyle) {
5103  xmask |= GDK_GC_JOIN_STYLE;
5104  xgval.join_style = (GdkJoinStyle) gval.fJoinStyle; // ident mapping
5105  }
5106  if ((mask & kGCFillStyle)) {
5107  xmask |= GDK_GC_FILL;
5108  xgval.fill = (GdkFill) gval.fFillStyle; // ident mapping
5109  }
5110  if ((mask & kGCTile)) {
5111  xmask |= GDK_GC_TILE;
5112  xgval.tile = (GdkPixmap *) gval.fTile;
5113  }
5114  if ((mask & kGCStipple)) {
5115  xmask |= GDK_GC_STIPPLE;
5116  xgval.stipple = (GdkPixmap *) gval.fStipple;
5117  }
5118  if ((mask & kGCTileStipXOrigin)) {
5119  xmask |= GDK_GC_TS_X_ORIGIN;
5120  xgval.ts_x_origin = gval.fTsXOrigin;
5121  }
5122  if ((mask & kGCTileStipYOrigin)) {
5123  xmask |= GDK_GC_TS_Y_ORIGIN;
5124  xgval.ts_y_origin = gval.fTsYOrigin;
5125  }
5126  if ((mask & kGCFont)) {
5127  xmask |= GDK_GC_FONT;
5128  xgval.font = (GdkFont *) gval.fFont;
5129  }
5130  if ((mask & kGCGraphicsExposures)) {
5131  xmask |= GDK_GC_EXPOSURES;
5132  xgval.graphics_exposures = gval.fGraphicsExposures;
5133  }
5134  if ((mask & kGCClipXOrigin)) {
5135  xmask |= GDK_GC_CLIP_X_ORIGIN;
5136  xgval.clip_x_origin = gval.fClipXOrigin;
5137  }
5138  if ((mask & kGCClipYOrigin)) {
5139  xmask |= GDK_GC_CLIP_Y_ORIGIN;
5140  xgval.clip_y_origin = gval.fClipYOrigin;
5141  }
5142  if ((mask & kGCClipMask)) {
5143  xmask |= GDK_GC_CLIP_MASK;
5144  xgval.clip_mask = (GdkPixmap *) gval.fClipMask;
5145  }
5146  } else {
5147  // map XValues to GCValues_t
5148  Mask_t mask = 0;
5149 
5150  if ((xmask & GDK_GC_FUNCTION)) {
5151  mask |= kGCFunction;
5152  gval.fFunction = (EGraphicsFunction) xgval.function; // ident mapping
5153  switch (xgval.function) {
5154  case GDK_CLEAR:
5155  gval.fFunction = kGXclear;
5156  break;
5157  case GDK_AND:
5158  gval.fFunction = kGXand;
5159  break;
5160  case GDK_AND_REVERSE:
5161  gval.fFunction = kGXandReverse;
5162  break;
5163  case GDK_COPY:
5164  gval.fFunction = kGXcopy;
5165  break;
5166  case GDK_AND_INVERT:
5167  gval.fFunction = kGXandInverted;
5168  break;
5169  case GDK_NOOP:
5170  gval.fFunction = kGXnoop;
5171  break;
5172  case GDK_XOR:
5173  gval.fFunction = kGXxor;
5174  break;
5175  case GDK_OR:
5176  gval.fFunction = kGXor;
5177  break;
5178  case GDK_EQUIV:
5179  gval.fFunction = kGXequiv;
5180  break;
5181  case GDK_INVERT:
5182  gval.fFunction = kGXinvert;
5183  break;
5184  case GDK_OR_REVERSE:
5185  gval.fFunction = kGXorReverse;
5186  break;
5187  case GDK_COPY_INVERT:
5188  gval.fFunction = kGXcopyInverted;
5189  break;
5190  case GDK_OR_INVERT:
5191  gval.fFunction = kGXorInverted;
5192  break;
5193  case GDK_NAND:
5194  gval.fFunction = kGXnand;
5195  break;
5196  case GDK_SET:
5197  gval.fFunction = kGXset;
5198  break;
5199  }
5200  }
5201  if (xmask & GDK_GC_SUBWINDOW) {
5202  mask |= kGCSubwindowMode;
5203  if (xgval.subwindow_mode == GDK_INCLUDE_INFERIORS)
5205  else
5207  }
5208  if ((xmask & GDK_GC_FOREGROUND)) {
5209  mask |= kGCForeground;
5210  gval.fForeground = xgval.foreground.pixel;
5211  }
5212  if ((xmask & GDK_GC_BACKGROUND)) {
5213  mask |= kGCBackground;
5214  gval.fBackground = xgval.background.pixel;
5215  }
5216  if ((xmask & GDK_GC_LINE_WIDTH)) {
5217  mask |= kGCLineWidth;
5218  gval.fLineWidth = xgval.line_width;
5219  }
5220  if ((xmask & GDK_GC_LINE_STYLE)) {
5221  mask |= kGCLineStyle;
5222  gval.fLineStyle = xgval.line_style; // ident mapping
5223  }
5224  if ((xmask & GDK_GC_CAP_STYLE)) {
5225  mask |= kGCCapStyle;
5226  gval.fCapStyle = xgval.cap_style; // ident mapping
5227  }
5228  if ((xmask & GDK_GC_JOIN_STYLE)) {
5229  mask |= kGCJoinStyle;
5230  gval.fJoinStyle = xgval.join_style; // ident mapping
5231  }
5232  if ((xmask & GDK_GC_FILL)) {
5233  mask |= kGCFillStyle;
5234  gval.fFillStyle = xgval.fill; // ident mapping
5235  }
5236  if ((xmask & GDK_GC_TILE)) {
5237  mask |= kGCTile;
5238  gval.fTile = (Pixmap_t) xgval.tile;
5239  }
5240  if ((xmask & GDK_GC_STIPPLE)) {
5241  mask |= kGCStipple;
5242  gval.fStipple = (Pixmap_t) xgval.stipple;
5243  }
5244  if ((xmask & GDK_GC_TS_X_ORIGIN)) {
5245  mask |= kGCTileStipXOrigin;
5246  gval.fTsXOrigin = xgval.ts_x_origin;
5247  }
5248  if ((xmask & GDK_GC_TS_Y_ORIGIN)) {
5249  mask |= kGCTileStipYOrigin;
5250  gval.fTsYOrigin = xgval.ts_y_origin;
5251  }
5252  if ((xmask & GDK_GC_FONT)) {
5253  mask |= kGCFont;
5254  gval.fFont = (FontH_t) xgval.font;
5255  }
5256  if ((xmask & GDK_GC_EXPOSURES)) {
5257  mask |= kGCGraphicsExposures;
5258  gval.fGraphicsExposures = (Bool_t) xgval.graphics_exposures;
5259  }
5260  if ((xmask & GDK_GC_CLIP_X_ORIGIN)) {
5261  mask |= kGCClipXOrigin;
5262  gval.fClipXOrigin = xgval.clip_x_origin;
5263  }
5264  if ((xmask & GDK_GC_CLIP_Y_ORIGIN)) {
5265  mask |= kGCClipYOrigin;
5266  gval.fClipYOrigin = xgval.clip_y_origin;
5267  }
5268  if ((xmask & GDK_GC_CLIP_MASK)) {
5269  mask |= kGCClipMask;
5270  gval.fClipMask = (Pixmap_t) xgval.clip_mask;
5271  }
5272  gval.fMask = mask;
5273  }
5274 }
5275 
5276 ////////////////////////////////////////////////////////////////////////////////
5277 /// Get window attributes and return filled in attributes structure.
5278 
5280 {
5281  if (!id) return;
5282 
5283  RECT rcClient, rcWind;
5284  ::GetClientRect((HWND)GDK_DRAWABLE_XID((GdkWindow *) id), &rcClient);
5285  ::GetWindowRect((HWND)GDK_DRAWABLE_XID((GdkWindow *) id), &rcWind);
5286 
5287  gdk_window_get_geometry((GdkWindow *) id, &attr.fX, &attr.fY,
5288  &attr.fWidth, &attr.fHeight, &attr.fDepth);
5289  attr.fX = ((rcWind.right - rcWind.left) - rcClient.right) / 2;
5290  attr.fY = ((rcWind.bottom - rcWind.top) - rcClient.bottom) - attr.fX;
5291 
5292  attr.fRoot = (Window_t) GDK_ROOT_PARENT();
5293  attr.fColormap = (Colormap_t) gdk_window_get_colormap((GdkWindow *) id);
5294  attr.fBorderWidth = 0;
5295  attr.fVisual = gdk_window_get_visual((GdkWindow *) id);
5296  attr.fClass = kInputOutput;
5297  attr.fBackingStore = kNotUseful;
5298  attr.fSaveUnder = kFALSE;
5299  attr.fMapInstalled = kTRUE;
5300  attr.fOverrideRedirect = kFALSE; // boolean value for override-redirect
5301 
5302  if (!gdk_window_is_visible((GdkWindow *) id)) {
5303  attr.fMapState = kIsUnmapped;
5304  } else if (!gdk_window_is_viewable((GdkWindow *) id)) {
5305  attr.fMapState = kIsUnviewable;
5306  } else {
5307  attr.fMapState = kIsViewable;
5308  }
5309 
5310  UInt_t tmp_mask = (UInt_t)gdk_window_get_events((GdkWindow *) id);
5311  UInt_t evmask;
5312  MapEventMask(evmask, tmp_mask, kFALSE);
5313 
5314  attr.fYourEventMask = evmask;
5315 }
5316 
5317 ////////////////////////////////////////////////////////////////////////////////
5318 ///
5319 
5321 {
5322  return 0;
5323 }
5324 
5325 ////////////////////////////////////////////////////////////////////////////////
5326 /// Get maximum number of planes.
5327 
5329 {
5330  return gdk_visual_get_best_depth();
5331 }
5332 
5333 ////////////////////////////////////////////////////////////////////////////////
5334 /// Return atom handle for atom_name. If it does not exist
5335 /// create it if only_if_exist is false. Atoms are used to communicate
5336 /// between different programs (i.e. window manager) via the X server.
5337 
5338 Atom_t TGWin32::InternAtom(const char *atom_name, Bool_t only_if_exist)
5339 {
5340  GdkAtom a = gdk_atom_intern((const gchar *) atom_name, only_if_exist);
5341 
5342  if (a == None) return kNone;
5343  return (Atom_t) a;
5344 }
5345 
5346 ////////////////////////////////////////////////////////////////////////////////
5347 /// Return handle to the default root window created when calling
5348 /// XOpenDisplay().
5349 
5351 {
5352  return (Window_t) GDK_ROOT_PARENT();
5353 }
5354 
5355 ////////////////////////////////////////////////////////////////////////////////
5356 /// Return the parent of the window.
5357 
5359 {
5360  if (!id) return (Window_t)0;
5361 
5362  return (Window_t)gdk_window_get_parent((GdkWindow *) id);
5363 }
5364 
5365 ////////////////////////////////////////////////////////////////////////////////
5366 /// Load font and query font. If font is not found 0 is returned,
5367 /// otherwise an opaque pointer to the FontStruct_t.
5368 /// Free the loaded font using DeleteFont().
5369 
5370 FontStruct_t TGWin32::LoadQueryFont(const char *font_name)
5371 {
5372  char family[100], weight[32], slant[32], fontname[256];
5373  Int_t n1, pixel, numfields;
5374 
5375  numfields = sscanf(font_name, "%s -%d%n", family, &pixel, &n1);
5376  if (numfields == 2) {
5377  sprintf(weight,"medium");
5378  if (strstr(font_name, "bold"))
5379  sprintf(weight,"bold");
5380  sprintf(slant,"r");
5381  if (strstr(font_name, "italic"))
5382  sprintf(slant,"i");
5383  sprintf(fontname, "-*-%s-%s-%s-*-*-%d-*-*-*-*-*-iso8859-1",
5384  family, weight, slant, pixel);
5385  }
5386  else
5387  sprintf(fontname, "%s", font_name);
5388  return (FontStruct_t) gdk_font_load(fontname);
5389 }
5390 
5391 ////////////////////////////////////////////////////////////////////////////////
5392 /// Return handle to font described by font structure.
5393 
5395 {
5396  if (fs) {
5397  return (FontH_t)gdk_font_ref((GdkFont *) fs);
5398  }
5399  return 0;
5400 }
5401 
5402 ////////////////////////////////////////////////////////////////////////////////
5403 /// Explicitely delete font structure obtained with LoadQueryFont().
5404 
5406 {
5407  gdk_font_unref((GdkFont *) fs);
5408 }
5409 
5410 ////////////////////////////////////////////////////////////////////////////////
5411 /// Create a graphics context using the values set in gval (but only for
5412 /// those entries that are in the mask).
5413 
5415 {
5416  if (!id) return (GContext_t)0;
5417 
5418  GdkGCValues xgval;
5419  ULong_t xmask = 0;
5420 
5421  if (gval) MapGCValues(*gval, xmask, xgval, kTRUE);
5422 
5423  xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN; // GDK_INCLUDE_INFERIORS;
5424 
5425  GdkGC *gc = gdk_gc_new_with_values((GdkDrawable *) id,
5426  &xgval, (GdkGCValuesMask)xmask);
5427  return (GContext_t) gc;
5428 }
5429 
5430 ////////////////////////////////////////////////////////////////////////////////
5431 /// Change entries in an existing graphics context, gc, by values from gval.
5432 
5434 {
5435  GdkGCValues xgval;
5436  ULong_t xmask = 0;
5437  Mask_t mask = 0;
5438 
5439  if (gval) {
5440  mask = gval->fMask;
5441  MapGCValues(*gval, xmask, xgval, kTRUE);
5442  }
5443  if (mask & kGCForeground) {
5444  gdk_gc_set_foreground((GdkGC *) gc, &xgval.foreground);
5445  }
5446  if (mask & kGCBackground) {
5447  gdk_gc_set_background((GdkGC *) gc, &xgval.background);
5448  }
5449  if (mask & kGCFont) {
5450  gdk_gc_set_font((GdkGC *) gc, xgval.font);
5451  }
5452  if (mask & kGCFunction) {
5453  gdk_gc_set_function((GdkGC *) gc, xgval.function);
5454  }
5455  if (mask & kGCFillStyle) {
5456  gdk_gc_set_fill((GdkGC *) gc, xgval.fill);
5457  }
5458  if (mask & kGCTile) {
5459  gdk_gc_set_tile((GdkGC *) gc, xgval.tile);
5460  }
5461  if (mask & kGCStipple) {
5462  gdk_gc_set_stipple((GdkGC *) gc, xgval.stipple);
5463  }
5464  if ((mask & kGCTileStipXOrigin) || (mask & kGCTileStipYOrigin)) {
5465  gdk_gc_set_ts_origin((GdkGC *) gc, xgval.ts_x_origin,
5466  xgval.ts_y_origin);
5467  }
5468  if ((mask & kGCClipXOrigin) || (mask & kGCClipYOrigin)) {
5469  gdk_gc_set_clip_origin((GdkGC *) gc, xgval.clip_x_origin,
5470  xgval.clip_y_origin);
5471  }
5472  if (mask & kGCClipMask) {
5473  gdk_gc_set_clip_mask((GdkGC *) gc, xgval.clip_mask);
5474  }
5475  if (mask & kGCGraphicsExposures) {
5476  gdk_gc_set_exposures((GdkGC *) gc, xgval.graphics_exposures);
5477  }
5478  if (mask & kGCLineWidth) {
5479  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_WIDTH);
5480  }
5481  if (mask & kGCLineStyle) {
5482  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_STYLE);
5483  }
5484  if (mask & kGCCapStyle) {
5485  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_CAP_STYLE);
5486  }
5487  if (mask & kGCJoinStyle) {
5488  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_JOIN_STYLE);
5489  }
5490  if (mask & kGCSubwindowMode) {
5491  gdk_gc_set_subwindow((GdkGC *) gc, xgval.subwindow_mode);
5492  }
5493 }
5494 
5495 ////////////////////////////////////////////////////////////////////////////////
5496 /// Copies graphics context from org to dest. Only the values specified
5497 /// in mask are copied. Both org and dest must exist.
5498 
5500 {
5501  GCValues_t gval;
5502  GdkGCValues xgval;
5503  ULong_t xmask;
5504 
5505  if (!mask) {
5506  // in this case copy all fields
5507  mask = (Mask_t) - 1;
5508  }
5509 
5510  gval.fMask = mask; // only set fMask used to convert to xmask
5511  MapGCValues(gval, xmask, xgval, kTRUE);
5512 
5513  gdk_gc_copy((GdkGC *) dest, (GdkGC *) org);
5514 }
5515 
5516 ////////////////////////////////////////////////////////////////////////////////
5517 /// Explicitely delete a graphics context.
5518 
5520 {
5521  gdk_gc_unref((GdkGC *) gc);
5522 }
5523 
5524 ////////////////////////////////////////////////////////////////////////////////
5525 /// Create cursor handle (just return cursor from cursor pool fCursors).
5526 
5528 {
5529  return (Cursor_t) fCursors[cursor];
5530 }
5531 
5532 ////////////////////////////////////////////////////////////////////////////////
5533 /// Creates a pixmap of the width and height you specified
5534 /// and returns a pixmap ID that identifies it.
5535 
5537 {
5538  GdkWindow *wid = (GdkWindow *)id;
5539  if (!id) wid = GDK_ROOT_PARENT();
5540 
5541  return (Pixmap_t) gdk_pixmap_new(wid, w, h, gdk_visual_get_best_depth());
5542 }
5543 
5544 ////////////////////////////////////////////////////////////////////////////////
5545 /// Create a pixmap from bitmap data. Ones will get foreground color and
5546 /// zeroes background color.
5547 
5549  UInt_t width, UInt_t height,
5550  ULong_t forecolor, ULong_t backcolor,
5551  Int_t depth)
5552 {
5553  GdkColor fore, back;
5554  fore.pixel = forecolor;
5555  fore.red = GetRValue(forecolor);
5556  fore.green = GetGValue(forecolor);
5557  fore.blue = GetBValue(forecolor);
5558 
5559  back.pixel = backcolor;
5560  back.red = GetRValue(backcolor);
5561  back.green = GetGValue(backcolor);
5562  back.blue = GetBValue(backcolor);
5563 
5564  GdkWindow *wid = (GdkWindow *)id;
5565  if (!id) wid = GDK_ROOT_PARENT();
5566 
5567  return (Pixmap_t) gdk_pixmap_create_from_data(wid, (char *) bitmap, width,
5568  height, depth, &fore, &back);
5569 }
5570 
5571 ////////////////////////////////////////////////////////////////////////////////
5572 /// Create a bitmap (i.e. pixmap with depth 1) from the bitmap data.
5573 
5575  UInt_t width, UInt_t height)
5576 {
5577  GdkWindow *wid = (GdkWindow *)id;
5578  if (!id) wid = GDK_ROOT_PARENT();
5579 
5580  Pixmap_t ret = (Pixmap_t) gdk_bitmap_create_from_data(wid,
5581  (char *)bitmap, width, height);
5582  return ret;
5583 }
5584 
5585 ////////////////////////////////////////////////////////////////////////////////
5586 /// Explicitely delete pixmap resource.
5587 
5589 {
5590  gdk_pixmap_unref((GdkPixmap *) pmap);
5591 }
5592 
5593 ////////////////////////////////////////////////////////////////////////////////
5594 /// Create a picture pixmap from data on file. The picture attributes
5595 /// are used for input and output. Returns kTRUE in case of success,
5596 /// kFALSE otherwise. If mask does not exist it is set to kNone.
5597 
5599  Pixmap_t & pict,
5600  Pixmap_t & pict_mask,
5601  PictureAttributes_t & attr)
5602 {
5603  GdkBitmap *gdk_pixmap_mask;
5604  if (strstr(filename, ".xpm") || strstr(filename, ".XPM")) {
5605  GdkWindow *wid = (GdkWindow *)id;
5606  if (!id) wid = GDK_ROOT_PARENT();
5607 
5608  pict = (Pixmap_t) gdk_pixmap_create_from_xpm(wid, &gdk_pixmap_mask, 0,
5609  filename);
5610  pict_mask = (Pixmap_t) gdk_pixmap_mask;
5611  } else if (strstr(filename, ".gif") || strstr(filename, ".GIF")) {
5612  pict = ReadGIF(0, 0, filename, id);
5613  pict_mask = kNone;
5614  }
5615 
5616  gdk_drawable_get_size((GdkPixmap *) pict, (int *) &attr.fWidth,
5617  (int *) &attr.fHeight);
5618  if (pict) {
5619  return kTRUE;
5620  }
5621  if (pict_mask) {
5622  pict_mask = kNone;
5623  }
5624  return kFALSE;
5625 }
5626 
5627 ////////////////////////////////////////////////////////////////////////////////
5628 /// Create a pixture pixmap from data. The picture attributes
5629 /// are used for input and output. Returns kTRUE in case of success,
5630 /// kFALSE otherwise. If mask does not exist it is set to kNone.
5631 
5633  Pixmap_t & pict,
5634  Pixmap_t & pict_mask,
5635  PictureAttributes_t & attr)
5636 {
5637  GdkBitmap *gdk_pixmap_mask;
5638  GdkWindow *wid = (GdkWindow *)id;
5639  if (!id) wid = GDK_ROOT_PARENT();
5640 
5641  pict = (Pixmap_t) gdk_pixmap_create_from_xpm_d(wid, &gdk_pixmap_mask, 0,
5642  data);
5643  pict_mask = (Pixmap_t) gdk_pixmap_mask;
5644 
5645  if (pict) {
5646  return kTRUE;
5647  }
5648  if (pict_mask) {
5649  pict_mask = kNone;
5650  }
5651  return kFALSE;
5652 }
5653 
5654 ////////////////////////////////////////////////////////////////////////////////
5655 /// Read picture data from file and store in ret_data. Returns kTRUE in
5656 /// case of success, kFALSE otherwise.
5657 
5658 Bool_t TGWin32::ReadPictureDataFromFile(const char *filename, char ***ret_data)
5659 {
5660  Bool_t ret = kFALSE;
5661  GdkPixmap *pxm = gdk_pixmap_create_from_xpm(NULL, NULL, NULL, filename);
5662  ret_data = 0;
5663 
5664  if (pxm==NULL) return kFALSE;
5665 
5666  HBITMAP hbm = (HBITMAP)GDK_DRAWABLE_XID(pxm);
5667  BITMAP bitmap;
5668 
5669  ret = ::GetObject(hbm, sizeof(HBITMAP), (LPVOID)&bitmap);
5670  ret_data = (char ***)&bitmap.bmBits;
5671  gdk_pixmap_unref(pxm);
5672  return ret;
5673 }
5674 
5675 ////////////////////////////////////////////////////////////////////////////////
5676 /// Delete picture data created by the function ReadPictureDataFromFile.
5677 
5679 {
5680  free(data);
5681 }
5682 
5683 ////////////////////////////////////////////////////////////////////////////////
5684 /// Specify a dash pattertn. Offset defines the phase of the pattern.
5685 /// Each element in the dash_list array specifies the length (in pixels)
5686 /// of a segment of the pattern. N defines the length of the list.
5687 
5688 void TGWin32::SetDashes(GContext_t gc, Int_t offset, const char *dash_list,
5689  Int_t n)
5690 {
5691  int i;
5692  gint8 dashes[32];
5693  for (i = 0; i < n; i++) {
5694  dashes[i] = (gint8) dash_list[i];
5695  }
5696  for (i = n; i < 32; i++) {
5697  dashes[i] = (gint8) 0;
5698  }
5699 
5700  gdk_gc_set_dashes((GdkGC *) gc, offset, dashes, n);
5701 }
5702 
5703 ////////////////////////////////////////////////////////////////////////////////
5704 /// Map a ColorStruct_t to a XColor structure.
5705 
5706 void TGWin32::MapColorStruct(ColorStruct_t * color, GdkColor & xcolor)
5707 {
5708  xcolor.pixel = color->fPixel;
5709  xcolor.red = color->fRed;
5710  xcolor.green = color->fGreen;
5711  xcolor.blue = color->fBlue;
5712 }
5713 
5714 ////////////////////////////////////////////////////////////////////////////////
5715 /// Parse string cname containing color name, like "green" or "#00FF00".
5716 /// It returns a filled in ColorStruct_t. Returns kFALSE in case parsing
5717 /// failed, kTRUE in case of success. On success, the ColorStruct_t
5718 /// fRed, fGreen and fBlue fields are all filled in and the mask is set
5719 /// for all three colors, but fPixel is not set.
5720 
5721 Bool_t TGWin32::ParseColor(Colormap_t cmap, const char *cname,
5722  ColorStruct_t & color)
5723 {
5724  GdkColor xc;
5725 
5726  if (gdk_color_parse((char *)cname, &xc)) {
5727  color.fPixel = xc.pixel = RGB(xc.red, xc.green, xc.blue);
5728  color.fRed = xc.red;
5729  color.fGreen = xc.green;
5730  color.fBlue = xc.blue;
5731  return kTRUE;
5732  }
5733  return kFALSE;
5734 }
5735 
5736 ////////////////////////////////////////////////////////////////////////////////
5737 /// Find and allocate a color cell according to the color values specified
5738 /// in the ColorStruct_t. If no cell could be allocated it returns kFALSE,
5739 /// otherwise kTRUE.
5740 
5742 {
5743  int status;
5744  GdkColor xc;
5745 
5746  xc.red = color.fRed;
5747  xc.green = color.fGreen;
5748  xc.blue = color.fBlue;
5749 
5750  status = gdk_colormap_alloc_color((GdkColormap *) cmap, &xc, FALSE, TRUE);
5751  color.fPixel = xc.pixel;
5752 
5753  return kTRUE; // status != 0 ? kTRUE : kFALSE;
5754 }
5755 
5756 ////////////////////////////////////////////////////////////////////////////////
5757 /// Fill in the primary color components for a specific pixel value.
5758 /// On input fPixel should be set on return the fRed, fGreen and
5759 /// fBlue components will be set.
5760 
5762 {
5763  GdkColor xc;
5764  xc.pixel = color.fPixel;
5765 
5766  GdkColorContext *cc = gdk_color_context_new(gdk_visual_get_system(), fColormap);
5767  gdk_color_context_query_color(cc, &xc);
5768  gdk_color_context_free(cc);
5769 
5770  color.fPixel = xc.pixel;
5771  color.fRed = xc.red;
5772  color.fGreen = xc.green;
5773  color.fBlue = xc.blue;
5774 }
5775 
5776 ////////////////////////////////////////////////////////////////////////////////
5777 /// Free color cell with specified pixel value.
5778 
5780 {
5781  // FIXME: to be implemented.
5782 }
5783 
5784 ////////////////////////////////////////////////////////////////////////////////
5785 /// Check if there is for window "id" an event of type "type". If there
5786 /// is fill in the event structure and return true. If no such event
5787 /// return false.
5788 
5790 {
5791  if (!id) return kFALSE;
5792 
5793  Event_t tev;
5794  GdkEvent xev;
5795 
5796  tev.fType = type;
5797  tev.fWindow = (Window_t) id;
5798  tev.fTime = 0;
5799  tev.fX = tev.fY = 0;
5800  tev.fXRoot = tev.fYRoot = 0;
5801  tev.fCode = 0;
5802  tev.fState = 0;
5803  tev.fWidth = tev.fHeight = 0;
5804  tev.fCount = 0;
5805  tev.fSendEvent = kFALSE;
5806  tev.fHandle = 0;
5807  tev.fFormat = 0;
5808  tev.fUser[0] = tev.fUser[1] = tev.fUser[2] = tev.fUser[3] = tev.fUser[4] = 0L;
5809 
5810  TGWin32MainThread::LockMSG();
5811  MapEvent(tev, xev, kTRUE);
5812  Bool_t r = gdk_check_typed_window_event((GdkWindow *) id, xev.type, &xev);
5813 
5814  if (r) MapEvent(ev, xev, kFALSE);
5815  TGWin32MainThread::UnlockMSG();
5816 
5817  return r ? kTRUE : kFALSE;
5818 }
5819 
5820 ////////////////////////////////////////////////////////////////////////////////
5821 /// Send event ev to window id.
5822 
5824 {
5825  if (!ev || !id) return;
5826 
5827  TGWin32MainThread::LockMSG();
5828  GdkEvent xev;
5829  MapEvent(*ev, xev, kTRUE);
5830  gdk_event_put(&xev);
5831  TGWin32MainThread::UnlockMSG();
5832 }
5833 
5834 ////////////////////////////////////////////////////////////////////////////////
5835 /// Returns number of pending events.
5836 
5838 {
5839  Int_t ret;
5840 
5841  TGWin32MainThread::LockMSG();
5842  ret = (Int_t)gdk_event_queue_find_first();
5843  TGWin32MainThread::UnlockMSG();
5844 
5845  return ret;
5846 }
5847 
5848 ////////////////////////////////////////////////////////////////////////////////
5849 /// Copies first pending event from event queue to Event_t structure
5850 /// and removes event from queue. Not all of the event fields are valid
5851 /// for each event type, except fType and fWindow.
5852 
5854 {
5855  TGWin32MainThread::LockMSG();
5856  GdkEvent *xev = gdk_event_unqueue();
5857 
5858  // fill in Event_t
5859  event.fType = kOtherEvent; // bb add
5860  if (xev == NULL) {
5861  TGWin32MainThread::UnlockMSG();
5862  return;
5863  }
5864  MapEvent(event, *xev, kFALSE);
5865  gdk_event_free (xev);
5866  TGWin32MainThread::UnlockMSG();
5867 }
5868 
5869 ////////////////////////////////////////////////////////////////////////////////
5870 /// Map modifier key state to or from X.
5871 
5872 void TGWin32::MapModifierState(UInt_t & state, UInt_t & xstate, Bool_t tox)
5873 {
5874  if (tox) {
5875  xstate = state;
5876  if (state & kAnyModifier) {
5877  xstate = GDK_MODIFIER_MASK;
5878  }
5879  } else {
5880  state = xstate;
5881  }
5882 }
5883 
5884 static void _set_event_time(GdkEvent &event, UInt_t time)
5885 {
5886  // set gdk event time
5887 
5888  switch (event.type) {
5889  case GDK_MOTION_NOTIFY:
5890  event.motion.time = time;
5891  case GDK_BUTTON_PRESS:
5892  case GDK_2BUTTON_PRESS:
5893  case GDK_3BUTTON_PRESS:
5894  case GDK_BUTTON_RELEASE:
5895  case GDK_SCROLL:
5896  event.button.time = time;
5897  case GDK_KEY_PRESS:
5898  case GDK_KEY_RELEASE:
5899  event.key.time = time;
5900  case GDK_ENTER_NOTIFY:
5901  case GDK_LEAVE_NOTIFY:
5902  event.crossing.time = time;
5903  case GDK_PROPERTY_NOTIFY:
5904  event.property.time = time;
5905  case GDK_SELECTION_CLEAR:
5906  case GDK_SELECTION_REQUEST:
5907  case GDK_SELECTION_NOTIFY:
5908  event.selection.time = time;
5909  case GDK_PROXIMITY_IN:
5910  case GDK_PROXIMITY_OUT:
5911  event.proximity.time = time;
5912  case GDK_DRAG_ENTER:
5913  case GDK_DRAG_LEAVE:
5914  case GDK_DRAG_MOTION:
5915  case GDK_DRAG_STATUS:
5916  case GDK_DROP_START:
5917  case GDK_DROP_FINISHED:
5918  event.dnd.time = time;
5919  default: /* use current time */
5920  break;
5921  }
5922 }
5923 
5924 ////////////////////////////////////////////////////////////////////////////////
5925 /// Map Event_t structure to gdk_event structure. If tox is false
5926 /// map the other way.
5927 
5928 void TGWin32::MapEvent(Event_t & ev, GdkEvent & xev, Bool_t tox)
5929 {
5930  if (tox) {
5931  // map from Event_t to gdk_event
5932  xev.type = GDK_NOTHING;
5933  if (ev.fType == kGKeyPress)
5934  xev.type = GDK_KEY_PRESS;
5935  if (ev.fType == kKeyRelease)
5936  xev.type = GDK_KEY_RELEASE;
5937  if (ev.fType == kButtonPress)
5938  xev.type = GDK_BUTTON_PRESS;
5939  if (ev.fType == kButtonRelease)
5940  xev.type = GDK_BUTTON_RELEASE;
5941  if (ev.fType == kMotionNotify)
5942  xev.type = GDK_MOTION_NOTIFY;
5943  if (ev.fType == kEnterNotify)
5944  xev.type = GDK_ENTER_NOTIFY;
5945  if (ev.fType == kLeaveNotify)
5946  xev.type = GDK_LEAVE_NOTIFY;
5947  if (ev.fType == kExpose)
5948  xev.type = GDK_EXPOSE;
5949  if (ev.fType == kConfigureNotify)
5950  xev.type = GDK_CONFIGURE;
5951  if (ev.fType == kMapNotify)
5952  xev.type = GDK_MAP;
5953  if (ev.fType == kUnmapNotify)
5954  xev.type = GDK_UNMAP;
5955  if (ev.fType == kDestroyNotify)
5956  xev.type = GDK_DESTROY;
5957  if (ev.fType == kClientMessage)
5958  xev.type = GDK_CLIENT_EVENT;
5959  if (ev.fType == kSelectionClear)
5960  xev.type = GDK_SELECTION_CLEAR;
5961  if (ev.fType == kSelectionRequest)
5962  xev.type = GDK_SELECTION_REQUEST;
5963  if (ev.fType == kSelectionNotify)
5964  xev.type = GDK_SELECTION_NOTIFY;
5965 
5966  xev.any.type = xev.type;
5967  xev.any.send_event = ev.fSendEvent;
5968  if (ev.fType == kDestroyNotify) {
5969  xev.any.window = (GdkWindow *) ev.fWindow;
5970  }
5971  if (ev.fType == kFocusIn) {
5972  xev.type = GDK_FOCUS_CHANGE;
5973  xev.focus_change.type = xev.type;
5974  xev.focus_change.window = (GdkWindow *) ev.fWindow;
5975  xev.focus_change.in = TRUE;
5976  }
5977  if (ev.fType == kFocusOut) {
5978  xev.type = GDK_FOCUS_CHANGE;
5979  xev.focus_change.type = xev.type;
5980  xev.focus_change.window = (GdkWindow *) ev.fWindow;
5981  xev.focus_change.in = FALSE;
5982  }
5983  if (ev.fType == kGKeyPress || ev.fType == kKeyRelease) {
5984  xev.key.window = (GdkWindow *) ev.fWindow;
5985  xev.key.type = xev.type;
5986  MapModifierState(ev.fState, xev.key.state, kTRUE); // key mask
5987  xev.key.keyval = ev.fCode; // key code
5988  }
5989  if (ev.fType == kButtonPress || ev.fType == kButtonRelease) {
5990  xev.button.window = (GdkWindow *) ev.fWindow;
5991  xev.button.type = xev.type;
5992  xev.button.x = ev.fX;
5993  xev.button.y = ev.fY;
5994  xev.button.x_root = ev.fXRoot;
5995  xev.button.y_root = ev.fYRoot;
5996  MapModifierState(ev.fState, xev.button.state, kTRUE); // button mask
5997  xev.button.button = ev.fCode; // button code
5998  }
5999  if (ev.fType == kSelectionNotify) {
6000  xev.selection.window = (GdkWindow *) ev.fUser[0];
6001  xev.selection.requestor = (guint32) ev.fUser[0];
6002  xev.selection.selection = (GdkAtom) ev.fUser[1];
6003  xev.selection.target = (GdkAtom) ev.fUser[2];
6004  xev.selection.property = (GdkAtom) ev.fUser[3];
6005  xev.selection.type = xev.type;
6006  }
6007  if (ev.fType == kClientMessage) {
6008  if ((ev.fFormat == 32) && (ev.fHandle == gWM_DELETE_WINDOW)) {
6009  xev.type = GDK_DELETE;
6010  xev.any.type = xev.type;
6011  xev.any.window = (GdkWindow *) ev.fWindow;
6012  } else {
6013  xev.client.window = (GdkWindow *) ev.fWindow;
6014  xev.client.type = xev.type;
6015  xev.client.message_type = (GdkAtom) ev.fHandle;
6016  xev.client.data_format = ev.fFormat;
6017  xev.client.data.l[0] = ev.fUser[0];
6018  if (sizeof(ev.fUser[0]) > 4) {
6019  SplitLong(ev.fUser[1], xev.client.data.l[1],
6020  xev.client.data.l[3]);
6021  SplitLong(ev.fUser[2], xev.client.data.l[2],
6022  xev.client.data.l[4]);
6023  } else {
6024  xev.client.data.l[1] = ev.fUser[1];
6025  xev.client.data.l[2] = ev.fUser[2];
6026  xev.client.data.l[3] = ev.fUser[3];
6027  xev.client.data.l[4] = ev.fUser[4];
6028  }
6029  }
6030  }
6031  if (ev.fType == kMotionNotify) {
6032  xev.motion.window = (GdkWindow *) ev.fWindow;
6033  xev.motion.type = xev.type;
6034  xev.motion.x = ev.fX;
6035  xev.motion.y = ev.fY;
6036  xev.motion.x_root = ev.fXRoot;
6037  xev.motion.y_root = ev.fYRoot;
6038  }
6039  if ((ev.fType == kEnterNotify) || (ev.fType == kLeaveNotify)) {
6040  xev.crossing.window = (GdkWindow *) ev.fWindow;
6041  xev.crossing.type = xev.type;
6042  xev.crossing.x = ev.fX;
6043  xev.crossing.y = ev.fY;
6044  xev.crossing.x_root = ev.fXRoot;
6045  xev.crossing.y_root = ev.fYRoot;
6046  xev.crossing.mode = (GdkCrossingMode) ev.fCode; // NotifyNormal, NotifyGrab, NotifyUngrab
6047  MapModifierState(ev.fState, xev.crossing.state, kTRUE); // key or button mask
6048  }
6049  if (ev.fType == kExpose) {
6050  xev.expose.window = (GdkWindow *) ev.fWindow;
6051  xev.expose.type = xev.type;
6052  xev.expose.area.x = ev.fX;
6053  xev.expose.area.y = ev.fY;
6054  xev.expose.area.width = ev.fWidth; // width and
6055  xev.expose.area.height = ev.fHeight; // height of exposed area
6056  xev.expose.count = ev.fCount; // number of expose events still to come
6057  }
6058  if (ev.fType == kConfigureNotify) {
6059  xev.configure.window = (GdkWindow *) ev.fWindow;
6060  xev.configure.type = xev.type;
6061  xev.configure.x = ev.fX;
6062  xev.configure.y = ev.fY;
6063  xev.configure.width = ev.fWidth;
6064  xev.configure.height = ev.fHeight;
6065  }
6066  if (ev.fType == kSelectionClear) {
6067  xev.selection.window = (GdkWindow *) ev.fWindow;
6068  xev.selection.type = xev.type;
6069  xev.selection.selection = ev.fUser[0];
6070  }
6071  if (ev.fType == kSelectionRequest) {
6072  xev.selection.window = (GdkWindow *) ev.fUser[0];
6073  xev.selection.type = xev.type;
6074  xev.selection.selection = ev.fUser[1];
6075  xev.selection.target = ev.fUser[2];
6076  xev.selection.property = ev.fUser[3];
6077  }
6078  if ((ev.fType == kMapNotify) || (ev.fType == kUnmapNotify)) {
6079  xev.any.window = (GdkWindow *) ev.fWindow;
6080  }
6081  if (xev.type != GDK_CLIENT_EVENT)
6082  _set_event_time(xev, ev.fTime);
6083  } else {
6084  // map from gdk_event to Event_t
6085  ev.fType = kOtherEvent;
6086  if (xev.type == GDK_KEY_PRESS)
6087  ev.fType = kGKeyPress;
6088  if (xev.type == GDK_KEY_RELEASE)
6089  ev.fType = kKeyRelease;
6090  if (xev.type == GDK_BUTTON_PRESS)
6091  ev.fType = kButtonPress;
6092  if (xev.type == GDK_BUTTON_RELEASE)
6093  ev.fType = kButtonRelease;
6094  if (xev.type == GDK_MOTION_NOTIFY)
6095  ev.fType = kMotionNotify;
6096  if (xev.type == GDK_ENTER_NOTIFY)
6097  ev.fType = kEnterNotify;
6098  if (xev.type == GDK_LEAVE_NOTIFY)
6099  ev.fType = kLeaveNotify;
6100  if (xev.type == GDK_EXPOSE)
6101  ev.fType = kExpose;
6102  if (xev.type == GDK_CONFIGURE)
6103  ev.fType = kConfigureNotify;
6104  if (xev.type == GDK_MAP)
6105  ev.fType = kMapNotify;
6106  if (xev.type == GDK_UNMAP)
6107  ev.fType = kUnmapNotify;
6108  if (xev.type == GDK_DESTROY)
6109  ev.fType = kDestroyNotify;
6110  if (xev.type == GDK_SELECTION_CLEAR)
6111  ev.fType = kSelectionClear;
6112  if (xev.type == GDK_SELECTION_REQUEST)
6113  ev.fType = kSelectionRequest;
6114  if (xev.type == GDK_SELECTION_NOTIFY)
6115  ev.fType = kSelectionNotify;
6116 
6117  ev.fSendEvent = kFALSE; //xev.any.send_event ? kTRUE : kFALSE;
6118  ev.fTime = gdk_event_get_time((GdkEvent *)&xev);
6119  ev.fWindow = (Window_t) xev.any.window;
6120 
6121  if ((xev.type == GDK_MAP) || (xev.type == GDK_UNMAP)) {
6122  ev.fWindow = (Window_t) xev.any.window;
6123  }
6124  if (xev.type == GDK_DELETE) {
6125  ev.fWindow = (Window_t) xev.any.window;
6126  ev.fType = kClientMessage;
6127  ev.fFormat = 32;
6129  ev.fUser[0] = (Long_t) gWM_DELETE_WINDOW;
6130  if (sizeof(ev.fUser[0]) > 4) {
6131  AsmLong(xev.client.data.l[1], xev.client.data.l[3],
6132  ev.fUser[1]);
6133  AsmLong(xev.client.data.l[2], xev.client.data.l[4],
6134  ev.fUser[2]);
6135  } else {
6136  ev.fUser[1] = 0; //xev.client.data.l[1];
6137  ev.fUser[2] = 0; //xev.client.data.l[2];
6138  ev.fUser[3] = 0; //xev.client.data.l[3];
6139  ev.fUser[4] = 0; //xev.client.data.l[4];
6140  }
6141  }
6142  if (xev.type == GDK_DESTROY) {
6143  ev.fType = kDestroyNotify;
6144  ev.fHandle = (Window_t) xev.any.window; // window to be destroyed
6145  ev.fWindow = (Window_t) xev.any.window;
6146  }
6147  if (xev.type == GDK_FOCUS_CHANGE) {
6148  ev.fWindow = (Window_t) xev.focus_change.window;
6149  ev.fCode = kNotifyNormal;
6150  ev.fState = 0;
6151  if (xev.focus_change.in == TRUE) {
6152  ev.fType = kFocusIn;
6153  } else {
6154  ev.fType = kFocusOut;
6155  }
6156  }
6157  if (ev.fType == kGKeyPress || ev.fType == kKeyRelease) {
6158  ev.fWindow = (Window_t) xev.key.window;
6159  MapModifierState(ev.fState, xev.key.state, kFALSE); // key mask
6160  ev.fCode = xev.key.keyval; // key code
6161  ev.fUser[1] = xev.key.length;
6162  if (xev.key.length > 0) ev.fUser[2] = xev.key.string[0];
6163  if (xev.key.length > 1) ev.fUser[3] = xev.key.string[1];
6164  if (xev.key.length > 2) ev.fUser[4] = xev.key.string[2];
6165  HWND tmpwin = (HWND) GetWindow((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.key.window), GW_CHILD);
6166  if (tmpwin) {
6167  ev.fUser[0] = (ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
6168  } else {
6169  ev.fUser[0] = (ULong_t) xev.key.window;
6170  }
6171  }
6172  if (ev.fType == kButtonPress || ev.fType == kButtonRelease) {
6173  ev.fWindow = (Window_t) xev.button.window;
6174  ev.fX = xev.button.x;
6175  ev.fY = xev.button.y;
6176  ev.fXRoot = xev.button.x_root;
6177  ev.fYRoot = xev.button.y_root;
6178  MapModifierState(ev.fState, xev.button.state, kFALSE); // button mask
6179  ev.fCode = xev.button.button; // button code
6180  POINT tpoint;
6181  tpoint.x = xev.button.x;
6182  tpoint.y = xev.button.y;
6183  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.button.window), tpoint);
6184  if (tmpwin) {
6185  ev.fUser[0] = (ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
6186  } else {
6187  ev.fUser[0] = (ULong_t) 0;
6188  }
6189  }
6190  if (ev.fType == kMotionNotify) {
6191  ev.fWindow = (Window_t) xev.motion.window;
6192  ev.fX = xev.motion.x;
6193  ev.fY = xev.motion.y;
6194  ev.fXRoot = xev.motion.x_root;
6195  ev.fYRoot = xev.motion.y_root;
6196  MapModifierState(ev.fState, xev.motion.state, kFALSE); // key or button mask
6197 
6198  POINT tpoint;
6199  tpoint.x = xev.button.x;
6200  tpoint.y = xev.button.y;
6201  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.motion.window), tpoint);
6202  if (tmpwin) {
6203  ev.fUser[0] = (ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
6204  } else {
6205  ev.fUser[0] = (ULong_t) xev.motion.window;
6206  }
6207  }
6208  if (ev.fType == kEnterNotify || ev.fType == kLeaveNotify) {
6209  ev.fWindow = (Window_t) xev.crossing.window;
6210  ev.fX = xev.crossing.x;
6211  ev.fY = xev.crossing.y;
6212  ev.fXRoot = xev.crossing.x_root;
6213  ev.fYRoot = xev.crossing.y_root;
6214  ev.fCode = xev.crossing.mode; // NotifyNormal, NotifyGrab, NotifyUngrab
6215  MapModifierState(ev.fState, xev.crossing.state, kFALSE); // key or button mask
6216  }
6217  if (ev.fType == kExpose) {
6218  ev.fWindow = (Window_t) xev.expose.window;
6219  ev.fX = xev.expose.area.x;
6220  ev.fY = xev.expose.area.y;
6221  ev.fWidth = xev.expose.area.width; // width and
6222  ev.fHeight = xev.expose.area.height; // height of exposed area
6223  ev.fCount = xev.expose.count; // number of expose events still to come
6224  }
6225  if (ev.fType == kConfigureNotify) {
6226  ev.fWindow = (Window_t) xev.configure.window;
6227  ev.fX = xev.configure.x;
6228  ev.fY = xev.configure.y;
6229  ev.fWidth = xev.configure.width;
6230  ev.fHeight = xev.configure.height;
6231  }
6232  if (xev.type == GDK_CLIENT_EVENT) {
6233  ev.fWindow = (Window_t) xev.client.window;
6234  ev.fType = kClientMessage;
6235  ev.fHandle = xev.client.message_type;
6236  ev.fFormat = xev.client.data_format;
6237  ev.fUser[0] = xev.client.data.l[0];
6238  if (sizeof(ev.fUser[0]) > 4) {
6239  AsmLong(xev.client.data.l[1], xev.client.data.l[3],
6240  ev.fUser[1]);
6241  AsmLong(xev.client.data.l[2], xev.client.data.l[4],
6242  ev.fUser[2]);
6243  } else {
6244  ev.fUser[1] = xev.client.data.l[1];
6245  ev.fUser[2] = xev.client.data.l[2];
6246  ev.fUser[3] = xev.client.data.l[3];
6247  ev.fUser[4] = xev.client.data.l[4];
6248  }
6249  }
6250  if (ev.fType == kSelectionClear) {
6251  ev.fWindow = (Window_t) xev.selection.window;
6252  ev.fUser[0] = xev.selection.selection;
6253  }
6254  if (ev.fType == kSelectionRequest) {
6255  ev.fWindow = (Window_t) xev.selection.window;
6256  ev.fUser[0] = (ULong_t) xev.selection.window;
6257  ev.fUser[1] = xev.selection.selection;
6258  ev.fUser[2] = xev.selection.target;
6259  ev.fUser[3] = xev.selection.property;
6260  }
6261  if (ev.fType == kSelectionNotify) {
6262  ev.fWindow = (Window_t) xev.selection.window;
6263  ev.fUser[0] = (ULong_t) xev.selection.window;
6264  ev.fUser[1] = xev.selection.selection;
6265  ev.fUser[2] = xev.selection.target;
6266  ev.fUser[3] = xev.selection.property;
6267  }
6268  if (xev.type == GDK_SCROLL) {
6269  ev.fType = kButtonRelease;
6270  if (xev.scroll.direction == GDK_SCROLL_UP) {
6271  ev.fCode = kButton4;
6272  } else if (xev.scroll.direction == GDK_SCROLL_DOWN) {
6273  ev.fCode = kButton5;
6274  }
6275  ev.fWindow = (Window_t) xev.scroll.window;
6276  ev.fX = xev.scroll.x;
6277  ev.fY = xev.scroll.y;
6278  ev.fXRoot = xev.scroll.x_root;
6279  ev.fYRoot = xev.scroll.y_root;
6280  POINT tpoint;
6281  tpoint.x = xev.scroll.x;
6282  tpoint.y = xev.scroll.y;
6283  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.scroll.window), tpoint);
6284  if (tmpwin) {
6285  ev.fUser[0] = (ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
6286  } else {
6287  ev.fUser[0] = (ULong_t) 0;
6288  }
6289  }
6290  }
6291 }
6292 
6293 ////////////////////////////////////////////////////////////////////////////////
6294 ///
6295 
6296 void TGWin32::Bell(Int_t percent)
6297 {
6298  gSystem->Beep();
6299 }
6300 
6301 ////////////////////////////////////////////////////////////////////////////////
6302 /// Copy a drawable (i.e. pixmap) to another drawable (pixmap, window).
6303 /// The graphics context gc will be used and the source will be copied
6304 /// from src_x,src_y,src_x+width,src_y+height to dest_x,dest_y.
6305 
6307  Int_t src_x, Int_t src_y, UInt_t width,
6308  UInt_t height, Int_t dest_x, Int_t dest_y)
6309 {
6310  if (!src || !dest) return;
6311 
6312  gdk_window_copy_area((GdkDrawable *) dest, (GdkGC *) gc, dest_x, dest_y,
6313  (GdkDrawable *) src, src_x, src_y, width, height);
6314 }
6315 
6316 ////////////////////////////////////////////////////////////////////////////////
6317 /// Change window attributes.
6318 
6320 {
6321  if (!id) return;
6322 
6323  GdkColor color;
6324  UInt_t xevmask;
6325  Mask_t evmask;
6326 
6327  if (attr && (attr->fMask & kWAEventMask)) {
6328  evmask = (Mask_t) attr->fEventMask;
6329  MapEventMask(evmask, xevmask);
6330  gdk_window_set_events((GdkWindow *) id, (GdkEventMask) xevmask);
6331  }
6332  if (attr && (attr->fMask & kWABackPixel)) {
6333  color.pixel = attr->fBackgroundPixel;
6334  color.red = GetRValue(attr->fBackgroundPixel);
6335  color.green = GetGValue(attr->fBackgroundPixel);
6336  color.blue = GetBValue(attr->fBackgroundPixel);
6337  gdk_window_set_background((GdkWindow *) id, &color);
6338  }
6339 // if (attr && (attr->fMask & kWAOverrideRedirect))
6340 // gdk_window_set_override_redirect ((GdkWindow *) id, attr->fOverrideRedirect);
6341  if (attr && (attr->fMask & kWABackPixmap)) {
6342  gdk_window_set_back_pixmap((GdkWindow *) id,
6343  (GdkPixmap *) attr->fBackgroundPixmap, 0);
6344  }
6345  if (attr && (attr->fMask & kWACursor)) {
6346  gdk_window_set_cursor((GdkWindow *) id, (GdkCursor *) attr->fCursor);
6347  }
6348  if (attr && (attr->fMask & kWAColormap)) {
6349  gdk_window_set_colormap((GdkWindow *) id,(GdkColormap *) attr->fColormap);
6350  }
6351  if (attr && (attr->fMask & kWABorderWidth)) {
6352  if (attr->fBorderWidth > 0) {
6353  gdk_window_set_decorations((GdkWindow *) id,
6354  (GdkWMDecoration) GDK_DECOR_BORDER);
6355  }
6356  }
6357 }
6358 
6359 ////////////////////////////////////////////////////////////////////////////////
6360 /// This function alters the property for the specified window and
6361 /// causes the X server to generate a PropertyNotify event on that
6362 /// window.
6363 
6365  UChar_t * data, Int_t len)
6366 {
6367  if (!id) return;
6368 
6369  gdk_property_change((GdkWindow *) id, (GdkAtom) property,
6370  (GdkAtom) type, 8, GDK_PROP_MODE_REPLACE, data,len);
6371 }
6372 
6373 ////////////////////////////////////////////////////////////////////////////////
6374 /// Draw a line.
6375 
6377  Int_t x2, Int_t y2)
6378 {
6379  if (!id) return;
6380 
6381  gdk_draw_line((GdkDrawable *) id, (GdkGC *) gc, x1, y1, x2, y2);
6382 }
6383 
6384 ////////////////////////////////////////////////////////////////////////////////
6385 /// Clear a window area to the bakcground color.
6386 
6388 {
6389  if (!id) return;
6390 
6391  gdk_window_clear_area((GdkWindow *) id, x, y, w, h);
6392 }
6393 
6394 ////////////////////////////////////////////////////////////////////////////////
6395 /// Tell WM to send message when window is closed via WM.
6396 
6398 {
6399  if (!id) return;
6400 
6401  Atom prop;
6402  prop = (Atom_t) gdk_atom_intern("WM_DELETE_WINDOW", FALSE);
6403 
6404  W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *) id),
6405  prop, XA_ATOM, 32, GDK_PROP_MODE_REPLACE,
6406  (unsigned char *) &gWM_DELETE_WINDOW, 1);
6407 }
6408 
6409 ////////////////////////////////////////////////////////////////////////////////
6410 /// Turn key auto repeat on or off.
6411 
6413 {
6414  if (on) {
6415  gdk_key_repeat_restore();
6416  } else {
6417  gdk_key_repeat_disable();
6418  }
6419 }
6420 
6421 ////////////////////////////////////////////////////////////////////////////////
6422 /// Establish passive grab on a certain key. That is, when a certain key
6423 /// keycode is hit while certain modifier's (Shift, Control, Meta, Alt)
6424 /// are active then the keyboard will be grabed for window id.
6425 /// When grab is false, ungrab the keyboard for this key and modifier.
6426 
6427 void TGWin32::GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab)
6428 {
6429  UInt_t xmod;
6430 
6431  MapModifierState(modifier, xmod);
6432 
6433  if (grab) {
6434  gdk_key_grab(keycode, (GdkEventMask)xmod, (GdkWindow *)id);
6435  } else {
6436  gdk_key_ungrab(keycode, (GdkEventMask)xmod, (GdkWindow *)id);
6437  }
6438 }
6439 
6440 ////////////////////////////////////////////////////////////////////////////////
6441 /// Establish passive grab on a certain mouse button. That is, when a
6442 /// certain mouse button is hit while certain modifier's (Shift, Control,
6443 /// Meta, Alt) are active then the mouse will be grabed for window id.
6444 /// When grab is false, ungrab the mouse button for this button and modifier.
6445 
6447  UInt_t evmask, Window_t confine, Cursor_t cursor,
6448  Bool_t grab)
6449 {
6450  UInt_t xevmask;
6451  UInt_t xmod;
6452 
6453  if (!id) return;
6454 
6455  MapModifierState(modifier, xmod);
6456 
6457  if (grab) {
6458  MapEventMask(evmask, xevmask);
6459  gdk_button_grab(button, xmod, ( GdkWindow *)id, 1, (GdkEventMask)xevmask,
6460  (GdkWindow*)confine, (GdkCursor*)cursor);
6461  } else {
6462  gdk_button_ungrab(button, xmod, ( GdkWindow *)id);
6463  }
6464 }
6465 
6466 ////////////////////////////////////////////////////////////////////////////////
6467 /// Establish an active pointer grab. While an active pointer grab is in
6468 /// effect, further pointer events are only reported to the grabbing
6469 /// client window.
6470 
6472  Cursor_t cursor, Bool_t grab, Bool_t owner_events)
6473 {
6474  UInt_t xevmask;
6475  MapEventMask(evmask, xevmask);
6476 
6477  if (grab) {
6478  if(!::IsWindowVisible((HWND)GDK_DRAWABLE_XID(id))) return;
6479  gdk_pointer_grab((GdkWindow *) id, owner_events, (GdkEventMask) xevmask,
6480  (GdkWindow *) confine, (GdkCursor *) cursor,
6481  GDK_CURRENT_TIME);
6482  } else {
6483  gdk_pointer_ungrab(GDK_CURRENT_TIME);
6484  ::SetCursor((HCURSOR)GDK_CURSOR_XID(fCursors[kPointer]));
6485  }
6486 }
6487 
6488 ////////////////////////////////////////////////////////////////////////////////
6489 /// Set window name.
6490 
6492 {
6493  if (!id) return;
6494 
6495  gdk_window_set_title((GdkWindow *) id, name);
6496 }
6497 
6498 ////////////////////////////////////////////////////////////////////////////////
6499 /// Set window icon name.
6500 
6502 {
6503  if (!id) return;
6504 
6505  gdk_window_set_icon_name((GdkWindow *) id, name);
6506 }
6507 
6508 ////////////////////////////////////////////////////////////////////////////////
6509 /// Set pixmap the WM can use when the window is iconized.
6510 
6512 {
6513  if (!id) return;
6514 
6515  gdk_window_set_icon((GdkWindow *)id, NULL, (GdkPixmap *)pic, (GdkPixmap *)pic);
6516 }
6517 
6518 #define safestrlen(s) ((s) ? strlen(s) : 0)
6519 
6520 ////////////////////////////////////////////////////////////////////////////////
6521 /// Set the windows class and resource name.
6522 
6523 void TGWin32::SetClassHints(Window_t id, char *className, char *resourceName)
6524 {
6525  if (!id) return;
6526 
6527  char *class_string;
6528  char *s;
6529  int len_nm, len_cl;
6530  GdkAtom prop;
6531 
6532  prop = gdk_atom_intern("WM_CLASS", kFALSE);
6533 
6534  len_nm = safestrlen(resourceName);
6535  len_cl = safestrlen(className);
6536 
6537  if ((class_string = s =
6538  (char *) malloc((unsigned) (len_nm + len_cl + 2)))) {
6539  if (len_nm) {
6540  strcpy(s, resourceName);
6541  s += len_nm + 1;
6542  } else
6543  *s++ = '\0';
6544  if (len_cl) {
6545  strcpy(s, className);
6546  } else {
6547  *s = '\0';
6548  }
6549 
6550  W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *) id),
6551  (Atom) XA_WM_CLASS, (Atom) XA_WM_CLASS, 8,
6552  GDK_PROP_MODE_REPLACE,
6553  (unsigned char *) class_string,
6554  len_nm + len_cl + 2);
6555  free(class_string);
6556  }
6557 }
6558 
6559 ////////////////////////////////////////////////////////////////////////////////
6560 /// Set decoration style for MWM-compatible wm (mwm, ncdwm, fvwm?).
6561 
6563  UInt_t input)
6564 {
6565  if (!id) return;
6566 
6567  gdk_window_set_decorations((GdkDrawable *) id, (GdkWMDecoration) value);
6568  gdk_window_set_functions((GdkDrawable *) id, (GdkWMFunction) funcs);
6569 }
6570 
6571 ////////////////////////////////////////////////////////////////////////////////
6572 ///
6573 
6575 {
6576  if (!id) return;
6577 
6578  gdk_window_move((GdkDrawable *) id, x, y);
6579 }
6580 
6581 ////////////////////////////////////////////////////////////////////////////////
6582 ///
6583 
6585 {
6586  if (!id) return;
6587 
6588  gdk_window_resize((GdkWindow *) id, w, h);
6589 }
6590 
6591 ////////////////////////////////////////////////////////////////////////////////
6592 /// Give the window manager minimum and maximum size hints. Also
6593 /// specify via winc and hinc the resize increments.
6594 
6596  UInt_t wmax, UInt_t hmax,
6597  UInt_t winc, UInt_t hinc)
6598 {
6599  if (!id) return;
6600 
6601  GdkGeometry hints;
6602  GdkWindowHints flags;
6603 
6604  flags = (GdkWindowHints) (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE |
6605  GDK_HINT_RESIZE_INC);
6606  hints.min_width = (Int_t) wmin;
6607  hints.max_width = (Int_t) wmax;
6608  hints.min_height = (Int_t) hmin;
6609  hints.max_height = (Int_t) hmax;
6610  hints.width_inc = (Int_t) winc;
6611  hints.height_inc = (Int_t) hinc;
6612 
6613  gdk_window_set_geometry_hints((GdkWindow *) id, (GdkGeometry *) &hints,
6614  (GdkWindowHints) flags);
6615 }
6616 
6617 ////////////////////////////////////////////////////////////////////////////////
6618 /// Set the initial state of the window. Either kNormalState or kIconicState.
6619 
6621 {
6622  if (!id) return;
6623 
6624 #if 0
6625  XWMHints hints;
6626  Int_t xstate = NormalState;
6627 
6628  if (state == kNormalState)
6629  xstate = NormalState;
6630  if (state == kIconicState)
6631  xstate = IconicState;
6632 
6633  hints.flags = StateHint;
6634  hints.initial_state = xstate;
6635 
6636  XSetWMHints((GdkWindow *) id, &hints);
6637 #endif
6638 }
6639 
6640 ////////////////////////////////////////////////////////////////////////////////
6641 /// Tell window manager that window is a transient window of gdk_parent_root.
6642 
6644 {
6645  if (!id) return;
6646 
6647  gdk_window_set_transient_for((GdkWindow *) id, (GdkWindow *) main_id);
6648 }
6649 
6650 ////////////////////////////////////////////////////////////////////////////////
6651 /// Draw a string using a specific graphics context in position (x,y).
6652 
6654  const char *s, Int_t len)
6655 {
6656  if (!id) return;
6657 
6658  GdkGCValues values;
6659  gdk_gc_get_values((GdkGC *) gc, &values);
6660  gdk_win32_draw_text((GdkDrawable *) id, (GdkFont *) values.font,
6661  (GdkGC *) gc, x, y, (const gchar *)s, len);
6662 }
6663 
6664 ////////////////////////////////////////////////////////////////////////////////
6665 /// Return length of string in pixels. Size depends on font.
6666 
6667 Int_t TGWin32::TextWidth(FontStruct_t font, const char *s, Int_t len)
6668 {
6669  return gdk_text_width((GdkFont *)font, s, len);
6670 }
6671 
6672 ////////////////////////////////////////////////////////////////////////////////
6673 /// Return some font properties.
6674 
6676  Int_t & max_descent)
6677 {
6678  GdkFont *f = (GdkFont *) font;
6679  max_ascent = f->ascent;
6680  max_descent = f->descent;
6681 }
6682 
6683 ////////////////////////////////////////////////////////////////////////////////
6684 /// Get current values from graphics context gc. Which values of the
6685 /// context to get is encoded in the GCValues::fMask member.
6686 
6688 {
6689  GdkGCValues xgval;
6690  ULong_t xmask;
6691 
6692  MapGCValues(gval, xmask, xgval, kTRUE);
6693  gdk_gc_get_values((GdkGC *) gc, &xgval);
6694  MapGCValues(gval, xmask, xgval, kFALSE);
6695 }
6696 
6697 ////////////////////////////////////////////////////////////////////////////////
6698 /// Retrieve associated font structure once we have the font handle.
6699 /// Free returned FontStruct_t using FreeFontStruct().
6700 
6702 {
6703  return (FontStruct_t) gdk_font_ref((GdkFont *) fh);
6704 }
6705 
6706 ////////////////////////////////////////////////////////////////////////////////
6707 /// Free font structure returned by GetFontStruct().
6708 
6710 {
6711  gdk_font_unref((GdkFont *) fs);
6712 }
6713 
6714 ////////////////////////////////////////////////////////////////////////////////
6715 /// Clear window.
6716 
6718 {
6719  if (!id) return;
6720 
6721  gdk_window_clear((GdkDrawable *) id);
6722 }
6723 
6724 ////////////////////////////////////////////////////////////////////////////////
6725 /// Convert a keysym to the appropriate keycode. For example keysym is
6726 /// a letter and keycode is the matching keyboard key (which is dependend
6727 /// on the current keyboard mapping).
6728 
6730 {
6731  UInt_t xkeysym;
6732  MapKeySym(keysym, xkeysym);
6733  return xkeysym;
6734 }
6735 
6736 ////////////////////////////////////////////////////////////////////////////////
6737 /// Draw a filled rectangle. Filling is done according to the gc.
6738 
6740  UInt_t w, UInt_t h)
6741 {
6742  if (!id) return;
6743 
6744  gdk_win32_draw_rectangle((GdkDrawable *) id, (GdkGC *) gc, kTRUE, x, y, w, h);
6745 }
6746 
6747 ////////////////////////////////////////////////////////////////////////////////
6748 /// Draw a rectangle outline.
6749 
6751  UInt_t w, UInt_t h)
6752 {
6753  if (!id) return;
6754 
6755  gdk_win32_draw_rectangle((GdkDrawable *) id, (GdkGC *) gc, kFALSE, x, y, w, h);
6756 }
6757 
6758 ////////////////////////////////////////////////////////////////////////////////
6759 /// Draws multiple line segments. Each line is specified by a pair of points.
6760 
6762  Int_t nseg)
6763 {
6764  if (!id) return;
6765 
6766  gdk_win32_draw_segments((GdkDrawable *) id, (GdkGC *) gc, (GdkSegment *)seg, nseg);
6767 }
6768 
6769 ////////////////////////////////////////////////////////////////////////////////
6770 /// Defines which input events the window is interested in. By default
6771 /// events are propageted up the window stack. This mask can also be
6772 /// set at window creation time via the SetWindowAttributes_t::fEventMask
6773 /// attribute.
6774 
6776 {
6777  if (!id) return;
6778 
6779  UInt_t xevmask;
6780  MapEventMask(evmask, xevmask, kTRUE);
6781  gdk_window_set_events((GdkWindow *) id, (GdkEventMask)xevmask);
6782 }
6783 
6784 ////////////////////////////////////////////////////////////////////////////////
6785 /// Returns the window id of the window having the input focus.
6786 
6788 {
6789  HWND hwnd = ::GetFocus();
6790  return (Window_t) gdk_xid_table_lookup(hwnd);
6791 }
6792 
6793 ////////////////////////////////////////////////////////////////////////////////
6794 /// Set keyboard input focus to window id.
6795 
6797 {
6798  if (!id) return;
6799 
6800  HWND hwnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
6801  ::SetFocus(hwnd);
6802 }
6803 
6804 ////////////////////////////////////////////////////////////////////////////////
6805 /// Returns the window id of the current owner of the primary selection.
6806 /// That is the window in which, for example some text is selected.
6807 
6809 {
6810  return (Window_t)gdk_selection_owner_get(gClipboardAtom);
6811 }
6812 
6813 ////////////////////////////////////////////////////////////////////////////////
6814 /// Makes the window id the current owner of the primary selection.
6815 /// That is the window in which, for example some text is selected.
6816 
6818 {
6819  if (!id) return;
6820 
6821  gdk_selection_owner_set((GdkWindow *) id, gClipboardAtom, GDK_CURRENT_TIME, 0);
6822 }
6823 
6824 ////////////////////////////////////////////////////////////////////////////////
6825 /// XConvertSelection() causes a SelectionRequest event to be sent to the
6826 /// current primary selection owner. This event specifies the selection
6827 /// property (primary selection), the format into which to convert that
6828 /// data before storing it (target = XA_STRING), the property in which
6829 /// the owner will place the information (sel_property), the window that
6830 /// wants the information (id), and the time of the conversion request
6831 /// (when).
6832 /// The selection owner responds by sending a SelectionNotify event, which
6833 /// confirms the selected atom and type.
6834 
6836 {
6837  if (!id) return;
6838 
6839  gdk_selection_convert((GdkWindow *) id, clipboard,
6840  gdk_atom_intern("GDK_TARGET_STRING", 0), when);
6841 }
6842 
6843 ////////////////////////////////////////////////////////////////////////////////
6844 /// Convert the keycode from the event structure to a key symbol (according
6845 /// to the modifiers specified in the event structure and the current
6846 /// keyboard mapping). In buf a null terminated ASCII string is returned
6847 /// representing the string that is currently mapped to the key code.
6848 
6849 void TGWin32::LookupString(Event_t * event, char *buf, Int_t buflen,
6850  UInt_t & keysym)
6851 {
6852  _lookup_string(event, buf, buflen);
6853  UInt_t ks, xks = (UInt_t) event->fCode;
6854  MapKeySym(ks, xks, kFALSE);
6855  keysym = (Int_t) ks;
6856 }
6857 
6858 ////////////////////////////////////////////////////////////////////////////////
6859 /// Map to and from X key symbols. Keysym are the values returned by
6860 /// XLookUpString.
6861 
6862 void TGWin32::MapKeySym(UInt_t & keysym, UInt_t & xkeysym, Bool_t tox)
6863 {
6864  if (tox) {
6865  xkeysym = GDK_VoidSymbol;
6866  if (keysym < 127) {
6867  xkeysym = keysym;
6868  } else if (keysym >= kKey_F1 && keysym <= kKey_F35) {
6869  xkeysym = GDK_F1 + (keysym - (UInt_t) kKey_F1); // function keys
6870  } else {
6871  for (int i = 0; gKeyMap[i].fKeySym; i++) { // any other keys
6872  if (keysym == (UInt_t) gKeyMap[i].fKeySym) {
6873  xkeysym = (UInt_t) gKeyMap[i].fXKeySym;
6874  break;
6875  }
6876  }
6877  }
6878  } else {
6879  keysym = kKey_Unknown;
6880  // commentary in X11/keysymdef says that X codes match ASCII
6881  if (xkeysym < 127) {
6882  keysym = xkeysym;
6883  } else if (xkeysym >= GDK_F1 && xkeysym <= GDK_F35) {
6884  keysym = kKey_F1 + (xkeysym - GDK_F1); // function keys
6885  } else if (xkeysym >= GDK_KP_0 && xkeysym <= GDK_KP_9) {
6886  keysym = kKey_0 + (xkeysym - GDK_KP_0); // numeric keypad keys
6887  } else {
6888  for (int i = 0; gKeyMap[i].fXKeySym; i++) { // any other keys
6889  if (xkeysym == gKeyMap[i].fXKeySym) {
6890  keysym = (UInt_t) gKeyMap[i].fKeySym;
6891  break;
6892  }
6893  }
6894  }
6895  }
6896 }
6897 
6898 ////////////////////////////////////////////////////////////////////////////////
6899 /// Get contents of paste buffer atom into string. If del is true delete
6900 /// the paste buffer afterwards.
6901 
6903  Int_t & nchar, Bool_t del)
6904 {
6905  if (!id) return;
6906 
6907  char *data;
6908  int nread, actual_format;
6909 
6910  nread = gdk_selection_property_get((GdkWindow *) id,
6911  (unsigned char **) &data,
6912  (GdkAtom *) & atom, &actual_format);
6913 
6914  if ((nread == 0) || (data == NULL)) {
6915  nchar = 0;
6916  return;
6917  }
6918 
6919  text.Insert(0, (const char *) data);
6920  nchar = 1; //strlen(data);
6921  g_free(data);
6922 
6923  // if (del)
6924  gdk_property_delete((GdkWindow *) id,
6925  gdk_atom_intern("GDK_SELECTION", FALSE));
6926 }
6927 
6928 ////////////////////////////////////////////////////////////////////////////////
6929 /// TranslateCoordinates translates coordinates from the frame of
6930 /// reference of one window to another. If the point is contained
6931 /// in a mapped child of the destination, the id of that child is
6932 /// returned as well.
6933 
6935  Int_t src_x, Int_t src_y,
6936  Int_t &dest_x, Int_t &dest_y,
6937  Window_t &child)
6938 {
6939  if (!src || !dest) return;
6940 
6941  HWND sw, dw, ch = NULL;
6942  POINT point;
6943  sw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)src);
6944  dw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)dest);
6945  point.x = src_x;
6946  point.y = src_y;
6947  ::MapWindowPoints(sw, // handle of window to be mapped from
6948  dw, // handle to window to be mapped to
6949  &point, // pointer to array with points to map
6950  1); // number of structures in array
6951  ch = ::ChildWindowFromPointEx(dw, point, CWP_SKIPDISABLED | CWP_SKIPINVISIBLE);
6952  child = (Window_t)gdk_xid_table_lookup(ch);
6953 
6954  if (child == src) {
6955  child = (Window_t) 0;
6956  }
6957  dest_x = point.x;
6958  dest_y = point.y;
6959 }
6960 
6961 ////////////////////////////////////////////////////////////////////////////////
6962 /// Return geometry of window (should be called GetGeometry but signature
6963 /// already used).
6964 
6966  UInt_t & w, UInt_t & h)
6967 {
6968  if (!id) return;
6969 
6970  Int_t ddum;
6971  if (GDK_DRAWABLE_TYPE(id) == GDK_DRAWABLE_PIXMAP) {
6972  x = y = 0;
6973  gdk_drawable_get_size((GdkDrawable *)id, (int*)&w, (int*)&h);
6974  }
6975  else {
6976  gdk_window_get_geometry((GdkDrawable *) id, &x, &y, (int*)&w,
6977  (int*)&h, &ddum);
6978  }
6979 }
6980 
6981 ////////////////////////////////////////////////////////////////////////////////
6982 /// FillPolygon fills the region closed by the specified path.
6983 /// The path is closed automatically if the last point in the list does
6984 /// not coincide with the first point. All point coordinates are
6985 /// treated as relative to the origin. For every pair of points
6986 /// inside the polygon, the line segment connecting them does not
6987 /// intersect the path.
6988 
6990  Int_t npnt)
6991 {
6992  if (!id) return;
6993 
6994  gdk_win32_draw_polygon((GdkWindow *) id, (GdkGC *) gc, 1, (GdkPoint *) points, npnt);
6995 }
6996 
6997 ////////////////////////////////////////////////////////////////////////////////
6998 /// Returns the root window the pointer is logically on and the pointer
6999 /// coordinates relative to the root window's origin.
7000 /// The pointer coordinates returned to win_x and win_y are relative to
7001 /// the origin of the specified window. In this case, QueryPointer returns
7002 /// the child that contains the pointer, if any, or else kNone to
7003 /// childw. QueryPointer returns the current logical state of the
7004 /// keyboard buttons and the modifier keys in mask.
7005 
7007  Window_t &childw, Int_t &root_x,
7008  Int_t &root_y, Int_t &win_x, Int_t &win_y,
7009  UInt_t &mask)
7010 {
7011  if (!id) return;
7012 
7013  POINT currPt;
7014  HWND chw, window;
7015  UInt_t umask = 0;
7016  BYTE kbd[256];
7017 
7018  window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
7019  rootw = (Window_t)GDK_ROOT_PARENT();
7020  ::GetCursorPos(&currPt);
7021  chw = ::WindowFromPoint(currPt);
7022  childw = (Window_t)gdk_xid_table_lookup(chw);
7023  root_x = currPt.x;
7024  root_y = currPt.y;
7025 
7026  ::ScreenToClient(window, &currPt);
7027  win_x = currPt.x;
7028  win_y = currPt.y;
7029 
7030  ::GetKeyboardState (kbd);
7031 
7032  if (kbd[VK_SHIFT] & 0x80) {
7033  umask |= GDK_SHIFT_MASK;
7034  }
7035  if (kbd[VK_CAPITAL] & 0x80) {
7036  umask |= GDK_LOCK_MASK;
7037  }
7038  if (kbd[VK_CONTROL] & 0x80) {
7039  umask |= GDK_CONTROL_MASK;
7040  }
7041  if (kbd[VK_MENU] & 0x80) {
7042  umask |= GDK_MOD1_MASK;
7043  }
7044  if (kbd[VK_LBUTTON] & 0x80) {
7045  umask |= GDK_BUTTON1_MASK;
7046  }
7047  if (kbd[VK_MBUTTON] & 0x80) {
7048  umask |= GDK_BUTTON2_MASK;
7049  }
7050  if (kbd[VK_RBUTTON] & 0x80) {
7051  umask |= GDK_BUTTON3_MASK;
7052  }
7053 
7054  MapModifierState(mask, umask, kFALSE);
7055 }
7056 
7057 ////////////////////////////////////////////////////////////////////////////////
7058 /// Set foreground color in graphics context (shortcut for ChangeGC with
7059 /// only foreground mask set).
7060 
7062 {
7063  GdkColor fore;
7064  fore.pixel = foreground;
7065  fore.red = GetRValue(foreground);
7066  fore.green = GetGValue(foreground);
7067  fore.blue = GetBValue(foreground);
7068  gdk_gc_set_foreground((GdkGC *) gc, &fore);
7069 }
7070 
7071 ////////////////////////////////////////////////////////////////////////////////
7072 /// Set clipping rectangles in graphics context. X, Y specify the origin
7073 /// of the rectangles. Recs specifies an array of rectangles that define
7074 /// the clipping mask and n is the number of rectangles.
7075 
7077  Rectangle_t * recs, Int_t n)
7078 {
7079  Int_t i;
7080  GdkRectangle *grects = new GdkRectangle[n];
7081 
7082  for (i = 0; i < n; i++) {
7083  grects[i].x = x+recs[i].fX;
7084  grects[i].y = y+recs[i].fY;
7085  grects[i].width = recs[i].fWidth;
7086  grects[i].height = recs[i].fHeight;
7087  }
7088 
7089  for (i = 0; i < n; i++) {
7090  gdk_gc_set_clip_rectangle((GdkGC *)gc, (GdkRectangle*)recs);
7091  }
7092  delete [] grects;
7093 }
7094 
7095 ////////////////////////////////////////////////////////////////////////////////
7096 /// Flush (mode = 0, default) or synchronize (mode = 1) X output buffer.
7097 /// Flush flushes output buffer. Sync flushes buffer and waits till all
7098 /// requests have been processed by X server.
7099 
7101 {
7102  GdiFlush();
7103 }
7104 
7105 ////////////////////////////////////////////////////////////////////////////////
7106 /// Create a new empty region.
7107 
7109 {
7110  return (Region_t) gdk_region_new();
7111 }
7112 
7113 ////////////////////////////////////////////////////////////////////////////////
7114 /// Destroy region.
7115 
7117 {
7118  gdk_region_destroy((GdkRegion *) reg);
7119 }
7120 
7121 ////////////////////////////////////////////////////////////////////////////////
7122 /// Union of rectangle with a region.
7123 
7125 {
7126  GdkRectangle r;
7127  r.x = rect->fX;
7128  r.y = rect->fY;
7129  r.width = rect->fWidth;
7130  r.height = rect->fHeight;
7131  dest = (Region_t) gdk_region_union_with_rect((GdkRegion *) src, &r);
7132 }
7133 
7134 ////////////////////////////////////////////////////////////////////////////////
7135 /// Create region for the polygon defined by the points array.
7136 /// If winding is true use WindingRule else EvenOddRule as fill rule.
7137 
7139 {
7140  return (Region_t) gdk_region_polygon((GdkPoint*)points, np,
7141  winding ? GDK_WINDING_RULE : GDK_EVEN_ODD_RULE);
7142 }
7143 
7144 ////////////////////////////////////////////////////////////////////////////////
7145 /// Compute the union of rega and regb and return result region.
7146 /// The output region may be the same result region.
7147 
7149 {
7150  result = (Region_t) gdk_regions_union((GdkRegion *) rega, (GdkRegion *) regb);
7151 }
7152 
7153 ////////////////////////////////////////////////////////////////////////////////
7154 /// Compute the intersection of rega and regb and return result region.
7155 /// The output region may be the same as the result region.
7156 
7158  Region_t result)
7159 {
7160  result = (Region_t) gdk_regions_intersect((GdkRegion *) rega,(GdkRegion *) regb);
7161 }
7162 
7163 ////////////////////////////////////////////////////////////////////////////////
7164 /// Subtract rega from regb.
7165 
7167 {
7168  result = (Region_t)gdk_regions_subtract((GdkRegion *) rega,(GdkRegion *) regb);
7169 }
7170 
7171 ////////////////////////////////////////////////////////////////////////////////
7172 /// Calculate the difference between the union and intersection of
7173 /// two regions.
7174 
7176 {
7177  result = (Region_t) gdk_regions_xor((GdkRegion *) rega, (GdkRegion *) regb);
7178 }
7179 
7180 ////////////////////////////////////////////////////////////////////////////////
7181 /// Return true if the region is empty.
7182 
7184 {
7185  return (Bool_t) gdk_region_empty((GdkRegion *) reg);
7186 }
7187 
7188 ////////////////////////////////////////////////////////////////////////////////
7189 /// Returns true if the point x,y is in the region.
7190 
7192 {
7193  return (Bool_t) gdk_region_point_in((GdkRegion *) reg, x, y);
7194 }
7195 
7196 ////////////////////////////////////////////////////////////////////////////////
7197 /// Returns true if two regions are equal.
7198 
7200 {
7201  return (Bool_t) gdk_region_equal((GdkRegion *) rega, (GdkRegion *) regb);
7202 }
7203 
7204 ////////////////////////////////////////////////////////////////////////////////
7205 /// Return smallest enclosing rectangle.
7206 
7208 {
7209  GdkRectangle r;
7210  gdk_region_get_clipbox((GdkRegion *) reg, &r);
7211  rect->fX = r.x;
7212  rect->fY = r.y;
7213  rect->fWidth = r.width;
7214  rect->fHeight = r.height;
7215 }
7216 
7217 ////////////////////////////////////////////////////////////////////////////////
7218 /// Return list of font names matching "fontname".
7219 
7220 char **TGWin32::ListFonts(const char *fontname, Int_t /*max*/, Int_t &count)
7221 {
7222  char foundry[32], family[100], weight[32], slant[32], font_name[256];
7223  char **fontlist;
7224  Int_t n1, fontcount = 0;
7225 
7226  sscanf(fontname, "-%30[^-]-%100[^-]-%30[^-]-%30[^-]-%n",
7227  foundry, family, weight, slant, &n1);
7228  // replace "medium" by "normal"
7229  if(!stricmp(weight,"medium")) {
7230  sprintf(weight,"normal");
7231  }
7232  // since all sizes are allowed with TTF, just forget it...
7233  sprintf(font_name, "-%s-%s-%s-%s-*", foundry, family, weight, slant);
7234  fontlist = gdk_font_list_new(font_name, &fontcount);
7235  count = fontcount;
7236 
7237  if (fontcount > 0) return fontlist;
7238  return 0;
7239 }
7240 
7241 ////////////////////////////////////////////////////////////////////////////////
7242 ///
7243 
7244 void TGWin32::FreeFontNames(char **fontlist)
7245 {
7246  gdk_font_list_free(fontlist);
7247 }
7248 
7249 ////////////////////////////////////////////////////////////////////////////////
7250 ///
7251 
7253 {
7254  return (Drawable_t) gdk_image_new(GDK_IMAGE_SHARED, gdk_visual_get_best(),
7255  width, height);
7256 }
7257 
7258 ////////////////////////////////////////////////////////////////////////////////
7259 ///
7260 
7262 {
7263  width = ((GdkImage*)id)->width;
7264  height = ((GdkImage*)id)->height;
7265 }
7266 
7267 ////////////////////////////////////////////////////////////////////////////////
7268 ///
7269 
7271 {
7272  if (!id) return;
7273 
7274  GdkImage *image = (GdkImage *)id;
7275  if (image->depth == 1) {
7276  if (pixel & 1) {
7277  ((UChar_t *) image->mem)[y * image->bpl + (x >> 3)] |= (1 << (7 - (x & 0x7)));
7278  } else {
7279  ((UChar_t *) image->mem)[y * image->bpl + (x >> 3)] &= ~(1 << (7 - (x & 0x7)));
7280  }
7281  } else {
7282  UChar_t *pixelp = (UChar_t *) image->mem + y * image->bpl + x * image->bpp;
7283  // Windows is always LSB, no need to check image->byte_order.
7284  switch (image->bpp) {
7285  case 4:
7286  pixelp[3] = 0;
7287  case 3:
7288  pixelp[2] = ((pixel >> 16) & 0xFF);
7289  case 2:
7290  pixelp[1] = ((pixel >> 8) & 0xFF);
7291  case 1:
7292  pixelp[0] = (pixel & 0xFF);
7293  }
7294  }
7295 }
7296 
7297 ////////////////////////////////////////////////////////////////////////////////
7298 ///
7299 
7301  Int_t dy, Int_t x, Int_t y, UInt_t w, UInt_t h)
7302 {
7303  if (!id) return;
7304 
7305  gdk_draw_image((GdkDrawable *) id, (GdkGC *)gc, (GdkImage *)img,
7306  x, y, dx, dy, w, h);
7307  ::GdiFlush();
7308 }
7309 
7310 ////////////////////////////////////////////////////////////////////////////////
7311 ///
7312 
7314 {
7315  gdk_image_unref((GdkImage *)img);
7316 }
7317 
7318 ////////////////////////////////////////////////////////////////////////////////
7319 /// Gets DIB bits
7320 /// x, y, width, height - position of bitmap
7321 /// returns a pointer on bitmap bits array
7322 /// in format:
7323 /// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
7324 ///
7325 /// Pixels are numbered from left to right and from top to bottom.
7326 /// By default all pixels from the whole drawable are returned.
7327 
7329  UInt_t width, UInt_t height)
7330 {
7331  HDC hdc, memdc;
7332  BITMAPINFO bmi;
7333  HGDIOBJ oldbitmap1, oldbitmap2;
7334  BITMAP bm;
7335  HBITMAP ximage = 0;
7336  VOID *bmbits = 0;
7337  unsigned char *ret = 0;
7338 
7339  if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7340  hdc = ::CreateCompatibleDC(NULL);
7341  oldbitmap1 = ::SelectObject(hdc, GDK_DRAWABLE_XID(wid));
7342  ::GetObject(GDK_DRAWABLE_XID(wid), sizeof(BITMAP), &bm);
7343  } else {
7344  hdc = ::GetDC((HWND)GDK_DRAWABLE_XID(wid));
7345  }
7346  memdc = ::CreateCompatibleDC(hdc);
7347 
7348  bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
7349  bmi.bmiHeader.biWidth = width;
7350  bmi.bmiHeader.biHeight = -1 * (int)(height);
7351  bmi.bmiHeader.biPlanes = 1;
7352  bmi.bmiHeader.biBitCount = 32;
7353  bmi.bmiHeader.biCompression = BI_RGB;
7354  bmi.bmiHeader.biSizeImage = 0;
7355  bmi.bmiHeader.biXPelsPerMeter = bmi.bmiHeader.biYPelsPerMeter = 0;
7356  bmi.bmiHeader.biClrUsed = 0;
7357  bmi.bmiHeader.biClrImportant = 0;
7358 
7359  ximage = ::CreateDIBSection(hdc, (BITMAPINFO *) &bmi, DIB_RGB_COLORS, &bmbits, NULL, 0);
7360 
7361  if (ximage && bmbits) {
7362  oldbitmap2 = ::SelectObject(memdc, ximage);
7363  ::BitBlt(memdc, x, y, width, height, hdc, 0, 0, SRCCOPY);
7364  ::SelectObject(memdc, oldbitmap2);
7365  }
7366  ::DeleteDC(memdc);
7367  if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7368  ::SelectObject(hdc, oldbitmap1);
7369  ::DeleteDC(hdc);
7370  } else {
7371  ::ReleaseDC((HWND)GDK_DRAWABLE_XID(wid), hdc);
7372  }
7373  if (ximage && bmbits) {
7374  ULong_t sz = width*height*4;
7375  ret = new unsigned char[sz];
7376  memcpy(ret, bmbits, sz);
7377  ::DeleteObject(ximage);
7378  }
7379  return ret;
7380 }
7381 
7382 ////////////////////////////////////////////////////////////////////////////////
7383 /// create an image from RGB data. RGB data is in format :
7384 /// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
7385 ///
7386 /// Pixels are numbered from left to right and from top to bottom.
7387 /// Note that data must be 32-bit aligned
7388 
7389 Pixmap_t TGWin32::CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height)
7390 {
7391  BITMAPINFO bmp_info;
7392  bmp_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
7393  bmp_info.bmiHeader.biWidth = width;
7394  bmp_info.bmiHeader.biHeight = -1 * (int)(height);
7395  bmp_info.bmiHeader.biPlanes = 1;
7396  bmp_info.bmiHeader.biBitCount = 32;
7397  bmp_info.bmiHeader.biCompression = BI_RGB;
7398  bmp_info.bmiHeader.biSizeImage = 0;
7399  bmp_info.bmiHeader.biClrUsed = 0;
7400  bmp_info.bmiHeader.biXPelsPerMeter = 0L;
7401  bmp_info.bmiHeader.biYPelsPerMeter = 0L;
7402  bmp_info.bmiHeader.biClrImportant = 0;
7403  bmp_info.bmiColors[0].rgbRed = 0;
7404  bmp_info.bmiColors[0].rgbGreen = 0;
7405  bmp_info.bmiColors[0].rgbBlue = 0;
7406  bmp_info.bmiColors[0].rgbReserved = 0;
7407 
7408  HDC hdc = ::GetDC(NULL);
7409  HBITMAP hbitmap = ::CreateDIBitmap(hdc, &bmp_info.bmiHeader, CBM_INIT,
7410  (void *)bits, &bmp_info, DIB_RGB_COLORS);
7411  ::ReleaseDC(NULL, hdc);
7412 
7413  SIZE size;
7414  // For an obscure reason, we have to set the size of the
7415  // bitmap this way before to call gdk_pixmap_foreign_new
7416  // otherwise, it fails...
7417  ::SetBitmapDimensionEx(hbitmap,width, height, &size);
7418 
7419  return (Pixmap_t)gdk_pixmap_foreign_new((guint32)hbitmap);
7420 }
7421 
7422 ////////////////////////////////////////////////////////////////////////////////
7423 ///register pixmap created by TGWin32GLManager
7424 
7426 {
7427  HBITMAP hBmp = reinterpret_cast<HBITMAP>(pix);
7428  SIZE sz = SIZE();
7429 
7430  SetBitmapDimensionEx(hBmp, w, h, &sz);
7431  GdkPixmap *newPix = gdk_pixmap_foreign_new(reinterpret_cast<guint32>(hBmp));
7432 
7433  Int_t wid = 0;
7434  for(; wid < fMaxNumberOfWindows; ++wid)
7435  if (!fWindows[wid].open)
7436  break;
7437 
7438  if (wid == fMaxNumberOfWindows) {
7439  Int_t newSize = fMaxNumberOfWindows + 10;
7440 
7441  fWindows = (XWindow_t *)TStorage::ReAlloc(fWindows, newSize * sizeof(XWindow_t),
7442  fMaxNumberOfWindows * sizeof(XWindow_t));
7443 
7444  for (Int_t i = fMaxNumberOfWindows; i < newSize; ++i)
7445  fWindows[i].open = 0;
7446 
7447  fMaxNumberOfWindows = newSize;
7448  }
7449 
7450  fWindows[wid].open = 1;
7451  gCws = fWindows + wid;
7452  gCws->window = newPix;
7453  gCws->drawing = gCws->window;
7454  gCws->buffer = 0;
7455  gCws->double_buffer = 0;
7456  gCws->ispixmap = 1;
7457  gCws->clip = 0;
7458  gCws->width = w;
7459  gCws->height = h;
7460  gCws->new_colors = 0;
7461 
7462  return wid;
7463 }
7464 
7465 ////////////////////////////////////////////////////////////////////////////////
7466 /// Register a window created by Qt as a ROOT window (like InitWindow()).
7467 
7469 {
7470  Int_t wid;
7471  // Select next free window number
7472 
7473  again:
7474  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
7475  if (!fWindows[wid].open) {
7476  fWindows[wid].open = 1;
7477  fWindows[wid].double_buffer = 0;
7478  gCws = &fWindows[wid];
7479  break;
7480  }
7481  }
7482 
7483  if (wid == fMaxNumberOfWindows) {
7484  int newsize = fMaxNumberOfWindows + 10;
7485  fWindows =
7486  (XWindow_t *) TStorage::ReAlloc(fWindows,
7487  newsize * sizeof(XWindow_t),
7488  fMaxNumberOfWindows *
7489  sizeof(XWindow_t));
7490 
7491  for (int i = fMaxNumberOfWindows; i < newsize; i++) {
7492  fWindows[i].open = 0;
7493  }
7494 
7495  fMaxNumberOfWindows = newsize;
7496  goto again;
7497  }
7498 
7499  gCws->window = gdk_window_foreign_new((guint32)qwid);
7500 
7501  gCws->drawing = gCws->window;
7502  gCws->buffer = 0;
7503  gCws->double_buffer = 0;
7504  gCws->ispixmap = 0;
7505  gCws->clip = 0;
7506  gCws->width = w;
7507  gCws->height = h;
7508  gCws->new_colors = 0;
7509 
7510  return wid;
7511 }
7512 
7513 ////////////////////////////////////////////////////////////////////////////////
7514 /// Remove a window created by Qt (like CloseWindow1()).
7515 
7517 {
7518  int wid;
7519 
7520  SelectWindow((int)qwid);
7521 
7522  if (gCws->buffer) {
7523  gdk_pixmap_unref(gCws->buffer);
7524  }
7525  if (gCws->new_colors) {
7526  gdk_colormap_free_colors((GdkColormap *) fColormap,
7527  (GdkColor *)gCws->new_colors, gCws->ncolors);
7528 
7529  delete [] gCws->new_colors;
7530  gCws->new_colors = 0;
7531  }
7532 
7533  GdiFlush();
7534  gCws->open = 0;
7535 
7536  if (!fWindows) return;
7537 
7538  // make first window in list the current window
7539  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
7540  if (fWindows[wid].open) {
7541  gCws = &fWindows[wid];
7542  return;
7543  }
7544  }
7545  gCws = 0;
7546 }
7547 
7548 ////////////////////////////////////////////////////////////////////////////////
7549 /// The Nonrectangular Window Shape Extension adds nonrectangular
7550 /// windows to the System.
7551 /// This allows for making shaped (partially transparent) windows
7552 
7554 {
7555  gdk_window_shape_combine_mask((GdkWindow *)id, (GdkBitmap *) mask, x, y);
7556 }
7557 
7558 ////////////////////////////////////////////////////////////////////////////////
7559 /// Returns the width of the screen in millimeters.
7560 
7562 {
7563  return (UInt_t)gdk_screen_width_mm();
7564 }
7565 
7566 //------------------------------ Drag and Drop ---------------------------------
7567 
7568 ////////////////////////////////////////////////////////////////////////////////
7569 /// Deletes the specified property on the specified window.
7570 
7572 {
7573  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7574  Atom_t atom = (Atom_t)GetProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7575  if (atom != 0) {
7576  GlobalDeleteAtom(atom);
7577  }
7578  RemoveProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7579 }
7580 
7581 ////////////////////////////////////////////////////////////////////////////////
7582 /// Returns the actual type of the property, the actual format of the property,
7583 /// and a pointer to the data actually returned.
7584 
7586  Bool_t del, Atom_t req_type, Atom_t *act_type,
7587  Int_t *act_format, ULong_t *nitems, ULong_t *bytes,
7588  unsigned char **prop_list)
7589 {
7590  HGLOBAL hdata;
7591  UChar_t *ptr, *data;
7592  UInt_t i, n, length;
7593 
7594  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7595  if (hWnd == NULL)
7596  return 0;
7597 
7598  Atom_t dndproxy = InternAtom("XdndProxy", kFALSE);
7599  Atom_t dndtypelist = InternAtom("XdndTypeList", kFALSE);
7600 
7601  if (prop == dndproxy)
7602  return 0;
7603  if (prop == dndtypelist) {
7604  *act_type = XA_ATOM;
7605  *prop_list = (unsigned char *)GetProp(hWnd, (LPCTSTR)MAKELONG(prop,0));
7606  for (n = 0; prop_list[n]; n++);
7607  *nitems = n;
7608  return n;
7609  }
7610  else {
7611  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7612  return 0;
7613  }
7614  hdata = GetClipboardData(CF_PRIVATEFIRST);
7615  ptr = (UChar_t *)GlobalLock(hdata);
7616  length = GlobalSize(hdata);
7617  data = (UChar_t *)malloc(length + 1);
7618  for (i = 0; i < length; i++) {
7619  data[i] = ptr[i];
7620  }
7621  GlobalUnlock(hdata);
7622  CloseClipboard();
7623  *prop_list = data;
7624  *bytes = *nitems = length;
7625  return length;
7626  }
7627  return 0;
7628 }
7629 
7630 ////////////////////////////////////////////////////////////////////////////////
7631 /// Changes the active cursor of the specified window.
7632 
7634 {
7635  UInt_t xevmask;
7636  MapEventMask(mask, xevmask);
7637  if (cur == kNone)
7638  gdk_window_set_cursor((GdkWindow *) win, fCursors[kHand]);
7639  else
7640  gdk_window_set_cursor((GdkWindow *) win, (GdkCursor *)cur);
7641 }
7642 
7643 ////////////////////////////////////////////////////////////////////////////////
7644 /// Get Clipboard data.
7645 
7647  Atom_t &prop, Time_t &stamp)
7648 {
7649  HGLOBAL hdata;
7650 
7651  static UINT gdk_selection_notify_msg =
7652  RegisterWindowMessage("gdk-selection-notify");
7653  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7654  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7655  return;
7656  }
7657  hdata = GetClipboardData(CF_PRIVATEFIRST);
7658  CloseClipboard();
7659  if (hdata == 0)
7660  return;
7661  /* Send ourselves an ersatz selection notify message so that we actually
7662  * fetch the data.
7663  */
7664  PostMessage(hWnd, gdk_selection_notify_msg, sel, target);
7665 }
7666 
7667 ////////////////////////////////////////////////////////////////////////////////
7668 /// Assigns owner of Clipboard.
7669 
7671 {
7672  static UINT gdk_selection_request_msg =
7673  RegisterWindowMessage("gdk-selection-request");
7674  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)owner);
7675  OpenClipboard(hWnd);
7676  EmptyClipboard();
7677  CloseClipboard();
7678  if (owner) {
7679  ::PostMessage(hWnd, gdk_selection_request_msg, sel, 0);
7680  }
7681  return kTRUE;
7682 }
7683 
7684 ////////////////////////////////////////////////////////////////////////////////
7685 /// Put data into Clipboard.
7686 
7688  Int_t format, UChar_t *data, Int_t len)
7689 {
7690  HGLOBAL hdata;
7691  Int_t i;
7692  UChar_t *ptr;
7693 
7694  if (data == 0 || len == 0)
7695  return;
7696  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)id))) {
7697  return;
7698  }
7699  hdata = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 1);
7700  ptr = (UChar_t *)GlobalLock(hdata);
7701  for (i = 0; i < len; i++) {
7702  *ptr++ = *data++;
7703  }
7704  GlobalUnlock(hdata);
7705  SetClipboardData(CF_PRIVATEFIRST, hdata);
7706  CloseClipboard();
7707 }
7708 
7709 ////////////////////////////////////////////////////////////////////////////////
7710 /// Add the list of drag and drop types to the Window win.
7711 
7712 void TGWin32::SetTypeList(Window_t win, Atom_t prop, Atom_t *typelist)
7713 {
7714  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)win),
7715  (LPCTSTR)MAKELONG(prop,0),
7716  (HANDLE)typelist);
7717 }
7718 
7719 ////////////////////////////////////////////////////////////////////////////////
7720 /// Recursively search in the children of Window for a Window which is at
7721 /// location x, y and is DND aware, with a maximum depth of maxd.
7722 /// Possibility to exclude dragwin and input.
7723 
7725  int x, int y, int maxd)
7726 {
7727  POINT point;
7728  POINT cpt;
7729  RECT rect;
7730  HWND hwnd, hwndc;
7731  HWND hwndt;
7732  Window_t win, retwin = kNone;
7733  Atom_t version = 0;
7734  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7735 
7736  cpt.x = x;
7737  cpt.y = y;
7738  hwnd = ::ChildWindowFromPointEx((HWND)GDK_DRAWABLE_XID((GdkWindow *)root),
7739  cpt, CWP_ALL);
7740  while (hwnd) {
7741  GetWindowRect(hwnd, &rect);
7742  if (PtInRect(&rect, cpt)) {
7743  if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7744  win = (Window_t) gdk_xid_table_lookup(hwnd);
7745  if (win && win != dragwin && win != input)
7746  return win;
7747  }
7748  Bool_t done = kFALSE;
7749  hwndt = hwnd;
7750  while (!done) {
7751  point = cpt;
7752  ::MapWindowPoints(NULL, hwndt, &point, 1);
7753  hwndc = ChildWindowFromPoint (hwndt, point);
7754  if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7755  win = (Window_t) gdk_xid_table_lookup(hwndc);
7756  if (win && win != dragwin && win != input)
7757  return win;
7758  }
7759  if (hwndc == NULL)
7760  done = TRUE;
7761  else if (hwndc == hwndt)
7762  done = TRUE;
7763  else
7764  hwndt = hwndc;
7765  if (GetProp(hwndt,(LPCTSTR)MAKELONG(dndaware,0))) {
7766  win = (Window_t) gdk_xid_table_lookup(hwndt);
7767  if (win && win != dragwin && win != input)
7768  return win;
7769  }
7770  }
7771  }
7772  hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
7773  }
7774  return kNone;
7775 }
7776 
7777 ////////////////////////////////////////////////////////////////////////////////
7778 /// Checks if Window win is DND aware, and knows any of the DND formats
7779 /// passed in argument.
7780 
7782 {
7783  if (!win) return kFALSE;
7784 
7785  Atom_t version = 0;
7786  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7787  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7788  while (window) {
7789  version = (Atom_t)GetProp(window,(LPCTSTR)MAKELONG(dndaware,0));
7790  if (version) return kTRUE;
7791  window = ::GetParent(window);
7792  }
7793  return kFALSE;
7794 }
7795 
7796 ////////////////////////////////////////////////////////////////////////////////
7797 /// Add XdndAware property and the list of drag and drop types to the
7798 /// Window win.
7799 
7801 {
7802  int n;
7803  if (!id) return;
7804 
7805  DWORD dwStyle = GetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7806  GWL_EXSTYLE);
7807  SetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)id), GWL_EXSTYLE,
7808  dwStyle | WS_EX_ACCEPTFILES);
7809  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7810  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7811  (LPCTSTR)MAKELONG(dndaware,0),
7812  (HANDLE)XDND_PROTOCOL_VERSION);
7813 
7814  if (typelist == 0)
7815  return;
7816  for (n = 0; typelist[n]; n++);
7817  Atom_t dndtypelist = InternAtom("XdndTypeList", kFALSE);
7818  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7819  (LPCTSTR)MAKELONG(dndtypelist,0),
7820  (HANDLE)typelist);
7821 
7822 }
7823 
7824 ////////////////////////////////////////////////////////////////////////////////
7825 /// Set user thread id. This is used when an extra thread is created
7826 /// to process events.
7827 
7829 {
7830  if (id == 0) {
7831  TGWin32ProxyBase::fgMainThreadId = ((TWinNTSystem*)gSystem)->GetGUIThreadId();
7832  }
7833  else {
7835  }
7836 }
7837 
Int_t fClipXOrigin
Definition: GuiTypes.h:244
UShort_t fBlue
Definition: GuiTypes.h:313
const int nx
Definition: kalman.C:16
EAlign
Definition: TGWin32.h:70
Pixmap_t ReadGIF(Int_t x0, Int_t y0, const char *file, Window_t id=0)
If id is NULL - loads the specified gif file at position [x0,y0] in the current window.
Definition: TGWin32.cxx:4512
static void Dealloc(void *ptr)
De-allocate block of memory, that was allocated via TStorage::Alloc().
Definition: TStorage.cxx:170
virtual void ExecuteCallBack(Bool_t sync)
Executes all batched callbacks and the latest callback This method is executed by server thread...
void CloseWindow1()
Delete current window.
Definition: TGWin32.cxx:1608
const Mask_t kKeyReleaseMask
Definition: GuiTypes.h:159
UShort_t fWidth
Definition: GuiTypes.h:362
void MapColorStruct(ColorStruct_t *color, GdkColor &xcolor)
Map a ColorStruct_t to a XColor structure.
Definition: TGWin32.cxx:5706
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:931
Definition: GuiTypes.h:74
void RescaleWindow(Int_t wid, UInt_t w, UInt_t h)
Rescale the window wid.
Definition: TGWin32.cxx:2702
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Int_t fLineStyle
Definition: GuiTypes.h:229
Bool_t fSendEvent
Definition: GuiTypes.h:183
Handle_t FontStruct_t
Definition: GuiTypes.h:38
const char * DisplayName(const char *dpyName=0)
Return hostname on which the display is opened.
Definition: TGWin32.cxx:2030
virtual ~TGWin32()
destructor.
Definition: TGWin32.cxx:817
void SetMarkerSize(Float_t markersize)
Set marker size index.
Definition: TGWin32.cxx:3373
static void Init()
Initialise the TrueType fonts interface.
Definition: TTF.cxx:65
void XorRegion(Region_t rega, Region_t regb, Region_t result)
Calculate the difference between the union and intersection of two regions.
Definition: TGWin32.cxx:7175
EDrawMode fDrawMode
Definition: TVirtualX.h:67
static double B[]
Int_t GetDepth() const
Get maximum number of planes.
Definition: TGWin32.cxx:5328
void Add(ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table. The key should be unique.
Definition: TExMap.cxx:87
void FillPolygon(Window_t id, GContext_t gc, Point_t *points, Int_t npnt)
FillPolygon fills the region closed by the specified path.
Definition: TGWin32.cxx:6989
static void Lock()
Definition: TGWin32.cxx:946
void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectangle_t *recs, Int_t n)
Set clipping rectangles in graphics context.
Definition: TGWin32.cxx:7076
void SetWMSize(Window_t id, UInt_t w, UInt_t h)
Tells window manager the desired size of window "id".
Definition: TGWin32.cxx:6584
Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...).
Definition: TVirtualX.h:58
void SetLineWidth(Width_t width)
Set line width.
Definition: TGWin32.cxx:3337
static GC * gGCpxmp
Definition: TGX11.cxx:96
An array of TObjects.
Definition: TObjArray.h:37
Short_t fY
Definition: GuiTypes.h:361
Bool_t Init(void *display=0)
Initialize Win32 system. Returns kFALSE in case of failure.
Definition: TGWin32.cxx:962
void ConvertSelection(Window_t, Atom_t &, Atom_t &, Atom_t &, Time_t &)
Get Clipboard data.
Definition: TGWin32.cxx:7646
float xmin
Definition: THbookFile.cxx:93
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition: TSystem.cxx:423
void MoveWindow(Int_t wid, Int_t x, Int_t y)
Move the window wid.
Definition: TGWin32.cxx:2089
Int_t EventsPending()
Returns number of pending events.
Definition: TGWin32.cxx:5837
void SetWindowBackground(Window_t id, ULong_t color)
Set the window background color.
Definition: TGWin32.cxx:4767
void SetLineType(Int_t n, Int_t *dash)
Set line type.
Definition: TGWin32.cxx:3261
void SetOpacity(Int_t percent)
Set opacity of a window.
Definition: TGWin32.cxx:3945
Pixmap_t fTile
Definition: GuiTypes.h:237
void SetLineColor(Color_t cindex)
Set color index for lines.
Definition: TGWin32.cxx:3233
void SelectWindow(Int_t wid)
Select window to which subsequent output is directed.
Definition: TGWin32.cxx:2840
XWindow_t * fWindows
List of windows.
Definition: TGWin32.h:83
XColor_t & GetColor(Int_t cid)
Return reference to internal color structure associated to color index cid.
Definition: TGWin32.cxx:1942
static GC * gGCline
Definition: TGX11.cxx:90
Bool_t ParseColor(Colormap_t cmap, const char *cname, ColorStruct_t &color)
Parse string cname containing color name, like "green" or "#00FF00".
Definition: TGWin32.cxx:5721
void ClosePixmap()
Delete current pixmap.
Definition: TGWin32.cxx:1592
void DeleteProperty(Window_t, Atom_t &)
Deletes the specified property on the specified window.
Definition: TGWin32.cxx:7571
long long Long64_t
Definition: RtypesCore.h:69
UShort_t fHeight
Definition: GuiTypes.h:362
EInitialState
Definition: GuiTypes.h:344
void SetDashes(GContext_t gc, Int_t offset, const char *dash_list, Int_t n)
Specify a dash pattertn.
Definition: TGWin32.cxx:5688
Float_t GetRed() const
Definition: TColor.h:56
void UpdateFillStyle()
Set fill area style index.
Definition: TGWin32.cxx:3180
short Style_t
Definition: RtypesCore.h:76
Window_t GetDefaultRootWindow() const
Return handle to the default root window created when calling XOpenDisplay().
Definition: TGWin32.cxx:5350
void CloseWindow()
Delete current window.
Definition: TGWin32.cxx:1600
Bool_t IsVisible(Int_t x, Int_t y, UInt_t w, UInt_t h)
Test if there is really something to render.
Definition: TGWin32.cxx:1412
void ReparentWindow(Window_t id, Window_t pid, Int_t x, Int_t y)
Reparent window, make pid the new parent and position the window at position (x,y) in new parent...
Definition: TGWin32.cxx:4757
Bool_t fHasTTFonts
True when TrueType fonts are used.
Definition: TGWin32.h:114
Bool_t fFillColorModified
Definition: TGWin32.h:132
void SetUserThreadId(ULong_t id)
Set user thread id.
Definition: TGWin32.cxx:7828
FontStruct_t LoadQueryFont(const char *font_name)
Load font and query font.
Definition: TGWin32.cxx:5370
Collectable string class.
Definition: TObjString.h:28
FontH_t fFont
Definition: GuiTypes.h:241
float Float_t
Definition: RtypesCore.h:53
void SetMarkerColor(Color_t cindex)
Set color index for markers.
Definition: TGWin32.cxx:3353
static Int_t gFillHollow
Definition: TGX11.cxx:100
static void GlobalUnlock()
unlock any proxy (client thread)
void MapRaised(Window_t id)
Map window on screen and put on top of all windows.
Definition: TGWin32.cxx:4620
UInt_t Mask_t
Definition: GuiTypes.h:40
RooArgList L(const RooAbsArg &v1)
static struct @67 gMarker
Pixmap_t fBackgroundPixmap
Definition: GuiTypes.h:93
void Update(Int_t mode=0)
Flush (mode = 0, default) or synchronize (mode = 1) X output buffer.
Definition: TGWin32.cxx:7100
float ymin
Definition: THbookFile.cxx:93
void GrabPointer(Window_t id, UInt_t evmask, Window_t confine, Cursor_t cursor, Bool_t grab=kTRUE, Bool_t owner_events=kTRUE)
Establish an active pointer grab.
Definition: TGWin32.cxx:6471
GContext_t CreateGC(Drawable_t id, GCValues_t *gval)
Create a graphics context using the values set in gval (but only for those entries that are in the ma...
Definition: TGWin32.cxx:5414
const Mask_t kButtonMotionMask
Definition: GuiTypes.h:163
const Mask_t kWACursor
Definition: GuiTypes.h:153
#define IDC_HAND
Definition: TGWin32.cxx:68
Float_t fTextMagnitude
Text Magnitude.
Definition: TGWin32.h:121
Int_t fCount
Definition: GuiTypes.h:182
void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
Return position and size of window wid.
Definition: TGWin32.cxx:1997
R__EXTERN TStyle * gStyle
Definition: TStyle.h:402
static Bool_t IsInitialized()
Definition: TTF.cxx:605
FT_Glyph fImage
glyph image
Definition: TTF.h:69
unsigned short UShort_t
Definition: RtypesCore.h:36
void ShapeCombineMask(Window_t id, Int_t x, Int_t y, Pixmap_t mask)
The Nonrectangular Window Shape Extension adds nonrectangular windows to the System.
Definition: TGWin32.cxx:7553
ULong_t Time_t
Definition: GuiTypes.h:41
void SetDoubleBufferOFF()
Turn double buffer mode off.
Definition: TGWin32.cxx:3067
Window_t GetInputFocus()
Returns the window id of the window having the input focus.
Definition: TGWin32.cxx:6787
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:131
void SetMarkerType(Int_t type, Int_t n, GdkPoint *xy)
Set marker type.
Definition: TGWin32.cxx:3395
#define BIT(n)
Definition: Rtypes.h:75
TH1 * h
Definition: legend2.C:5
Description of a X11 color.
Definition: TGWin32.h:59
void DeleteImage(Drawable_t img)
Deallocates the memory associated with the image img.
Definition: TGWin32.cxx:7313
Bool_t ReadPictureDataFromFile(const char *filename, char ***ret_data)
Read picture data from file and store in ret_data.
Definition: TGWin32.cxx:5658
void CloseDisplay()
close display (terminate server/gMainThread thread)
Definition: TGWin32.cxx:900
const Mask_t kLeaveWindowMask
Definition: GuiTypes.h:167
EGEventType
Definition: GuiTypes.h:58
Handle_t Cursor_t
Definition: GuiTypes.h:33
const Mask_t kWABackPixmap
Definition: GuiTypes.h:138
static XWindow_t * gTws
Definition: TGX11.cxx:81
void SetColor(GdkGC *gc, Int_t ci)
Set the foreground color in GdkGC.
Definition: TGWin32.cxx:2957
Bool_t fUseSysPointers
True when using system mouse pointers.
Definition: TGWin32.h:115
Bool_t CheckEvent(Window_t id, EGEventType type, Event_t &ev)
Check if there is for window "id" an event of type "type".
Definition: TGWin32.cxx:5789
Window_t FindRWindow(Window_t win, Window_t dragwin, Window_t input, int x, int y, int maxd)
Recursively search in the children of Window for a Window which is at location x, y and is DND aware...
Definition: TGWin32.cxx:7724
Int_t fTsYOrigin
Definition: GuiTypes.h:240
SCoord_t fX
Definition: TPoint.h:35
void SetWMSizeHints(Window_t id, UInt_t wmin, UInt_t hmin, UInt_t wmax, UInt_t hmax, UInt_t winc, UInt_t hinc)
Give the window manager minimum and maximum size hints.
Definition: TGWin32.cxx:6595
Size_t fMarkerSize
Marker size.
Definition: TAttMarker.h:24
Bool_t fMarkerColorModified
Definition: TGWin32.h:137
static UInt_t fMaxResponseTime
max period for waiting response from server thread
static KeySymbolMap_t gKeyMap[]
Definition: GX11Gui.cxx:73
#define gROOT
Definition: TROOT.h:375
Int_t fY
Definition: GuiTypes.h:177
void RaiseWindow(Window_t id)
Put window on top of window stack.
Definition: TGWin32.cxx:4680
void UpdateLineStyle()
Update line style.
Definition: TGWin32.cxx:3301
Handle_t GContext_t
Definition: GuiTypes.h:37
Colormap_t fColormap
Definition: GuiTypes.h:107
void SetWindowName(Window_t id, char *name)
Set window name.
Definition: TGWin32.cxx:6491
ULong_t GetPixel(Color_t cindex)
Return pixel value associated to specified ROOT color number.
Definition: TGWin32.cxx:2945
SCoord_t fY
Definition: TPoint.h:36
void DrawFillArea(Int_t n, TPoint *xy)
Fill area described by polygon.
Definition: TGWin32.cxx:1737
R__EXTERN Atom_t gWM_DELETE_WINDOW
Definition: TVirtualX.h:39
Basic string class.
Definition: TString.h:129
static Cursor gNullCursor
Definition: TGX11.cxx:154
void ChangeGC(GContext_t gc, GCValues_t *gval)
Change entries in an existing graphics context, gc, by values from gval.
Definition: TGWin32.cxx:5433
const Mask_t kGCLineStyle
Definition: GuiTypes.h:290
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:168
Short_t fX
Definition: GuiTypes.h:356
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
virtual TTimer * RemoveTimer(TTimer *t)
Remove timer from list of system timers.
Definition: TSystem.cxx:488
TArc * a
Definition: textangle.C:12
void UpdateLineColor()
Definition: TGWin32.cxx:3244
FT_Vector fAlign
alignment vector
Definition: TGWin32.h:73
Int_t fRedDiv
Red value divider, -1 if no TrueColor visual.
Definition: TGWin32.h:123
void GetWindowAttributes(Window_t id, WindowAttributes_t &attr)
Get window attributes and return filled in attributes structure.
Definition: TGWin32.cxx:5279
Handle_t Drawable_t
Definition: GuiTypes.h:30
static GC * gGCmark
Definition: TGX11.cxx:91
static int gJoinStyle
Definition: TGX11.cxx:131
Int_t fClipYOrigin
Definition: GuiTypes.h:245
void SetWMState(Window_t id, EInitialState state)
Set the initial state of the window. Either kNormalState or kIconicState.
Definition: TGWin32.cxx:6620
void DrawImage(FT_Bitmap *source, ULong_t fore, ULong_t back, GdkImage *xim, Int_t bx, Int_t by)
Draw FT_Bitmap bitmap to xim image at position bx,by using specified foreground color.
Definition: TGWin32.cxx:1237
Int_t fFillStyle
Definition: GuiTypes.h:233
Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h)
Register a window created by Qt as a ROOT window (like InitWindow()).
Definition: TGWin32.cxx:7468
void UnmapWindow(Window_t id)
Unmap window from screen.
Definition: TGWin32.cxx:4647
Pixmap_t fClipMask
Definition: GuiTypes.h:246
#define NULL
Definition: RtypesCore.h:88
R__EXTERN TApplication * gApplication
Definition: TApplication.h:165
Int_t fRedShift
Bits to left shift red, -1 if no TrueColor visual.
Definition: TGWin32.h:126
static std::string format(double x, double y, int digits, int width)
ECursor
Definition: TVirtualX.h:44
TObject * At(Int_t idx) const
Definition: TObjArray.h:165
This class is the basic interface to the Win32 graphics system.
Definition: TGWin32.h:67
Proxy classes provide thread-safe interface to global objects.
#define XDND_PROTOCOL_VERSION
Definition: TGWin32.cxx:66
#define safestrlen(s)
Definition: TGWin32.cxx:6518
short Font_t
Definition: RtypesCore.h:75
void MapSubwindows(Window_t id)
Maps all subwindows for the specified window "id" in top-to-bottom stacking order.
Definition: TGWin32.cxx:4609
void FreeFontStruct(FontStruct_t fs)
Free font structure returned by GetFontStruct().
Definition: TGWin32.cxx:6709
Window_t fWindow
Definition: GuiTypes.h:175
#define malloc
Definition: civetweb.c:818
Handle_t Display_t
Definition: GuiTypes.h:26
Int_t fTextAlignV
Text Alignment Vertical.
Definition: TGWin32.h:117
TString & Insert(Ssiz_t pos, const char *s)
Definition: TString.h:597
void DeletePictureData(void *data)
Delete picture data created by the function ReadPictureDataFromFile.
Definition: TGWin32.cxx:5678
void MapKeySym(UInt_t &keysym, UInt_t &xkeysym, Bool_t tox=kTRUE)
Map to and from X key symbols.
Definition: TGWin32.cxx:6862
Float_t GetBlue() const
Definition: TColor.h:58
Int_t TextWidth(FontStruct_t font, const char *s, Int_t len)
Return length of string in pixels. Size depends on font.
Definition: TGWin32.cxx:6667
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
void gdk_win32_draw_lines(GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints)
void PutPixel(Drawable_t id, Int_t x, Int_t y, ULong_t pixel)
Overwrites the pixel in the image with the specified pixel value.
Definition: TGWin32.cxx:7270
EGraphicsFunction fFunction
Definition: GuiTypes.h:224
#define G(x, y, z)
Int_t OpenDisplay(const char *dpyName=0)
Open the display. Return -1 if the opening fails, 0 when ok.
Definition: TGWin32.cxx:979
int GIFquantize(UInt_t width, UInt_t height, Int_t *ncol, Byte_t *red, Byte_t *green, Byte_t *blue, Byte_t *outputBuf, Byte_t *outputCmap)
const ULong_t kMWMHintsFunctions
Definition: GX11Gui.cxx:55
static GC * gGCtext
Definition: TGX11.cxx:93
void SendEvent(Window_t id, Event_t *ev)
Send event ev to window id.
Definition: TGWin32.cxx:5823
Handle_t FontH_t
Definition: GuiTypes.h:34
Int_t fBlueDiv
Blue value divider.
Definition: TGWin32.h:125
void Align(void)
Compute alignment variables.
Definition: TGWin32.cxx:1207
void GetPasteBuffer(Window_t id, Atom_t atom, TString &text, Int_t &nchar, Bool_t del)
Get contents of paste buffer atom into string.
Definition: TGWin32.cxx:6902
ULong_t fBackgroundPixel
Definition: GuiTypes.h:94
const Mask_t kPointerMotionMask
Definition: GuiTypes.h:162
Bool_t fMapInstalled
Definition: GuiTypes.h:128
void SetDoubleBuffer(Int_t wid, Int_t mode)
Set the double buffer on/off on window wid.
Definition: TGWin32.cxx:3031
Region_t CreateRegion()
Create a new empty region.
Definition: TGWin32.cxx:7108
UShort_t fRed
Definition: GuiTypes.h:311
const Mask_t kGCClipMask
Definition: GuiTypes.h:304
void LowerWindow(Window_t id)
Lower window so it lays below all its siblings.
Definition: TGWin32.cxx:4699
long GIFencode(int Width, int Height, Int_t Ncol, Byte_t R[], Byte_t G[], Byte_t B[], Byte_t ScLine[], void(*get_scline)(int, int, Byte_t *), void(*pb)(Byte_t))
Pixmap_t CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height)
create an image from RGB data.
Definition: TGWin32.cxx:7389
static const double x2[5]
Int_t fGreenDiv
Green value divider.
Definition: TGWin32.h:124
Double_t x[n]
Definition: legend1.C:17
static void LayoutGlyphs()
Compute the glyphs positions, fgAscent and fgWidth (needed for alignment).
Definition: TTF.cxx:181
void SetTextFont(Font_t fontnumber)
Set specified font.
Definition: TGWin32.cxx:1540
unsigned long KeySym
Definition: TGWin32.h:53
void QueryPointer(Int_t &ix, Int_t &iy)
Query pointer position.
Definition: TGWin32.cxx:2266
Display_t GetDisplay() const
Returns handle to display (might be useful in some cases where direct X11 manipulation outside of TVi...
Definition: TGWin32.cxx:5320
void SetDoubleBufferON()
Turn double buffer mode on.
Definition: TGWin32.cxx:3077
void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text, ETextMode mode)
Draw text using TrueType fonts.
Definition: TGWin32.cxx:1357
void SetFillColor(Color_t cindex)
Set color index for fill areas.
Definition: TGWin32.cxx:3135
static void SetTextFont(Font_t fontnumber)
Set specified font.
Definition: TTF.cxx:488
Float_t GetGreen() const
Definition: TColor.h:57
unsigned char Byte_t
Definition: RtypesCore.h:60
void UpdateFillColor()
Definition: TGWin32.cxx:3150
void GetPlanes(Int_t &nplanes)
Get maximum number of planes.
Definition: TGWin32.cxx:2038
Handle_t fXEvent
Current native (GDK) event.
Definition: TGWin32.h:129
Int_t GetProperty(Window_t, Atom_t, Long_t, Long_t, Bool_t, Atom_t, Atom_t *, Int_t *, ULong_t *, ULong_t *, unsigned char **)
Returns the actual type of the property, the actual format of the property, and a pointer to the data...
Definition: TGWin32.cxx:7585
static void GetTextExtent(UInt_t &w, UInt_t &h, char *text)
Get width (w) and height (h) when text is horizontal.
Definition: TTF.cxx:132
static TVirtualX * fgRealObject
unsigned int r3[N_CITIES]
Definition: simanTSP.cxx:323
const int ny
Definition: kalman.C:17
void DeletePixmap(Pixmap_t pmap)
Explicitely delete pixmap resource.
Definition: TGWin32.cxx:5588
static void PrepareString(const char *string)
Put the characters in "string" in the "glyphs" array.
Definition: TTF.cxx:247
void SetInput(Int_t inp)
Set input on or off.
Definition: TGWin32.cxx:3225
Handle_t fHandle
Definition: GuiTypes.h:184
static FILE * gGifFile
Definition: TGWin32.cxx:4268
Handle_t Atom_t
Definition: GuiTypes.h:36
const Int_t kMAXMK
Definition: TGX11.cxx:118
ULong_t fForeground
Definition: GuiTypes.h:226
Colormap_t fColormap
Definition: GuiTypes.h:127
Bool_t CreatePictureFromFile(Drawable_t id, const char *filename, Pixmap_t &pict, Pixmap_t &pict_mask, PictureAttributes_t &attr)
Create a picture pixmap from data on file.
Definition: TGWin32.cxx:5598
const Mask_t kGCFont
Definition: GuiTypes.h:299
Int_t fXRoot
Definition: GuiTypes.h:178
void CopyGC(GContext_t org, GContext_t dest, Mask_t mask)
Copies graphics context from org to dest.
Definition: TGWin32.cxx:5499
Int_t WriteGIF(char *name)
Writes the current window into GIF file.
Definition: TGWin32.cxx:4374
Bool_t fPenModified
line syle || width modified
Definition: TGWin32.h:135
const Mask_t kGCLineWidth
Definition: GuiTypes.h:289
static void Unlock()
Definition: TGWin32.cxx:954
void MapGCValues(GCValues_t &gval, ULong_t &xmask, GdkGCValues &xgval, Bool_t tox=kTRUE)
Map a GCValues_t to a XCGValues structure if tox is true.
Definition: TGWin32.cxx:5010
const Mask_t kWAColormap
Definition: GuiTypes.h:152
void ChangeProperty(Window_t id, Atom_t property, Atom_t type, UChar_t *data, Int_t len)
This function alters the property for the specified window and causes the X server to generate a Prop...
Definition: TGWin32.cxx:6364
static TVirtualX * RealObject()
const Mask_t kGCGraphicsExposures
Definition: GuiTypes.h:301
static void GlobalLock()
lock any proxy (client thread)
const ULong_t kMWMHintsInputMode
Definition: GX11Gui.cxx:57
void GetImageSize(Drawable_t id, UInt_t &width, UInt_t &height)
Returns the width and height of the image id.
Definition: TGWin32.cxx:7261
Pixmap_t CreatePixmap(Drawable_t id, UInt_t w, UInt_t h)
Creates a pixmap of the width and height you specified and returns a pixmap ID that identifies it...
Definition: TGWin32.cxx:5536
void GrabButton(Window_t id, EMouseButton button, UInt_t modifier, UInt_t evmask, Window_t confine, Cursor_t cursor, Bool_t grab=kTRUE)
Establish passive grab on a certain mouse button.
Definition: TGWin32.cxx:6446
void gdk_win32_draw_arc(GdkDrawable *drawable, GdkGC *gc, gint filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2)
Bool_t fLineColorModified
Definition: TGWin32.h:134
void IntersectRegion(Region_t rega, Region_t regb, Region_t result)
Compute the intersection of rega and regb and return result region.
Definition: TGWin32.cxx:7157
void UpdateMarkerColor()
Definition: TGWin32.cxx:3363
Bool_t CreatePictureFromData(Drawable_t id, char **data, Pixmap_t &pict, Pixmap_t &pict_mask, PictureAttributes_t &attr)
Create a pixture pixmap from data.
Definition: TGWin32.cxx:5632
R__EXTERN ULong_t gConsoleWindow
Definition: TWinNTSystem.h:265
static void PutByte(Byte_t b)
Put byte b in output stream.
Definition: TGWin32.cxx:4298
void FreeColor(Colormap_t cmap, ULong_t pixel)
Free color cell with specified pixel value.
Definition: TGWin32.cxx:5779
static GC * gGCfill
Definition: TGX11.cxx:92
static TTGlyph * GetGlyphs()
Definition: TTF.cxx:647
you should not use this method at all Int_t Int_t Double_t bm
Definition: TRolke.cxx:630
Int_t OpenPixmap(UInt_t w, UInt_t h)
Open a new pixmap.
Definition: TGWin32.cxx:2103
void SetCursor(Int_t win, ECursor cursor)
Set the cursor.
Definition: TGWin32.cxx:2999
void MapEventMask(UInt_t &emask, UInt_t &xemask, Bool_t tox=kTRUE)
Map event mask to or from gdk.
Definition: TGWin32.cxx:4898
Int_t fGreenShift
Bits to left shift green.
Definition: TGWin32.h:127
static TVirtualX * ProxyObject()
void RenderString(Int_t x, Int_t y, ETextMode mode)
Perform the string rendering in the pad.
Definition: TGWin32.cxx:1434
static ULong_t fgMainThreadId
main thread ID
static GC * gGCdash
Definition: TGX11.cxx:95
int GIFdecode(Byte_t *GIFarr, Byte_t *PIXarr, int *Width, int *Height, int *Ncols, Byte_t *R, Byte_t *G, Byte_t *B)
Definition: gifdecode.c:149
void SetMWMHints(Window_t id, UInt_t value, UInt_t funcs, UInt_t input)
Set decoration style for MWM-compatible wm (mwm, ncdwm, fvwm?).
Definition: TGWin32.cxx:6562
void GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab=kTRUE)
Establish passive grab on a certain key.
Definition: TGWin32.cxx:6427
Int_t fTsXOrigin
Definition: GuiTypes.h:239
short Color_t
Definition: RtypesCore.h:79
Short_t fX
Definition: GuiTypes.h:361
void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b)
Get rgb values for color "index".
Definition: TGWin32.cxx:2046
virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess)
Return the size of a character string.
Definition: TGWin32.cxx:2066
static int gDashOffset
Definition: TGX11.cxx:134
Bool_t IsDNDAware(Window_t win, Atom_t *typelist)
Checks if Window win is DND aware, and knows any of the DND formats passed in argument.
Definition: TGWin32.cxx:7781
void Warp(Int_t ix, Int_t iy, Window_t id=0)
Set pointer position.
Definition: TGWin32.cxx:4227
const ULong_t kMWMHintsDecorations
Definition: GX11Gui.cxx:56
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition: TAttText.h:41
static void SetSmoothing(Bool_t state)
Set smoothing (anti-aliasing) flag.
Definition: TTF.cxx:362
void SetFillStyle(Style_t style)
Set fill area style.
Definition: TGWin32.cxx:3169
Int_t KeysymToKeycode(UInt_t keysym)
Convert a keysym to the appropriate keycode.
Definition: TGWin32.cxx:6729
void SetDrawMode(EDrawMode mode)
Set the drawing mode.
Definition: TGWin32.cxx:3106
Definition: TPoint.h:31
Style_t fMarkerStyle
Marker style.
Definition: TAttMarker.h:23
void SetIconName(Window_t id, char *name)
Set window icon name.
Definition: TGWin32.cxx:6501
Bool_t PointInRegion(Int_t x, Int_t y, Region_t reg)
Returns true if the point x,y is in the region.
Definition: TGWin32.cxx:7191
#define None
Definition: TGWin32.h:55
void SetLineStyle(Style_t linestyle)
Set line style.
Definition: TGWin32.cxx:3290
point * points
Definition: X3DBuffer.c:20
UShort_t fGreen
Definition: GuiTypes.h:312
const Mask_t kButtonPressMask
Definition: GuiTypes.h:160
void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2, Int_t nx, Int_t ny, Int_t *ic)
Draw a cell array.
Definition: TGWin32.cxx:1701
Bool_t fOverrideRedirect
Definition: GuiTypes.h:106
void SetTextSize(Float_t textsize)
Set current text size.
Definition: TGWin32.cxx:1564
void GetCharacterUp(Float_t &chupx, Float_t &chupy)
Return character up vector.
Definition: TGWin32.cxx:1932
Int_t RequestLocator(Int_t mode, Int_t ctyp, Int_t &x, Int_t &y)
Request Locator position.
Definition: TGWin32.cxx:2311
void SetDNDAware(Window_t win, Atom_t *typelist)
Add XdndAware property and the list of drag and drop types to the Window win.
Definition: TGWin32.cxx:7800
Int_t fTextAlign
Text alignment (set in SetTextAlign)
Definition: TGWin32.h:118
const Mask_t kKeyPressMask
Definition: GuiTypes.h:158
void DrawPolyLine(Int_t n, TPoint *xy)
Draw a line through all points.
Definition: TGWin32.cxx:1798
void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos)
Copy the pixmap wid at the position xpos, ypos in the current window.
Definition: TGWin32.cxx:1647
static XWindow_t * gCws
Definition: TGX11.cxx:80
Bool_t fGraphicsExposures
Definition: GuiTypes.h:243
Int_t fTextAlignH
Text Alignment Horizontal.
Definition: TGWin32.h:116
void DrawSegments(Drawable_t id, GContext_t gc, Segment_t *seg, Int_t nseg)
Draws multiple line segments. Each line is specified by a pair of points.
Definition: TGWin32.cxx:6761
Float_t fTextAngle
Text angle.
Definition: TAttText.h:21
static ULong_t fgPostMessageId
post message ID
char ** ListFonts(const char *fontname, Int_t max, Int_t &count)
Return list of font names matching "fontname".
Definition: TGWin32.cxx:7220
float ymax
Definition: THbookFile.cxx:93
const Int_t kPropMWMHintElements
Definition: GX11Gui.cxx:60
Bool_t AllocColor(GdkColormap *cmap, GdkColor *color)
Allocate color in colormap.
Definition: TGWin32.cxx:1163
Style_t fLineStyle
Line style.
Definition: TAttLine.h:22
void SetClipOFF(Int_t wid)
Turn off the clipping for the window wid.
Definition: TGWin32.cxx:2899
void SetWindowBackgroundPixmap(Window_t id, Pixmap_t pxm)
Set pixmap as window background.
Definition: TGWin32.cxx:4783
EMouseButton
Definition: GuiTypes.h:213
void MapModifierState(UInt_t &state, UInt_t &xstate, Bool_t tox=kTRUE)
Map modifier key state to or from X.
Definition: TGWin32.cxx:5872
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition: TExMap.cxx:173
TPaveText * pt
static Int_t GetWidth()
Definition: TTF.cxx:612
void FreeFontNames(char **fontlist)
Frees the specified the array of strings "fontlist".
Definition: TGWin32.cxx:7244
TRandom2 r(17)
GdkVisual * fVisual
Definition: TGWin32.h:111
const Mask_t kWAEventMask
Definition: GuiTypes.h:150
R__EXTERN TSystem * gSystem
Definition: TSystem.h:539
Time_t fTime
Definition: GuiTypes.h:176
EGEventType fType
Definition: GuiTypes.h:174
XPoint xy[kMAXMK]
Definition: TGX11.cxx:122
void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMode mode)
Draw a box.
Definition: TGWin32.cxx:1662
UInt_t fHeight
Definition: GuiTypes.h:181
Bool_t SetSelectionOwner(Window_t, Atom_t &)
Assigns owner of Clipboard.
Definition: TGWin32.cxx:7670
Bool_t fFillStyleModified
Definition: TGWin32.h:133
const Mask_t kGCClipXOrigin
Definition: GuiTypes.h:302
const char * GetLineStyleString(Int_t i=1) const
Return line style string (used by PostScript).
Definition: TStyle.cxx:792
Color_t fLineColor
Line color.
Definition: TAttLine.h:21
virtual Int_t GetValue(const char *name, Int_t dflt)
Returns the integer value for a resource.
Definition: TEnv.cxx:482
VOID CALLBACK MyTimerProc(HWND hwnd, UINT message, UINT idTimer, DWORD dwTime)
Windows timer handling events while moving/resizing windows.
Definition: TGWin32.cxx:835
static ULong_t fgUserThreadId
user (e.g. python) thread ID
void gdk_win32_draw_rectangle(GdkDrawable *drawable, GdkGC *gc, gint filled, gint x, gint y, gint width, gint height)
unsigned int r1[N_CITIES]
Definition: simanTSP.cxx:321
void gdk_win32_draw_points(GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints)
R__EXTERN TVirtualX *(* gPtr2VirtualX)()
Definition: TVirtualX.h:351
const Mask_t kExposureMask
Definition: GuiTypes.h:164
static FT_Matrix * GetRotMatrix()
Definition: TTF.cxx:633
Float_t fCharacterUpX
Character Up vector along X.
Definition: TGWin32.h:119
unsigned int UInt_t
Definition: RtypesCore.h:42
Width_t fLineWidth
Line width.
Definition: TAttLine.h:23
TTF helper class containing glyphs description.
Definition: TTF.h:65
TMarker * m
Definition: textangle.C:8
void SetCharacterUp(Float_t chupx, Float_t chupy)
Set character up vector.
Definition: TGWin32.cxx:2870
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:873
void ChangeActivePointerGrab(Window_t, UInt_t, Cursor_t)
Changes the active cursor of the specified window.
Definition: TGWin32.cxx:7633
static GdkImage * gGifImage
Definition: TGWin32.cxx:4269
void MakeOpaqueColors(Int_t percent, ULong_t *orgcolors, Int_t ncolors)
Get RGB values for orgcolors, add percent neutral to the RGB and allocate new_colors.
Definition: TGWin32.cxx:4008
#define calloc
Definition: civetweb.c:819
short Short_t
Definition: RtypesCore.h:35
void ClearWindow()
Clear current window.
Definition: TGWin32.cxx:1573
Int_t fYRoot
Definition: GuiTypes.h:178
TLine * l
Definition: textangle.C:4
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
const Mask_t kGCClipYOrigin
Definition: GuiTypes.h:303
#define CALLBACK
Definition: TGLFaceSet.cxx:30
const Mask_t kGCJoinStyle
Definition: GuiTypes.h:292
Double_t ACos(Double_t)
Definition: TMath.h:572
float xmax
Definition: THbookFile.cxx:93
GdkImage * GetBackground(Int_t x, Int_t y, UInt_t w, UInt_t h)
Get the background of the current window in an XImage.
Definition: TGWin32.cxx:1386
void QueryColors(GdkColormap *cmap, GdkColor *colors, Int_t ncolors)
Returns the current RGB value for the pixel in the XColor structure.
Definition: TGWin32.cxx:1180
Font_t fTextFont
Text font.
Definition: TAttText.h:25
void SetTextColor(Color_t cindex)
Set color index for text.
Definition: TGWin32.cxx:4180
void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2)
Draw a line.
Definition: TGWin32.cxx:1770
void Reset(Detail::TBranchProxy *x)
GdkCursor * fCursors[kNumCursors]
List of cursors.
Definition: TGWin32.h:85
#define XA_ATOM
Definition: xatom.h:13
void DestroySubwindows(Window_t id)
Destroy all internal subwindows.
Definition: TGWin32.cxx:4670
#define VOID
Definition: triangle.h:286
void GetRegionBox(Region_t reg, Rectangle_t *)
Return smallest enclosing rectangle.
Definition: TGWin32.cxx:7207
void Bell(Int_t percent)
Sets the sound bell. Percent is loudness from -100% to 100%.
Definition: TGWin32.cxx:6296
void RemoveWindow(ULong_t qwid)
Remove a window created by Qt (like CloseWindow1()).
Definition: TGWin32.cxx:7516
ULong_t fPixel
Definition: GuiTypes.h:310
void SetMarkerStyle(Style_t markerstyle)
Set marker style.
Definition: TGWin32.cxx:3409
Int_t GetDoubleBuffer(Int_t wid)
Query the double buffer value for the window wid.
Definition: TGWin32.cxx:1977
const unsigned char gStipples[26][32]
Definition: RStipples.h:26
#define gVirtualX
Definition: TVirtualX.h:350
void MapEvent(Event_t &ev, GdkEvent &xev, Bool_t tox=kTRUE)
Map Event_t structure to gdk_event structure.
Definition: TGWin32.cxx:5928
Pixmap_t fStipple
Definition: GuiTypes.h:238
Handle_t Colormap_t
Definition: GuiTypes.h:32
short Width_t
Definition: RtypesCore.h:78
const Bool_t kFALSE
Definition: RtypesCore.h:92
Cursor_t CreateCursor(ECursor cursor)
Create cursor handle (just return cursor from cursor pool fCursors).
Definition: TGWin32.cxx:5527
void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t *attr)
Change window attributes.
Definition: TGWin32.cxx:6319
EKeySym
Definition: KeySymbols.h:25
static void * Alloc(size_t size)
Allocate a block of memory, that later can be resized using TStorage::ReAlloc().
Definition: TStorage.cxx:152
void LookupString(Event_t *event, char *buf, Int_t buflen, UInt_t &keysym)
Convert the keycode from the event structure to a key symbol (according to the modifiers specified in...
Definition: TGWin32.cxx:6849
void DestroyWindow(Window_t id)
Destroy window.
Definition: TGWin32.cxx:4657
const Mask_t kEnterWindowMask
Definition: GuiTypes.h:166
long Long_t
Definition: RtypesCore.h:50
FontH_t GetFontHandle(FontStruct_t fs)
Return handle to font described by font structure.
Definition: TGWin32.cxx:5394
void DrawPolyMarker(Int_t n, TPoint *xy)
Draw n markers with the current attributes at position x, y.
Definition: TGWin32.cxx:1854
void ImgPickPalette(GdkImage *image, Int_t &ncol, Int_t *&R, Int_t *&G, Int_t *&B)
Returns in R G B the ncol colors of the palette used by the image.
Definition: TGWin32.cxx:4312
void RemovePixmap(GdkDrawable *pix)
Remove the pixmap pix.
Definition: TGWin32.cxx:2280
void FillRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw a filled rectangle. Filling is done according to the gc.
Definition: TGWin32.cxx:6739
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition: TString.cxx:2251
#define XA_WM_CLASS
Definition: xatom.h:76
void DrawString(Drawable_t id, GContext_t gc, Int_t x, Int_t y, const char *s, Int_t len)
Draw a string using a specific graphics context in position (x,y).
Definition: TGWin32.cxx:6653
ULong_t fBackground
Definition: GuiTypes.h:227
static const double x1[5]
Int_t fDepth
Number of color planes.
Definition: TGWin32.h:122
#define ClassImp(name)
Definition: Rtypes.h:336
double f(double x)
void gdk_win32_draw_segments(GdkDrawable *drawable, GdkGC *gc, GdkSegment *segs, gint nsegs)
const Mask_t kGCFillStyle
Definition: GuiTypes.h:293
const Mask_t kStructureNotifyMask
Definition: GuiTypes.h:165
void WritePixmap(Int_t wid, UInt_t w, UInt_t h, char *pxname)
Write the pixmap wid in the bitmap file pxname.
Definition: TGWin32.cxx:4251
void ChangeProperties(Window_t id, Atom_t property, Atom_t type, Int_t format, UChar_t *data, Int_t len)
Put data into Clipboard.
Definition: TGWin32.cxx:7687
static Int_t GetAscent()
Definition: TTF.cxx:619
R__EXTERN TWin32SplashThread * gSplash
void DrawRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw a rectangle outline.
Definition: TGWin32.cxx:6750
void SetInputFocus(Window_t id)
Set keyboard input focus to window id.
Definition: TGWin32.cxx:6796
Bool_t GUIThreadMessageFunc(MSG *msg)
Message processing function for the GUI thread.
Definition: TGWin32.cxx:846
TText * text
Bool_t EqualRegion(Region_t rega, Region_t regb)
Returns true if two regions are equal.
Definition: TGWin32.cxx:7199
void SetWMPosition(Window_t id, Int_t x, Int_t y)
Tells the window manager the desired position [x,y] of window "id".
Definition: TGWin32.cxx:6574
Float_t fCharacterUpY
Character Up vector along Y.
Definition: TGWin32.h:120
const Mask_t kButtonReleaseMask
Definition: GuiTypes.h:161
void ClearArea(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h)
Clear a window area to the bakcground color.
Definition: TGWin32.cxx:6387
static GC gGCecho
Definition: TGX11.cxx:98
UInt_t fCode
Definition: GuiTypes.h:179
Pixmap_t CreateBitmap(Drawable_t id, const char *bitmap, UInt_t width, UInt_t height)
Create a bitmap (i.e. pixmap with depth 1) from the bitmap data.
Definition: TGWin32.cxx:5574
const Handle_t kParentRelative
Definition: GuiTypes.h:89
int type
Definition: TGX11.cxx:120
#define TRUE
R__EXTERN TEnv * gEnv
Definition: TEnv.h:170
const Mask_t kGCTile
Definition: GuiTypes.h:295
void WMDeleteNotify(Window_t id)
Tell WM to send message when window is closed via WM.
Definition: TGWin32.cxx:6397
Int_t RequestString(Int_t x, Int_t y, char *text)
Request a string.
Definition: TGWin32.cxx:2466
#define free
Definition: civetweb.c:821
const Mask_t kWAOverrideRedirect
Definition: GuiTypes.h:148
unsigned long ULong_t
Definition: RtypesCore.h:51
Int_t fJoinStyle
Definition: GuiTypes.h:232
TGWin32()
Default constructor.
Definition: TGWin32.cxx:757
Window_t fRoot
Definition: GuiTypes.h:119
TCanvas * style()
Definition: style.C:1
Double_t y[n]
Definition: legend1.C:17
char ** Argv() const
Definition: TApplication.h:136
void AsmLong(Long_t i1, Long_t i2, Long_t &ll)
Definition: GX11Gui.cxx:159
const Mask_t kGCFunction
Definition: GuiTypes.h:285
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
const Mask_t kGCCapStyle
Definition: GuiTypes.h:291
void MapSetWindowAttributes(SetWindowAttributes_t *attr, ULong_t &xmask, GdkWindowAttr &xattr)
Map a SetWindowAttributes_t to a GdkWindowAttr structure.
Definition: TGWin32.cxx:4977
Bool_t IsCmdThread() const
returns kTRUE if we are inside cmd/server thread
Definition: TGWin32.cxx:887
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:572
static int gDashSize
Definition: TGX11.cxx:135
void Beep(Int_t freq=-1, Int_t duration=-1, Bool_t setDefault=kFALSE)
Beep for duration milliseconds with a tone of frequency freq.
Definition: TSystem.cxx:331
const Mask_t kGCForeground
Definition: GuiTypes.h:287
The color creation and management class.
Definition: TColor.h:19
void SelectInput(Window_t id, UInt_t evmask)
Defines which input events the window is interested in.
Definition: TGWin32.cxx:6775
GdkColormap * fColormap
Default colormap, 0 if b/w.
Definition: TGWin32.h:112
Window_t CreateWindow(Window_t parent, Int_t x, Int_t y, UInt_t w, UInt_t h, UInt_t border, Int_t depth, UInt_t clss, void *visual, SetWindowAttributes_t *attr, UInt_t wtype)
Return handle to newly created gdk window.
Definition: TGWin32.cxx:4793
void GetGCValues(GContext_t gc, GCValues_t &gval)
Get current values from graphics context gc.
Definition: TGWin32.cxx:6687
const char null_cursor_bits[]
Definition: TGX11.cxx:150
Bool_t fMarkerStyleModified
Definition: TGWin32.h:136
Int_t fCapStyle
Definition: GuiTypes.h:230
Float_t fTextSize
Text size.
Definition: TAttText.h:22
static GC gGClist[kMAXGC]
Definition: TGX11.cxx:89
void PutImage(Int_t offset, Int_t itran, Int_t x0, Int_t y0, Int_t nx, Int_t ny, Int_t xmin, Int_t ymin, Int_t xmax, Int_t ymax, UChar_t *image, Drawable_t id)
Draw image.
Definition: TGWin32.cxx:4437
void SetWMTransientHint(Window_t id, Window_t main_id)
Tell window manager that window is a transient window of gdk_parent_root.
Definition: TGWin32.cxx:6643
Long_t fUser[5]
Definition: GuiTypes.h:186
void MapWindow(Window_t id)
Map window on screen.
Definition: TGWin32.cxx:4594
void UnionRegion(Region_t rega, Region_t regb, Region_t result)
Compute the union of rega and regb and return result region.
Definition: TGWin32.cxx:7148
static ULong_t fgPingMessageId
ping message ID
void SetIconPixmap(Window_t id, Pixmap_t pic)
Set pixmap the WM can use when the window is iconized.
Definition: TGWin32.cxx:6511
static Pixmap gFillPattern
Definition: TGX11.cxx:101
#define org(otri, vertexptr)
Definition: triangle.c:1037
void GetFontProperties(FontStruct_t font, Int_t &max_ascent, Int_t &max_descent)
Return some font properties.
Definition: TGWin32.cxx:6675
Window_t GetCurrentWindow() const
Return current window pointer. Protected method used by TGWin32TTF.
Definition: TGWin32.cxx:1955
static void * ReAlloc(void *vp, size_t size)
Reallocate (i.e.
Definition: TStorage.cxx:183
const Mask_t kGCStipple
Definition: GuiTypes.h:296
UInt_t fWidth
Definition: GuiTypes.h:181
Int_t InitWindow(ULong_t window)
Open window and return window number.
Definition: TGWin32.cxx:2162
static char gDashList[10]
Definition: TGX11.cxx:132
static void SetRotationMatrix(Float_t angle)
Set the rotation matrix used to rotate the font outlines.
Definition: TTF.cxx:339
Int_t fMaxNumberOfWindows
Maximum number of windows.
Definition: TGWin32.h:82
void DeleteFont(FontStruct_t fs)
Explicitely delete font structure obtained with LoadQueryFont().
Definition: TGWin32.cxx:5405
#define FALSE
Bool_t fOverrideRedirect
Definition: GuiTypes.h:133
Handle_t Window_t
Definition: GuiTypes.h:28
void UpdateMarkerStyle()
Definition: TGWin32.cxx:3419
GdkColor color
Definition: TGWin32.h:60
Int_t fFormat
Definition: GuiTypes.h:185
Mask_t fMask
Definition: GuiTypes.h:250
Window_t GetWindowID(Int_t wid)
Return the X11 window identifier.
Definition: TGWin32.cxx:2077
unsigned char * GetColorBits(Drawable_t wid, Int_t x, Int_t y, UInt_t width, UInt_t height)
Gets DIB bits x, y, width, height - position of bitmap returns a pointer on bitmap bits array in form...
Definition: TGWin32.cxx:7328
void DestroyRegion(Region_t reg)
Destroy region.
Definition: TGWin32.cxx:7116
void SplitLong(Long_t ll, Long_t &i1, Long_t &i2)
Definition: GX11Gui.cxx:148
Bool_t EmptyRegion(Region_t reg)
Return true if the region is empty.
Definition: TGWin32.cxx:7183
const Mask_t kGCTileStipYOrigin
Definition: GuiTypes.h:298
void GetWindowSize(Drawable_t id, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
Return geometry of window (should be called GetGeometry but signature already used).
Definition: TGWin32.cxx:6965
void MoveResizeWindow(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h)
Move and resize a window.
Definition: TGWin32.cxx:4721
void ResizeWindow(Int_t wid)
Resize the current window if necessary.
Definition: TGWin32.cxx:2791
const Mask_t kGCSubwindowMode
Definition: GuiTypes.h:300
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition: TSystem.cxx:478
Int_t fScreenNumber
Screen number.
Definition: TGWin32.h:113
Definition: file.py:1
Bool_t Next(ULong64_t &hash, Long64_t &key, Long64_t &value)
Get next entry from TExMap. Returns kFALSE at end of map.
Definition: TExMap.cxx:411
const Mask_t kWABorderWidth
Definition: GuiTypes.h:142
Region_t PolygonRegion(Point_t *points, Int_t np, Bool_t winding)
Create region for the polygon defined by the points array.
Definition: TGWin32.cxx:7138
#define dest(otri, vertexptr)
Definition: triangle.c:1040
Color_t fFillColor
Fill area color.
Definition: TAttFill.h:22
#define XA_STRING
Definition: xatom.h:40
const Mask_t kGCBackground
Definition: GuiTypes.h:288
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:200
Window_t GetPrimarySelectionOwner()
Returns the window id of the current owner of the primary selection.
Definition: TGWin32.cxx:6808
Int_t AddPixmap(ULong_t pix, UInt_t w, UInt_t h)
register pixmap created by TGWin32GLManager
Definition: TGWin32.cxx:7425
#define BITmask(x)
Window_t GetParent(Window_t id) const
Return the parent of the window.
Definition: TGWin32.cxx:5358
UInt_t ScreenWidthMM() const
Returns the width of the screen in millimeters.
Definition: TGWin32.cxx:7561
Handle_t Region_t
Definition: GuiTypes.h:31
const Mask_t kGCTileStipXOrigin
Definition: GuiTypes.h:297
void SetForeground(GContext_t gc, ULong_t foreground)
Set foreground color in graphics context (shortcut for ChangeGC with only foreground mask set)...
Definition: TGWin32.cxx:7061
const Mask_t kFocusChangeMask
Definition: GuiTypes.h:168
Handle_t Pixmap_t
Definition: GuiTypes.h:29
int Seek_t
Definition: RtypesCore.h:49
void Sync(Int_t mode)
Set synchronisation on or off.
Definition: TGWin32.cxx:4198
Int_t fLineWidth
Definition: GuiTypes.h:228
static int gLineStyle
Definition: TGX11.cxx:129
Int_t FindColor(ULong_t pixel, ULong_t *orgcolors, Int_t ncolors)
Returns index in orgcolors (and new_colors) for pixel.
Definition: TGWin32.cxx:4068
const Int_t kPropMotifWMHintsElements
Definition: GX11Gui.cxx:59
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
void SubtractRegion(Region_t rega, Region_t regb, Region_t result)
Subtract rega from regb.
Definition: TGWin32.cxx:7166
const Int_t kBIGGEST_RGB_VALUE
Definition: TGX11.cxx:83
const size_t kBitsPerByte
Definition: RtypesCore.h:114
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:494
UInt_t fState
Definition: GuiTypes.h:180
static ULong_t gKeybdMask
Definition: TGX11.cxx:144
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition: TAttText.h:43
R__EXTERN Int_t gDebug
Definition: Rtypes.h:83
TExMap * fColors
Hash list of colors.
Definition: TGWin32.h:84
Bool_t fDefined
true if pixel value is defined
Definition: TGWin32.h:61
#define TESTBIT(n, i)
Definition: Rtypes.h:78
static int gDashLength
Definition: TGX11.cxx:133
void NextEvent(Event_t &event)
Copies first pending event from event queue to Event_t structure and removes event from queue...
Definition: TGWin32.cxx:5853
static void SetTextSize(Float_t textsize)
Set current text size.
Definition: TTF.cxx:559
void ConvertPrimarySelection(Window_t id, Atom_t clipboard, Time_t when)
XConvertSelection() causes a SelectionRequest event to be sent to the current primary selection owner...
Definition: TGWin32.cxx:6835
void UnionRectWithRegion(Rectangle_t *rect, Region_t src, Region_t dest)
Union of rectangle with a region.
Definition: TGWin32.cxx:7124
void gdk_win32_draw_polygon(GdkDrawable *drawable, GdkGC *gc, gint filled, GdkPoint *points, gint npoints)
const Mask_t kWABackPixel
Definition: GuiTypes.h:139
static void _set_event_time(GdkEvent &event, UInt_t time)
Definition: TGWin32.cxx:5884
Int_t fSubwindowMode
Definition: GuiTypes.h:242
void SetClassHints(Window_t id, char *className, char *resourceName)
Set the windows class and resource name.
Definition: TGWin32.cxx:6523
GdkGC * GetGC(Int_t which) const
Return desired Graphics Context ("which" maps directly on gGCList[]).
Definition: TGWin32.cxx:1964
double result[121]
unsigned char UChar_t
Definition: RtypesCore.h:34
Int_t fBlueShift
Bits to left shift blue.
Definition: TGWin32.h:128
void UpdateWindow(Int_t mode)
Update display.
Definition: TGWin32.cxx:4211
static int gCapStyle
Definition: TGX11.cxx:130
Double_t Sqrt(Double_t x)
Definition: TMath.h:591
void SetClipRegion(Int_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h)
Set clipping region for the window wid.
Definition: TGWin32.cxx:2917
unsigned long Atom
Definition: xatom.h:9
Drawable_t CreateImage(UInt_t width, UInt_t height)
Allocates the memory needed for an drawable.
Definition: TGWin32.cxx:7252
Int_t ResizePixmap(Int_t wid, UInt_t w, UInt_t h)
Resize a pixmap.
Definition: TGWin32.cxx:2743
FontStruct_t GetFontStruct(FontH_t fh)
Retrieve associated font structure once we have the font handle.
Definition: TGWin32.cxx:6701
static Int_t GetNumGlyphs()
Definition: TTF.cxx:626
void SetTypeList(Window_t win, Atom_t prop, Atom_t *typelist)
Add the list of drag and drop types to the Window win.
Definition: TGWin32.cxx:7712
Color_t fMarkerColor
Marker color.
Definition: TAttMarker.h:22
const Mask_t kAnyModifier
Definition: GuiTypes.h:209
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:155
Atom_t InternAtom(const char *atom_name, Bool_t only_if_exist)
Return atom handle for atom_name.
Definition: TGWin32.cxx:5338
void SetKeyAutoRepeat(Bool_t on=kTRUE)
Turn key auto repeat on or off.
Definition: TGWin32.cxx:6412
const Bool_t kTRUE
Definition: RtypesCore.h:91
const int kMAXGC
Definition: TGX11.cxx:88
void gdk_win32_draw_text(GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, const gchar *text, gint text_length)
void QueryColor(Colormap_t cmap, ColorStruct_t &color)
Fill in the primary color components for a specific pixel value.
Definition: TGWin32.cxx:5761
Long_t fYourEventMask
Definition: GuiTypes.h:131
int GIFinfo(Byte_t *GIFarr, int *Width, int *Height, int *Ncols)
Definition: gifdecode.c:80
static XFontStruct * gTextFont
Definition: TGX11.cxx:112
const Int_t n
Definition: legend1.C:16
Int_t fX
Definition: GuiTypes.h:177
EGraphicsFunction
Definition: GuiTypes.h:66
void TranslateCoordinates(Window_t src, Window_t dest, Int_t src_x, Int_t src_y, Int_t &dest_x, Int_t &dest_y, Window_t &child)
TranslateCoordinates translates coordinates from the frame of reference of one window to another...
Definition: TGWin32.cxx:6934
TRandom3 R
a TMatrixD.
Definition: testIO.cxx:28
R__EXTERN TInterpreter *(* gPtr2Interpreter)()
Definition: TInterpreter.h:500
TObject * fRefreshTimer
TGWin32RefreshTimer for GUI thread message handler.
Definition: TGWin32.h:130
void SetTextAlign(Short_t talign=11)
Set text alignment.
Definition: TGWin32.cxx:4120
unsigned int r2[N_CITIES]
Definition: simanTSP.cxx:322
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:33
static ULong_t gMouseMask
Definition: TGX11.cxx:140
void CopyArea(Drawable_t src, Drawable_t dest, GContext_t gc, Int_t src_x, Int_t src_y, UInt_t width, UInt_t height, Int_t dest_x, Int_t dest_y)
Copy a drawable (i.e.
Definition: TGWin32.cxx:6306
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:859
void DeleteGC(GContext_t gc)
Explicitely delete a graphics context.
Definition: TGWin32.cxx:5519
void SetPrimarySelectionOwner(Window_t id)
Makes the window id the current owner of the primary selection.
Definition: TGWin32.cxx:6817
static const FT_BBox & GetBox()
Definition: TTF.cxx:640
Style_t fFillStyle
Fill area style.
Definition: TAttFill.h:23
static Bool_t GetSmoothing()
Definition: TTF.cxx:598
void IconifyWindow(Window_t id)
Iconify the window.
Definition: TGWin32.cxx:4745
int gdk_debug_level
Definition: TGWin32.cxx:137
segment * segs
Definition: X3DBuffer.c:21
static GC * gGCinvt
Definition: TGX11.cxx:94
Short_t fY
Definition: GuiTypes.h:356
ULong_t Handle_t
Definition: GuiTypes.h:25
void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b)
Set color intensities for given color index.
Definition: TGWin32.cxx:4083