ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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 
240 const Int_t kPropMotifWMHintsElements = 4;
241 const Int_t kPropMWMHintElements = kPropMotifWMHintsElements;
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) {
992  gdk_debug_level = gDebug;
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 {
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  }
1840  gDashOffset %= gDashLength;
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 {
2068  TTF::SetTextFont(gTextFont);
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 
2361  gdk_win32_draw_arc(gCws->window, gGCecho, kFALSE,
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:
2371  gdk_win32_draw_rectangle( gCws->window, gGCecho, kFALSE,
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
2498  TTF::SetTextFont(gTextFont);
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) {
3153  SetColor(gGCfill, fFillColor);
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 {
3246  SetColor(gGCline, Int_t(fLineColor));
3247  SetColor(gGCdash, Int_t(fLineColor));
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 {
3365  SetColor(gGCmark, Int_t(fMarkerColor));
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[15];
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 {
3695  // single dot
3696  SetMarkerType(0, 0, shape);
3697  }
3699 }
3700 
3701 ////////////////////////////////////////////////////////////////////////////////
3702 /// Set opacity of a window. This image manipulation routine works
3703 /// by adding to a percent amount of neutral to each pixels RGB.
3704 /// Since it requires quite some additional color map entries is it
3705 /// only supported on displays with more than > 8 color planes (> 256
3706 /// colors)
3707 
3709 {
3710  Int_t depth = gdk_visual_get_best_depth();
3711 
3712  if (depth <= 8) return;
3713  if (percent == 0) return;
3714 
3715  // if 100 percent then just make white
3716  ULong_t *orgcolors = 0, *tmpc = 0;
3717  Int_t maxcolors = 0, ncolors, ntmpc = 0;
3718 
3719  // save previous allocated colors, delete at end when not used anymore
3720  if (gCws->new_colors) {
3721  tmpc = gCws->new_colors;
3722  ntmpc = gCws->ncolors;
3723  }
3724  // get pixmap from server as image
3725  GdkImage *image = gdk_image_get((GdkDrawable*)gCws->drawing, 0, 0,
3726  gCws->width, gCws->height);
3727 
3728  // collect different image colors
3729  int x, y;
3730  for (y = 0; y < (int) gCws->height; y++) {
3731  for (x = 0; x < (int) gCws->width; x++) {
3732  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
3733  CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
3734  }
3735  }
3736  if (ncolors == 0) {
3737  gdk_image_unref(image);
3738  ::operator delete(orgcolors);
3739  return;
3740  }
3741  // create opaque counter parts
3742  MakeOpaqueColors(percent, orgcolors, ncolors);
3743 
3744  // put opaque colors in image
3745  for (y = 0; y < (int) gCws->height; y++) {
3746  for (x = 0; x < (int) gCws->width; x++) {
3747  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
3748  Int_t idx = FindColor(pixel, orgcolors, ncolors);
3749  PutPixel((Drawable_t)image, x, y, gCws->new_colors[idx]);
3750  }
3751  }
3752 
3753  // put image back in pixmap on server
3754  gdk_draw_image(gCws->drawing, gGCpxmp, (GdkImage *)image,
3755  0, 0, 0, 0, gCws->width, gCws->height);
3756  GdiFlush();
3757 
3758  // clean up
3759  if (tmpc) {
3760  gdk_colors_free((GdkColormap *)fColormap, tmpc, ntmpc, 0);
3761  delete[]tmpc;
3762  }
3763  gdk_image_unref(image);
3764  ::operator delete(orgcolors);
3765 }
3766 
3767 ////////////////////////////////////////////////////////////////////////////////
3768 /// Get RGB values for orgcolors, add percent neutral to the RGB and
3769 /// allocate new_colors.
3770 
3771 void TGWin32::MakeOpaqueColors(Int_t percent, ULong_t *orgcolors, Int_t ncolors)
3772 {
3773  Int_t ret;
3774  if (ncolors <= 0) return;
3775  GdkColor *xcol = new GdkColor[ncolors];
3776 
3777  int i;
3778  for (i = 0; i < ncolors; i++) {
3779  xcol[i].pixel = orgcolors[i];
3780  xcol[i].red = xcol[i].green = xcol[i].blue = 0;
3781  }
3782 
3783  GdkColorContext *cc;
3784  cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)fColormap);
3785  gdk_color_context_query_colors(cc, xcol, ncolors);
3786  gdk_color_context_free(cc);
3787 
3788  UShort_t add = percent * kBIGGEST_RGB_VALUE / 100;
3789 
3790  Int_t val;
3791  for (i = 0; i < ncolors; i++) {
3792  val = xcol[i].red + add;
3793  if (val > kBIGGEST_RGB_VALUE) {
3794  val = kBIGGEST_RGB_VALUE;
3795  }
3796  xcol[i].red = (UShort_t) val;
3797  val = xcol[i].green + add;
3798  if (val > kBIGGEST_RGB_VALUE) {
3799  val = kBIGGEST_RGB_VALUE;
3800  }
3801  xcol[i].green = (UShort_t) val;
3802  val = xcol[i].blue + add;
3803  if (val > kBIGGEST_RGB_VALUE) {
3804  val = kBIGGEST_RGB_VALUE;
3805  }
3806  xcol[i].blue = (UShort_t) val;
3807 
3808  ret = gdk_color_alloc((GdkColormap *)fColormap, &xcol[i]);
3809 
3810  if (!ret) {
3811  Warning("MakeOpaqueColors",
3812  "failed to allocate color %hd, %hd, %hd", xcol[i].red,
3813  xcol[i].green, xcol[i].blue);
3814  // assumes that in case of failure xcol[i].pixel is not changed
3815  }
3816  }
3817 
3818  gCws->new_colors = new ULong_t[ncolors];
3819  gCws->ncolors = ncolors;
3820 
3821  for (i = 0; i < ncolors; i++) {
3822  gCws->new_colors[i] = xcol[i].pixel;
3823  }
3824 
3825  delete []xcol;
3826 }
3827 
3828 ////////////////////////////////////////////////////////////////////////////////
3829 /// Returns index in orgcolors (and new_colors) for pixel.
3830 
3831 Int_t TGWin32::FindColor(ULong_t pixel, ULong_t * orgcolors, Int_t ncolors)
3832 {
3833  for (int i = 0; i < ncolors; i++) {
3834  if (pixel == orgcolors[i]) return i;
3835  }
3836  Error("FindColor", "did not find color, should never happen!");
3837 
3838  return 0;
3839 }
3840 
3841 ////////////////////////////////////////////////////////////////////////////////
3842 /// Set color intensities for given color index.
3843 /// cindex : color index
3844 /// r,g,b : red, green, blue intensities between 0.0 and 1.0
3845 
3846 void TGWin32::SetRGB(int cindex, float r, float g, float b)
3847 {
3848  GdkColor xcol;
3849 
3850  if (fColormap && cindex >= 0) {
3851  xcol.red = (unsigned short) (r * kBIGGEST_RGB_VALUE);
3852  xcol.green = (unsigned short) (g * kBIGGEST_RGB_VALUE);
3853  xcol.blue = (unsigned short) (b * kBIGGEST_RGB_VALUE);
3854  xcol.pixel = RGB(xcol.red, xcol.green, xcol.blue);
3855 
3856  XColor_t &col = GetColor(cindex);
3857  if (col.fDefined) {
3858  // if color is already defined with same rgb just return
3859  if (col.color.red == xcol.red && col.color.green == xcol.green &&
3860  col.color.blue == xcol.blue)
3861  return;
3862  col.fDefined = kFALSE;
3863  gdk_colormap_free_colors((GdkColormap *) fColormap,
3864  (GdkColor *)&col, 1);
3865  }
3866 
3867  Int_t ret = gdk_colormap_alloc_color(fColormap, &xcol, 1, 1);
3868  if (ret != 0) {
3869  col.fDefined = kTRUE;
3870  col.color.pixel = xcol.pixel;
3871  col.color.red = xcol.red;
3872  col.color.green = xcol.green;
3873  col.color.blue = xcol.blue;
3874  }
3875  }
3876 }
3877 
3878 ////////////////////////////////////////////////////////////////////////////////
3879 /// Set text alignment.
3880 /// txalh : horizontal text alignment
3881 /// txalv : vertical text alignment
3882 
3884 {
3885  static Short_t current = 0;
3886  if (talign==current) return;
3887  current = talign;
3888 
3889  Int_t txalh = talign / 10;
3890  Int_t txalv = talign % 10;
3891  fTextAlignH = txalh;
3892  fTextAlignV = txalv;
3893 
3894  switch (txalh) {
3895 
3896  case 0:
3897  case 1:
3898  switch (txalv) { //left
3899  case 1:
3900  fTextAlign = 7; //bottom
3901  break;
3902  case 2:
3903  fTextAlign = 4; //center
3904  break;
3905  case 3:
3906  fTextAlign = 1; //top
3907  break;
3908  }
3909  break;
3910  case 2:
3911  switch (txalv) { //center
3912  case 1:
3913  fTextAlign = 8; //bottom
3914  break;
3915  case 2:
3916  fTextAlign = 5; //center
3917  break;
3918  case 3:
3919  fTextAlign = 2; //top
3920  break;
3921  }
3922  break;
3923  case 3:
3924  switch (txalv) { //right
3925  case 1:
3926  fTextAlign = 9; //bottom
3927  break;
3928  case 2:
3929  fTextAlign = 6; //center
3930  break;
3931  case 3:
3932  fTextAlign = 3; //top
3933  break;
3934  }
3935  break;
3936  }
3938 }
3939 
3940 ////////////////////////////////////////////////////////////////////////////////
3941 /// Set color index for text.
3942 
3944 {
3945  static Int_t current = 0;
3946  GdkGCValues values;
3947  if ((cindex < 0) || (Int_t(cindex)==current)) return;
3948 
3949  SetColor(gGCtext, Int_t(cindex));
3950  gdk_gc_get_values(gGCtext, &values);
3951  gdk_gc_set_foreground(gGCinvt, &values.background);
3952  gdk_gc_set_background(gGCinvt, &values.foreground);
3953  gdk_gc_set_background(gGCtext, (GdkColor *) & GetColor(0).color);
3954  current = Int_t(cindex);
3955 }
3956 
3957 ////////////////////////////////////////////////////////////////////////////////
3958 
3959 void TGWin32::Sync(int mode)
3960 {
3961 }
3962 
3963 ////////////////////////////////////////////////////////////////////////////////
3964 /// Update display.
3965 /// mode : (1) update
3966 /// (0) sync
3967 ///
3968 /// Synchronise client and server once (not permanent).
3969 /// Copy the pixmap gCws->drawing on the window gCws->window
3970 /// if the double buffer is on.
3971 
3973 {
3974  if (gCws && gCws->double_buffer) {
3975  gdk_window_copy_area(gCws->window, gGCpxmp, 0, 0,
3976  gCws->drawing, 0, 0, gCws->width, gCws->height);
3977  }
3978  Update(mode);
3979 }
3980 
3981 ////////////////////////////////////////////////////////////////////////////////
3982 /// Set pointer position.
3983 /// ix : New X coordinate of pointer
3984 /// iy : New Y coordinate of pointer
3985 /// Coordinates are relative to the origin of the window id
3986 /// or to the origin of the current window if id == 0.
3987 
3988 void TGWin32::Warp(int ix, int iy, Window_t id)
3989 {
3990  if (!id) return;
3991 
3992  POINT cpt, tmp;
3993  HWND dw;
3994  if (!id)
3995  dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)gCws->window);
3996  else
3997  dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)id);
3998  GetCursorPos(&cpt);
3999  tmp.x = ix > 0 ? ix : cpt.x;
4000  tmp.y = iy > 0 ? iy : cpt.y;
4001  ClientToScreen(dw, &tmp);
4002  SetCursorPos(tmp.x, tmp.y);
4003 }
4004 
4005 ////////////////////////////////////////////////////////////////////////////////
4006 /// Write the pixmap wid in the bitmap file pxname.
4007 /// wid : Pixmap address
4008 /// w,h : Width and height of the pixmap.
4009 /// lenname : pixmap name length
4010 /// pxname : pixmap name
4011 
4012 void TGWin32::WritePixmap(int wid, unsigned int w, unsigned int h,
4013  char *pxname)
4014 {
4015  int wval, hval;
4016  wval = w;
4017  hval = h;
4018 
4019  if (!fWindows) return;
4020  gTws = &fWindows[wid];
4021 // XWriteBitmapFile(fDisplay,pxname,(Pixmap)gTws->drawing,wval,hval,-1,-1);
4022 }
4023 
4024 
4025 //
4026 // Functions for GIFencode()
4027 //
4028 
4029 static FILE *gGifFile; // output unit used WriteGIF and PutByte
4030 static GdkImage *gGifImage = 0; // image used in WriteGIF and GetPixel
4031 
4032 extern "C" {
4033  int GIFquantize(UInt_t width, UInt_t height, Int_t * ncol, Byte_t * red,
4034  Byte_t * green, Byte_t * blue, Byte_t * outputBuf,
4035  Byte_t * outputCmap);
4036  long GIFencode(int Width, int Height, Int_t Ncol, Byte_t R[],
4037  Byte_t G[], Byte_t B[], Byte_t ScLine[],
4038  void (*get_scline) (int, int, Byte_t *),
4039  void (*pb) (Byte_t));
4040  int GIFdecode(Byte_t * GIFarr, Byte_t * PIXarr, int *Width, int *Height,
4041  int *Ncols, Byte_t * R, Byte_t * G, Byte_t * B);
4042  int GIFinfo(Byte_t * GIFarr, int *Width, int *Height, int *Ncols);
4043 }
4044 
4045 
4046 ////////////////////////////////////////////////////////////////////////////////
4047 /// Get pixels in line y and put in array scline.
4048 
4049 static void GetPixel(int y, int width, Byte_t * scline)
4050 {
4051  for (int i = 0; i < width; i++) {
4052  scline[i] = Byte_t(GetPixelImage((Drawable_t)gGifImage, i, y));
4053  }
4054 }
4055 
4056 ////////////////////////////////////////////////////////////////////////////////
4057 /// Put byte b in output stream.
4058 
4059 static void PutByte(Byte_t b)
4060 {
4061  if (ferror(gGifFile) == 0) fputc(b, gGifFile);
4062 }
4063 
4064 ////////////////////////////////////////////////////////////////////////////////
4065 /// Returns in R G B the ncol colors of the palette used by the image.
4066 /// The image pixels are changed to index values in these R G B arrays.
4067 /// This produces a colormap with only the used colors (so even on displays
4068 /// with more than 8 planes we will be able to create GIF's when the image
4069 /// contains no more than 256 different colors). If it does contain more
4070 /// colors we will have to use GIFquantize to reduce the number of colors.
4071 /// The R G B arrays must be deleted by the caller.
4072 
4073 void TGWin32::ImgPickPalette(GdkImage * image, Int_t & ncol, Int_t * &R,
4074  Int_t * &G, Int_t * &B)
4075 {
4076  ULong_t *orgcolors = 0;
4077  Int_t maxcolors = 0, ncolors;
4078 
4079  // collect different image colors
4080  int x, y;
4081  for (x = 0; x < (int) gCws->width; x++) {
4082  for (y = 0; y < (int) gCws->height; y++) {
4083  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
4084  CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
4085  }
4086  }
4087 
4088  // get RGB values belonging to pixels
4089  GdkColor *xcol = new GdkColor[ncolors];
4090 
4091  int i;
4092  for (i = 0; i < ncolors; i++) {
4093  xcol[i].pixel = orgcolors[i];
4094 // xcol[i].red = xcol[i].green = xcol[i].blue = 0;
4095  xcol[i].red = GetRValue(xcol[i].pixel);
4096  xcol[i].green = GetGValue(xcol[i].pixel);
4097  xcol[i].blue = GetBValue(xcol[i].pixel);
4098  }
4099 
4100  GdkColorContext *cc;
4101  cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)fColormap);
4102  gdk_color_context_query_colors(cc, xcol, ncolors);
4103  gdk_color_context_free(cc);
4104 
4105  // create RGB arrays and store RGB's for each color and set number of colors
4106  // (space must be delete by caller)
4107  R = new Int_t[ncolors];
4108  G = new Int_t[ncolors];
4109  B = new Int_t[ncolors];
4110 
4111  for (i = 0; i < ncolors; i++) {
4112  R[i] = xcol[i].red;
4113  G[i] = xcol[i].green;
4114  B[i] = xcol[i].blue;
4115  }
4116  ncol = ncolors;
4117 
4118  // update image with indices (pixels) into the new RGB colormap
4119  for (x = 0; x < (int) gCws->width; x++) {
4120  for (y = 0; y < (int) gCws->height; y++) {
4121  ULong_t pixel = GetPixelImage((Drawable_t)image, x, y);
4122  Int_t idx = FindColor(pixel, orgcolors, ncolors);
4123  PutPixel((Drawable_t)image, x, y, idx);
4124  }
4125  }
4126 
4127  // cleanup
4128  delete[]xcol;
4129  ::operator delete(orgcolors);
4130 }
4131 
4132 ////////////////////////////////////////////////////////////////////////////////
4133 /// Writes the current window into GIF file.
4134 
4136 {
4137  Byte_t scline[2000], r[256], b[256], g[256];
4138  Int_t *R, *G, *B;
4139  Int_t ncol, maxcol, i;
4140 
4141  if (gGifImage) {
4142  gdk_image_unref((GdkImage *)gGifImage);
4143  }
4144 
4145  gGifImage = gdk_image_get((GdkDrawable*)gCws->drawing, 0, 0,
4146  gCws->width, gCws->height);
4147 
4148  ImgPickPalette(gGifImage, ncol, R, G, B);
4149 
4150  if (ncol > 256) {
4151  //GIFquantize(...);
4152  Error("WriteGIF",
4153  "can not create GIF of image containing more than 256 colors");
4154  delete[]R;
4155  delete[]G;
4156  delete[]B;
4157  return 0;
4158  }
4159 
4160  maxcol = 0;
4161  for (i = 0; i < ncol; i++) {
4162  if (maxcol < R[i]) maxcol = R[i];
4163  if (maxcol < G[i]) maxcol = G[i];
4164  if (maxcol < B[i]) maxcol = B[i];
4165  r[i] = 0;
4166  g[i] = 0;
4167  b[i] = 0;
4168  }
4169  if (maxcol != 0) {
4170  for (i = 0; i < ncol; i++) {
4171  r[i] = R[i] * 255 / maxcol;
4172  g[i] = G[i] * 255 / maxcol;
4173  b[i] = B[i] * 255 / maxcol;
4174  }
4175  }
4176 
4177  gGifFile = fopen(name, "wb");
4178 
4179  if (gGifFile) {
4180  GIFencode(gCws->width, gCws->height,
4181  ncol, r, g, b, scline, ::GetPixel, PutByte);
4182  fclose(gGifFile);
4183  i = 1;
4184  } else {
4185  Error("WriteGIF","cannot write file: %s",name);
4186  i = 0;
4187  }
4188  delete[]R;
4189  delete[]G;
4190  delete[]B;
4191 
4192  return i;
4193 }
4194 
4195 ////////////////////////////////////////////////////////////////////////////////
4196 /// Draw image.
4197 
4198 void TGWin32::PutImage(int offset, int itran, int x0, int y0, int nx,
4199  int ny, int xmin, int ymin, int xmax, int ymax,
4200  unsigned char *image, Drawable_t wid)
4201 {
4202  const int MAX_SEGMENT = 20;
4203  int i, n, x, y, xcur, x1, x2, y1, y2;
4204  unsigned char *jimg, *jbase, icol;
4205  int nlines[256];
4206  GdkSegment lines[256][MAX_SEGMENT];
4207  GdkDrawable *id;
4208 
4209  if (wid) {
4210  id = (GdkDrawable*)wid;
4211  } else {
4212  id = gCws->drawing;
4213  }
4214 
4215  for (i = 0; i < 256; i++) nlines[i] = 0;
4216 
4217  x1 = x0 + xmin;
4218  y1 = y0 + ny - ymax - 1;
4219  x2 = x0 + xmax;
4220  y2 = y0 + ny - ymin - 1;
4221  jbase = image + (ymin - 1) * nx + xmin;
4222 
4223  for (y = y2; y >= y1; y--) {
4224  xcur = x1;
4225  jbase += nx;
4226  for (jimg = jbase, icol = *jimg++, x = x1 + 1; x <= x2; jimg++, x++) {
4227  if (icol != *jimg) {
4228  if (icol != itran) {
4229  n = nlines[icol]++;
4230  lines[icol][n].x1 = xcur;
4231  lines[icol][n].y1 = y;
4232  lines[icol][n].x2 = x - 1;
4233  lines[icol][n].y2 = y;
4234  if (nlines[icol] == MAX_SEGMENT) {
4235  SetColor(gGCline, (int) icol + offset);
4236  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4237  (GdkSegment *) &lines[icol][0], MAX_SEGMENT);
4238  nlines[icol] = 0;
4239  }
4240  }
4241  icol = *jimg;
4242  xcur = x;
4243  }
4244  }
4245  if (icol != itran) {
4246  n = nlines[icol]++;
4247  lines[icol][n].x1 = xcur;
4248  lines[icol][n].y1 = y;
4249  lines[icol][n].x2 = x - 1;
4250  lines[icol][n].y2 = y;
4251  if (nlines[icol] == MAX_SEGMENT) {
4252  SetColor(gGCline, (int) icol + offset);
4253  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4254  (GdkSegment *)&lines[icol][0], MAX_SEGMENT);
4255  nlines[icol] = 0;
4256  }
4257  }
4258  }
4259 
4260  for (i = 0; i < 256; i++) {
4261  if (nlines[i] != 0) {
4262  SetColor(gGCline, i + offset);
4263  gdk_win32_draw_segments(id, (GdkGC *) gGCline,
4264  (GdkSegment *)&lines[icol][0], nlines[i]);
4265  }
4266  }
4267 }
4268 
4269 ////////////////////////////////////////////////////////////////////////////////
4270 /// If id is NULL - loads the specified gif file at position [x0,y0] in the
4271 /// current window. Otherwise creates pixmap from gif file
4272 
4273 Pixmap_t TGWin32::ReadGIF(int x0, int y0, const char *file, Window_t id)
4274 {
4275  FILE *fd;
4276  Seek_t filesize;
4277  unsigned char *GIFarr, *PIXarr, R[256], G[256], B[256], *j1, *j2, icol;
4278  int i, j, k, width, height, ncolor, irep, offset;
4279  float rr, gg, bb;
4280  Pixmap_t pic = 0;
4281 
4282  fd = fopen(file, "r+b");
4283  if (!fd) {
4284  Error("ReadGIF", "unable to open GIF file");
4285  return pic;
4286  }
4287 
4288  fseek(fd, 0L, 2);
4289  filesize = Seek_t(ftell(fd));
4290  fseek(fd, 0L, 0);
4291 
4292  if (!(GIFarr = (unsigned char *) calloc(filesize + 256, 1))) {
4293  fclose(fd);
4294  Error("ReadGIF", "unable to allocate array for gif");
4295  return pic;
4296  }
4297 
4298  if (fread(GIFarr, filesize, 1, fd) != 1) {
4299  fclose(fd);
4300  Error("ReadGIF", "GIF file read failed");
4301  return pic;
4302  }
4303  fclose(fd);
4304 
4305  irep = GIFinfo(GIFarr, &width, &height, &ncolor);
4306  if (irep != 0) {
4307  return pic;
4308  }
4309 
4310  if (!(PIXarr = (unsigned char *) calloc((width * height), 1))) {
4311  Error("ReadGIF", "unable to allocate array for image");
4312  return pic;
4313  }
4314 
4315  irep = GIFdecode(GIFarr, PIXarr, &width, &height, &ncolor, R, G, B);
4316  if (irep != 0) {
4317  return pic;
4318  }
4319  // S E T P A L E T T E
4320 
4321  offset = 8;
4322 
4323  for (i = 0; i < ncolor; i++) {
4324  rr = R[i] / 255.;
4325  gg = G[i] / 255.;
4326  bb = B[i] / 255.;
4327  j = i + offset;
4328  SetRGB(j, rr, gg, bb);
4329  }
4330 
4331  // O U T P U T I M A G E
4332 
4333  for (i = 1; i <= height / 2; i++) {
4334  j1 = PIXarr + (i - 1) * width;
4335  j2 = PIXarr + (height - i) * width;
4336  for (k = 0; k < width; k++) {
4337  icol = *j1;
4338  *j1++ = *j2;
4339  *j2++ = icol;
4340  }
4341  }
4342 
4343  if (id) pic = CreatePixmap(id, width, height);
4344  PutImage(offset, -1, x0, y0, width, height, 0, 0, width-1, height-1, PIXarr, pic);
4345 
4346  if (pic) return pic;
4347  else if (gCws->drawing) return (Pixmap_t)gCws->drawing;
4348  else return 0;
4349 }
4350 
4351 //////////////////////////// GWin32Gui //////////////////////////////////////////
4352 ////////////////////////////////////////////////////////////////////////////////
4353 /// Map window on screen.
4354 
4356 {
4357  if (!id) return;
4358 
4359  gdk_window_show((GdkWindow *)id);
4360  if ((GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_TEMP) &&
4361  (GetParent(id) == GetDefaultRootWindow())) {
4362  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4363  ::SetForegroundWindow(window);
4364  }
4365 }
4366 
4367 ////////////////////////////////////////////////////////////////////////////////
4368 ///
4369 
4371 {
4372  if (!id) return;
4373 
4374  EnumChildWindows((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
4375  EnumChildProc, (LPARAM) NULL);
4376 }
4377 
4378 ////////////////////////////////////////////////////////////////////////////////
4379 /// Map window on screen and put on top of all windows.
4380 
4382 {
4383  if (!id) return;
4384 
4385  HWND hwnd = ::GetForegroundWindow();
4386  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4387  gdk_window_show((GdkWindow *)id);
4388  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_TEMP) {
4389  ::BringWindowToTop(window);
4390  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_CHILD)
4391  ::SetForegroundWindow(window);
4392  }
4393 
4394  if (gConsoleWindow && (hwnd == (HWND)gConsoleWindow)) {
4395  RECT r1, r2, r3;
4396  ::GetWindowRect((HWND)gConsoleWindow, &r1);
4397  HWND fore = ::GetForegroundWindow();
4398  ::GetWindowRect(fore, &r2);
4399  if (!::IntersectRect(&r3, &r2, &r1)) {
4400  ::SetForegroundWindow((HWND)gConsoleWindow);
4401  }
4402  }
4403 }
4404 
4405 ////////////////////////////////////////////////////////////////////////////////
4406 /// Unmap window from screen.
4407 
4409 {
4410  if (!id) return;
4411 
4412  gdk_window_hide((GdkWindow *) id);
4413 }
4414 
4415 ////////////////////////////////////////////////////////////////////////////////
4416 /// Destroy window.
4417 
4419 {
4420  if (!id) return;
4421 
4422  // we need to unmap the window before to destroy it, in order to properly
4423  // receive kUnmapNotify needed by gClient->WaitForUnmap()...
4424  gdk_window_hide((GdkWindow *) id);
4425  gdk_window_destroy((GdkDrawable *) id, kTRUE);
4426 }
4427 
4428 ////////////////////////////////////////////////////////////////////////////////
4429 /// Destroy all internal subwindows
4430 
4432 {
4433  if (!id) return;
4434 
4435  gdk_window_destroy((GdkDrawable *) id, kFALSE);
4436 }
4437 
4438 ////////////////////////////////////////////////////////////////////////////////
4439 /// Put window on top of window stack.
4440 
4442 {
4443  if (!id) return;
4444 
4445  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4446  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) == GDK_WINDOW_TEMP) {
4447  ::SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0,
4448  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4449  }
4450  else {
4451  ::BringWindowToTop(window);
4452  if (GDK_DRAWABLE_TYPE((GdkWindow *)id) != GDK_WINDOW_CHILD)
4453  ::SetForegroundWindow(window);
4454  }
4455 }
4456 
4457 ////////////////////////////////////////////////////////////////////////////////
4458 /// Lower window so it lays below all its siblings.
4459 
4461 {
4462  if (!id) return;
4463 
4464  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
4465  ::SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0,
4466  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4467 }
4468 
4469 ////////////////////////////////////////////////////////////////////////////////
4470 /// Move a window.
4471 
4473 {
4474  if (!id) return;
4475 
4476  gdk_window_move((GdkDrawable *) id, x, y);
4477 }
4478 
4479 ////////////////////////////////////////////////////////////////////////////////
4480 /// Move and resize a window.
4481 
4483  UInt_t h)
4484 {
4485  if (!id) return;
4486 
4487  gdk_window_move_resize((GdkWindow *) id, x, y, w, h);
4488 }
4489 
4490 ////////////////////////////////////////////////////////////////////////////////
4491 /// Resize the window.
4492 
4494 {
4495  if (!id) return;
4496 
4497  // protect against potential negative values
4498  if (w >= (UInt_t)INT_MAX || h >= (UInt_t)INT_MAX)
4499  return;
4500  gdk_window_resize((GdkWindow *) id, w, h);
4501 }
4502 
4503 ////////////////////////////////////////////////////////////////////////////////
4504 /// Iconify the window.
4505 
4507 {
4508  if (!id) return;
4509 
4510  gdk_window_lower((GdkWindow *) id);
4511  ::CloseWindow((HWND)GDK_DRAWABLE_XID((GdkWindow *)id));
4512 }
4513 
4514 ////////////////////////////////////////////////////////////////////////////////
4515 /// Reparent window, make pid the new parent and position the window at
4516 /// position (x,y) in new parent.
4517 
4519 {
4520  if (!id) return;
4521 
4522  gdk_window_reparent((GdkWindow *)id, (GdkWindow *)pid, x, y);
4523 }
4524 
4525 ////////////////////////////////////////////////////////////////////////////////
4526 /// Set the window background color.
4527 
4529 {
4530  if (!id) return;
4531 
4532  GdkColor back;
4533  back.pixel = color;
4534  back.red = GetRValue(color);
4535  back.green = GetGValue(color);
4536  back.blue = GetBValue(color);
4537 
4538  gdk_window_set_background((GdkWindow *) id, &back);
4539 }
4540 
4541 ////////////////////////////////////////////////////////////////////////////////
4542 /// Set pixmap as window background.
4543 
4545 {
4546  if (!id) return;
4547 
4548  gdk_window_set_back_pixmap((GdkWindow *) id, (GdkPixmap *) pxm, 0);
4549 }
4550 
4551 ////////////////////////////////////////////////////////////////////////////////
4552 /// Return handle to newly created gdk window.
4553 
4555  UInt_t w, UInt_t h, UInt_t border,
4556  Int_t depth, UInt_t clss,
4557  void *visual, SetWindowAttributes_t * attr,
4558  UInt_t wtype)
4559 {
4560  GdkWindowAttr xattr;
4561  GdkWindow *newWin;
4562  GdkColor background_color;
4563  ULong_t xmask = 0;
4564 
4565  if (attr) {
4566  MapSetWindowAttributes(attr, xmask, xattr);
4567  xattr.window_type = GDK_WINDOW_CHILD;
4568  if (wtype & kMainFrame) {
4569  xattr.window_type = GDK_WINDOW_TOPLEVEL;
4570  }
4571  if (wtype & kTransientFrame) {
4572  xattr.window_type = GDK_WINDOW_DIALOG;
4573  }
4574  if (wtype & kTempFrame) {
4575  xattr.window_type = GDK_WINDOW_TEMP;
4576  }
4577  newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4578  } else {
4579  xattr.width = w;
4580  xattr.height = h;
4581  xattr.wclass = GDK_INPUT_OUTPUT;
4582  xattr.event_mask = 0L; //GDK_ALL_EVENTS_MASK;
4583  xattr.event_mask |= GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
4584  GDK_PROPERTY_CHANGE_MASK;
4585 // GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK;
4586  if (x >= 0) {
4587  xattr.x = x;
4588  } else {
4589  xattr.x = -1.0 * x;
4590  }
4591  if (y >= 0) {
4592  xattr.y = y;
4593  } else {
4594  xattr.y = -1.0 * y;
4595  }
4596  xattr.colormap = gdk_colormap_get_system();
4597  xattr.cursor = NULL;
4598  xattr.override_redirect = TRUE;
4599  if ((xattr.y > 0) && (xattr.x > 0)) {
4600  xmask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP |
4601  GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4602  } else {
4603  xmask = GDK_WA_COLORMAP | GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4604  }
4605  if (visual != NULL) {
4606  xattr.visual = (GdkVisual *) visual;
4607  xmask |= GDK_WA_VISUAL;
4608  } else {
4609  xattr.visual = gdk_visual_get_system();
4610  xmask |= GDK_WA_VISUAL;
4611  }
4612  xattr.window_type = GDK_WINDOW_CHILD;
4613  if (wtype & kMainFrame) {
4614  xattr.window_type = GDK_WINDOW_TOPLEVEL;
4615  }
4616  if (wtype & kTransientFrame) {
4617  xattr.window_type = GDK_WINDOW_DIALOG;
4618  }
4619  if (wtype & kTempFrame) {
4620  xattr.window_type = GDK_WINDOW_TEMP;
4621  }
4622  newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4623  gdk_window_set_events(newWin, (GdkEventMask) 0L);
4624  }
4625  if (border > 0) {
4626  gdk_window_set_decorations(newWin,
4627  (GdkWMDecoration) GDK_DECOR_BORDER);
4628  }
4629  if (attr) {
4630  if ((attr->fMask & kWABackPixmap)) {
4631  if (attr->fBackgroundPixmap == kNone) {
4632  gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 0);
4633  } else if (attr->fBackgroundPixmap == kParentRelative) {
4634  gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 1);
4635  } else {
4636  gdk_window_set_back_pixmap(newWin,
4637  (GdkPixmap *) attr->
4638  fBackgroundPixmap, 0);
4639  }
4640  }
4641  if ((attr->fMask & kWABackPixel)) {
4642  background_color.pixel = attr->fBackgroundPixel;
4643  background_color.red = GetRValue(attr->fBackgroundPixel);
4644  background_color.green = GetGValue(attr->fBackgroundPixel);
4645  background_color.blue = GetBValue(attr->fBackgroundPixel);
4646  gdk_window_set_background(newWin, &background_color);
4647  }
4648  }
4649  if (!fUseSysPointers) {
4650  ::SetClassLong((HWND)GDK_DRAWABLE_XID(newWin), GCL_HCURSOR,
4651  (LONG)GDK_CURSOR_XID(fCursors[kPointer]));
4652  }
4653  return (Window_t) newWin;
4654 }
4655 
4656 ////////////////////////////////////////////////////////////////////////////////
4657 /// Map event mask to or from gdk.
4658 
4659 void TGWin32::MapEventMask(UInt_t & emask, UInt_t & xemask, Bool_t tox)
4660 {
4661  if (tox) {
4662  Long_t lxemask = 0L;
4663  if ((emask & kKeyPressMask)) {
4664  lxemask |= GDK_KEY_PRESS_MASK;
4665  }
4666  if ((emask & kKeyReleaseMask)) {
4667  lxemask |= GDK_KEY_RELEASE_MASK;
4668  }
4669  if ((emask & kButtonPressMask)) {
4670  lxemask |= GDK_BUTTON_PRESS_MASK;
4671  }
4672  if ((emask & kButtonReleaseMask)) {
4673  lxemask |= GDK_BUTTON_RELEASE_MASK;
4674  }
4675  if ((emask & kPointerMotionMask)) {
4676  lxemask |= GDK_POINTER_MOTION_MASK;
4677  }
4678  if ((emask & kButtonMotionMask)) {
4679  lxemask |= GDK_BUTTON_MOTION_MASK;
4680  }
4681  if ((emask & kExposureMask)) {
4682  lxemask |= GDK_EXPOSURE_MASK;
4683  }
4684  if ((emask & kStructureNotifyMask)) {
4685  lxemask |= GDK_STRUCTURE_MASK;
4686  }
4687  if ((emask & kEnterWindowMask)) {
4688  lxemask |= GDK_ENTER_NOTIFY_MASK;
4689  }
4690  if ((emask & kLeaveWindowMask)) {
4691  lxemask |= GDK_LEAVE_NOTIFY_MASK;
4692  }
4693  if ((emask & kFocusChangeMask)) {
4694  lxemask |= GDK_FOCUS_CHANGE_MASK;
4695  }
4696  xemask = (UInt_t) lxemask;
4697  } else {
4698  emask = 0;
4699  if ((xemask & GDK_KEY_PRESS_MASK)) {
4700  emask |= kKeyPressMask;
4701  }
4702  if ((xemask & GDK_KEY_RELEASE_MASK)) {
4703  emask |= kKeyReleaseMask;
4704  }
4705  if ((xemask & GDK_BUTTON_PRESS_MASK)) {
4706  emask |= kButtonPressMask;
4707  }
4708  if ((xemask & GDK_BUTTON_RELEASE_MASK)) {
4709  emask |= kButtonReleaseMask;
4710  }
4711  if ((xemask & GDK_POINTER_MOTION_MASK)) {
4712  emask |= kPointerMotionMask;
4713  }
4714  if ((xemask & GDK_BUTTON_MOTION_MASK)) {
4715  emask |= kButtonMotionMask;
4716  }
4717  if ((xemask & GDK_EXPOSURE_MASK)) {
4718  emask |= kExposureMask;
4719  }
4720  if ((xemask & GDK_STRUCTURE_MASK)) {
4721  emask |= kStructureNotifyMask;
4722  }
4723  if ((xemask & GDK_ENTER_NOTIFY_MASK)) {
4724  emask |= kEnterWindowMask;
4725  }
4726  if ((xemask & GDK_LEAVE_NOTIFY_MASK)) {
4727  emask |= kLeaveWindowMask;
4728  }
4729  if ((xemask & GDK_FOCUS_CHANGE_MASK)) {
4730  emask |= kFocusChangeMask;
4731  }
4732  }
4733 }
4734 
4735 ////////////////////////////////////////////////////////////////////////////////
4736 /// Map a SetWindowAttributes_t to a GdkWindowAttr structure.
4737 
4739  ULong_t & xmask,
4740  GdkWindowAttr & xattr)
4741 {
4742  Mask_t mask = attr->fMask;
4743  xmask = 0;
4744 
4745  if ((mask & kWAOverrideRedirect)) {
4746  xmask |= GDK_WA_NOREDIR;
4747  xattr.override_redirect = attr->fOverrideRedirect;
4748  }
4749  if ((mask & kWAEventMask)) {
4750  UInt_t xmsk, msk = (UInt_t) attr->fEventMask;
4751  MapEventMask(msk, xmsk, kTRUE);
4752  xattr.event_mask = xmsk;
4753  }
4754  if ((mask & kWAColormap)) {
4755  xmask |= GDK_WA_COLORMAP;
4756  xattr.colormap = (GdkColormap *) attr->fColormap;
4757  }
4758  if ((mask & kWACursor)) {
4759  xmask |= GDK_WA_CURSOR;
4760  if (attr->fCursor != kNone) {
4761  xattr.cursor = (GdkCursor *) attr->fCursor;
4762  }
4763  }
4764  xattr.wclass = GDK_INPUT_OUTPUT;
4765 }
4766 
4767 ////////////////////////////////////////////////////////////////////////////////
4768 /// Map a GCValues_t to a XCGValues structure if tox is true. Map
4769 /// the other way in case tox is false.
4770 
4772  ULong_t & xmask, GdkGCValues & xgval, Bool_t tox)
4773 {
4774  if (tox) {
4775  // map GCValues_t to XGCValues
4776  Mask_t mask = gval.fMask;
4777  xmask = 0;
4778 
4779  if ((mask & kGCFunction)) {
4780  xmask |= GDK_GC_FUNCTION;
4781  switch (gval.fFunction) {
4782  case kGXclear:
4783  xgval.function = GDK_CLEAR;
4784  break;
4785  case kGXand:
4786  xgval.function = GDK_AND;
4787  break;
4788  case kGXandReverse:
4789  xgval.function = GDK_AND_REVERSE;
4790  break;
4791  case kGXcopy:
4792  xgval.function = GDK_COPY;
4793  break;
4794  case kGXandInverted:
4795  xgval.function = GDK_AND_INVERT;
4796  break;
4797  case kGXnoop:
4798  xgval.function = GDK_NOOP;
4799  break;
4800  case kGXxor:
4801  xgval.function = GDK_XOR;
4802  break;
4803  case kGXor:
4804  xgval.function = GDK_OR;
4805  break;
4806  case kGXequiv:
4807  xgval.function = GDK_EQUIV;
4808  break;
4809  case kGXinvert:
4810  xgval.function = GDK_INVERT;
4811  break;
4812  case kGXorReverse:
4813  xgval.function = GDK_OR_REVERSE;
4814  break;
4815  case kGXcopyInverted:
4816  xgval.function = GDK_COPY_INVERT;
4817  break;
4818  case kGXorInverted:
4819  xgval.function = GDK_OR_INVERT;
4820  break;
4821  case kGXnand:
4822  xgval.function = GDK_NAND;
4823  break;
4824  case kGXset:
4825  xgval.function = GDK_SET;
4826  break;
4827  }
4828  }
4829  if (mask & kGCSubwindowMode) {
4830  xmask |= GDK_GC_SUBWINDOW;
4831  if (gval.fSubwindowMode == kIncludeInferiors) {
4832  xgval.subwindow_mode = GDK_INCLUDE_INFERIORS;
4833  } else {
4834  xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN;
4835  }
4836  }
4837  if (mask & kGCForeground) {
4838  xmask |= GDK_GC_FOREGROUND;
4839  xgval.foreground.pixel = gval.fForeground;
4840  xgval.foreground.red = GetRValue(gval.fForeground);
4841  xgval.foreground.green = GetGValue(gval.fForeground);
4842  xgval.foreground.blue = GetBValue(gval.fForeground);
4843  }
4844  if (mask & kGCBackground) {
4845  xmask |= GDK_GC_BACKGROUND;
4846  xgval.background.pixel = gval.fBackground;
4847  xgval.background.red = GetRValue(gval.fBackground);
4848  xgval.background.green = GetGValue(gval.fBackground);
4849  xgval.background.blue = GetBValue(gval.fBackground);
4850  }
4851  if (mask & kGCLineWidth) {
4852  xmask |= GDK_GC_LINE_WIDTH;
4853  xgval.line_width = gval.fLineWidth;
4854  }
4855  if (mask & kGCLineStyle) {
4856  xmask |= GDK_GC_LINE_STYLE;
4857  xgval.line_style = (GdkLineStyle) gval.fLineStyle; // ident mapping
4858  }
4859  if (mask & kGCCapStyle) {
4860  xmask |= GDK_GC_CAP_STYLE;
4861  xgval.cap_style = (GdkCapStyle) gval.fCapStyle; // ident mapping
4862  }
4863  if (mask & kGCJoinStyle) {
4864  xmask |= GDK_GC_JOIN_STYLE;
4865  xgval.join_style = (GdkJoinStyle) gval.fJoinStyle; // ident mapping
4866  }
4867  if ((mask & kGCFillStyle)) {
4868  xmask |= GDK_GC_FILL;
4869  xgval.fill = (GdkFill) gval.fFillStyle; // ident mapping
4870  }
4871  if ((mask & kGCTile)) {
4872  xmask |= GDK_GC_TILE;
4873  xgval.tile = (GdkPixmap *) gval.fTile;
4874  }
4875  if ((mask & kGCStipple)) {
4876  xmask |= GDK_GC_STIPPLE;
4877  xgval.stipple = (GdkPixmap *) gval.fStipple;
4878  }
4879  if ((mask & kGCTileStipXOrigin)) {
4880  xmask |= GDK_GC_TS_X_ORIGIN;
4881  xgval.ts_x_origin = gval.fTsXOrigin;
4882  }
4883  if ((mask & kGCTileStipYOrigin)) {
4884  xmask |= GDK_GC_TS_Y_ORIGIN;
4885  xgval.ts_y_origin = gval.fTsYOrigin;
4886  }
4887  if ((mask & kGCFont)) {
4888  xmask |= GDK_GC_FONT;
4889  xgval.font = (GdkFont *) gval.fFont;
4890  }
4891  if ((mask & kGCGraphicsExposures)) {
4892  xmask |= GDK_GC_EXPOSURES;
4893  xgval.graphics_exposures = gval.fGraphicsExposures;
4894  }
4895  if ((mask & kGCClipXOrigin)) {
4896  xmask |= GDK_GC_CLIP_X_ORIGIN;
4897  xgval.clip_x_origin = gval.fClipXOrigin;
4898  }
4899  if ((mask & kGCClipYOrigin)) {
4900  xmask |= GDK_GC_CLIP_Y_ORIGIN;
4901  xgval.clip_y_origin = gval.fClipYOrigin;
4902  }
4903  if ((mask & kGCClipMask)) {
4904  xmask |= GDK_GC_CLIP_MASK;
4905  xgval.clip_mask = (GdkPixmap *) gval.fClipMask;
4906  }
4907  } else {
4908  // map XValues to GCValues_t
4909  Mask_t mask = 0;
4910 
4911  if ((xmask & GDK_GC_FUNCTION)) {
4912  mask |= kGCFunction;
4913  gval.fFunction = (EGraphicsFunction) xgval.function; // ident mapping
4914  switch (xgval.function) {
4915  case GDK_CLEAR:
4916  gval.fFunction = kGXclear;
4917  break;
4918  case GDK_AND:
4919  gval.fFunction = kGXand;
4920  break;
4921  case GDK_AND_REVERSE:
4922  gval.fFunction = kGXandReverse;
4923  break;
4924  case GDK_COPY:
4925  gval.fFunction = kGXcopy;
4926  break;
4927  case GDK_AND_INVERT:
4928  gval.fFunction = kGXandInverted;
4929  break;
4930  case GDK_NOOP:
4931  gval.fFunction = kGXnoop;
4932  break;
4933  case GDK_XOR:
4934  gval.fFunction = kGXxor;
4935  break;
4936  case GDK_OR:
4937  gval.fFunction = kGXor;
4938  break;
4939  case GDK_EQUIV:
4940  gval.fFunction = kGXequiv;
4941  break;
4942  case GDK_INVERT:
4943  gval.fFunction = kGXinvert;
4944  break;
4945  case GDK_OR_REVERSE:
4946  gval.fFunction = kGXorReverse;
4947  break;
4948  case GDK_COPY_INVERT:
4949  gval.fFunction = kGXcopyInverted;
4950  break;
4951  case GDK_OR_INVERT:
4952  gval.fFunction = kGXorInverted;
4953  break;
4954  case GDK_NAND:
4955  gval.fFunction = kGXnand;
4956  break;
4957  case GDK_SET:
4958  gval.fFunction = kGXset;
4959  break;
4960  }
4961  }
4962  if (xmask & GDK_GC_SUBWINDOW) {
4963  mask |= kGCSubwindowMode;
4964  if (xgval.subwindow_mode == GDK_INCLUDE_INFERIORS)
4966  else
4968  }
4969  if ((xmask & GDK_GC_FOREGROUND)) {
4970  mask |= kGCForeground;
4971  gval.fForeground = xgval.foreground.pixel;
4972  }
4973  if ((xmask & GDK_GC_BACKGROUND)) {
4974  mask |= kGCBackground;
4975  gval.fBackground = xgval.background.pixel;
4976  }
4977  if ((xmask & GDK_GC_LINE_WIDTH)) {
4978  mask |= kGCLineWidth;
4979  gval.fLineWidth = xgval.line_width;
4980  }
4981  if ((xmask & GDK_GC_LINE_STYLE)) {
4982  mask |= kGCLineStyle;
4983  gval.fLineStyle = xgval.line_style; // ident mapping
4984  }
4985  if ((xmask & GDK_GC_CAP_STYLE)) {
4986  mask |= kGCCapStyle;
4987  gval.fCapStyle = xgval.cap_style; // ident mapping
4988  }
4989  if ((xmask & GDK_GC_JOIN_STYLE)) {
4990  mask |= kGCJoinStyle;
4991  gval.fJoinStyle = xgval.join_style; // ident mapping
4992  }
4993  if ((xmask & GDK_GC_FILL)) {
4994  mask |= kGCFillStyle;
4995  gval.fFillStyle = xgval.fill; // ident mapping
4996  }
4997  if ((xmask & GDK_GC_TILE)) {
4998  mask |= kGCTile;
4999  gval.fTile = (Pixmap_t) xgval.tile;
5000  }
5001  if ((xmask & GDK_GC_STIPPLE)) {
5002  mask |= kGCStipple;
5003  gval.fStipple = (Pixmap_t) xgval.stipple;
5004  }
5005  if ((xmask & GDK_GC_TS_X_ORIGIN)) {
5006  mask |= kGCTileStipXOrigin;
5007  gval.fTsXOrigin = xgval.ts_x_origin;
5008  }
5009  if ((xmask & GDK_GC_TS_Y_ORIGIN)) {
5010  mask |= kGCTileStipYOrigin;
5011  gval.fTsYOrigin = xgval.ts_y_origin;
5012  }
5013  if ((xmask & GDK_GC_FONT)) {
5014  mask |= kGCFont;
5015  gval.fFont = (FontH_t) xgval.font;
5016  }
5017  if ((xmask & GDK_GC_EXPOSURES)) {
5018  mask |= kGCGraphicsExposures;
5019  gval.fGraphicsExposures = (Bool_t) xgval.graphics_exposures;
5020  }
5021  if ((xmask & GDK_GC_CLIP_X_ORIGIN)) {
5022  mask |= kGCClipXOrigin;
5023  gval.fClipXOrigin = xgval.clip_x_origin;
5024  }
5025  if ((xmask & GDK_GC_CLIP_Y_ORIGIN)) {
5026  mask |= kGCClipYOrigin;
5027  gval.fClipYOrigin = xgval.clip_y_origin;
5028  }
5029  if ((xmask & GDK_GC_CLIP_MASK)) {
5030  mask |= kGCClipMask;
5031  gval.fClipMask = (Pixmap_t) xgval.clip_mask;
5032  }
5033  gval.fMask = mask;
5034  }
5035 }
5036 
5037 ////////////////////////////////////////////////////////////////////////////////
5038 /// Get window attributes and return filled in attributes structure.
5039 
5041 {
5042  if (!id) return;
5043 
5044  RECT rcClient, rcWind;
5045  ::GetClientRect((HWND)GDK_DRAWABLE_XID((GdkWindow *) id), &rcClient);
5046  ::GetWindowRect((HWND)GDK_DRAWABLE_XID((GdkWindow *) id), &rcWind);
5047 
5048  gdk_window_get_geometry((GdkWindow *) id, &attr.fX, &attr.fY,
5049  &attr.fWidth, &attr.fHeight, &attr.fDepth);
5050  attr.fX = ((rcWind.right - rcWind.left) - rcClient.right) / 2;
5051  attr.fY = ((rcWind.bottom - rcWind.top) - rcClient.bottom) - attr.fX;
5052 
5053  attr.fRoot = (Window_t) GDK_ROOT_PARENT();
5054  attr.fColormap = (Colormap_t) gdk_window_get_colormap((GdkWindow *) id);
5055  attr.fBorderWidth = 0;
5056  attr.fVisual = gdk_window_get_visual((GdkWindow *) id);
5057  attr.fClass = kInputOutput;
5058  attr.fBackingStore = kNotUseful;
5059  attr.fSaveUnder = kFALSE;
5060  attr.fMapInstalled = kTRUE;
5061  attr.fOverrideRedirect = kFALSE; // boolean value for override-redirect
5062 
5063  if (!gdk_window_is_visible((GdkWindow *) id)) {
5064  attr.fMapState = kIsUnmapped;
5065  } else if (!gdk_window_is_viewable((GdkWindow *) id)) {
5066  attr.fMapState = kIsUnviewable;
5067  } else {
5068  attr.fMapState = kIsViewable;
5069  }
5070 
5071  UInt_t tmp_mask = (UInt_t)gdk_window_get_events((GdkWindow *) id);
5072  UInt_t evmask;
5073  MapEventMask(evmask, tmp_mask, kFALSE);
5074 
5075  attr.fYourEventMask = evmask;
5076 }
5077 
5078 ////////////////////////////////////////////////////////////////////////////////
5079 ///
5080 
5082 {
5083  return 0;
5084 }
5085 
5086 ////////////////////////////////////////////////////////////////////////////////
5087 /// Get maximum number of planes.
5088 
5090 {
5091  return gdk_visual_get_best_depth();
5092 }
5093 
5094 ////////////////////////////////////////////////////////////////////////////////
5095 /// Return atom handle for atom_name. If it does not exist
5096 /// create it if only_if_exist is false. Atoms are used to communicate
5097 /// between different programs (i.e. window manager) via the X server.
5098 
5099 Atom_t TGWin32::InternAtom(const char *atom_name, Bool_t only_if_exist)
5100 {
5101  GdkAtom a = gdk_atom_intern((const gchar *) atom_name, only_if_exist);
5102 
5103  if (a == None) return kNone;
5104  return (Atom_t) a;
5105 }
5106 
5107 ////////////////////////////////////////////////////////////////////////////////
5108 /// Return handle to the default root window created when calling
5109 /// XOpenDisplay().
5110 
5112 {
5113  return (Window_t) GDK_ROOT_PARENT();
5114 }
5115 
5116 ////////////////////////////////////////////////////////////////////////////////
5117 /// Return the parent of the window.
5118 
5120 {
5121  if (!id) return (Window_t)0;
5122 
5123  return (Window_t)gdk_window_get_parent((GdkWindow *) id);
5124 }
5125 
5126 ////////////////////////////////////////////////////////////////////////////////
5127 /// Load font and query font. If font is not found 0 is returned,
5128 /// otherwise an opaque pointer to the FontStruct_t.
5129 /// Free the loaded font using DeleteFont().
5130 
5131 FontStruct_t TGWin32::LoadQueryFont(const char *font_name)
5132 {
5133  char family[100], weight[32], slant[32], fontname[256];
5134  Int_t n1, pixel, numfields;
5135 
5136  numfields = sscanf(font_name, "%s -%d%n", family, &pixel, &n1);
5137  if (numfields == 2) {
5138  sprintf(weight,"medium");
5139  if (strstr(font_name, "bold"))
5140  sprintf(weight,"bold");
5141  sprintf(slant,"r");
5142  if (strstr(font_name, "italic"))
5143  sprintf(slant,"i");
5144  sprintf(fontname, "-*-%s-%s-%s-*-*-%d-*-*-*-*-*-iso8859-1",
5145  family, weight, slant, pixel);
5146  }
5147  else
5148  sprintf(fontname, "%s", font_name);
5149  return (FontStruct_t) gdk_font_load(fontname);
5150 }
5151 
5152 ////////////////////////////////////////////////////////////////////////////////
5153 /// Return handle to font described by font structure.
5154 
5156 {
5157  if (fs) {
5158  return (FontH_t)gdk_font_ref((GdkFont *) fs);
5159  }
5160  return 0;
5161 }
5162 
5163 ////////////////////////////////////////////////////////////////////////////////
5164 /// Explicitely delete font structure obtained with LoadQueryFont().
5165 
5167 {
5168  gdk_font_unref((GdkFont *) fs);
5169 }
5170 
5171 ////////////////////////////////////////////////////////////////////////////////
5172 /// Create a graphics context using the values set in gval (but only for
5173 /// those entries that are in the mask).
5174 
5176 {
5177  if (!id) return (GContext_t)0;
5178 
5179  GdkGCValues xgval;
5180  ULong_t xmask = 0;
5181 
5182  if (gval) MapGCValues(*gval, xmask, xgval, kTRUE);
5183 
5184  xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN; // GDK_INCLUDE_INFERIORS;
5185 
5186  GdkGC *gc = gdk_gc_new_with_values((GdkDrawable *) id,
5187  &xgval, (GdkGCValuesMask)xmask);
5188  return (GContext_t) gc;
5189 }
5190 
5191 ////////////////////////////////////////////////////////////////////////////////
5192 /// Change entries in an existing graphics context, gc, by values from gval.
5193 
5195 {
5196  GdkGCValues xgval;
5197  ULong_t xmask = 0;
5198  Mask_t mask = 0;
5199 
5200  if (gval) {
5201  mask = gval->fMask;
5202  MapGCValues(*gval, xmask, xgval, kTRUE);
5203  }
5204  if (mask & kGCForeground) {
5205  gdk_gc_set_foreground((GdkGC *) gc, &xgval.foreground);
5206  }
5207  if (mask & kGCBackground) {
5208  gdk_gc_set_background((GdkGC *) gc, &xgval.background);
5209  }
5210  if (mask & kGCFont) {
5211  gdk_gc_set_font((GdkGC *) gc, xgval.font);
5212  }
5213  if (mask & kGCFunction) {
5214  gdk_gc_set_function((GdkGC *) gc, xgval.function);
5215  }
5216  if (mask & kGCFillStyle) {
5217  gdk_gc_set_fill((GdkGC *) gc, xgval.fill);
5218  }
5219  if (mask & kGCTile) {
5220  gdk_gc_set_tile((GdkGC *) gc, xgval.tile);
5221  }
5222  if (mask & kGCStipple) {
5223  gdk_gc_set_stipple((GdkGC *) gc, xgval.stipple);
5224  }
5225  if ((mask & kGCTileStipXOrigin) || (mask & kGCTileStipYOrigin)) {
5226  gdk_gc_set_ts_origin((GdkGC *) gc, xgval.ts_x_origin,
5227  xgval.ts_y_origin);
5228  }
5229  if ((mask & kGCClipXOrigin) || (mask & kGCClipYOrigin)) {
5230  gdk_gc_set_clip_origin((GdkGC *) gc, xgval.clip_x_origin,
5231  xgval.clip_y_origin);
5232  }
5233  if (mask & kGCClipMask) {
5234  gdk_gc_set_clip_mask((GdkGC *) gc, xgval.clip_mask);
5235  }
5236  if (mask & kGCGraphicsExposures) {
5237  gdk_gc_set_exposures((GdkGC *) gc, xgval.graphics_exposures);
5238  }
5239  if (mask & kGCLineWidth) {
5240  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_WIDTH);
5241  }
5242  if (mask & kGCLineStyle) {
5243  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_STYLE);
5244  }
5245  if (mask & kGCCapStyle) {
5246  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_CAP_STYLE);
5247  }
5248  if (mask & kGCJoinStyle) {
5249  gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_JOIN_STYLE);
5250  }
5251  if (mask & kGCSubwindowMode) {
5252  gdk_gc_set_subwindow((GdkGC *) gc, xgval.subwindow_mode);
5253  }
5254 }
5255 
5256 ////////////////////////////////////////////////////////////////////////////////
5257 /// Copies graphics context from org to dest. Only the values specified
5258 /// in mask are copied. Both org and dest must exist.
5259 
5261 {
5262  GCValues_t gval;
5263  GdkGCValues xgval;
5264  ULong_t xmask;
5265 
5266  if (!mask) {
5267  // in this case copy all fields
5268  mask = (Mask_t) - 1;
5269  }
5270 
5271  gval.fMask = mask; // only set fMask used to convert to xmask
5272  MapGCValues(gval, xmask, xgval, kTRUE);
5273 
5274  gdk_gc_copy((GdkGC *) dest, (GdkGC *) org);
5275 }
5276 
5277 ////////////////////////////////////////////////////////////////////////////////
5278 /// Explicitely delete a graphics context.
5279 
5281 {
5282  gdk_gc_unref((GdkGC *) gc);
5283 }
5284 
5285 ////////////////////////////////////////////////////////////////////////////////
5286 /// Create cursor handle (just return cursor from cursor pool fCursors).
5287 
5289 {
5290  return (Cursor_t) fCursors[cursor];
5291 }
5292 
5293 ////////////////////////////////////////////////////////////////////////////////
5294 /// Creates a pixmap of the width and height you specified
5295 /// and returns a pixmap ID that identifies it.
5296 
5298 {
5299  GdkWindow *wid = (GdkWindow *)id;
5300  if (!id) wid = GDK_ROOT_PARENT();
5301 
5302  return (Pixmap_t) gdk_pixmap_new(wid, w, h, gdk_visual_get_best_depth());
5303 }
5304 
5305 ////////////////////////////////////////////////////////////////////////////////
5306 /// Create a pixmap from bitmap data. Ones will get foreground color and
5307 /// zeroes background color.
5308 
5310  UInt_t width, UInt_t height,
5311  ULong_t forecolor, ULong_t backcolor,
5312  Int_t depth)
5313 {
5314  GdkColor fore, back;
5315  fore.pixel = forecolor;
5316  fore.red = GetRValue(forecolor);
5317  fore.green = GetGValue(forecolor);
5318  fore.blue = GetBValue(forecolor);
5319 
5320  back.pixel = backcolor;
5321  back.red = GetRValue(backcolor);
5322  back.green = GetGValue(backcolor);
5323  back.blue = GetBValue(backcolor);
5324 
5325  GdkWindow *wid = (GdkWindow *)id;
5326  if (!id) wid = GDK_ROOT_PARENT();
5327 
5328  return (Pixmap_t) gdk_pixmap_create_from_data(wid, (char *) bitmap, width,
5329  height, depth, &fore, &back);
5330 }
5331 
5332 ////////////////////////////////////////////////////////////////////////////////
5333 /// Create a bitmap (i.e. pixmap with depth 1) from the bitmap data.
5334 
5336  UInt_t width, UInt_t height)
5337 {
5338  GdkWindow *wid = (GdkWindow *)id;
5339  if (!id) wid = GDK_ROOT_PARENT();
5340 
5341  Pixmap_t ret = (Pixmap_t) gdk_bitmap_create_from_data(wid,
5342  (char *)bitmap, width, height);
5343  return ret;
5344 }
5345 
5346 ////////////////////////////////////////////////////////////////////////////////
5347 /// Explicitely delete pixmap resource.
5348 
5350 {
5351  gdk_pixmap_unref((GdkPixmap *) pmap);
5352 }
5353 
5354 ////////////////////////////////////////////////////////////////////////////////
5355 /// Create a picture pixmap from data on file. The picture attributes
5356 /// are used for input and output. Returns kTRUE in case of success,
5357 /// kFALSE otherwise. If mask does not exist it is set to kNone.
5358 
5360  Pixmap_t & pict,
5361  Pixmap_t & pict_mask,
5363 {
5364  GdkBitmap *gdk_pixmap_mask;
5365  if (strstr(filename, ".xpm") || strstr(filename, ".XPM")) {
5366  GdkWindow *wid = (GdkWindow *)id;
5367  if (!id) wid = GDK_ROOT_PARENT();
5368 
5369  pict = (Pixmap_t) gdk_pixmap_create_from_xpm(wid, &gdk_pixmap_mask, 0,
5370  filename);
5371  pict_mask = (Pixmap_t) gdk_pixmap_mask;
5372  } else if (strstr(filename, ".gif") || strstr(filename, ".GIF")) {
5373  pict = ReadGIF(0, 0, filename, id);
5374  pict_mask = kNone;
5375  }
5376 
5377  gdk_drawable_get_size((GdkPixmap *) pict, (int *) &attr.fWidth,
5378  (int *) &attr.fHeight);
5379  if (pict) {
5380  return kTRUE;
5381  }
5382  if (pict_mask) {
5383  pict_mask = kNone;
5384  }
5385  return kFALSE;
5386 }
5387 
5388 ////////////////////////////////////////////////////////////////////////////////
5389 /// Create a pixture pixmap from data. The picture attributes
5390 /// are used for input and output. Returns kTRUE in case of success,
5391 /// kFALSE otherwise. If mask does not exist it is set to kNone.
5392 
5394  Pixmap_t & pict,
5395  Pixmap_t & pict_mask,
5397 {
5398  GdkBitmap *gdk_pixmap_mask;
5399  GdkWindow *wid = (GdkWindow *)id;
5400  if (!id) wid = GDK_ROOT_PARENT();
5401 
5402  pict = (Pixmap_t) gdk_pixmap_create_from_xpm_d(wid, &gdk_pixmap_mask, 0,
5403  data);
5404  pict_mask = (Pixmap_t) gdk_pixmap_mask;
5405 
5406  if (pict) {
5407  return kTRUE;
5408  }
5409  if (pict_mask) {
5410  pict_mask = kNone;
5411  }
5412  return kFALSE;
5413 }
5414 
5415 ////////////////////////////////////////////////////////////////////////////////
5416 /// Read picture data from file and store in ret_data. Returns kTRUE in
5417 /// case of success, kFALSE otherwise.
5418 
5419 Bool_t TGWin32::ReadPictureDataFromFile(const char *filename, char ***ret_data)
5420 {
5421  Bool_t ret = kFALSE;
5422  GdkPixmap *pxm = gdk_pixmap_create_from_xpm(NULL, NULL, NULL, filename);
5423  ret_data = 0;
5424 
5425  if (pxm==NULL) return kFALSE;
5426 
5427  HBITMAP hbm = (HBITMAP)GDK_DRAWABLE_XID(pxm);
5428  BITMAP bitmap;
5429 
5430  ret = ::GetObject(hbm, sizeof(HBITMAP), (LPVOID)&bitmap);
5431  ret_data = (char ***)&bitmap.bmBits;
5432  gdk_pixmap_unref(pxm);
5433  return ret;
5434 }
5435 
5436 ////////////////////////////////////////////////////////////////////////////////
5437 /// Delete picture data created by the function ReadPictureDataFromFile.
5438 
5440 {
5441  free(data);
5442 }
5443 
5444 ////////////////////////////////////////////////////////////////////////////////
5445 /// Specify a dash pattertn. Offset defines the phase of the pattern.
5446 /// Each element in the dash_list array specifies the length (in pixels)
5447 /// of a segment of the pattern. N defines the length of the list.
5448 
5449 void TGWin32::SetDashes(GContext_t gc, Int_t offset, const char *dash_list,
5450  Int_t n)
5451 {
5452  int i;
5453  gint8 dashes[32];
5454  for (i = 0; i < n; i++) {
5455  dashes[i] = (gint8) dash_list[i];
5456  }
5457  for (i = n; i < 32; i++) {
5458  dashes[i] = (gint8) 0;
5459  }
5460 
5461  gdk_gc_set_dashes((GdkGC *) gc, offset, dashes, n);
5462 }
5463 
5464 ////////////////////////////////////////////////////////////////////////////////
5465 /// Map a ColorStruct_t to a XColor structure.
5466 
5467 void TGWin32::MapColorStruct(ColorStruct_t * color, GdkColor & xcolor)
5468 {
5469  xcolor.pixel = color->fPixel;
5470  xcolor.red = color->fRed;
5471  xcolor.green = color->fGreen;
5472  xcolor.blue = color->fBlue;
5473 }
5474 
5475 ////////////////////////////////////////////////////////////////////////////////
5476 /// Parse string cname containing color name, like "green" or "#00FF00".
5477 /// It returns a filled in ColorStruct_t. Returns kFALSE in case parsing
5478 /// failed, kTRUE in case of success. On success, the ColorStruct_t
5479 /// fRed, fGreen and fBlue fields are all filled in and the mask is set
5480 /// for all three colors, but fPixel is not set.
5481 
5482 Bool_t TGWin32::ParseColor(Colormap_t cmap, const char *cname,
5483  ColorStruct_t & color)
5484 {
5485  GdkColor xc;
5486 
5487  if (gdk_color_parse((char *)cname, &xc)) {
5488  color.fPixel = xc.pixel = RGB(xc.red, xc.green, xc.blue);
5489  color.fRed = xc.red;
5490  color.fGreen = xc.green;
5491  color.fBlue = xc.blue;
5492  return kTRUE;
5493  }
5494  return kFALSE;
5495 }
5496 
5497 ////////////////////////////////////////////////////////////////////////////////
5498 /// Find and allocate a color cell according to the color values specified
5499 /// in the ColorStruct_t. If no cell could be allocated it returns kFALSE,
5500 /// otherwise kTRUE.
5501 
5503 {
5504  int status;
5505  GdkColor xc;
5506 
5507  xc.red = color.fRed;
5508  xc.green = color.fGreen;
5509  xc.blue = color.fBlue;
5510 
5511  status = gdk_colormap_alloc_color((GdkColormap *) cmap, &xc, FALSE, TRUE);
5512  color.fPixel = xc.pixel;
5513 
5514  return kTRUE; // status != 0 ? kTRUE : kFALSE;
5515 }
5516 
5517 ////////////////////////////////////////////////////////////////////////////////
5518 /// Fill in the primary color components for a specific pixel value.
5519 /// On input fPixel should be set on return the fRed, fGreen and
5520 /// fBlue components will be set.
5521 
5523 {
5524  GdkColor xc;
5525  xc.pixel = color.fPixel;
5526 
5527  GdkColorContext *cc = gdk_color_context_new(gdk_visual_get_system(), fColormap);
5528  gdk_color_context_query_color(cc, &xc);
5529  gdk_color_context_free(cc);
5530 
5531  color.fPixel = xc.pixel;
5532  color.fRed = xc.red;
5533  color.fGreen = xc.green;
5534  color.fBlue = xc.blue;
5535 }
5536 
5537 ////////////////////////////////////////////////////////////////////////////////
5538 /// Free color cell with specified pixel value.
5539 
5541 {
5542  // FIXME: to be implemented.
5543 }
5544 
5545 ////////////////////////////////////////////////////////////////////////////////
5546 /// Check if there is for window "id" an event of type "type". If there
5547 /// is fill in the event structure and return true. If no such event
5548 /// return false.
5549 
5551 {
5552  if (!id) return kFALSE;
5553 
5554  Event_t tev;
5555  GdkEvent xev;
5556 
5557  tev.fType = type;
5558  tev.fWindow = (Window_t) id;
5559  tev.fTime = 0;
5560  tev.fX = tev.fY = 0;
5561  tev.fXRoot = tev.fYRoot = 0;
5562  tev.fCode = 0;
5563  tev.fState = 0;
5564  tev.fWidth = tev.fHeight = 0;
5565  tev.fCount = 0;
5566  tev.fSendEvent = kFALSE;
5567  tev.fHandle = 0;
5568  tev.fFormat = 0;
5569  tev.fUser[0] = tev.fUser[1] = tev.fUser[2] = tev.fUser[3] = tev.fUser[4] = 0L;
5570 
5571  TGWin32MainThread::LockMSG();
5572  MapEvent(tev, xev, kTRUE);
5573  Bool_t r = gdk_check_typed_window_event((GdkWindow *) id, xev.type, &xev);
5574 
5575  if (r) MapEvent(ev, xev, kFALSE);
5576  TGWin32MainThread::UnlockMSG();
5577 
5578  return r ? kTRUE : kFALSE;
5579 }
5580 
5581 ////////////////////////////////////////////////////////////////////////////////
5582 /// Send event ev to window id.
5583 
5585 {
5586  if (!ev || !id) return;
5587 
5588  TGWin32MainThread::LockMSG();
5589  GdkEvent xev;
5590  MapEvent(*ev, xev, kTRUE);
5591  gdk_event_put(&xev);
5592  TGWin32MainThread::UnlockMSG();
5593 }
5594 
5595 ////////////////////////////////////////////////////////////////////////////////
5596 /// Returns number of pending events.
5597 
5599 {
5600  Int_t ret;
5601 
5602  TGWin32MainThread::LockMSG();
5603  ret = (Int_t)gdk_event_queue_find_first();
5604  TGWin32MainThread::UnlockMSG();
5605 
5606  return ret;
5607 }
5608 
5609 ////////////////////////////////////////////////////////////////////////////////
5610 /// Copies first pending event from event queue to Event_t structure
5611 /// and removes event from queue. Not all of the event fields are valid
5612 /// for each event type, except fType and fWindow.
5613 
5615 {
5616  TGWin32MainThread::LockMSG();
5617  GdkEvent *xev = gdk_event_unqueue();
5618 
5619  // fill in Event_t
5620  event.fType = kOtherEvent; // bb add
5621  if (xev == NULL) {
5622  TGWin32MainThread::UnlockMSG();
5623  return;
5624  }
5625  MapEvent(event, *xev, kFALSE);
5626  gdk_event_free (xev);
5627  TGWin32MainThread::UnlockMSG();
5628 }
5629 
5630 ////////////////////////////////////////////////////////////////////////////////
5631 /// Map modifier key state to or from X.
5632 
5633 void TGWin32::MapModifierState(UInt_t & state, UInt_t & xstate, Bool_t tox)
5634 {
5635  if (tox) {
5636  xstate = state;
5637  if (state & kAnyModifier) {
5638  xstate = GDK_MODIFIER_MASK;
5639  }
5640  } else {
5641  state = xstate;
5642  }
5643 }
5644 
5645 static void _set_event_time(GdkEvent &event, UInt_t time)
5646 {
5647  // set gdk event time
5648 
5649  switch (event.type) {
5650  case GDK_MOTION_NOTIFY:
5651  event.motion.time = time;
5652  case GDK_BUTTON_PRESS:
5653  case GDK_2BUTTON_PRESS:
5654  case GDK_3BUTTON_PRESS:
5655  case GDK_BUTTON_RELEASE:
5656  case GDK_SCROLL:
5657  event.button.time = time;
5658  case GDK_KEY_PRESS:
5659  case GDK_KEY_RELEASE:
5660  event.key.time = time;
5661  case GDK_ENTER_NOTIFY:
5662  case GDK_LEAVE_NOTIFY:
5663  event.crossing.time = time;
5664  case GDK_PROPERTY_NOTIFY:
5665  event.property.time = time;
5666  case GDK_SELECTION_CLEAR:
5667  case GDK_SELECTION_REQUEST:
5668  case GDK_SELECTION_NOTIFY:
5669  event.selection.time = time;
5670  case GDK_PROXIMITY_IN:
5671  case GDK_PROXIMITY_OUT:
5672  event.proximity.time = time;
5673  case GDK_DRAG_ENTER:
5674  case GDK_DRAG_LEAVE:
5675  case GDK_DRAG_MOTION:
5676  case GDK_DRAG_STATUS:
5677  case GDK_DROP_START:
5678  case GDK_DROP_FINISHED:
5679  event.dnd.time = time;
5680  default: /* use current time */
5681  break;
5682  }
5683 }
5684 
5685 ////////////////////////////////////////////////////////////////////////////////
5686 /// Map Event_t structure to gdk_event structure. If tox is false
5687 /// map the other way.
5688 
5689 void TGWin32::MapEvent(Event_t & ev, GdkEvent & xev, Bool_t tox)
5690 {
5691  if (tox) {
5692  // map from Event_t to gdk_event
5693  xev.type = GDK_NOTHING;
5694  if (ev.fType == kGKeyPress)
5695  xev.type = GDK_KEY_PRESS;
5696  if (ev.fType == kKeyRelease)
5697  xev.type = GDK_KEY_RELEASE;
5698  if (ev.fType == kButtonPress)
5699  xev.type = GDK_BUTTON_PRESS;
5700  if (ev.fType == kButtonRelease)
5701  xev.type = GDK_BUTTON_RELEASE;
5702  if (ev.fType == kMotionNotify)
5703  xev.type = GDK_MOTION_NOTIFY;
5704  if (ev.fType == kEnterNotify)
5705  xev.type = GDK_ENTER_NOTIFY;
5706  if (ev.fType == kLeaveNotify)
5707  xev.type = GDK_LEAVE_NOTIFY;
5708  if (ev.fType == kExpose)
5709  xev.type = GDK_EXPOSE;
5710  if (ev.fType == kConfigureNotify)
5711  xev.type = GDK_CONFIGURE;
5712  if (ev.fType == kMapNotify)
5713  xev.type = GDK_MAP;
5714  if (ev.fType == kUnmapNotify)
5715  xev.type = GDK_UNMAP;
5716  if (ev.fType == kDestroyNotify)
5717  xev.type = GDK_DESTROY;
5718  if (ev.fType == kClientMessage)
5719  xev.type = GDK_CLIENT_EVENT;
5720  if (ev.fType == kSelectionClear)
5721  xev.type = GDK_SELECTION_CLEAR;
5722  if (ev.fType == kSelectionRequest)
5723  xev.type = GDK_SELECTION_REQUEST;
5724  if (ev.fType == kSelectionNotify)
5725  xev.type = GDK_SELECTION_NOTIFY;
5726 
5727  xev.any.type = xev.type;
5728  xev.any.send_event = ev.fSendEvent;
5729  if (ev.fType == kDestroyNotify) {
5730  xev.any.window = (GdkWindow *) ev.fWindow;
5731  }
5732  if (ev.fType == kFocusIn) {
5733  xev.type = GDK_FOCUS_CHANGE;
5734  xev.focus_change.type = xev.type;
5735  xev.focus_change.window = (GdkWindow *) ev.fWindow;
5736  xev.focus_change.in = TRUE;
5737  }
5738  if (ev.fType == kFocusOut) {
5739  xev.type = GDK_FOCUS_CHANGE;
5740  xev.focus_change.type = xev.type;
5741  xev.focus_change.window = (GdkWindow *) ev.fWindow;
5742  xev.focus_change.in = FALSE;
5743  }
5744  if (ev.fType == kGKeyPress || ev.fType == kKeyRelease) {
5745  xev.key.window = (GdkWindow *) ev.fWindow;
5746  xev.key.type = xev.type;
5747  MapModifierState(ev.fState, xev.key.state, kTRUE); // key mask
5748  xev.key.keyval = ev.fCode; // key code
5749  }
5750  if (ev.fType == kButtonPress || ev.fType == kButtonRelease) {
5751  xev.button.window = (GdkWindow *) ev.fWindow;
5752  xev.button.type = xev.type;
5753  xev.button.x = ev.fX;
5754  xev.button.y = ev.fY;
5755  xev.button.x_root = ev.fXRoot;
5756  xev.button.y_root = ev.fYRoot;
5757  MapModifierState(ev.fState, xev.button.state, kTRUE); // button mask
5758  xev.button.button = ev.fCode; // button code
5759  }
5760  if (ev.fType == kSelectionNotify) {
5761  xev.selection.window = (GdkWindow *) ev.fUser[0];
5762  xev.selection.requestor = (guint32) ev.fUser[0];
5763  xev.selection.selection = (GdkAtom) ev.fUser[1];
5764  xev.selection.target = (GdkAtom) ev.fUser[2];
5765  xev.selection.property = (GdkAtom) ev.fUser[3];
5766  xev.selection.type = xev.type;
5767  }
5768  if (ev.fType == kClientMessage) {
5769  if ((ev.fFormat == 32) && (ev.fHandle == gWM_DELETE_WINDOW)) {
5770  xev.type = GDK_DELETE;
5771  xev.any.type = xev.type;
5772  xev.any.window = (GdkWindow *) ev.fWindow;
5773  } else {
5774  xev.client.window = (GdkWindow *) ev.fWindow;
5775  xev.client.type = xev.type;
5776  xev.client.message_type = (GdkAtom) ev.fHandle;
5777  xev.client.data_format = ev.fFormat;
5778  xev.client.data.l[0] = ev.fUser[0];
5779  if (sizeof(ev.fUser[0]) > 4) {
5780  SplitLong(ev.fUser[1], xev.client.data.l[1],
5781  xev.client.data.l[3]);
5782  SplitLong(ev.fUser[2], xev.client.data.l[2],
5783  xev.client.data.l[4]);
5784  } else {
5785  xev.client.data.l[1] = ev.fUser[1];
5786  xev.client.data.l[2] = ev.fUser[2];
5787  xev.client.data.l[3] = ev.fUser[3];
5788  xev.client.data.l[4] = ev.fUser[4];
5789  }
5790  }
5791  }
5792  if (ev.fType == kMotionNotify) {
5793  xev.motion.window = (GdkWindow *) ev.fWindow;
5794  xev.motion.type = xev.type;
5795  xev.motion.x = ev.fX;
5796  xev.motion.y = ev.fY;
5797  xev.motion.x_root = ev.fXRoot;
5798  xev.motion.y_root = ev.fYRoot;
5799  }
5800  if ((ev.fType == kEnterNotify) || (ev.fType == kLeaveNotify)) {
5801  xev.crossing.window = (GdkWindow *) ev.fWindow;
5802  xev.crossing.type = xev.type;
5803  xev.crossing.x = ev.fX;
5804  xev.crossing.y = ev.fY;
5805  xev.crossing.x_root = ev.fXRoot;
5806  xev.crossing.y_root = ev.fYRoot;
5807  xev.crossing.mode = (GdkCrossingMode) ev.fCode; // NotifyNormal, NotifyGrab, NotifyUngrab
5808  MapModifierState(ev.fState, xev.crossing.state, kTRUE); // key or button mask
5809  }
5810  if (ev.fType == kExpose) {
5811  xev.expose.window = (GdkWindow *) ev.fWindow;
5812  xev.expose.type = xev.type;
5813  xev.expose.area.x = ev.fX;
5814  xev.expose.area.y = ev.fY;
5815  xev.expose.area.width = ev.fWidth; // width and
5816  xev.expose.area.height = ev.fHeight; // height of exposed area
5817  xev.expose.count = ev.fCount; // number of expose events still to come
5818  }
5819  if (ev.fType == kConfigureNotify) {
5820  xev.configure.window = (GdkWindow *) ev.fWindow;
5821  xev.configure.type = xev.type;
5822  xev.configure.x = ev.fX;
5823  xev.configure.y = ev.fY;
5824  xev.configure.width = ev.fWidth;
5825  xev.configure.height = ev.fHeight;
5826  }
5827  if (ev.fType == kSelectionClear) {
5828  xev.selection.window = (GdkWindow *) ev.fWindow;
5829  xev.selection.type = xev.type;
5830  xev.selection.selection = ev.fUser[0];
5831  }
5832  if (ev.fType == kSelectionRequest) {
5833  xev.selection.window = (GdkWindow *) ev.fUser[0];
5834  xev.selection.type = xev.type;
5835  xev.selection.selection = ev.fUser[1];
5836  xev.selection.target = ev.fUser[2];
5837  xev.selection.property = ev.fUser[3];
5838  }
5839  if ((ev.fType == kMapNotify) || (ev.fType == kUnmapNotify)) {
5840  xev.any.window = (GdkWindow *) ev.fWindow;
5841  }
5842  if (xev.type != GDK_CLIENT_EVENT)
5843  _set_event_time(xev, ev.fTime);
5844  } else {
5845  // map from gdk_event to Event_t
5846  ev.fType = kOtherEvent;
5847  if (xev.type == GDK_KEY_PRESS)
5848  ev.fType = kGKeyPress;
5849  if (xev.type == GDK_KEY_RELEASE)
5850  ev.fType = kKeyRelease;
5851  if (xev.type == GDK_BUTTON_PRESS)
5852  ev.fType = kButtonPress;
5853  if (xev.type == GDK_BUTTON_RELEASE)
5854  ev.fType = kButtonRelease;
5855  if (xev.type == GDK_MOTION_NOTIFY)
5856  ev.fType = kMotionNotify;
5857  if (xev.type == GDK_ENTER_NOTIFY)
5858  ev.fType = kEnterNotify;
5859  if (xev.type == GDK_LEAVE_NOTIFY)
5860  ev.fType = kLeaveNotify;
5861  if (xev.type == GDK_EXPOSE)
5862  ev.fType = kExpose;
5863  if (xev.type == GDK_CONFIGURE)
5864  ev.fType = kConfigureNotify;
5865  if (xev.type == GDK_MAP)
5866  ev.fType = kMapNotify;
5867  if (xev.type == GDK_UNMAP)
5868  ev.fType = kUnmapNotify;
5869  if (xev.type == GDK_DESTROY)
5870  ev.fType = kDestroyNotify;
5871  if (xev.type == GDK_SELECTION_CLEAR)
5872  ev.fType = kSelectionClear;
5873  if (xev.type == GDK_SELECTION_REQUEST)
5874  ev.fType = kSelectionRequest;
5875  if (xev.type == GDK_SELECTION_NOTIFY)
5876  ev.fType = kSelectionNotify;
5877 
5878  ev.fSendEvent = kFALSE; //xev.any.send_event ? kTRUE : kFALSE;
5879  ev.fTime = gdk_event_get_time((GdkEvent *)&xev);
5880  ev.fWindow = (Window_t) xev.any.window;
5881 
5882  if ((xev.type == GDK_MAP) || (xev.type == GDK_UNMAP)) {
5883  ev.fWindow = (Window_t) xev.any.window;
5884  }
5885  if (xev.type == GDK_DELETE) {
5886  ev.fWindow = (Window_t) xev.any.window;
5887  ev.fType = kClientMessage;
5888  ev.fFormat = 32;
5890  ev.fUser[0] = (Long_t) gWM_DELETE_WINDOW;
5891  if (sizeof(ev.fUser[0]) > 4) {
5892  AsmLong(xev.client.data.l[1], xev.client.data.l[3],
5893  ev.fUser[1]);
5894  AsmLong(xev.client.data.l[2], xev.client.data.l[4],
5895  ev.fUser[2]);
5896  } else {
5897  ev.fUser[1] = 0; //xev.client.data.l[1];
5898  ev.fUser[2] = 0; //xev.client.data.l[2];
5899  ev.fUser[3] = 0; //xev.client.data.l[3];
5900  ev.fUser[4] = 0; //xev.client.data.l[4];
5901  }
5902  }
5903  if (xev.type == GDK_DESTROY) {
5904  ev.fType = kDestroyNotify;
5905  ev.fHandle = (Window_t) xev.any.window; // window to be destroyed
5906  ev.fWindow = (Window_t) xev.any.window;
5907  }
5908  if (xev.type == GDK_FOCUS_CHANGE) {
5909  ev.fWindow = (Window_t) xev.focus_change.window;
5910  ev.fCode = kNotifyNormal;
5911  ev.fState = 0;
5912  if (xev.focus_change.in == TRUE) {
5913  ev.fType = kFocusIn;
5914  } else {
5915  ev.fType = kFocusOut;
5916  }
5917  }
5918  if (ev.fType == kGKeyPress || ev.fType == kKeyRelease) {
5919  ev.fWindow = (Window_t) xev.key.window;
5920  MapModifierState(ev.fState, xev.key.state, kFALSE); // key mask
5921  ev.fCode = xev.key.keyval; // key code
5922  ev.fUser[1] = xev.key.length;
5923  if (xev.key.length > 0) ev.fUser[2] = xev.key.string[0];
5924  if (xev.key.length > 1) ev.fUser[3] = xev.key.string[1];
5925  if (xev.key.length > 2) ev.fUser[4] = xev.key.string[2];
5926  HWND tmpwin = (HWND) GetWindow((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.key.window), GW_CHILD);
5927  if (tmpwin) {
5928  ev.fUser[0] = (ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
5929  } else {
5930  ev.fUser[0] = (ULong_t) xev.key.window;
5931  }
5932  }
5933  if (ev.fType == kButtonPress || ev.fType == kButtonRelease) {
5934  ev.fWindow = (Window_t) xev.button.window;
5935  ev.fX = xev.button.x;
5936  ev.fY = xev.button.y;
5937  ev.fXRoot = xev.button.x_root;
5938  ev.fYRoot = xev.button.y_root;
5939  MapModifierState(ev.fState, xev.button.state, kFALSE); // button mask
5940  ev.fCode = xev.button.button; // button code
5941  POINT tpoint;
5942  tpoint.x = xev.button.x;
5943  tpoint.y = xev.button.y;
5944  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.button.window), tpoint);
5945  if (tmpwin) {
5946  ev.fUser[0] = (ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
5947  } else {
5948  ev.fUser[0] = (ULong_t) 0;
5949  }
5950  }
5951  if (ev.fType == kMotionNotify) {
5952  ev.fWindow = (Window_t) xev.motion.window;
5953  ev.fX = xev.motion.x;
5954  ev.fY = xev.motion.y;
5955  ev.fXRoot = xev.motion.x_root;
5956  ev.fYRoot = xev.motion.y_root;
5957  MapModifierState(ev.fState, xev.motion.state, kFALSE); // key or button mask
5958 
5959  POINT tpoint;
5960  tpoint.x = xev.button.x;
5961  tpoint.y = xev.button.y;
5962  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.motion.window), tpoint);
5963  if (tmpwin) {
5964  ev.fUser[0] = (ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
5965  } else {
5966  ev.fUser[0] = (ULong_t) xev.motion.window;
5967  }
5968  }
5969  if (ev.fType == kEnterNotify || ev.fType == kLeaveNotify) {
5970  ev.fWindow = (Window_t) xev.crossing.window;
5971  ev.fX = xev.crossing.x;
5972  ev.fY = xev.crossing.y;
5973  ev.fXRoot = xev.crossing.x_root;
5974  ev.fYRoot = xev.crossing.y_root;
5975  ev.fCode = xev.crossing.mode; // NotifyNormal, NotifyGrab, NotifyUngrab
5976  MapModifierState(ev.fState, xev.crossing.state, kFALSE); // key or button mask
5977  }
5978  if (ev.fType == kExpose) {
5979  ev.fWindow = (Window_t) xev.expose.window;
5980  ev.fX = xev.expose.area.x;
5981  ev.fY = xev.expose.area.y;
5982  ev.fWidth = xev.expose.area.width; // width and
5983  ev.fHeight = xev.expose.area.height; // height of exposed area
5984  ev.fCount = xev.expose.count; // number of expose events still to come
5985  }
5986  if (ev.fType == kConfigureNotify) {
5987  ev.fWindow = (Window_t) xev.configure.window;
5988  ev.fX = xev.configure.x;
5989  ev.fY = xev.configure.y;
5990  ev.fWidth = xev.configure.width;
5991  ev.fHeight = xev.configure.height;
5992  }
5993  if (xev.type == GDK_CLIENT_EVENT) {
5994  ev.fWindow = (Window_t) xev.client.window;
5995  ev.fType = kClientMessage;
5996  ev.fHandle = xev.client.message_type;
5997  ev.fFormat = xev.client.data_format;
5998  ev.fUser[0] = xev.client.data.l[0];
5999  if (sizeof(ev.fUser[0]) > 4) {
6000  AsmLong(xev.client.data.l[1], xev.client.data.l[3],
6001  ev.fUser[1]);
6002  AsmLong(xev.client.data.l[2], xev.client.data.l[4],
6003  ev.fUser[2]);
6004  } else {
6005  ev.fUser[1] = xev.client.data.l[1];
6006  ev.fUser[2] = xev.client.data.l[2];
6007  ev.fUser[3] = xev.client.data.l[3];
6008  ev.fUser[4] = xev.client.data.l[4];
6009  }
6010  }
6011  if (ev.fType == kSelectionClear) {
6012  ev.fWindow = (Window_t) xev.selection.window;
6013  ev.fUser[0] = xev.selection.selection;
6014  }
6015  if (ev.fType == kSelectionRequest) {
6016  ev.fWindow = (Window_t) xev.selection.window;
6017  ev.fUser[0] = (ULong_t) xev.selection.window;
6018  ev.fUser[1] = xev.selection.selection;
6019  ev.fUser[2] = xev.selection.target;
6020  ev.fUser[3] = xev.selection.property;
6021  }
6022  if (ev.fType == kSelectionNotify) {
6023  ev.fWindow = (Window_t) xev.selection.window;
6024  ev.fUser[0] = (ULong_t) xev.selection.window;
6025  ev.fUser[1] = xev.selection.selection;
6026  ev.fUser[2] = xev.selection.target;
6027  ev.fUser[3] = xev.selection.property;
6028  }
6029  if (xev.type == GDK_SCROLL) {
6030  ev.fType = kButtonRelease;
6031  if (xev.scroll.direction == GDK_SCROLL_UP) {
6032  ev.fCode = kButton4;
6033  } else if (xev.scroll.direction == GDK_SCROLL_DOWN) {
6034  ev.fCode = kButton5;
6035  }
6036  ev.fWindow = (Window_t) xev.scroll.window;
6037  ev.fX = xev.scroll.x;
6038  ev.fY = xev.scroll.y;
6039  ev.fXRoot = xev.scroll.x_root;
6040  ev.fYRoot = xev.scroll.y_root;
6041  POINT tpoint;
6042  tpoint.x = xev.scroll.x;
6043  tpoint.y = xev.scroll.y;
6044  HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.scroll.window), tpoint);
6045  if (tmpwin) {
6046  ev.fUser[0] = (ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
6047  } else {
6048  ev.fUser[0] = (ULong_t) 0;
6049  }
6050  }
6051  }
6052 }
6053 
6054 ////////////////////////////////////////////////////////////////////////////////
6055 ///
6056 
6057 void TGWin32::Bell(Int_t percent)
6058 {
6059  gSystem->Beep();
6060 }
6061 
6062 ////////////////////////////////////////////////////////////////////////////////
6063 /// Copy a drawable (i.e. pixmap) to another drawable (pixmap, window).
6064 /// The graphics context gc will be used and the source will be copied
6065 /// from src_x,src_y,src_x+width,src_y+height to dest_x,dest_y.
6066 
6068  Int_t src_x, Int_t src_y, UInt_t width,
6069  UInt_t height, Int_t dest_x, Int_t dest_y)
6070 {
6071  if (!src || !dest) return;
6072 
6073  gdk_window_copy_area((GdkDrawable *) dest, (GdkGC *) gc, dest_x, dest_y,
6074  (GdkDrawable *) src, src_x, src_y, width, height);
6075 }
6076 
6077 ////////////////////////////////////////////////////////////////////////////////
6078 /// Change window attributes.
6079 
6081 {
6082  if (!id) return;
6083 
6084  GdkColor color;
6085  UInt_t xevmask;
6086  Mask_t evmask;
6087 
6088  if (attr && (attr->fMask & kWAEventMask)) {
6089  evmask = (Mask_t) attr->fEventMask;
6090  MapEventMask(evmask, xevmask);
6091  gdk_window_set_events((GdkWindow *) id, (GdkEventMask) xevmask);
6092  }
6093  if (attr && (attr->fMask & kWABackPixel)) {
6094  color.pixel = attr->fBackgroundPixel;
6095  color.red = GetRValue(attr->fBackgroundPixel);
6096  color.green = GetGValue(attr->fBackgroundPixel);
6097  color.blue = GetBValue(attr->fBackgroundPixel);
6098  gdk_window_set_background((GdkWindow *) id, &color);
6099  }
6100 // if (attr && (attr->fMask & kWAOverrideRedirect))
6101 // gdk_window_set_override_redirect ((GdkWindow *) id, attr->fOverrideRedirect);
6102  if (attr && (attr->fMask & kWABackPixmap)) {
6103  gdk_window_set_back_pixmap((GdkWindow *) id,
6104  (GdkPixmap *) attr->fBackgroundPixmap, 0);
6105  }
6106  if (attr && (attr->fMask & kWACursor)) {
6107  gdk_window_set_cursor((GdkWindow *) id, (GdkCursor *) attr->fCursor);
6108  }
6109  if (attr && (attr->fMask & kWAColormap)) {
6110  gdk_window_set_colormap((GdkWindow *) id,(GdkColormap *) attr->fColormap);
6111  }
6112  if (attr && (attr->fMask & kWABorderWidth)) {
6113  if (attr->fBorderWidth > 0) {
6114  gdk_window_set_decorations((GdkWindow *) id,
6115  (GdkWMDecoration) GDK_DECOR_BORDER);
6116  }
6117  }
6118 }
6119 
6120 ////////////////////////////////////////////////////////////////////////////////
6121 /// This function alters the property for the specified window and
6122 /// causes the X server to generate a PropertyNotify event on that
6123 /// window.
6124 
6126  UChar_t * data, Int_t len)
6127 {
6128  if (!id) return;
6129 
6130  gdk_property_change((GdkWindow *) id, (GdkAtom) property,
6131  (GdkAtom) type, 8, GDK_PROP_MODE_REPLACE, data,len);
6132 }
6133 
6134 ////////////////////////////////////////////////////////////////////////////////
6135 /// Draw a line.
6136 
6138  Int_t x2, Int_t y2)
6139 {
6140  if (!id) return;
6141 
6142  gdk_draw_line((GdkDrawable *) id, (GdkGC *) gc, x1, y1, x2, y2);
6143 }
6144 
6145 ////////////////////////////////////////////////////////////////////////////////
6146 /// Clear a window area to the bakcground color.
6147 
6149 {
6150  if (!id) return;
6151 
6152  gdk_window_clear_area((GdkWindow *) id, x, y, w, h);
6153 }
6154 
6155 ////////////////////////////////////////////////////////////////////////////////
6156 /// Tell WM to send message when window is closed via WM.
6157 
6159 {
6160  if (!id) return;
6161 
6162  Atom prop;
6163  prop = (Atom_t) gdk_atom_intern("WM_DELETE_WINDOW", FALSE);
6164 
6165  W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *) id),
6166  prop, XA_ATOM, 32, GDK_PROP_MODE_REPLACE,
6167  (unsigned char *) &gWM_DELETE_WINDOW, 1);
6168 }
6169 
6170 ////////////////////////////////////////////////////////////////////////////////
6171 /// Turn key auto repeat on or off.
6172 
6174 {
6175  if (on) {
6176  gdk_key_repeat_restore();
6177  } else {
6178  gdk_key_repeat_disable();
6179  }
6180 }
6181 
6182 ////////////////////////////////////////////////////////////////////////////////
6183 /// Establish passive grab on a certain key. That is, when a certain key
6184 /// keycode is hit while certain modifier's (Shift, Control, Meta, Alt)
6185 /// are active then the keyboard will be grabed for window id.
6186 /// When grab is false, ungrab the keyboard for this key and modifier.
6187 
6188 void TGWin32::GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab)
6189 {
6190  UInt_t xmod;
6191 
6192  MapModifierState(modifier, xmod);
6193 
6194  if (grab) {
6195  gdk_key_grab(keycode, (GdkEventMask)xmod, (GdkWindow *)id);
6196  } else {
6197  gdk_key_ungrab(keycode, (GdkEventMask)xmod, (GdkWindow *)id);
6198  }
6199 }
6200 
6201 ////////////////////////////////////////////////////////////////////////////////
6202 /// Establish passive grab on a certain mouse button. That is, when a
6203 /// certain mouse button is hit while certain modifier's (Shift, Control,
6204 /// Meta, Alt) are active then the mouse will be grabed for window id.
6205 /// When grab is false, ungrab the mouse button for this button and modifier.
6206 
6208  UInt_t evmask, Window_t confine, Cursor_t cursor,
6209  Bool_t grab)
6210 {
6211  UInt_t xevmask;
6212  UInt_t xmod;
6213 
6214  if (!id) return;
6215 
6216  MapModifierState(modifier, xmod);
6217 
6218  if (grab) {
6219  MapEventMask(evmask, xevmask);
6220  gdk_button_grab(button, xmod, ( GdkWindow *)id, 1, (GdkEventMask)xevmask,
6221  (GdkWindow*)confine, (GdkCursor*)cursor);
6222  } else {
6223  gdk_button_ungrab(button, xmod, ( GdkWindow *)id);
6224  }
6225 }
6226 
6227 ////////////////////////////////////////////////////////////////////////////////
6228 /// Establish an active pointer grab. While an active pointer grab is in
6229 /// effect, further pointer events are only reported to the grabbing
6230 /// client window.
6231 
6233  Cursor_t cursor, Bool_t grab, Bool_t owner_events)
6234 {
6235  UInt_t xevmask;
6236  MapEventMask(evmask, xevmask);
6237 
6238  if (grab) {
6239  if(!::IsWindowVisible((HWND)GDK_DRAWABLE_XID(id))) return;
6240  gdk_pointer_grab((GdkWindow *) id, owner_events, (GdkEventMask) xevmask,
6241  (GdkWindow *) confine, (GdkCursor *) cursor,
6242  GDK_CURRENT_TIME);
6243  } else {
6244  gdk_pointer_ungrab(GDK_CURRENT_TIME);
6245  ::SetCursor((HCURSOR)GDK_CURSOR_XID(fCursors[kPointer]));
6246  }
6247 }
6248 
6249 ////////////////////////////////////////////////////////////////////////////////
6250 /// Set window name.
6251 
6253 {
6254  if (!id) return;
6255 
6256  gdk_window_set_title((GdkWindow *) id, name);
6257 }
6258 
6259 ////////////////////////////////////////////////////////////////////////////////
6260 /// Set window icon name.
6261 
6263 {
6264  if (!id) return;
6265 
6266  gdk_window_set_icon_name((GdkWindow *) id, name);
6267 }
6268 
6269 ////////////////////////////////////////////////////////////////////////////////
6270 /// Set pixmap the WM can use when the window is iconized.
6271 
6273 {
6274  if (!id) return;
6275 
6276  gdk_window_set_icon((GdkWindow *)id, NULL, (GdkPixmap *)pic, (GdkPixmap *)pic);
6277 }
6278 
6279 #define safestrlen(s) ((s) ? strlen(s) : 0)
6280 
6281 ////////////////////////////////////////////////////////////////////////////////
6282 /// Set the windows class and resource name.
6283 
6284 void TGWin32::SetClassHints(Window_t id, char *className, char *resourceName)
6285 {
6286  if (!id) return;
6287 
6288  char *class_string;
6289  char *s;
6290  int len_nm, len_cl;
6291  GdkAtom prop;
6292 
6293  prop = gdk_atom_intern("WM_CLASS", kFALSE);
6294 
6295  len_nm = safestrlen(resourceName);
6296  len_cl = safestrlen(className);
6297 
6298  if ((class_string = s =
6299  (char *) malloc((unsigned) (len_nm + len_cl + 2)))) {
6300  if (len_nm) {
6301  strcpy(s, resourceName);
6302  s += len_nm + 1;
6303  } else
6304  *s++ = '\0';
6305  if (len_cl) {
6306  strcpy(s, className);
6307  } else {
6308  *s = '\0';
6309  }
6310 
6311  W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *) id),
6312  (Atom) XA_WM_CLASS, (Atom) XA_WM_CLASS, 8,
6313  GDK_PROP_MODE_REPLACE,
6314  (unsigned char *) class_string,
6315  len_nm + len_cl + 2);
6316  free(class_string);
6317  }
6318 }
6319 
6320 ////////////////////////////////////////////////////////////////////////////////
6321 /// Set decoration style for MWM-compatible wm (mwm, ncdwm, fvwm?).
6322 
6324  UInt_t input)
6325 {
6326  if (!id) return;
6327 
6328  gdk_window_set_decorations((GdkDrawable *) id, (GdkWMDecoration) value);
6329  gdk_window_set_functions((GdkDrawable *) id, (GdkWMFunction) funcs);
6330 }
6331 
6332 ////////////////////////////////////////////////////////////////////////////////
6333 ///
6334 
6336 {
6337  if (!id) return;
6338 
6339  gdk_window_move((GdkDrawable *) id, x, y);
6340 }
6341 
6342 ////////////////////////////////////////////////////////////////////////////////
6343 ///
6344 
6346 {
6347  if (!id) return;
6348 
6349  gdk_window_resize((GdkWindow *) id, w, h);
6350 }
6351 
6352 ////////////////////////////////////////////////////////////////////////////////
6353 /// Give the window manager minimum and maximum size hints. Also
6354 /// specify via winc and hinc the resize increments.
6355 
6357  UInt_t wmax, UInt_t hmax,
6358  UInt_t winc, UInt_t hinc)
6359 {
6360  if (!id) return;
6361 
6362  GdkGeometry hints;
6363  GdkWindowHints flags;
6364 
6365  flags = (GdkWindowHints) (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE |
6366  GDK_HINT_RESIZE_INC);
6367  hints.min_width = (Int_t) wmin;
6368  hints.max_width = (Int_t) wmax;
6369  hints.min_height = (Int_t) hmin;
6370  hints.max_height = (Int_t) hmax;
6371  hints.width_inc = (Int_t) winc;
6372  hints.height_inc = (Int_t) hinc;
6373 
6374  gdk_window_set_geometry_hints((GdkWindow *) id, (GdkGeometry *) &hints,
6375  (GdkWindowHints) flags);
6376 }
6377 
6378 ////////////////////////////////////////////////////////////////////////////////
6379 /// Set the initial state of the window. Either kNormalState or kIconicState.
6380 
6382 {
6383  if (!id) return;
6384 
6385 #if 0
6386  XWMHints hints;
6387  Int_t xstate = NormalState;
6388 
6389  if (state == kNormalState)
6390  xstate = NormalState;
6391  if (state == kIconicState)
6392  xstate = IconicState;
6393 
6394  hints.flags = StateHint;
6395  hints.initial_state = xstate;
6396 
6397  XSetWMHints((GdkWindow *) id, &hints);
6398 #endif
6399 }
6400 
6401 ////////////////////////////////////////////////////////////////////////////////
6402 /// Tell window manager that window is a transient window of gdk_parent_root.
6403 
6405 {
6406  if (!id) return;
6407 
6408  gdk_window_set_transient_for((GdkWindow *) id, (GdkWindow *) main_id);
6409 }
6410 
6411 ////////////////////////////////////////////////////////////////////////////////
6412 /// Draw a string using a specific graphics context in position (x,y).
6413 
6415  const char *s, Int_t len)
6416 {
6417  if (!id) return;
6418 
6419  GdkGCValues values;
6420  gdk_gc_get_values((GdkGC *) gc, &values);
6421  gdk_win32_draw_text((GdkDrawable *) id, (GdkFont *) values.font,
6422  (GdkGC *) gc, x, y, (const gchar *)s, len);
6423 }
6424 
6425 ////////////////////////////////////////////////////////////////////////////////
6426 /// Return length of string in pixels. Size depends on font.
6427 
6428 Int_t TGWin32::TextWidth(FontStruct_t font, const char *s, Int_t len)
6429 {
6430  return gdk_text_width((GdkFont *)font, s, len);
6431 }
6432 
6433 ////////////////////////////////////////////////////////////////////////////////
6434 /// Return some font properties.
6435 
6437  Int_t & max_descent)
6438 {
6439  GdkFont *f = (GdkFont *) font;
6440  max_ascent = f->ascent;
6441  max_descent = f->descent;
6442 }
6443 
6444 ////////////////////////////////////////////////////////////////////////////////
6445 /// Get current values from graphics context gc. Which values of the
6446 /// context to get is encoded in the GCValues::fMask member.
6447 
6449 {
6450  GdkGCValues xgval;
6451  ULong_t xmask;
6452 
6453  MapGCValues(gval, xmask, xgval, kTRUE);
6454  gdk_gc_get_values((GdkGC *) gc, &xgval);
6455  MapGCValues(gval, xmask, xgval, kFALSE);
6456 }
6457 
6458 ////////////////////////////////////////////////////////////////////////////////
6459 /// Retrieve associated font structure once we have the font handle.
6460 /// Free returned FontStruct_t using FreeFontStruct().
6461 
6463 {
6464  return (FontStruct_t) gdk_font_ref((GdkFont *) fh);
6465 }
6466 
6467 ////////////////////////////////////////////////////////////////////////////////
6468 /// Free font structure returned by GetFontStruct().
6469 
6471 {
6472  gdk_font_unref((GdkFont *) fs);
6473 }
6474 
6475 ////////////////////////////////////////////////////////////////////////////////
6476 /// Clear window.
6477 
6479 {
6480  if (!id) return;
6481 
6482  gdk_window_clear((GdkDrawable *) id);
6483 }
6484 
6485 ////////////////////////////////////////////////////////////////////////////////
6486 /// Convert a keysym to the appropriate keycode. For example keysym is
6487 /// a letter and keycode is the matching keyboard key (which is dependend
6488 /// on the current keyboard mapping).
6489 
6491 {
6492  UInt_t xkeysym;
6493  MapKeySym(keysym, xkeysym);
6494  return xkeysym;
6495 }
6496 
6497 ////////////////////////////////////////////////////////////////////////////////
6498 /// Draw a filled rectangle. Filling is done according to the gc.
6499 
6501  UInt_t w, UInt_t h)
6502 {
6503  if (!id) return;
6504 
6505  gdk_win32_draw_rectangle((GdkDrawable *) id, (GdkGC *) gc, kTRUE, x, y, w, h);
6506 }
6507 
6508 ////////////////////////////////////////////////////////////////////////////////
6509 /// Draw a rectangle outline.
6510 
6512  UInt_t w, UInt_t h)
6513 {
6514  if (!id) return;
6515 
6516  gdk_win32_draw_rectangle((GdkDrawable *) id, (GdkGC *) gc, kFALSE, x, y, w, h);
6517 }
6518 
6519 ////////////////////////////////////////////////////////////////////////////////
6520 /// Draws multiple line segments. Each line is specified by a pair of points.
6521 
6523  Int_t nseg)
6524 {
6525  if (!id) return;
6526 
6527  gdk_win32_draw_segments((GdkDrawable *) id, (GdkGC *) gc, (GdkSegment *)seg, nseg);
6528 }
6529 
6530 ////////////////////////////////////////////////////////////////////////////////
6531 /// Defines which input events the window is interested in. By default
6532 /// events are propageted up the window stack. This mask can also be
6533 /// set at window creation time via the SetWindowAttributes_t::fEventMask
6534 /// attribute.
6535 
6537 {
6538  if (!id) return;
6539 
6540  UInt_t xevmask;
6541  MapEventMask(evmask, xevmask, kTRUE);
6542  gdk_window_set_events((GdkWindow *) id, (GdkEventMask)xevmask);
6543 }
6544 
6545 ////////////////////////////////////////////////////////////////////////////////
6546 /// Returns the window id of the window having the input focus.
6547 
6549 {
6550  HWND hwnd = ::GetFocus();
6551  return (Window_t) gdk_xid_table_lookup(hwnd);
6552 }
6553 
6554 ////////////////////////////////////////////////////////////////////////////////
6555 /// Set keyboard input focus to window id.
6556 
6558 {
6559  if (!id) return;
6560 
6561  HWND hwnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
6562  ::SetFocus(hwnd);
6563 }
6564 
6565 ////////////////////////////////////////////////////////////////////////////////
6566 /// Returns the window id of the current owner of the primary selection.
6567 /// That is the window in which, for example some text is selected.
6568 
6570 {
6571  return (Window_t)gdk_selection_owner_get(gClipboardAtom);
6572 }
6573 
6574 ////////////////////////////////////////////////////////////////////////////////
6575 /// Makes the window id the current owner of the primary selection.
6576 /// That is the window in which, for example some text is selected.
6577 
6579 {
6580  if (!id) return;
6581 
6582  gdk_selection_owner_set((GdkWindow *) id, gClipboardAtom, GDK_CURRENT_TIME, 0);
6583 }
6584 
6585 ////////////////////////////////////////////////////////////////////////////////
6586 /// XConvertSelection() causes a SelectionRequest event to be sent to the
6587 /// current primary selection owner. This event specifies the selection
6588 /// property (primary selection), the format into which to convert that
6589 /// data before storing it (target = XA_STRING), the property in which
6590 /// the owner will place the information (sel_property), the window that
6591 /// wants the information (id), and the time of the conversion request
6592 /// (when).
6593 /// The selection owner responds by sending a SelectionNotify event, which
6594 /// confirms the selected atom and type.
6595 
6597 {
6598  if (!id) return;
6599 
6600  gdk_selection_convert((GdkWindow *) id, clipboard,
6601  gdk_atom_intern("GDK_TARGET_STRING", 0), when);
6602 }
6603 
6604 ////////////////////////////////////////////////////////////////////////////////
6605 /// Convert the keycode from the event structure to a key symbol (according
6606 /// to the modifiers specified in the event structure and the current
6607 /// keyboard mapping). In buf a null terminated ASCII string is returned
6608 /// representing the string that is currently mapped to the key code.
6609 
6610 void TGWin32::LookupString(Event_t * event, char *buf, Int_t buflen,
6611  UInt_t & keysym)
6612 {
6613  _lookup_string(event, buf, buflen);
6614  UInt_t ks, xks = (UInt_t) event->fCode;
6615  MapKeySym(ks, xks, kFALSE);
6616  keysym = (Int_t) ks;
6617 }
6618 
6619 ////////////////////////////////////////////////////////////////////////////////
6620 /// Map to and from X key symbols. Keysym are the values returned by
6621 /// XLookUpString.
6622 
6623 void TGWin32::MapKeySym(UInt_t & keysym, UInt_t & xkeysym, Bool_t tox)
6624 {
6625  if (tox) {
6626  xkeysym = GDK_VoidSymbol;
6627  if (keysym < 127) {
6628  xkeysym = keysym;
6629  } else if (keysym >= kKey_F1 && keysym <= kKey_F35) {
6630  xkeysym = GDK_F1 + (keysym - (UInt_t) kKey_F1); // function keys
6631  } else {
6632  for (int i = 0; gKeyMap[i].fKeySym; i++) { // any other keys
6633  if (keysym == (UInt_t) gKeyMap[i].fKeySym) {
6634  xkeysym = (UInt_t) gKeyMap[i].fXKeySym;
6635  break;
6636  }
6637  }
6638  }
6639  } else {
6640  keysym = kKey_Unknown;
6641  // commentary in X11/keysymdef says that X codes match ASCII
6642  if (xkeysym < 127) {
6643  keysym = xkeysym;
6644  } else if (xkeysym >= GDK_F1 && xkeysym <= GDK_F35) {
6645  keysym = kKey_F1 + (xkeysym - GDK_F1); // function keys
6646  } else if (xkeysym >= GDK_KP_0 && xkeysym <= GDK_KP_9) {
6647  keysym = kKey_0 + (xkeysym - GDK_KP_0); // numeric keypad keys
6648  } else {
6649  for (int i = 0; gKeyMap[i].fXKeySym; i++) { // any other keys
6650  if (xkeysym == gKeyMap[i].fXKeySym) {
6651  keysym = (UInt_t) gKeyMap[i].fKeySym;
6652  break;
6653  }
6654  }
6655  }
6656  }
6657 }
6658 
6659 ////////////////////////////////////////////////////////////////////////////////
6660 /// Get contents of paste buffer atom into string. If del is true delete
6661 /// the paste buffer afterwards.
6662 
6664  Int_t & nchar, Bool_t del)
6665 {
6666  if (!id) return;
6667 
6668  char *data;
6669  int nread, actual_format;
6670 
6671  nread = gdk_selection_property_get((GdkWindow *) id,
6672  (unsigned char **) &data,
6673  (GdkAtom *) & atom, &actual_format);
6674 
6675  if ((nread == 0) || (data == NULL)) {
6676  nchar = 0;
6677  return;
6678  }
6679 
6680  text.Insert(0, (const char *) data);
6681  nchar = 1; //strlen(data);
6682  g_free(data);
6683 
6684  // if (del)
6685  gdk_property_delete((GdkWindow *) id,
6686  gdk_atom_intern("GDK_SELECTION", FALSE));
6687 }
6688 
6689 ////////////////////////////////////////////////////////////////////////////////
6690 /// TranslateCoordinates translates coordinates from the frame of
6691 /// reference of one window to another. If the point is contained
6692 /// in a mapped child of the destination, the id of that child is
6693 /// returned as well.
6694 
6696  Int_t src_x, Int_t src_y,
6697  Int_t &dest_x, Int_t &dest_y,
6698  Window_t &child)
6699 {
6700  if (!src || !dest) return;
6701 
6702  HWND sw, dw, ch = NULL;
6703  POINT point;
6704  sw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)src);
6705  dw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)dest);
6706  point.x = src_x;
6707  point.y = src_y;
6708  ::MapWindowPoints(sw, // handle of window to be mapped from
6709  dw, // handle to window to be mapped to
6710  &point, // pointer to array with points to map
6711  1); // number of structures in array
6712  ch = ::ChildWindowFromPointEx(dw, point, CWP_SKIPDISABLED | CWP_SKIPINVISIBLE);
6713  child = (Window_t)gdk_xid_table_lookup(ch);
6714 
6715  if (child == src) {
6716  child = (Window_t) 0;
6717  }
6718  dest_x = point.x;
6719  dest_y = point.y;
6720 }
6721 
6722 ////////////////////////////////////////////////////////////////////////////////
6723 /// Return geometry of window (should be called GetGeometry but signature
6724 /// already used).
6725 
6727  UInt_t & w, UInt_t & h)
6728 {
6729  if (!id) return;
6730 
6731  Int_t ddum;
6732  if (GDK_DRAWABLE_TYPE(id) == GDK_DRAWABLE_PIXMAP) {
6733  x = y = 0;
6734  gdk_drawable_get_size((GdkDrawable *)id, (int*)&w, (int*)&h);
6735  }
6736  else {
6737  gdk_window_get_geometry((GdkDrawable *) id, &x, &y, (int*)&w,
6738  (int*)&h, &ddum);
6739  }
6740 }
6741 
6742 ////////////////////////////////////////////////////////////////////////////////
6743 /// FillPolygon fills the region closed by the specified path.
6744 /// The path is closed automatically if the last point in the list does
6745 /// not coincide with the first point. All point coordinates are
6746 /// treated as relative to the origin. For every pair of points
6747 /// inside the polygon, the line segment connecting them does not
6748 /// intersect the path.
6749 
6751  Int_t npnt)
6752 {
6753  if (!id) return;
6754 
6755  gdk_win32_draw_polygon((GdkWindow *) id, (GdkGC *) gc, 1, (GdkPoint *) points, npnt);
6756 }
6757 
6758 ////////////////////////////////////////////////////////////////////////////////
6759 /// Returns the root window the pointer is logically on and the pointer
6760 /// coordinates relative to the root window's origin.
6761 /// The pointer coordinates returned to win_x and win_y are relative to
6762 /// the origin of the specified window. In this case, QueryPointer returns
6763 /// the child that contains the pointer, if any, or else kNone to
6764 /// childw. QueryPointer returns the current logical state of the
6765 /// keyboard buttons and the modifier keys in mask.
6766 
6768  Window_t &childw, Int_t &root_x,
6769  Int_t &root_y, Int_t &win_x, Int_t &win_y,
6770  UInt_t &mask)
6771 {
6772  if (!id) return;
6773 
6774  POINT currPt;
6775  HWND chw, window;
6776  UInt_t umask = 0;
6777  BYTE kbd[256];
6778 
6779  window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)id);
6780  rootw = (Window_t)GDK_ROOT_PARENT();
6781  ::GetCursorPos(&currPt);
6782  chw = ::WindowFromPoint(currPt);
6783  childw = (Window_t)gdk_xid_table_lookup(chw);
6784  root_x = currPt.x;
6785  root_y = currPt.y;
6786 
6787  ::ScreenToClient(window, &currPt);
6788  win_x = currPt.x;
6789  win_y = currPt.y;
6790 
6791  ::GetKeyboardState (kbd);
6792 
6793  if (kbd[VK_SHIFT] & 0x80) {
6794  umask |= GDK_SHIFT_MASK;
6795  }
6796  if (kbd[VK_CAPITAL] & 0x80) {
6797  umask |= GDK_LOCK_MASK;
6798  }
6799  if (kbd[VK_CONTROL] & 0x80) {
6800  umask |= GDK_CONTROL_MASK;
6801  }
6802  if (kbd[VK_MENU] & 0x80) {
6803  umask |= GDK_MOD1_MASK;
6804  }
6805  if (kbd[VK_LBUTTON] & 0x80) {
6806  umask |= GDK_BUTTON1_MASK;
6807  }
6808  if (kbd[VK_MBUTTON] & 0x80) {
6809  umask |= GDK_BUTTON2_MASK;
6810  }
6811  if (kbd[VK_RBUTTON] & 0x80) {
6812  umask |= GDK_BUTTON3_MASK;
6813  }
6814 
6815  MapModifierState(mask, umask, kFALSE);
6816 }
6817 
6818 ////////////////////////////////////////////////////////////////////////////////
6819 /// Set foreground color in graphics context (shortcut for ChangeGC with
6820 /// only foreground mask set).
6821 
6823 {
6824  GdkColor fore;
6825  fore.pixel = foreground;
6826  fore.red = GetRValue(foreground);
6827  fore.green = GetGValue(foreground);
6828  fore.blue = GetBValue(foreground);
6829  gdk_gc_set_foreground((GdkGC *) gc, &fore);
6830 }
6831 
6832 ////////////////////////////////////////////////////////////////////////////////
6833 /// Set clipping rectangles in graphics context. X, Y specify the origin
6834 /// of the rectangles. Recs specifies an array of rectangles that define
6835 /// the clipping mask and n is the number of rectangles.
6836 
6838  Rectangle_t * recs, Int_t n)
6839 {
6840  Int_t i;
6841  GdkRectangle *grects = new GdkRectangle[n];
6842 
6843  for (i = 0; i < n; i++) {
6844  grects[i].x = x+recs[i].fX;
6845  grects[i].y = y+recs[i].fY;
6846  grects[i].width = recs[i].fWidth;
6847  grects[i].height = recs[i].fHeight;
6848  }
6849 
6850  for (i = 0; i < n; i++) {
6851  gdk_gc_set_clip_rectangle((GdkGC *)gc, (GdkRectangle*)recs);
6852  }
6853  delete [] grects;
6854 }
6855 
6856 ////////////////////////////////////////////////////////////////////////////////
6857 /// Flush (mode = 0, default) or synchronize (mode = 1) X output buffer.
6858 /// Flush flushes output buffer. Sync flushes buffer and waits till all
6859 /// requests have been processed by X server.
6860 
6862 {
6863  GdiFlush();
6864 }
6865 
6866 ////////////////////////////////////////////////////////////////////////////////
6867 /// Create a new empty region.
6868 
6870 {
6871  return (Region_t) gdk_region_new();
6872 }
6873 
6874 ////////////////////////////////////////////////////////////////////////////////
6875 /// Destroy region.
6876 
6878 {
6879  gdk_region_destroy((GdkRegion *) reg);
6880 }
6881 
6882 ////////////////////////////////////////////////////////////////////////////////
6883 /// Union of rectangle with a region.
6884 
6886 {
6887  GdkRectangle r;
6888  r.x = rect->fX;
6889  r.y = rect->fY;
6890  r.width = rect->fWidth;
6891  r.height = rect->fHeight;
6892  dest = (Region_t) gdk_region_union_with_rect((GdkRegion *) src, &r);
6893 }
6894 
6895 ////////////////////////////////////////////////////////////////////////////////
6896 /// Create region for the polygon defined by the points array.
6897 /// If winding is true use WindingRule else EvenOddRule as fill rule.
6898 
6900 {
6901  return (Region_t) gdk_region_polygon((GdkPoint*)points, np,
6902  winding ? GDK_WINDING_RULE : GDK_EVEN_ODD_RULE);
6903 }
6904 
6905 ////////////////////////////////////////////////////////////////////////////////
6906 /// Compute the union of rega and regb and return result region.
6907 /// The output region may be the same result region.
6908 
6910 {
6911  result = (Region_t) gdk_regions_union((GdkRegion *) rega, (GdkRegion *) regb);
6912 }
6913 
6914 ////////////////////////////////////////////////////////////////////////////////
6915 /// Compute the intersection of rega and regb and return result region.
6916 /// The output region may be the same as the result region.
6917 
6919  Region_t result)
6920 {
6921  result = (Region_t) gdk_regions_intersect((GdkRegion *) rega,(GdkRegion *) regb);
6922 }
6923 
6924 ////////////////////////////////////////////////////////////////////////////////
6925 /// Subtract rega from regb.
6926 
6928 {
6929  result = (Region_t)gdk_regions_subtract((GdkRegion *) rega,(GdkRegion *) regb);
6930 }
6931 
6932 ////////////////////////////////////////////////////////////////////////////////
6933 /// Calculate the difference between the union and intersection of
6934 /// two regions.
6935 
6937 {
6938  result = (Region_t) gdk_regions_xor((GdkRegion *) rega, (GdkRegion *) regb);
6939 }
6940 
6941 ////////////////////////////////////////////////////////////////////////////////
6942 /// Return true if the region is empty.
6943 
6945 {
6946  return (Bool_t) gdk_region_empty((GdkRegion *) reg);
6947 }
6948 
6949 ////////////////////////////////////////////////////////////////////////////////
6950 /// Returns true if the point x,y is in the region.
6951 
6953 {
6954  return (Bool_t) gdk_region_point_in((GdkRegion *) reg, x, y);
6955 }
6956 
6957 ////////////////////////////////////////////////////////////////////////////////
6958 /// Returns true if two regions are equal.
6959 
6961 {
6962  return (Bool_t) gdk_region_equal((GdkRegion *) rega, (GdkRegion *) regb);
6963 }
6964 
6965 ////////////////////////////////////////////////////////////////////////////////
6966 /// Return smallest enclosing rectangle.
6967 
6969 {
6970  GdkRectangle r;
6971  gdk_region_get_clipbox((GdkRegion *) reg, &r);
6972  rect->fX = r.x;
6973  rect->fY = r.y;
6974  rect->fWidth = r.width;
6975  rect->fHeight = r.height;
6976 }
6977 
6978 ////////////////////////////////////////////////////////////////////////////////
6979 /// Return list of font names matching "fontname".
6980 
6981 char **TGWin32::ListFonts(const char *fontname, Int_t /*max*/, Int_t &count)
6982 {
6983  char foundry[32], family[100], weight[32], slant[32], font_name[256];
6984  char **fontlist;
6985  Int_t n1, fontcount = 0;
6986 
6987  sscanf(fontname, "-%30[^-]-%100[^-]-%30[^-]-%30[^-]-%n",
6988  foundry, family, weight, slant, &n1);
6989  // replace "medium" by "normal"
6990  if(!stricmp(weight,"medium")) {
6991  sprintf(weight,"normal");
6992  }
6993  // since all sizes are allowed with TTF, just forget it...
6994  sprintf(font_name, "-%s-%s-%s-%s-*", foundry, family, weight, slant);
6995  fontlist = gdk_font_list_new(font_name, &fontcount);
6996  count = fontcount;
6997 
6998  if (fontcount > 0) return fontlist;
6999  return 0;
7000 }
7001 
7002 ////////////////////////////////////////////////////////////////////////////////
7003 ///
7004 
7005 void TGWin32::FreeFontNames(char **fontlist)
7006 {
7007  gdk_font_list_free(fontlist);
7008 }
7009 
7010 ////////////////////////////////////////////////////////////////////////////////
7011 ///
7012 
7014 {
7015  return (Drawable_t) gdk_image_new(GDK_IMAGE_SHARED, gdk_visual_get_best(),
7016  width, height);
7017 }
7018 
7019 ////////////////////////////////////////////////////////////////////////////////
7020 ///
7021 
7023 {
7024  width = ((GdkImage*)id)->width;
7025  height = ((GdkImage*)id)->height;
7026 }
7027 
7028 ////////////////////////////////////////////////////////////////////////////////
7029 ///
7030 
7032 {
7033  if (!id) return;
7034 
7035  GdkImage *image = (GdkImage *)id;
7036  if (image->depth == 1) {
7037  if (pixel & 1) {
7038  ((UChar_t *) image->mem)[y * image->bpl + (x >> 3)] |= (1 << (7 - (x & 0x7)));
7039  } else {
7040  ((UChar_t *) image->mem)[y * image->bpl + (x >> 3)] &= ~(1 << (7 - (x & 0x7)));
7041  }
7042  } else {
7043  UChar_t *pixelp = (UChar_t *) image->mem + y * image->bpl + x * image->bpp;
7044  // Windows is always LSB, no need to check image->byte_order.
7045  switch (image->bpp) {
7046  case 4:
7047  pixelp[3] = 0;
7048  case 3:
7049  pixelp[2] = ((pixel >> 16) & 0xFF);
7050  case 2:
7051  pixelp[1] = ((pixel >> 8) & 0xFF);
7052  case 1:
7053  pixelp[0] = (pixel & 0xFF);
7054  }
7055  }
7056 }
7057 
7058 ////////////////////////////////////////////////////////////////////////////////
7059 ///
7060 
7062  Int_t dy, Int_t x, Int_t y, UInt_t w, UInt_t h)
7063 {
7064  if (!id) return;
7065 
7066  gdk_draw_image((GdkDrawable *) id, (GdkGC *)gc, (GdkImage *)img,
7067  x, y, dx, dy, w, h);
7068  ::GdiFlush();
7069 }
7070 
7071 ////////////////////////////////////////////////////////////////////////////////
7072 ///
7073 
7075 {
7076  gdk_image_unref((GdkImage *)img);
7077 }
7078 
7079 ////////////////////////////////////////////////////////////////////////////////
7080 /// Gets DIB bits
7081 /// x, y, width, height - position of bitmap
7082 /// returns a pointer on bitmap bits array
7083 /// in format:
7084 /// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
7085 ///
7086 /// Pixels are numbered from left to right and from top to bottom.
7087 /// By default all pixels from the whole drawable are returned.
7088 
7090  UInt_t width, UInt_t height)
7091 {
7092  HDC hdc, memdc;
7093  BITMAPINFO bmi;
7094  HGDIOBJ oldbitmap1, oldbitmap2;
7095  BITMAP bm;
7096  HBITMAP ximage = 0;
7097  VOID *bmbits = 0;
7098  unsigned char *ret = 0;
7099 
7100  if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7101  hdc = ::CreateCompatibleDC(NULL);
7102  oldbitmap1 = ::SelectObject(hdc, GDK_DRAWABLE_XID(wid));
7103  ::GetObject(GDK_DRAWABLE_XID(wid), sizeof(BITMAP), &bm);
7104  } else {
7105  hdc = ::GetDC((HWND)GDK_DRAWABLE_XID(wid));
7106  }
7107  memdc = ::CreateCompatibleDC(hdc);
7108 
7109  bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
7110  bmi.bmiHeader.biWidth = width;
7111  bmi.bmiHeader.biHeight = -1 * (int)(height);
7112  bmi.bmiHeader.biPlanes = 1;
7113  bmi.bmiHeader.biBitCount = 32;
7114  bmi.bmiHeader.biCompression = BI_RGB;
7115  bmi.bmiHeader.biSizeImage = 0;
7116  bmi.bmiHeader.biXPelsPerMeter = bmi.bmiHeader.biYPelsPerMeter = 0;
7117  bmi.bmiHeader.biClrUsed = 0;
7118  bmi.bmiHeader.biClrImportant = 0;
7119 
7120  ximage = ::CreateDIBSection(hdc, (BITMAPINFO *) &bmi, DIB_RGB_COLORS, &bmbits, NULL, 0);
7121 
7122  if (ximage && bmbits) {
7123  oldbitmap2 = ::SelectObject(memdc, ximage);
7124  ::BitBlt(memdc, x, y, width, height, hdc, 0, 0, SRCCOPY);
7125  ::SelectObject(memdc, oldbitmap2);
7126  }
7127  ::DeleteDC(memdc);
7128  if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7129  ::SelectObject(hdc, oldbitmap1);
7130  ::DeleteDC(hdc);
7131  } else {
7132  ::ReleaseDC((HWND)GDK_DRAWABLE_XID(wid), hdc);
7133  }
7134  if (ximage && bmbits) {
7135  ULong_t sz = width*height*4;
7136  ret = new unsigned char[sz];
7137  memcpy(ret, bmbits, sz);
7138  ::DeleteObject(ximage);
7139  }
7140  return ret;
7141 }
7142 
7143 ////////////////////////////////////////////////////////////////////////////////
7144 /// create an image from RGB data. RGB data is in format :
7145 /// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
7146 ///
7147 /// Pixels are numbered from left to right and from top to bottom.
7148 /// Note that data must be 32-bit aligned
7149 
7150 Pixmap_t TGWin32::CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height)
7151 {
7152  BITMAPINFO bmp_info;
7153  bmp_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
7154  bmp_info.bmiHeader.biWidth = width;
7155  bmp_info.bmiHeader.biHeight = -1 * (int)(height);
7156  bmp_info.bmiHeader.biPlanes = 1;
7157  bmp_info.bmiHeader.biBitCount = 32;
7158  bmp_info.bmiHeader.biCompression = BI_RGB;
7159  bmp_info.bmiHeader.biSizeImage = 0;
7160  bmp_info.bmiHeader.biClrUsed = 0;
7161  bmp_info.bmiHeader.biXPelsPerMeter = 0L;
7162  bmp_info.bmiHeader.biYPelsPerMeter = 0L;
7163  bmp_info.bmiHeader.biClrImportant = 0;
7164  bmp_info.bmiColors[0].rgbRed = 0;
7165  bmp_info.bmiColors[0].rgbGreen = 0;
7166  bmp_info.bmiColors[0].rgbBlue = 0;
7167  bmp_info.bmiColors[0].rgbReserved = 0;
7168 
7169  HDC hdc = ::GetDC(NULL);
7170  HBITMAP hbitmap = ::CreateDIBitmap(hdc, &bmp_info.bmiHeader, CBM_INIT,
7171  (void *)bits, &bmp_info, DIB_RGB_COLORS);
7172  ::ReleaseDC(NULL, hdc);
7173 
7174  SIZE size;
7175  // For an obscure reason, we have to set the size of the
7176  // bitmap this way before to call gdk_pixmap_foreign_new
7177  // otherwise, it fails...
7178  ::SetBitmapDimensionEx(hbitmap,width, height, &size);
7179 
7180  return (Pixmap_t)gdk_pixmap_foreign_new((guint32)hbitmap);
7181 }
7182 
7183 ////////////////////////////////////////////////////////////////////////////////
7184 ///register pixmap created by TGWin32GLManager
7185 
7187 {
7188  HBITMAP hBmp = reinterpret_cast<HBITMAP>(pix);
7189  SIZE sz = SIZE();
7190 
7191  SetBitmapDimensionEx(hBmp, w, h, &sz);
7192  GdkPixmap *newPix = gdk_pixmap_foreign_new(reinterpret_cast<guint32>(hBmp));
7193 
7194  Int_t wid = 0;
7195  for(; wid < fMaxNumberOfWindows; ++wid)
7196  if (!fWindows[wid].open)
7197  break;
7198 
7199  if (wid == fMaxNumberOfWindows) {
7200  Int_t newSize = fMaxNumberOfWindows + 10;
7201 
7202  fWindows = (XWindow_t *)TStorage::ReAlloc(fWindows, newSize * sizeof(XWindow_t),
7203  fMaxNumberOfWindows * sizeof(XWindow_t));
7204 
7205  for (Int_t i = fMaxNumberOfWindows; i < newSize; ++i)
7206  fWindows[i].open = 0;
7207 
7208  fMaxNumberOfWindows = newSize;
7209  }
7210 
7211  fWindows[wid].open = 1;
7212  gCws = fWindows + wid;
7213  gCws->window = newPix;
7214  gCws->drawing = gCws->window;
7215  gCws->buffer = 0;
7216  gCws->double_buffer = 0;
7217  gCws->ispixmap = 1;
7218  gCws->clip = 0;
7219  gCws->width = w;
7220  gCws->height = h;
7221  gCws->new_colors = 0;
7222 
7223  return wid;
7224 }
7225 
7226 ////////////////////////////////////////////////////////////////////////////////
7227 /// Register a window created by Qt as a ROOT window (like InitWindow()).
7228 
7230 {
7231  Int_t wid;
7232  // Select next free window number
7233 
7234  again:
7235  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
7236  if (!fWindows[wid].open) {
7237  fWindows[wid].open = 1;
7238  fWindows[wid].double_buffer = 0;
7239  gCws = &fWindows[wid];
7240  break;
7241  }
7242  }
7243 
7244  if (wid == fMaxNumberOfWindows) {
7245  int newsize = fMaxNumberOfWindows + 10;
7246  fWindows =
7247  (XWindow_t *) TStorage::ReAlloc(fWindows,
7248  newsize * sizeof(XWindow_t),
7249  fMaxNumberOfWindows *
7250  sizeof(XWindow_t));
7251 
7252  for (int i = fMaxNumberOfWindows; i < newsize; i++) {
7253  fWindows[i].open = 0;
7254  }
7255 
7256  fMaxNumberOfWindows = newsize;
7257  goto again;
7258  }
7259 
7260  gCws->window = gdk_window_foreign_new((guint32)qwid);
7261 
7262  gCws->drawing = gCws->window;
7263  gCws->buffer = 0;
7264  gCws->double_buffer = 0;
7265  gCws->ispixmap = 0;
7266  gCws->clip = 0;
7267  gCws->width = w;
7268  gCws->height = h;
7269  gCws->new_colors = 0;
7270 
7271  return wid;
7272 }
7273 
7274 ////////////////////////////////////////////////////////////////////////////////
7275 /// Remove a window created by Qt (like CloseWindow1()).
7276 
7278 {
7279  int wid;
7280 
7281  SelectWindow((int)qwid);
7282 
7283  if (gCws->buffer) {
7284  gdk_pixmap_unref(gCws->buffer);
7285  }
7286  if (gCws->new_colors) {
7287  gdk_colormap_free_colors((GdkColormap *) fColormap,
7288  (GdkColor *)gCws->new_colors, gCws->ncolors);
7289 
7290  delete [] gCws->new_colors;
7291  gCws->new_colors = 0;
7292  }
7293 
7294  GdiFlush();
7295  gCws->open = 0;
7296 
7297  if (!fWindows) return;
7298 
7299  // make first window in list the current window
7300  for (wid = 0; wid < fMaxNumberOfWindows; wid++) {
7301  if (fWindows[wid].open) {
7302  gCws = &fWindows[wid];
7303  return;
7304  }
7305  }
7306  gCws = 0;
7307 }
7308 
7309 ////////////////////////////////////////////////////////////////////////////////
7310 /// The Nonrectangular Window Shape Extension adds nonrectangular
7311 /// windows to the System.
7312 /// This allows for making shaped (partially transparent) windows
7313 
7315 {
7316  gdk_window_shape_combine_mask((GdkWindow *)id, (GdkBitmap *) mask, x, y);
7317 }
7318 
7319 ////////////////////////////////////////////////////////////////////////////////
7320 /// Returns the width of the screen in millimeters.
7321 
7323 {
7324  return (UInt_t)gdk_screen_width_mm();
7325 }
7326 
7327 //------------------------------ Drag and Drop ---------------------------------
7328 
7329 ////////////////////////////////////////////////////////////////////////////////
7330 /// Deletes the specified property on the specified window.
7331 
7333 {
7334  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7335  Atom_t atom = (Atom_t)GetProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7336  if (atom != 0) {
7337  GlobalDeleteAtom(atom);
7338  }
7339  RemoveProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7340 }
7341 
7342 ////////////////////////////////////////////////////////////////////////////////
7343 /// Returns the actual type of the property, the actual format of the property,
7344 /// and a pointer to the data actually returned.
7345 
7347  Bool_t del, Atom_t req_type, Atom_t *act_type,
7348  Int_t *act_format, ULong_t *nitems, ULong_t *bytes,
7349  unsigned char **prop_list)
7350 {
7351  HGLOBAL hdata;
7352  UChar_t *ptr, *data;
7353  UInt_t i, n, length;
7354 
7355  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7356  if (hWnd == NULL)
7357  return 0;
7358 
7359  Atom_t dndproxy = InternAtom("XdndProxy", kFALSE);
7360  Atom_t dndtypelist = InternAtom("XdndTypeList", kFALSE);
7361 
7362  if (prop == dndproxy)
7363  return 0;
7364  if (prop == dndtypelist) {
7365  *act_type = XA_ATOM;
7366  *prop_list = (unsigned char *)GetProp(hWnd, (LPCTSTR)MAKELONG(prop,0));
7367  for (n = 0; prop_list[n]; n++);
7368  *nitems = n;
7369  return n;
7370  }
7371  else {
7372  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7373  return 0;
7374  }
7375  hdata = GetClipboardData(CF_PRIVATEFIRST);
7376  ptr = (UChar_t *)GlobalLock(hdata);
7377  length = GlobalSize(hdata);
7378  data = (UChar_t *)malloc(length + 1);
7379  for (i = 0; i < length; i++) {
7380  data[i] = ptr[i];
7381  }
7382  GlobalUnlock(hdata);
7383  CloseClipboard();
7384  *prop_list = data;
7385  *bytes = *nitems = length;
7386  return length;
7387  }
7388  return 0;
7389 }
7390 
7391 ////////////////////////////////////////////////////////////////////////////////
7392 /// Changes the active cursor of the specified window.
7393 
7395 {
7396  UInt_t xevmask;
7397  MapEventMask(mask, xevmask);
7398  if (cur == kNone)
7399  gdk_window_set_cursor((GdkWindow *) win, fCursors[kHand]);
7400  else
7401  gdk_window_set_cursor((GdkWindow *) win, (GdkCursor *)cur);
7402 }
7403 
7404 ////////////////////////////////////////////////////////////////////////////////
7405 /// Get Clipboard data.
7406 
7408  Atom_t &prop, Time_t &stamp)
7409 {
7410  HGLOBAL hdata;
7411 
7412  static UINT gdk_selection_notify_msg =
7413  RegisterWindowMessage("gdk-selection-notify");
7414  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7415  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7416  return;
7417  }
7418  hdata = GetClipboardData(CF_PRIVATEFIRST);
7419  CloseClipboard();
7420  if (hdata == 0)
7421  return;
7422  /* Send ourselves an ersatz selection notify message so that we actually
7423  * fetch the data.
7424  */
7425  PostMessage(hWnd, gdk_selection_notify_msg, sel, target);
7426 }
7427 
7428 ////////////////////////////////////////////////////////////////////////////////
7429 /// Assigns owner of Clipboard.
7430 
7432 {
7433  static UINT gdk_selection_request_msg =
7434  RegisterWindowMessage("gdk-selection-request");
7435  HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)owner);
7436  OpenClipboard(hWnd);
7437  EmptyClipboard();
7438  CloseClipboard();
7439  if (owner) {
7440  ::PostMessage(hWnd, gdk_selection_request_msg, sel, 0);
7441  }
7442  return kTRUE;
7443 }
7444 
7445 ////////////////////////////////////////////////////////////////////////////////
7446 /// Put data into Clipboard.
7447 
7449  Int_t format, UChar_t *data, Int_t len)
7450 {
7451  HGLOBAL hdata;
7452  Int_t i;
7453  UChar_t *ptr;
7454 
7455  if (data == 0 || len == 0)
7456  return;
7457  if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)id))) {
7458  return;
7459  }
7460  hdata = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 1);
7461  ptr = (UChar_t *)GlobalLock(hdata);
7462  for (i = 0; i < len; i++) {
7463  *ptr++ = *data++;
7464  }
7465  GlobalUnlock(hdata);
7466  SetClipboardData(CF_PRIVATEFIRST, hdata);
7467  CloseClipboard();
7468 }
7469 
7470 ////////////////////////////////////////////////////////////////////////////////
7471 /// Add the list of drag and drop types to the Window win.
7472 
7474 {
7475  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)win),
7476  (LPCTSTR)MAKELONG(prop,0),
7477  (HANDLE)typelist);
7478 }
7479 
7480 ////////////////////////////////////////////////////////////////////////////////
7481 /// Recursively search in the children of Window for a Window which is at
7482 /// location x, y and is DND aware, with a maximum depth of maxd.
7483 /// Possibility to exclude dragwin and input.
7484 
7486  int x, int y, int maxd)
7487 {
7488  POINT point;
7489  POINT cpt;
7490  RECT rect;
7491  HWND hwnd, hwndc;
7492  HWND hwndt;
7493  Window_t win, retwin = kNone;
7494  Atom_t version = 0;
7495  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7496 
7497  cpt.x = x;
7498  cpt.y = y;
7499  hwnd = ::ChildWindowFromPointEx((HWND)GDK_DRAWABLE_XID((GdkWindow *)root),
7500  cpt, CWP_ALL);
7501  while (hwnd) {
7502  GetWindowRect(hwnd, &rect);
7503  if (PtInRect(&rect, cpt)) {
7504  if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7505  win = (Window_t) gdk_xid_table_lookup(hwnd);
7506  if (win && win != dragwin && win != input)
7507  return win;
7508  }
7509  Bool_t done = kFALSE;
7510  hwndt = hwnd;
7511  while (!done) {
7512  point = cpt;
7513  ::MapWindowPoints(NULL, hwndt, &point, 1);
7514  hwndc = ChildWindowFromPoint (hwndt, point);
7515  if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7516  win = (Window_t) gdk_xid_table_lookup(hwndc);
7517  if (win && win != dragwin && win != input)
7518  return win;
7519  }
7520  if (hwndc == NULL)
7521  done = TRUE;
7522  else if (hwndc == hwndt)
7523  done = TRUE;
7524  else
7525  hwndt = hwndc;
7526  if (GetProp(hwndt,(LPCTSTR)MAKELONG(dndaware,0))) {
7527  win = (Window_t) gdk_xid_table_lookup(hwndt);
7528  if (win && win != dragwin && win != input)
7529  return win;
7530  }
7531  }
7532  }
7533  hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
7534  }
7535  return kNone;
7536 }
7537 
7538 ////////////////////////////////////////////////////////////////////////////////
7539 /// Checks if Window win is DND aware, and knows any of the DND formats
7540 /// passed in argument.
7541 
7543 {
7544  if (!win) return kFALSE;
7545 
7546  Atom_t version = 0;
7547  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7548  HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7549  while (window) {
7550  version = (Atom_t)GetProp(window,(LPCTSTR)MAKELONG(dndaware,0));
7551  if (version) return kTRUE;
7552  window = ::GetParent(window);
7553  }
7554  return kFALSE;
7555 }
7556 
7557 ////////////////////////////////////////////////////////////////////////////////
7558 /// Add XdndAware property and the list of drag and drop types to the
7559 /// Window win.
7560 
7562 {
7563  int n;
7564  if (!id) return;
7565 
7566  DWORD dwStyle = GetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7567  GWL_EXSTYLE);
7568  SetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)id), GWL_EXSTYLE,
7569  dwStyle | WS_EX_ACCEPTFILES);
7570  Atom_t dndaware = InternAtom("XdndAware", kFALSE);
7571  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7572  (LPCTSTR)MAKELONG(dndaware,0),
7573  (HANDLE)XDND_PROTOCOL_VERSION);
7574 
7575  if (typelist == 0)
7576  return;
7577  for (n = 0; typelist[n]; n++);
7578  Atom_t dndtypelist = InternAtom("XdndTypeList", kFALSE);
7579  SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)id),
7580  (LPCTSTR)MAKELONG(dndtypelist,0),
7581  (HANDLE)typelist);
7582 
7583 }
7584 
7585 ////////////////////////////////////////////////////////////////////////////////
7586 /// Set user thread id. This is used when an extra thread is created
7587 /// to process events.
7588 
7590 {
7591  if (id == 0) {
7592  TGWin32ProxyBase::fgMainThreadId = ((TWinNTSystem*)gSystem)->GetGUIThreadId();
7593  }
7594  else {
7596  }
7597 }
7598 
Int_t fClipXOrigin
Definition: GuiTypes.h:246
UShort_t fBlue
Definition: GuiTypes.h:315
const int nx
Definition: kalman.C:16
EAlign
Definition: TGWin32.h:83
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:4273
static void Dealloc(void *ptr)
De-allocate block of memory, that was allocated via TStorage::Alloc().
Definition: TStorage.cxx:164
virtual void ExecuteCallBack(Bool_t sync)
Executes all batched callbacks and the latest callback This method is executed by server thread...
tuple row
Definition: mrt.py:26
void CloseWindow1()
Delete current window.
Definition: TGWin32.cxx:1608
const Mask_t kKeyReleaseMask
Definition: GuiTypes.h:161
UShort_t fWidth
Definition: GuiTypes.h:364
void MapColorStruct(ColorStruct_t *color, GdkColor &xcolor)
Map a ColorStruct_t to a XColor structure.
Definition: TGWin32.cxx:5467
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:912
const char * GetLineStyleString(Int_t i=1) const
Return line style string (used by PostScript).
Definition: TStyle.cxx:787
Definition: GuiTypes.h:76
void RescaleWindow(Int_t wid, UInt_t w, UInt_t h)
Rescale the window wid.
Definition: TGWin32.cxx:2702
GdkGC * GetGC(Int_t which) const
Return desired Graphics Context ("which" maps directly on gGCList[]).
Definition: TGWin32.cxx:1964
Int_t fLineStyle
Definition: GuiTypes.h:231
Bool_t fSendEvent
Definition: GuiTypes.h:185
Handle_t FontStruct_t
Definition: GuiTypes.h:40
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:67
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:6936
EDrawMode fDrawMode
Definition: TVirtualX.h:79
static double B[]
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:6750
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:6837
void SetWMSize(Window_t id, UInt_t w, UInt_t h)
Tells window manager the desired size of window "id".
Definition: TGWin32.cxx:6345
Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...).
Definition: TVirtualX.h:70
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:39
Short_t fY
Definition: GuiTypes.h:363
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:7407
float xmin
Definition: THbookFile.cxx:93
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition: TSystem.cxx:420
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:5598
void SetWindowBackground(Window_t id, ULong_t color)
Set the window background color.
Definition: TGWin32.cxx:4528
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:3708
Pixmap_t fTile
Definition: GuiTypes.h:239
void SetLineColor(Color_t cindex)
Set color index for lines.
Definition: TGWin32.cxx:3233
tuple buffer
Definition: tree.py:99
void SelectWindow(Int_t wid)
Select window to which subsequent output is directed.
Definition: TGWin32.cxx:2840
XWindow_t * fWindows
Definition: TGWin32.h:96
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:5482
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:7332
long long Long64_t
Definition: RtypesCore.h:69
UShort_t fHeight
Definition: GuiTypes.h:364
EInitialState
Definition: GuiTypes.h:346
void SetDashes(GContext_t gc, Int_t offset, const char *dash_list, Int_t n)
Specify a dash pattertn.
Definition: TGWin32.cxx:5449
void UpdateFillStyle()
Set fill area style index.
Definition: TGWin32.cxx:3180
short Style_t
Definition: RtypesCore.h:76
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:4518
Bool_t fHasTTFonts
Definition: TGWin32.h:127
void Reset()
Reset the timer.
Definition: TTimer.cxx:155
Bool_t fFillColorModified
Definition: TGWin32.h:145
void SetUserThreadId(ULong_t id)
Set user thread id.
Definition: TGWin32.cxx:7589
FontStruct_t LoadQueryFont(const char *font_name)
Load font and query font.
Definition: TGWin32.cxx:5131
Collectable string class.
Definition: TObjString.h:32
FontH_t fFont
Definition: GuiTypes.h:243
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:4381
UInt_t Mask_t
Definition: GuiTypes.h:42
return c
RooArgList L(const RooAbsArg &v1)
const char * current
Definition: demos.C:12
Pixmap_t fBackgroundPixmap
Definition: GuiTypes.h:95
tuple offset
Definition: tree.py:93
void Update(Int_t mode=0)
Flush (mode = 0, default) or synchronize (mode = 1) X output buffer.
Definition: TGWin32.cxx:6861
float ymin
Definition: THbookFile.cxx:93
Display_t GetDisplay() const
Returns handle to display (might be useful in some cases where direct X11 manipulation outside of TVi...
Definition: TGWin32.cxx:5081
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:6232
UInt_t ScreenWidthMM() const
Returns the width of the screen in millimeters.
Definition: TGWin32.cxx:7322
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:5175
const Mask_t kButtonMotionMask
Definition: GuiTypes.h:165
const Mask_t kWACursor
Definition: GuiTypes.h:155
#define IDC_HAND
Definition: TGWin32.cxx:68
Float_t fTextMagnitude
Definition: TGWin32.h:134
Int_t fCount
Definition: GuiTypes.h:184
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:423
static Bool_t IsInitialized()
Definition: TTF.cxx:618
FT_Glyph fImage
Definition: TTF.h:79
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:7314
ULong_t Time_t
Definition: GuiTypes.h:43
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:6548
virtual void SetName(const char *name)
Change (i.e.
Definition: TNamed.cxx:128
void SetMarkerType(Int_t type, Int_t n, GdkPoint *xy)
Set marker type.
Definition: TGWin32.cxx:3395
#define BIT(n)
Definition: Rtypes.h:120
TH1 * h
Definition: legend2.C:5
Description of a X11 color.
Definition: TGWin32.h:72
void DeleteImage(Drawable_t img)
Deallocates the memory associated with the image img.
Definition: TGWin32.cxx:7074
std::vector< double > values
Definition: TwoHistoFit2D.C:32
Bool_t ReadPictureDataFromFile(const char *filename, char ***ret_data)
Read picture data from file and store in ret_data.
Definition: TGWin32.cxx:5419
void CloseDisplay()
close display (terminate server/gMainThread thread)
Definition: TGWin32.cxx:900
const Mask_t kLeaveWindowMask
Definition: GuiTypes.h:169
EGEventType
Definition: GuiTypes.h:60
Handle_t Cursor_t
Definition: GuiTypes.h:35
const Mask_t kWABackPixmap
Definition: GuiTypes.h:140
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
Definition: TGWin32.h:128
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:5550
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:7485
Int_t fTsYOrigin
Definition: GuiTypes.h:242
R__EXTERN TVirtualX *(* gPtr2VirtualX)()
Definition: TVirtualX.h:363
SCoord_t fX
Definition: TPoint.h:37
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:6356
Size_t fMarkerSize
Definition: TAttMarker.h:37
Bool_t fMarkerColorModified
Definition: TGWin32.h:150
static const char * filename()
static UInt_t fMaxResponseTime
#define gROOT
Definition: TROOT.h:344
Int_t fY
Definition: GuiTypes.h:179
void RaiseWindow(Window_t id)
Put window on top of window stack.
Definition: TGWin32.cxx:4441
void UpdateLineStyle()
Update line style.
Definition: TGWin32.cxx:3301
Handle_t GContext_t
Definition: GuiTypes.h:39
Colormap_t fColormap
Definition: GuiTypes.h:109
void SetWindowName(Window_t id, char *name)
Set window name.
Definition: TGWin32.cxx:6252
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:38
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:51
Basic string class.
Definition: TString.h:137
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:5194
const Mask_t kGCLineStyle
Definition: GuiTypes.h:292
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:170
Short_t fX
Definition: GuiTypes.h:358
TAlienJobStatus * status
Definition: TAlienJob.cxx:51
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:485
TArc * a
Definition: textangle.C:12
const Bool_t kFALSE
Definition: Rtypes.h:92
Float_t GetGreen() const
Definition: TColor.h:86
void UpdateLineColor()
Definition: TGWin32.cxx:3244
FT_Vector fAlign
Definition: TGWin32.h:86
Int_t fRedDiv
Definition: TGWin32.h:136
void GetWindowAttributes(Window_t id, WindowAttributes_t &attr)
Get window attributes and return filled in attributes structure.
Definition: TGWin32.cxx:5040
Handle_t Drawable_t
Definition: GuiTypes.h:32
static GC * gGCmark
Definition: TGX11.cxx:91
Int_t fClipYOrigin
Definition: GuiTypes.h:247
void SetWMState(Window_t id, EInitialState state)
Set the initial state of the window. Either kNormalState or kIconicState.
Definition: TGWin32.cxx:6381
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:235
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:7229
void UnmapWindow(Window_t id)
Unmap window from screen.
Definition: TGWin32.cxx:4408
Pixmap_t fClipMask
Definition: GuiTypes.h:248
R__EXTERN TApplication * gApplication
Definition: TApplication.h:171
Int_t fRedShift
Definition: TGWin32.h:139
static std::string format(double x, double y, int digits, int width)
ECursor
Definition: TVirtualX.h:56
This class is the basic interface to the Win32 graphics system.
Definition: TGWin32.h:80
tuple lines
Definition: mrt.py:16
#define XDND_PROTOCOL_VERSION
Definition: TGWin32.cxx:66
#define safestrlen(s)
Definition: TGWin32.cxx:6279
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:4370
void FreeFontStruct(FontStruct_t fs)
Free font structure returned by GetFontStruct().
Definition: TGWin32.cxx:6470
Window_t fWindow
Definition: GuiTypes.h:177
Handle_t Display_t
Definition: GuiTypes.h:28
Int_t fTextAlignV
Definition: TGWin32.h:130
TString & Insert(Ssiz_t pos, const char *s)
Definition: TString.h:592
void DeletePictureData(void *data)
Delete picture data created by the function ReadPictureDataFromFile.
Definition: TGWin32.cxx:5439
void MapKeySym(UInt_t &keysym, UInt_t &xkeysym, Bool_t tox=kTRUE)
Map to and from X key symbols.
Definition: TGWin32.cxx:6623
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:6428
Short_t Abs(Short_t d)
Definition: TMathBase.h:110
typedef LONG(WINAPI *PROCNTQSI)(UINT
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:7031
tuple window
Definition: gui_ex.py:57
EGraphicsFunction fFunction
Definition: GuiTypes.h:226
#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
TFile * f
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)
static GC * gGCtext
Definition: TGX11.cxx:93
void SendEvent(Window_t id, Event_t *ev)
Send event ev to window id.
Definition: TGWin32.cxx:5584
Handle_t FontH_t
Definition: GuiTypes.h:36
static struct @63 gMarker
const uint32_t SIZE
Definition: stressVdt.cxx:21
Int_t fBlueDiv
Definition: TGWin32.h:138
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:6663
ULong_t fBackgroundPixel
Definition: GuiTypes.h:96
const Mask_t kPointerMotionMask
Definition: GuiTypes.h:164
Window_t GetParent(Window_t id) const
Return the parent of the window.
Definition: TGWin32.cxx:5119
Bool_t fMapInstalled
Definition: GuiTypes.h:130
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:6869
UShort_t fRed
Definition: GuiTypes.h:313
const Mask_t kGCClipMask
Definition: GuiTypes.h:306
void LowerWindow(Window_t id)
Lower window so it lays below all its siblings.
Definition: TGWin32.cxx:4460
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:7150
static const double x2[5]
Int_t fGreenDiv
Definition: TGWin32.h:137
Double_t x[n]
Definition: legend1.C:17
static void LayoutGlyphs()
Compute the glyphs positions, fgAscent and fgWidth (needed for alignment).
Definition: TTF.cxx:183
void SetTextFont(Font_t fontnumber)
Set specified font.
Definition: TGWin32.cxx:1540
unsigned long KeySym
Definition: TGWin32.h:66
void QueryPointer(Int_t &ix, Int_t &iy)
Query pointer position.
Definition: TGWin32.cxx:2266
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
TBonjourRegistrar * reg
Definition: hserv2bonj.C:28
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:496
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
Definition: TGWin32.h:142
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:7346
static void GetTextExtent(UInt_t &w, UInt_t &h, char *text)
Get width (w) and height (h) when text is horizontal.
Definition: TTF.cxx:134
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:5349
Float_t GetBlue() const
Definition: TColor.h:87
static void PrepareString(const char *string)
Put the characters in "string" in the "glyphs" array.
Definition: TTF.cxx:249
void SetInput(Int_t inp)
Set input on or off.
Definition: TGWin32.cxx:3225
int d
Definition: tornado.py:11
Handle_t fHandle
Definition: GuiTypes.h:186
static FILE * gGifFile
Definition: TGWin32.cxx:4029
Handle_t Atom_t
Definition: GuiTypes.h:38
const Int_t kMAXMK
Definition: TGX11.cxx:118
ULong_t fForeground
Definition: GuiTypes.h:228
Colormap_t fColormap
Definition: GuiTypes.h:129
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:5359
const Mask_t kGCFont
Definition: GuiTypes.h:301
Int_t fXRoot
Definition: GuiTypes.h:180
void CopyGC(GContext_t org, GContext_t dest, Mask_t mask)
Copies graphics context from org to dest.
Definition: TGWin32.cxx:5260
Int_t WriteGIF(char *name)
Writes the current window into GIF file.
Definition: TGWin32.cxx:4135
Bool_t fPenModified
Definition: TGWin32.h:148
const Mask_t kGCLineWidth
Definition: GuiTypes.h:291
if(pyself &&pyself!=Py_None)
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:4771
const Mask_t kWAColormap
Definition: GuiTypes.h:154
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:6125
static TVirtualX * RealObject()
void align()
Definition: geodemo.C:1778
const Mask_t kGCGraphicsExposures
Definition: GuiTypes.h:303
static void GlobalLock()
lock any proxy (client thread)
void GetImageSize(Drawable_t id, UInt_t &width, UInt_t &height)
Returns the width and height of the image id.
Definition: TGWin32.cxx:7022
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:5297
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:6207
void gdk_win32_draw_arc(GdkDrawable *drawable, GdkGC *gc, gint filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2)
tuple np
Definition: multifit.py:30
Bool_t fLineColorModified
Definition: TGWin32.h:147
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:6918
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:5393
R__EXTERN ULong_t gConsoleWindow
Definition: TWinNTSystem.h:262
static void PutByte(Byte_t b)
Put byte b in output stream.
Definition: TGWin32.cxx:4059
void FreeColor(Colormap_t cmap, ULong_t pixel)
Free color cell with specified pixel value.
Definition: TGWin32.cxx:5540
static GC * gGCfill
Definition: TGX11.cxx:92
static TTGlyph * GetGlyphs()
Definition: TTF.cxx:660
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:4659
XFontStruct * id
Definition: TGX11.cxx:108
Int_t fGreenShift
Definition: TGWin32.h:140
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:918
static TVirtualX * ProxyObject()
const char *msg switch(type)
Window_t GetDefaultRootWindow() const
Return handle to the default root window created when calling XOpenDisplay().
Definition: TGWin32.cxx:5111
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
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:6323
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:6188
Int_t fTsXOrigin
Definition: GuiTypes.h:241
short Color_t
Definition: RtypesCore.h:79
Short_t fX
Definition: GuiTypes.h:363
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
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:7542
void Warp(Int_t ix, Int_t iy, Window_t id=0)
Set pointer position.
Definition: TGWin32.cxx:3988
ClassImp(TGWin32) TGWin32
Default constructor.
Definition: TGWin32.cxx:752
virtual void SetTextAlign(Short_t align=11)
Definition: TAttText.h:55
static void SetSmoothing(Bool_t state)
Set smoothing (anti-aliasing) flag.
Definition: TTF.cxx:364
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:6490
void SetDrawMode(EDrawMode mode)
Set the drawing mode.
Definition: TGWin32.cxx:3106
virtual Bool_t Notify()
Notify when timer times out.
Definition: TTimer.cxx:141
Definition: TPoint.h:33
Style_t fMarkerStyle
Definition: TAttMarker.h:36
void SetIconName(Window_t id, char *name)
Set window icon name.
Definition: TGWin32.cxx:6262
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:6952
#define None
Definition: TGWin32.h:68
void SetLineStyle(Style_t linestyle)
Set line style.
Definition: TGWin32.cxx:3290
point * points
Definition: X3DBuffer.c:20
char ** Argv() const
Definition: TApplication.h:142
UShort_t fGreen
Definition: GuiTypes.h:314
const Mask_t kButtonPressMask
Definition: GuiTypes.h:162
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:108
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:7561
Int_t fTextAlign
Definition: TGWin32.h:131
const Mask_t kKeyPressMask
Definition: GuiTypes.h:160
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:245
Int_t fTextAlignH
Definition: TGWin32.h:129
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:6522
Float_t fTextAngle
Definition: TAttText.h:35
static ULong_t fgPostMessageId
char ** ListFonts(const char *fontname, Int_t max, Int_t &count)
Return list of font names matching "fontname".
Definition: TGWin32.cxx:6981
float ymax
Definition: THbookFile.cxx:93
Bool_t AllocColor(GdkColormap *cmap, GdkColor *color)
Allocate color in colormap.
Definition: TGWin32.cxx:1163
Style_t fLineStyle
Definition: TAttLine.h:36
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:4544
EMouseButton
Definition: GuiTypes.h:215
void MapModifierState(UInt_t &state, UInt_t &xstate, Bool_t tox=kTRUE)
Map modifier key state to or from X.
Definition: TGWin32.cxx:5633
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:625
ROOT::R::TRInterface & r
Definition: Object.C:4
void FreeFontNames(char **fontlist)
Frees the specified the array of strings "fontlist".
Definition: TGWin32.cxx:7005
Double_t length(const TVector2 &v)
Definition: CsgOps.cxx:347
GdkVisual * fVisual
Definition: TGWin32.h:124
const Mask_t kWAEventMask
Definition: GuiTypes.h:152
R__EXTERN TSystem * gSystem
Definition: TSystem.h:545
Time_t fTime
Definition: GuiTypes.h:178
EGEventType fType
Definition: GuiTypes.h:176
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:183
TPaveLabel title(3, 27.1, 15, 28.7,"ROOT Environment and Tools")
Bool_t SetSelectionOwner(Window_t, Atom_t &)
Assigns owner of Clipboard.
Definition: TGWin32.cxx:7431
Bool_t fFillStyleModified
Definition: TGWin32.h:146
const Mask_t kGCClipXOrigin
Definition: GuiTypes.h:304
Color_t fLineColor
Definition: TAttLine.h:35
virtual Int_t GetValue(const char *name, Int_t dflt)
Returns the integer value for a resource.
Definition: TEnv.cxx:494
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
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)
Bool_t IsCmdThread() const
returns kTRUE if we are inside cmd/server thread
Definition: TGWin32.cxx:887
virtual Color_t GetFillColor() const
Definition: TAttFill.h:43
const Mask_t kExposureMask
Definition: GuiTypes.h:166
static FT_Matrix * GetRotMatrix()
Definition: TTF.cxx:646
Float_t fCharacterUpX
Definition: TGWin32.h:132
unsigned int UInt_t
Definition: RtypesCore.h:42
Width_t fLineWidth
Definition: TAttLine.h:37
TTF helper class containing glyphs description.
Definition: TTF.h:75
TMarker * m
Definition: textangle.C:8
void SetCharacterUp(Float_t chupx, Float_t chupy)
Set character up vector.
Definition: TGWin32.cxx:2870
void ChangeActivePointerGrab(Window_t, UInt_t, Cursor_t)
Changes the active cursor of the specified window.
Definition: TGWin32.cxx:7394
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:3771
tuple w
Definition: qtexample.py:51
short Short_t
Definition: RtypesCore.h:35
void ClearWindow()
Clear current window.
Definition: TGWin32.cxx:1573
Int_t fYRoot
Definition: GuiTypes.h:180
TLine * l
Definition: textangle.C:4
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:57
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
const Mask_t kGCClipYOrigin
Definition: GuiTypes.h:305
#define CALLBACK
Definition: TGLFaceSet.cxx:30
const Mask_t kGCJoinStyle
Definition: GuiTypes.h:294
Double_t ACos(Double_t)
Definition: TMath.h:445
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
Definition: TAttText.h:39
void SetTextColor(Color_t cindex)
Set color index for text.
Definition: TGWin32.cxx:3943
void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2)
Draw a line.
Definition: TGWin32.cxx:1770
GdkCursor * fCursors[kNumCursors]
Definition: TGWin32.h:98
#define XA_ATOM
Definition: xatom.h:13
void DestroySubwindows(Window_t id)
Destroy all internal subwindows.
Definition: TGWin32.cxx:4431
#define VOID
Definition: triangle.h:286
void GetRegionBox(Region_t reg, Rectangle_t *)
Return smallest enclosing rectangle.
Definition: TGWin32.cxx:6968
void Bell(Int_t percent)
Sets the sound bell. Percent is loudness from -100% to 100%.
Definition: TGWin32.cxx:6057
void RemoveWindow(ULong_t qwid)
Remove a window created by Qt (like CloseWindow1()).
Definition: TGWin32.cxx:7277
ULong_t fPixel
Definition: GuiTypes.h:312
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:28
#define gVirtualX
Definition: TVirtualX.h:362
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition: TString.cxx:2227
tuple free
Definition: fildir.py:30
void MapEvent(Event_t &ev, GdkEvent &xev, Bool_t tox=kTRUE)
Map Event_t structure to gdk_event structure.
Definition: TGWin32.cxx:5689
Pixmap_t fStipple
Definition: GuiTypes.h:240
Handle_t Colormap_t
Definition: GuiTypes.h:34
short Width_t
Definition: RtypesCore.h:78
Cursor_t CreateCursor(ECursor cursor)
Create cursor handle (just return cursor from cursor pool fCursors).
Definition: TGWin32.cxx:5288
void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t *attr)
Change window attributes.
Definition: TGWin32.cxx:6080
EKeySym
Definition: KeySymbols.h:27
static void * Alloc(size_t size)
Allocate a block of memory, that later can be resized using TStorage::ReAlloc().
Definition: TStorage.cxx:146
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:6610
void DestroyWindow(Window_t id)
Destroy window.
Definition: TGWin32.cxx:4418
const Mask_t kEnterWindowMask
Definition: GuiTypes.h:168
long Long_t
Definition: RtypesCore.h:50
FontH_t GetFontHandle(FontStruct_t fs)
Return handle to font described by font structure.
Definition: TGWin32.cxx:5155
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:4073
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:6500
#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:6414
ULong_t fBackground
Definition: GuiTypes.h:229
static const double x1[5]
Int_t fDepth
Definition: TGWin32.h:135
void gdk_win32_draw_segments(GdkDrawable *drawable, GdkGC *gc, GdkSegment *segs, gint nsegs)
const Mask_t kGCFillStyle
Definition: GuiTypes.h:295
const Mask_t kStructureNotifyMask
Definition: GuiTypes.h:167
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:4012
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:7448
tuple file
Definition: fildir.py:20
static Int_t GetAscent()
Definition: TTF.cxx:632
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:6511
void SetInputFocus(Window_t id)
Set keyboard input focus to window id.
Definition: TGWin32.cxx:6557
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:6960
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:6335
Float_t fCharacterUpY
Definition: TGWin32.h:133
const Mask_t kButtonReleaseMask
Definition: GuiTypes.h:163
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:6148
static GC gGCecho
Definition: TGX11.cxx:98
UInt_t fCode
Definition: GuiTypes.h:181
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:5335
const Handle_t kParentRelative
Definition: GuiTypes.h:91
int type
Definition: TGX11.cxx:120
R__EXTERN TEnv * gEnv
Definition: TEnv.h:174
const Mask_t kGCTile
Definition: GuiTypes.h:297
void WMDeleteNotify(Window_t id)
Tell WM to send message when window is closed via WM.
Definition: TGWin32.cxx:6158
Int_t RequestString(Int_t x, Int_t y, char *text)
Request a string.
Definition: TGWin32.cxx:2466
const Mask_t kWAOverrideRedirect
Definition: GuiTypes.h:150
unsigned long ULong_t
Definition: RtypesCore.h:51
TTimer(const TTimer &)
Int_t fJoinStyle
Definition: GuiTypes.h:234
Window_t fRoot
Definition: GuiTypes.h:121
TCanvas * style()
Definition: style.C:1
Double_t y[n]
Definition: legend1.C:17
void AsmLong(Long_t i1, Long_t i2, Long_t &ll)
Definition: GX11Gui.cxx:159
const Mask_t kGCFunction
Definition: GuiTypes.h:287
const Mask_t kGCCapStyle
Definition: GuiTypes.h:293
void MapSetWindowAttributes(SetWindowAttributes_t *attr, ULong_t &xmask, GdkWindowAttr &xattr)
Map a SetWindowAttributes_t to a GdkWindowAttr structure.
Definition: TGWin32.cxx:4738
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:328
const Mask_t kGCForeground
Definition: GuiTypes.h:289
The color creation and management class.
Definition: TColor.h:47
void SelectInput(Window_t id, UInt_t evmask)
Defines which input events the window is interested in.
Definition: TGWin32.cxx:6536
Float_t GetRed() const
Definition: TColor.h:85
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:494
GdkColormap * fColormap
Definition: TGWin32.h:125
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:4554
void GetGCValues(GContext_t gc, GCValues_t &gval)
Get current values from graphics context gc.
Definition: TGWin32.cxx:6448
static void GetPixel(int y, int width, Byte_t *scline)
Get pixels in line y and put in array scline.
Definition: TGWin32.cxx:4049
Bool_t fMarkerStyleModified
Definition: TGWin32.h:149
Int_t fCapStyle
Definition: GuiTypes.h:232
Float_t fTextSize
Definition: TAttText.h:36
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:4198
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:6404
Long_t fUser[5]
Definition: GuiTypes.h:188
void MapWindow(Window_t id)
Map window on screen.
Definition: TGWin32.cxx:4355
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:6909
static ULong_t fgPingMessageId
void SetIconPixmap(Window_t id, Pixmap_t pic)
Set pixmap the WM can use when the window is iconized.
Definition: TGWin32.cxx:6272
static Pixmap gFillPattern
Definition: TGX11.cxx:101
#define name(a, b)
Definition: linkTestLib0.cpp:5
void * handle(void *ptr)
Definition: threads.C:12
#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:6436
static void * ReAlloc(void *vp, size_t size)
Reallocate (i.e.
Definition: TStorage.cxx:177
const Mask_t kGCStipple
Definition: GuiTypes.h:298
UInt_t fWidth
Definition: GuiTypes.h:183
Int_t InitWindow(ULong_t window)
Open window and return window number.
Definition: TGWin32.cxx:2162
static void SetRotationMatrix(Float_t angle)
Set the rotation matrix used to rotate the font outlines.
Definition: TTF.cxx:341
Int_t fMaxNumberOfWindows
Definition: TGWin32.h:95
void DeleteFont(FontStruct_t fs)
Explicitely delete font structure obtained with LoadQueryFont().
Definition: TGWin32.cxx:5166
Bool_t fOverrideRedirect
Definition: GuiTypes.h:135
Handle_t Window_t
Definition: GuiTypes.h:30
void UpdateMarkerStyle()
Definition: TGWin32.cxx:3419
Window_t GetCurrentWindow() const
Return current window pointer. Protected method used by TGWin32TTF.
Definition: TGWin32.cxx:1955
GdkColor color
Definition: TGWin32.h:73
Int_t fFormat
Definition: GuiTypes.h:187
Mask_t fMask
Definition: GuiTypes.h:252
R__EXTERN TInterpreter *(* gPtr2Interpreter)()
Definition: TInterpreter.h:503
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:7089
void DestroyRegion(Region_t reg)
Destroy region.
Definition: TGWin32.cxx:6877
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:6944
const Mask_t kGCTileStipYOrigin
Definition: GuiTypes.h:300
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:6726
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:4482
Int_t GetDepth() const
Get maximum number of planes.
Definition: TGWin32.cxx:5089
void ResizeWindow(Int_t wid)
Resize the current window if necessary.
Definition: TGWin32.cxx:2791
const Mask_t kGCSubwindowMode
Definition: GuiTypes.h:302
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition: TSystem.cxx:475
Int_t fScreenNumber
Definition: TGWin32.h:126
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:144
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:6899
const size_t kBitsPerByte
Definition: Rtypes.h:114
#define dest(otri, vertexptr)
Definition: triangle.c:1040
Color_t fFillColor
Definition: TAttFill.h:35
#define XA_STRING
Definition: xatom.h:40
const Mask_t kGCBackground
Definition: GuiTypes.h:290
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:202
Window_t GetPrimarySelectionOwner()
Returns the window id of the current owner of the primary selection.
Definition: TGWin32.cxx:6569
Int_t AddPixmap(ULong_t pix, UInt_t w, UInt_t h)
register pixmap created by TGWin32GLManager
Definition: TGWin32.cxx:7186
#define BITmask(x)
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:567
Handle_t Region_t
Definition: GuiTypes.h:33
const Mask_t kGCTileStipXOrigin
Definition: GuiTypes.h:299
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:6822
const Mask_t kFocusChangeMask
Definition: GuiTypes.h:170
Handle_t Pixmap_t
Definition: GuiTypes.h:31
int Seek_t
Definition: RtypesCore.h:49
void Sync(Int_t mode)
Set synchronisation on or off.
Definition: TGWin32.cxx:3959
Int_t fLineWidth
Definition: GuiTypes.h:230
Int_t FindColor(ULong_t pixel, ULong_t *orgcolors, Int_t ncolors)
Returns index in orgcolors (and new_colors) for pixel.
Definition: TGWin32.cxx:3831
const Int_t kPropMotifWMHintsElements
Definition: GX11Gui.cxx:59
void SubtractRegion(Region_t rega, Region_t regb, Region_t result)
Subtract rega from regb.
Definition: TGWin32.cxx:6927
const Int_t kBIGGEST_RGB_VALUE
Definition: TGX11.cxx:83
#define NULL
Definition: Rtypes.h:82
void * GetObject() const
UInt_t fState
Definition: GuiTypes.h:182
R__EXTERN Int_t gDebug
Definition: Rtypes.h:128
TExMap * fColors
Definition: TGWin32.h:97
Bool_t fDefined
true if pixel value is defined
Definition: TGWin32.h:74
#define TESTBIT(n, i)
Definition: Rtypes.h:123
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:5614
static void SetTextSize(Float_t textsize)
Set current text size.
Definition: TTF.cxx:572
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:6596
void UnionRectWithRegion(Rectangle_t *rect, Region_t src, Region_t dest)
Union of rectangle with a region.
Definition: TGWin32.cxx:6885
void gdk_win32_draw_polygon(GdkDrawable *drawable, GdkGC *gc, gint filled, GdkPoint *points, gint npoints)
const Mask_t kWABackPixel
Definition: GuiTypes.h:141
static void _set_event_time(GdkEvent &event, UInt_t time)
Definition: TGWin32.cxx:5645
Int_t fSubwindowMode
Definition: GuiTypes.h:244
void SetClassHints(Window_t id, char *className, char *resourceName)
Set the windows class and resource name.
Definition: TGWin32.cxx:6284
double result[121]
unsigned char UChar_t
Definition: RtypesCore.h:34
Int_t fBlueShift
Definition: TGWin32.h:141
void UpdateWindow(Int_t mode)
Update display.
Definition: TGWin32.cxx:3972
Double_t Sqrt(Double_t x)
Definition: TMath.h:464
TObject * At(Int_t idx) const
Definition: TObjArray.h:167
string message
Definition: ROOT.py:94
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:7013
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:6462
static Int_t GetNumGlyphs()
Definition: TTF.cxx:639
const Bool_t kTRUE
Definition: Rtypes.h:91
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:7473
Color_t fMarkerColor
Definition: TAttMarker.h:35
const Mask_t kAnyModifier
Definition: GuiTypes.h:211
virtual void SetTitle(const char *title="")
Change (i.e. set) the title of the TNamed.
Definition: TNamed.cxx:152
Atom_t InternAtom(const char *atom_name, Bool_t only_if_exist)
Return atom handle for atom_name.
Definition: TGWin32.cxx:5099
void SetKeyAutoRepeat(Bool_t on=kTRUE)
Turn key auto repeat on or off.
Definition: TGWin32.cxx:6173
float value
Definition: math.cpp:443
Vc_ALWAYS_INLINE_L T *Vc_ALWAYS_INLINE_R malloc(size_t n)
Allocates memory on the Heap with alignment and padding suitable for vectorized access.
Definition: memory.h:67
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:5522
Long_t fYourEventMask
Definition: GuiTypes.h:133
int GIFinfo(Byte_t *GIFarr, int *Width, int *Height, int *Ncols)
Definition: gifdecode.c:80
const Int_t n
Definition: legend1.C:16
Int_t fX
Definition: GuiTypes.h:179
EGraphicsFunction
Definition: GuiTypes.h:68
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:6695
TRandom3 R
a TMatrixD.
Definition: testIO.cxx:28
TObject * fRefreshTimer
Definition: TGWin32.h:143
void SetTextAlign(Short_t talign=11)
Set text alignment.
Definition: TGWin32.cxx:3883
unsigned int r2[N_CITIES]
Definition: simanTSP.cxx:322
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:35
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:6067
void DeleteGC(GContext_t gc)
Explicitely delete a graphics context.
Definition: TGWin32.cxx:5280
void SetPrimarySelectionOwner(Window_t id)
Makes the window id the current owner of the primary selection.
Definition: TGWin32.cxx:6578
static const FT_BBox & GetBox()
Definition: TTF.cxx:653
Style_t fFillStyle
Definition: TAttFill.h:36
static Bool_t GetSmoothing()
Definition: TTF.cxx:611
void IconifyWindow(Window_t id)
Iconify the window.
Definition: TGWin32.cxx:4506
int gdk_debug_level
Definition: TGWin32.cxx:137
const char Int_t const char * image
Definition: TXSlave.cxx:46
segment * segs
Definition: X3DBuffer.c:21
static GC * gGCinvt
Definition: TGX11.cxx:94
Short_t fY
Definition: GuiTypes.h:358
ULong_t Handle_t
Definition: GuiTypes.h:27
void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b)
Set color intensities for given color index.
Definition: TGWin32.cxx:3846
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:904