36#include "gdk/gdkkeysyms.h"
64#define XDND_PROTOCOL_VERSION 5
66#define IDC_HAND MAKEINTRESOURCE(32649)
119 GdkDrawable *drawing;
140GdkAtom gClipboardAtom = GDK_NONE;
141static XWindow_t *
gCws;
142static XWindow_t *
gTws;
177static const char *
gTextFont =
"arial.ttf";
209 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK
210 | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK
211 | GDK_KEY_RELEASE_MASK;
213 GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK |
214 GDK_LEAVE_NOTIFY_MASK;
220 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
221 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
222 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
226static bool gdk_initialized =
false;
230struct MWMHintsProperty_t {
249struct KeySymbolMap_t {
254static const char *keyCodeToString[] = {
308static KeySymbolMap_t
gKeyMap[] = {
311#ifndef GDK_ISO_Left_Tab
365 int n =
event->fUser[1];
367 for (i = 0; i <
n; i++) {
368 buf[i] =
event->fUser[2 + i];
374 if (event->
fCode <= 0x20) {
375 strncpy(buf, keyCodeToString[event->
fCode], buflen - 1);
407 conv.i[0] = (
Int_t) i1;
408 conv.i[1] = (
Int_t) i2;
415static BOOL
CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam)
417 ::ShowWindow(hwndChild, SW_SHOWNORMAL);
418 GdkWindow *child = gdk_window_lookup(hwndChild);
420 ((GdkWindowPrivate *) child)->mapped =
TRUE;
426static void _ChangeProperty(HWND w,
char *np,
char *dp,
int n,
Atom_t type)
431 hMem = ::GetProp(w, np);
435 hMem = ::GlobalAlloc(GHND,
n +
sizeof(
Atom_t));
436 p = (
char *) ::GlobalLock(hMem);
438 memcpy(p +
sizeof(
Atom_t), dp,
n);
439 ::GlobalUnlock(hMem);
440 ::SetProp(w, np, hMem);
448 int format,
int mode,
const unsigned char *data,
456 if (mode == GDK_PROP_MODE_REPLACE || mode == GDK_PROP_MODE_PREPEND) {
457 len = (
int) ::GlobalGetAtomName(property, buffer,
sizeof(buffer));
458 if ((atomName = (
char *)
malloc(len + 1)) == NULL) {
461 strcpy(atomName, buffer);
463 sprintf(propName,
"#0x%0.4x", (
unsigned) atomName);
464 _ChangeProperty(w, propName, (
char *) data, nelements,
type);
472static int _GetWindowProperty(GdkWindow *
id,
Atom_t property,
Long_t long_offset,
474 Atom_t * actual_type_return,
480 char *data, *destPtr;
485 w = (HWND) GDK_DRAWABLE_XID(
id);
487 if (::IsClipboardFormatAvailable(CF_TEXT) && ::OpenClipboard(NULL)) {
488 handle = ::GetClipboardData(CF_TEXT);
489 if (handle != NULL) {
490 data = (
char *) ::GlobalLock(handle);
491 *nitems_return = strlen(data);
493 destPtr = (
char *) *prop_return;
494 while (*data !=
'\0') {
502 ::GlobalUnlock(handle);
504 *bytes_after_return = 0;
510 ::RemoveProp(w, propName);
522 GdkImage *image = (GdkImage *)
id;
525 if (image->depth == 1) {
526 pixel = (((
char *) image->mem)[
y * image->bpl + (
x >> 3)] & (1 << (7 - (
x & 0x7)))) != 0;
529 switch (image->bpp) {
535 pixel = pixelp[0] | (pixelp[1] << 8);
538 pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
541 pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
551static void CollectImageColors(
ULong_t pixel,
ULong_t * &orgcolors,
554 if (maxcolors == 0) {
560 for (
int i = 0; i < ncolors; i++) {
561 if (pixel == orgcolors[i])
return;
563 if (ncolors >= maxcolors) {
571 orgcolors[ncolors++] = pixel;
577static char *EventMask2String(
UInt_t evmask)
579 static char bfr[500];
584 if (evmask & k##x##Mask) \
585 p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
603class TGWin32MainThread {
608 static LPCRITICAL_SECTION fCritSec;
609 static LPCRITICAL_SECTION fMessageMutex;
612 ~TGWin32MainThread();
613 static void LockMSG();
614 static void UnlockMSG();
617TGWin32MainThread *gMainThread = 0;
618LPCRITICAL_SECTION TGWin32MainThread::fCritSec = 0;
619LPCRITICAL_SECTION TGWin32MainThread::fMessageMutex = 0;
625TGWin32MainThread::~TGWin32MainThread()
628 ::LeaveCriticalSection(fCritSec);
629 ::DeleteCriticalSection(fCritSec);
635 ::LeaveCriticalSection(fMessageMutex);
636 ::DeleteCriticalSection(fMessageMutex);
637 delete fMessageMutex;
642 ::PostThreadMessage(fId, WM_QUIT, 0, 0);
643 ::CloseHandle(fHandle);
651void TGWin32MainThread::LockMSG()
653 if (fMessageMutex) ::EnterCriticalSection(fMessageMutex);
659void TGWin32MainThread::UnlockMSG()
661 if (fMessageMutex) ::LeaveCriticalSection(fMessageMutex);
668VOID CALLBACK MyTimerProc(HWND hwnd, UINT message, UINT idTimer, DWORD dwTime)
679Bool_t GUIThreadMessageFunc(MSG *msg)
682 static Int_t m_timer = 0;
684 if ( (msg->message == WM_NCLBUTTONDOWN) ) {
686 m_timer = SetTimer(NULL, 1, 20, (TIMERPROC) MyTimerProc);
688 else if (msg->message == WM_NCMOUSELEAVE ) {
690 KillTimer(NULL, m_timer);
709 TGWin32MainThread::LockMSG();
710 TranslateMessage(msg);
711 DispatchMessage(msg);
712 TGWin32MainThread::UnlockMSG();
719class TGWin32RefreshTimer :
public TTimer {
729 while (::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE)) {
730 ::PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE);
734 GUIThreadMessageFunc(&msg);
743static DWORD WINAPI MessageProcessingLoop(void *p)
747 Bool_t endLoop = kFALSE;
748 TGWin32RefreshTimer *refersh = 0;
750 // force to create message queue
751 ::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
753 // periodically we refresh windows
754 // Don't create refresh timer if the application has been created inside PVSS
756 TString arg = gSystem->BaseName(gApplication->Argv(0));
757 if (!arg.Contains("PVSS"))
758 refersh = new TGWin32RefreshTimer();
762 erret = ::GetMessage(&msg, NULL, NULL, NULL);
763 if (erret <= 0) endLoop = kTRUE;
764 endLoop = MessageProcessingFunc(&msg);
767 TGWin32::Instance()->CloseDisplay();
773 erret = ::GetLastError();
774 Error("MsgLoop", "Error in GetMessage");
786TGWin32MainThread::TGWin32MainThread()
788 fCritSec =
new CRITICAL_SECTION;
789 ::InitializeCriticalSection(fCritSec);
790 fMessageMutex =
new CRITICAL_SECTION;
791 ::InitializeCriticalSection(fMessageMutex);
851 if (!
gROOT->IsBatch() && !gMainThread) {
852 gMainThread =
new TGWin32MainThread();
870 while (it.
Next(key, value)) {
882#ifdef OLD_THREAD_IMPLEMENTATION
904 TGWin32MainThread *delThread = gMainThread;
934 if (gMainThread && gMainThread->fCritSec) ::EnterCriticalSection(gMainThread->fCritSec);
942 if (gMainThread && gMainThread->fCritSec) ::LeaveCriticalSection(gMainThread->fCritSec);
950 if (!gdk_initialized) {
951 if (!gdk_init_check(NULL, NULL))
return kFALSE;
952 gdk_initialized =
true;
955 if (!gClipboardAtom) {
956 gClipboardAtom = gdk_atom_intern(
"CLIPBOARD",
kFALSE);
967 GdkPixmap *pixmp1, *pixmp2;
973 if (!
Init((
void*)dpyName)) {
983 fore.red = fore.green = fore.blue = 0;
984 back.red = back.green = back.blue = 0;
985 color.red = color.green = color.blue = 0;
988 fVisual = gdk_visual_get_best();
990 fDepth = gdk_visual_get_best_depth();
999 for (i = 0; i <
kMAXGC; i++) {
1000 gGClist[i] = gdk_gc_new(GDK_ROOT_PARENT());
1013 gdk_gc_get_values(
gGCtext, &gcvals);
1014 gdk_gc_set_foreground(
gGCinvt, &gcvals.background);
1015 gdk_gc_set_background(
gGCinvt, &gcvals.foreground);
1019 gdk_color_black(
fColormap, &echov.foreground);
1020 gdk_color_white(
fColormap, &echov.background);
1021 echov.function = GDK_INVERT;
1022 echov.subwindow_mode = GDK_CLIP_BY_CHILDREN;
1024 gdk_gc_new_with_values((GdkWindow *) GDK_ROOT_PARENT(), &echov,
1025 (GdkGCValuesMask) (GDK_GC_FOREGROUND |
1030 pixmp1 = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
1033 pixmp2 = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
1036 gNullCursor = gdk_cursor_new_from_pixmap((GdkDrawable *)pixmp1, (GdkDrawable *)pixmp2,
1037 &fore, &back, 0, 0);
1086 if ( gdk_visual_get_best_type() == GDK_VISUAL_TRUE_COLOR) {
1092 if ((
fVisual->blue_mask >> i) == 1) {
1101 if ((
fVisual->green_mask >> i) == 1) {
1110 if ((
fVisual->red_mask >> i) == 1) {
1118 SetTitle(
"ROOT interface to Win32 with TrueType fonts");
1152 if ( gdk_color_alloc((GdkColormap *)cmap, (GdkColor *)color) )
return kTRUE;
1171 GdkColorContext *cc = gdk_color_context_new(gdk_visual_get_system(), cmap);
1172 gdk_color_context_query_colors(cc, color, ncolors);
1173 gdk_color_context_free(cc);
1175 for (
Int_t i = 0; i < ncolors; i++) {
1226 UChar_t d = 0, *s = source->buffer;
1230 static GdkColor col[5];
1231 GdkColor *bcol = 0, *bc;
1239 const Int_t maxdots = 50000;
1241 dots =
Int_t(source->width * source->rows);
1242 dots = dots > maxdots ? maxdots : dots;
1243 bcol =
new GdkColor[dots];
1248 for (
y = 0;
y < (
int) source->rows;
y++) {
1249 for (
x = 0;
x < (
int) source->width;
x++, bc++) {
1250 bc->pixel = GetPixelImage((
Drawable_t)xim, bx +
x, by +
y);
1251 if (++dotcnt >= maxdots)
break;
1258 for (
y = 0;
y < (
int) source->rows;
y++) {
1259 for (
x = 0;
x < (
int) source->width;
x++, bc++) {
1263 if (++dotcnt >= maxdots)
break;
1272 if (bc->red ==
r && bc->green ==
g && bc->blue ==
b) {
1286 if (fore != col[4].pixel || back != col[0].pixel) {
1287 col[4].pixel = fore;
1289 col[3].pixel = back;
1297 for (
x = 3;
x > 0;
x--) {
1298 col[
x].red = (col[4].red *
x + col[0].red *(4-
x)) /4;
1299 col[
x].green = (col[4].green*
x + col[0].green*(4-
x)) /4;
1300 col[
x].blue = (col[4].blue *
x + col[0].blue *(4-
x)) /4;
1302 Warning(
"DrawImage",
"cannot allocate smoothing color");
1303 col[
x].pixel = col[
x+1].pixel;
1310 for (
y = 0;
y < (
int) source->rows;
y++) {
1311 for (
x = 0;
x < (
int) source->width;
x++) {
1313 d = ((
d + 10) * 5) / 256;
1315 if (
d &&
x < (
int) source->width) {
1324 for (
int y = 0;
y < (
int) source->rows;
y++) {
1327 for (
int x = 0;
x < (
int) source->width;
x++) {
1328 if (
n == 0)
d = *s++;
1334 row += source->pitch;
1390 if (
y+
h > height)
h = height -
y;
1392 return gdk_image_get((GdkDrawable*)cws,
x,
y, w,
h);
1407 if ((
int)w == 0 || (
int)
h == 0)
return kFALSE;
1411 if (
y + (
int)h <= 0 || y >= (
int)height)
return kFALSE;
1439 GdkImage *xim = gdk_image_new(GDK_IMAGE_SHARED, gdk_visual_get_best(), w,
h);
1448 gdk_gc_get_values((GdkGC*)
GetGC(3), &gcvals);
1455 Error(
"DrawText",
"error getting background image");
1460 Int_t xo = 0, yo = 0;
1461 if (
x1 < 0) xo = -
x1;
1462 if (y1 < 0) yo = -y1;
1464 for (
int yp = 0; yp < (
int) bim->height; yp++) {
1465 for (
int xp = 0; xp < (
int) bim->width; xp++) {
1466 pixel = GetPixelImage((
Drawable_t)bim, xp, yp);
1471 gdk_image_unref((GdkImage *)bim);
1479 pixel = gcvals.background.pixel;
1481 pixel = GetPixelImage((
Drawable_t)bim, 0, 0);
1483 Int_t xo = 0, yo = 0;
1484 if (
x1 < 0) xo = -
x1;
1485 if (y1 < 0) yo = -y1;
1487 for (
int yp = 0; yp <
h; yp++) {
1488 for (
int xp = 0; xp < (
int) w; xp++) {
1493 gdk_image_unref((GdkImage *)bim);
1503 if (FT_Glyph_To_Bitmap(&glyph->
fImage,
1505 : ft_render_mode_mono,
1507 FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph->
fImage;
1508 FT_Bitmap* source = &bitmap->bitmap;
1511 bx = bitmap->left+Xoff;
1512 by =
h - bitmap->top-Yoff;
1513 DrawImage(source, gcvals.foreground.pixel, bg, xim, bx, by);
1518 gdk_draw_image((GdkDrawable *)cws,
GetGC(6), xim, 0, 0,
x1, y1, w,
h);
1520 gdk_image_unref(xim);
1563 if (!
gCws->ispixmap && !
gCws->double_buffer) {
1564 gdk_window_set_background(
gCws->drawing, (GdkColor *) &
GetColor(0).color);
1565 gdk_window_clear(
gCws->drawing);
1598 if (
gCws->ispixmap) {
1599 gdk_pixmap_unref(
gCws->window);
1601 gdk_window_destroy(
gCws->window,
kTRUE);
1605 gdk_pixmap_unref(
gCws->buffer);
1607 if (
gCws->new_colors) {
1608 gdk_colormap_free_colors((GdkColormap *)
fColormap,
1609 (GdkColor *)
gCws->new_colors,
gCws->ncolors);
1611 delete []
gCws->new_colors;
1612 gCws->new_colors = 0;
1638 gdk_window_copy_area(
gCws->drawing,
gGCpxmp, xpos, ypos,
gTws->drawing,
1690 int i, j, icol, ix, iy, w,
h, current_icol;
1702 for (i = 0; i < nx; i++) {
1704 for (j = 0; j < ny; j++) {
1705 icol = ic[i + (nx * j)];
1706 if (icol != current_icol) {
1708 current_icol = icol;
1726 static int lastn = 0;
1727 static GdkPoint *
xy = 0;
1735 delete [] (GdkPoint *)
xy;
1736 xy =
new GdkPoint[
n];
1739 for (i = 0; i <
n; i++) {
1740 xy[i].x = xyt[i].
fX;
1741 xy[i].y = xyt[i].
fY;
1772 dashes[i] = (gint8) 0;
1792 for (i = 0; i <
n; i++) {
1794 xy[i].fY = xyt[i].
fY;
1811 dashes[i] = (gint8) 0;
1818 for (i = 1; i <
n; i++) {
1819 int dx =
xy[i].fX -
xy[i - 1].fX;
1820 int dy =
xy[i].fY -
xy[i - 1].fY;
1822 if (dx < 0) dx = -dx;
1823 if (dy < 0) dy = -dy;
1843 static int lastn = 0;
1844 static GdkPoint *
xy = 0;
1852 delete [] (GdkPoint *)
xy;
1853 xy =
new GdkPoint[
n];
1857 for (i = 0; i <
n; i++) {
1858 xy[i].x = xyt[i].
fX;
1859 xy[i].y = xyt[i].
fY;
1868 for (
m = 0;
m <
n;
m++) {
1886 for (i = 0; i <
gMarker.n; i++) {
1895 for (i = 0; i <
gMarker.n; i++) {
1902 for (i = 0; i <
gMarker.n; i += 2) {
1952 if (which >=
kMAXGC || which < 0) {
1953 Error(
"GetGC",
"trying to get illegal GdkGC (which = %d)", which);
1972 return gTws->double_buffer;
1992 w = gdk_screen_width();
1993 h = gdk_screen_height();
1999 gdk_window_get_geometry((GdkDrawable *)
gTws->window, &
x, &
y,
2000 &
width, &height, &depth);
2002 gdk_window_get_deskrelative_origin((GdkDrawable *)
gTws->window, &
x, &
y);
2004 if (
width > 0 && height > 0) {
2006 gTws->height = height;
2026 nplanes = gdk_visual_get_best_depth();
2036 }
else if (index == 1) {
2080 if (!
gTws->open)
return;
2082 gdk_window_move((GdkDrawable *)
gTws->window,
x,
y);
2109 newsize *
sizeof(XWindow_t),
2118 depth =gdk_visual_get_best_depth();
2119 gCws->window = (GdkPixmap *) gdk_pixmap_new(GDK_ROOT_PARENT(),wval,hval,depth);
2120 gdk_drawable_get_size((GdkDrawable *)
gCws->window, &ww, &hh);
2122 for (i = 0; i <
kMAXGC; i++) {
2123 gdk_gc_set_clip_mask((GdkGC *)
gGClist[i], (GdkDrawable *)None);
2134 gCws->double_buffer = 0;
2138 gCws->height = hval;
2139 gCws->new_colors = 0;
2150 GdkWindowAttr attributes;
2151 unsigned long attr_mask = 0;
2154 int wval, hval, depth;
2156 GdkWindow *wind = (GdkWindow *) win;
2158 gdk_window_get_geometry(wind, &xval, &yval, &wval, &hval, &depth);
2176 newsize *
sizeof(XWindow_t),
2188 attributes.wclass = GDK_INPUT_OUTPUT;
2189 attributes.event_mask = 0L;
2190 attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
2191 GDK_PROPERTY_CHANGE_MASK;
2194 attributes.x = xval;
2196 attributes.x = -1.0 * xval;
2200 attributes.y = yval;
2202 attributes.y = -1.0 * yval;
2204 attributes.width = wval;
2205 attributes.height = hval;
2206 attributes.colormap = gdk_colormap_get_system();
2207 attributes.visual = gdk_window_get_visual(wind);
2208 attributes.override_redirect =
TRUE;
2210 if ((attributes.y > 0) && (attributes.x > 0)) {
2211 attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP |
2212 GDK_WA_WMCLASS | GDK_WA_NOREDIR;
2214 attr_mask = GDK_WA_COLORMAP | GDK_WA_WMCLASS | GDK_WA_NOREDIR;
2217 if (attributes.visual != NULL) {
2218 attr_mask |= GDK_WA_VISUAL;
2220 attributes.window_type = GDK_WINDOW_CHILD;
2221 gCws->window = gdk_window_new(wind, &attributes, attr_mask);
2222 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
gCws->window);
2223 ::ShowWindow(window, SW_SHOWNORMAL);
2224 ::ShowWindow(window, SW_RESTORE);
2225 ::BringWindowToTop(window);
2228 ::SetClassLong(window, GCL_HCURSOR,
2236 gCws->double_buffer = 0;
2240 gCws->height = hval;
2241 gCws->new_colors = 0;
2268 gdk_pixmap_unref((GdkPixmap *)pix);
2299 static int xloc = 0;
2300 static int yloc = 0;
2301 static int xlocp = 0;
2302 static int ylocp = 0;
2303 static GdkCursor *cursor = NULL;
2311 if (cursor == NULL) {
2313 gdk_window_set_cursor((GdkWindow *)
gCws->window, (GdkCursor *)
gNullCursor);
2317 cursor = gdk_syscursor_new((
ULong_t)IDC_CROSS);
2319 cursor = gdk_cursor_new((GdkCursorType)GDK_CROSSHAIR);
2320 gdk_window_set_cursor((GdkWindow *)
gCws->window, (GdkCursor *)cursor);
2330 while (button_press == 0) {
2331 event = gdk_event_get();
2344 radius = (
int)
TMath::Sqrt((
double)((xloc - xlocp) * (xloc - xlocp) +
2345 (yloc - ylocp) * (yloc - ylocp)));
2348 xlocp - radius, ylocp - radius,
2349 2 * radius, 2 * radius, 0, 23040);
2353 gdk_draw_line(
gCws->window,
gGCecho, xlocp, ylocp, xloc, yloc);
2366 xloc =
event->button.x;
2367 yloc =
event->button.y;
2369 switch (event->type) {
2371 case GDK_LEAVE_NOTIFY:
2374 event = gdk_event_get();
2376 if (event->type == GDK_ENTER_NOTIFY) {
2377 gdk_event_free(event);
2380 gdk_event_free(event);
2387 case GDK_BUTTON_PRESS:
2388 button_press =
event->button.button;
2389 xlocp =
event->button.x;
2390 ylocp =
event->button.y;
2391 gdk_cursor_unref(cursor);
2395 case GDK_BUTTON_RELEASE:
2397 button_press = 10 +
event->button.button;
2398 xlocp =
event->button.x;
2399 ylocp =
event->button.y;
2405 button_press =
event->key.keyval;
2406 xlocp =
event->button.x;
2407 ylocp =
event->button.y;
2411 case GDK_KEY_RELEASE:
2413 button_press = -1 * (
int)(event->key.keyval);
2414 xlocp =
event->button.x;
2415 ylocp =
event->button.y;
2423 xtmp =
event->button.x;
2424 ytmp =
event->button.y;
2426 gdk_event_free(event);
2429 if (button_press == 0) {
2440 return button_press;
2454 static GdkCursor *cursor = NULL;
2455 static int percent = 0;
2456 static GdkWindow *CurWnd;
2461 int len_text = strlen(
text);
2465 CurWnd = (GdkWindow *)
gCws->window;
2467 if (cursor == NULL) {
2469 cursor = gdk_syscursor_new((
ULong_t)IDC_HELP);
2471 cursor = gdk_cursor_new((GdkCursorType)GDK_QUESTION_ARROW);
2474 gdk_window_set_cursor(CurWnd, cursor);
2476 for (nt = len_text; nt > 0 &&
text[nt - 1] ==
' '; nt--);
2479 focuswindow = ::SetFocus((HWND)GDK_DRAWABLE_XID(CurWnd));
2494 event = gdk_event_get();
2497 ::SleepEx(10,
kTRUE);
2508 char *stmp =
new char[
pt+1];
2516 if (
pt < len_text) {
2524 if (event != NULL) {
2525 switch (event->type) {
2526 case GDK_BUTTON_PRESS:
2527 case GDK_ENTER_NOTIFY:
2528 focuswindow = ::SetFocus((HWND)GDK_DRAWABLE_XID(CurWnd));
2531 case GDK_LEAVE_NOTIFY:
2532 ::SetFocus(focuswindow);
2535 nbytes =
event->key.length;
2536 for (i = 0; i < nbytes; i++) {
2537 keybuf[i] =
event->key.string[i];
2539 keysym =
event->key.keyval;
2575 if (isascii(keybuf[0]) && isprint(keybuf[0])) {
2577 if (nt < len_text) {
2580 for (i = nt - 1; i >
pt; i--) {
2583 if (
pt < len_text) {
2588 switch (keybuf[0]) {
2595 for (i =
pt; i < nt; i++) {
2616 for (i =
pt; i < nt; i++) {
2636 for (i =
pt; i < nt; i++)
2666 gdk_event_free(event);
2670 ::SetFocus(focuswindow);
2675 gdk_cursor_unref(cursor);
2699 if (
gTws->width == w &&
gTws->height ==
h)
2702 gdk_window_resize((GdkWindow *)
gTws->window, w,
h);
2706 if (
gTws->width < w ||
gTws->height <
h) {
2707 gdk_pixmap_unref(
gTws->buffer);
2708 gTws->buffer = gdk_pixmap_new(GDK_ROOT_PARENT(),
2709 w,
h, gdk_visual_get_best_depth());
2711 for (i = 0; i <
kMAXGC; i++) {
2712 gdk_gc_set_clip_mask(
gGClist[i], None);
2746 if (
gTws->width >= wval - 1 &&
gTws->width <= wval + 1 &&
2747 gTws->height >= hval - 1 &&
gTws->height <= hval + 1)
2751 if (
gTws->width < wval ||
gTws->height < hval) {
2752 gdk_pixmap_unref((GdkPixmap *)
gTws->window);
2753 depth = gdk_visual_get_best_depth();
2754 gTws->window = gdk_pixmap_new(GDK_ROOT_PARENT(), wval, hval, depth);
2757 gdk_drawable_get_size(
gTws->window, &ww, &hh);
2759 for (i = 0; i <
kMAXGC; i++) {
2760 gdk_gc_set_clip_mask((GdkGC *)
gGClist[i], (GdkDrawable *)None);
2770 gTws->height = hval;
2780 int xval = 0, yval = 0;
2781 GdkWindow *win, *root = NULL;
2782 int wval = 0, hval = 0, depth = 0;
2788 win = (GdkWindow *)
gTws->window;
2789 gdk_window_get_geometry(win, &xval, &yval,
2790 &wval, &hval, &depth);
2793 if (
gTws->width == wval &&
gTws->height == hval) {
2797 gdk_window_resize((GdkWindow *)
gTws->window, wval, hval);
2800 if (
gTws->width < wval ||
gTws->height < hval) {
2801 gdk_pixmap_unref((GdkPixmap *)
gTws->buffer);
2802 depth = gdk_visual_get_best_depth();
2803 gTws->buffer = (GdkPixmap *) gdk_pixmap_new(GDK_ROOT_PARENT(),
2807 for (i = 0; i <
kMAXGC; i++) {
2808 gdk_gc_set_clip_mask((GdkGC *)
gGClist[i], (GdkDrawable *)None);
2820 gTws->height = hval;
2837 if (
gCws->clip && !
gCws->ispixmap && !
gCws->double_buffer) {
2838 rect.x =
gCws->xclip;
2839 rect.y =
gCws->yclip;
2840 rect.width =
gCws->wclip;
2841 rect.height =
gCws->hclip;
2843 for (i = 0; i <
kMAXGC; i++) {
2844 gdk_gc_set_clip_rectangle((GdkGC *)
gGClist[i], &rect);
2847 for (i = 0; i <
kMAXGC; i++) {
2848 gdk_gc_set_clip_mask((GdkGC *)
gGClist[i], (GdkDrawable *)None);
2860 if (chupx == 0 && chupy == 0) {
2862 }
else if (chupx == 0 && chupy == 1) {
2864 }
else if (chupx == -1 && chupy == 0) {
2866 }
else if (chupx == 0 && chupy == -1) {
2868 }
else if (chupx == 1 && chupy == 0) {
2874 180.) / 3.14159) - 90;
2892 for (
int i = 0; i <
kMAXGC; i++) {
2893 gdk_gc_set_clip_mask((GdkGC *)
gGClist[i], (GdkDrawable *)None);
2916 if (
gTws->clip && !
gTws->ispixmap && !
gTws->double_buffer) {
2917 rect.x =
gTws->xclip;
2918 rect.y =
gTws->yclip;
2919 rect.width =
gTws->wclip;
2920 rect.height =
gTws->hclip;
2922 for (
int i = 0; i <
kMAXGC; i++) {
2923 gdk_gc_set_clip_rectangle((GdkGC *)
gGClist[i], &rect);
2937 return col.
color.pixel;
2957 }
else if (!
fColormap && (ci < 0 || ci > 1)) {
2962 gdk_gc_get_values(gc, &gcvals);
2964 color.pixel = col.
color.pixel ^ gcvals.background.pixel;
2965 color.red = GetRValue(color.pixel);
2966 color.green = GetGValue(color.pixel);
2967 color.blue = GetBValue(color.pixel);
2968 gdk_gc_set_foreground(gc, &color);
2971 gdk_gc_set_foreground(gc, &col.
color);
2974 gdk_gc_get_values(gc, &gcvals);
2976 if (gcvals.foreground.pixel != gcvals.background.pixel) {
2977 gdk_gc_set_background(gc, &
GetColor(!ci).color);
2990 gdk_window_set_cursor((GdkWindow *)
gTws->window, (GdkCursor *)
fCursors[cursor]);
3000 static GdkWindow *lid = 0;
3001 static GdkCursor *lcur = 0;
3003 if ((lid == (GdkWindow *)
id) && (lcur==(GdkCursor *)curid))
return;
3004 lid = (GdkWindow *)
id;
3005 lcur = (GdkCursor *)curid;
3007 gdk_window_set_cursor((GdkWindow *)
id, (GdkCursor *)curid);
3037 if (!
gTws->open)
return;
3055 if (!
gTws->double_buffer)
return;
3056 gTws->double_buffer = 0;
3067 if (!
gTws->buffer) {
3068 gTws->buffer = gdk_pixmap_new(GDK_ROOT_PARENT(),
3070 gdk_visual_get_best_depth());
3076 for (
int i = 0; i <
kMAXGC; i++) {
3077 gdk_gc_set_clip_mask(
gGClist[i], None);
3079 gTws->double_buffer = 1;
3098 for (i = 0; i <
kMAXGC; i++) {
3099 gdk_gc_set_function(
gGClist[i], GDK_COPY);
3104 for (i = 0; i <
kMAXGC; i++) {
3105 gdk_gc_set_function(
gGClist[i], GDK_XOR);
3110 for (i = 0; i <
kMAXGC; i++) {
3111 gdk_gc_set_function(
gGClist[i], GDK_INVERT);
3168 static int current_fasi = 0;
3177 gdk_gc_set_fill(
gGCfill, GDK_SOLID);
3186 gdk_gc_set_fill(
gGCfill, GDK_STIPPLED);
3188 if (fasi != current_fasi) {
3193 int stn = (fasi >= 1 && fasi <=25) ? fasi : 2;
3195 for (
int i=0;i<32;++i)
3197 gFillPattern = gdk_bitmap_create_from_data(GDK_ROOT_PARENT(),
3198 (
const char *)&pattern, 16, 16);
3200 current_fasi = fasi;
3216 EnableWindow((HWND) GDK_DRAWABLE_XID(
gCws->window), inp);
3224 if ((cindex < 0) || (cindex==
fLineColor))
return;
3293 static Int_t dashed[2] = { 3, 3 };
3294 static Int_t dotted[2] = { 1, 2 };
3295 static Int_t dasheddotted[4] = { 3, 4, 1, 4 };
3311 for (
Int_t j = 0; j<nt; j++) {
3313 sscanf(((
TObjString*)tokens->
At(j))->GetName(),
"%d", &it);
3314 linestyle[j] = (
Int_t)(it/4);
3317 delete [] linestyle;
3388 for (
int i = 0; i <
gMarker.n; i++) {
3413 if (markerstyle == 1 || markerstyle == 6 || markerstyle == 7) {
3414 gdk_gc_set_line_attributes(
gGCmark, 0, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
3422 static GdkPoint shape[30];
3425 Int_t im =
Int_t(4 * MarkerSizeReduced + 0.5);
3427 if (markerstyle == 2) {
3438 }
else if (markerstyle == 3 || markerstyle == 31) {
3458 }
else if (markerstyle == 4 || markerstyle == 24) {
3461 }
else if (markerstyle == 5) {
3473 }
else if (markerstyle == 6) {
3484 }
else if (markerstyle == 7) {
3499 }
else if (markerstyle == 8 || markerstyle == 20) {
3502 }
else if (markerstyle == 21) {
3515 }
else if (markerstyle == 22) {
3526 }
else if (markerstyle == 23) {
3537 }
else if (markerstyle == 25) {
3550 }
else if (markerstyle == 26) {
3561 }
else if (markerstyle == 27) {
3563 Int_t imx =
Int_t(2.66 * MarkerSizeReduced + 0.5);
3575 }
else if (markerstyle == 28) {
3577 Int_t imx =
Int_t(1.33 * MarkerSizeReduced + 0.5);
3605 }
else if (markerstyle == 29) {
3607 Int_t im1 =
Int_t(0.66 * MarkerSizeReduced + 0.5);
3608 Int_t im2 =
Int_t(2.00 * MarkerSizeReduced + 0.5);
3609 Int_t im3 =
Int_t(2.66 * MarkerSizeReduced + 0.5);
3610 Int_t im4 =
Int_t(1.33 * MarkerSizeReduced + 0.5);
3634 }
else if (markerstyle == 30) {
3636 Int_t im1 =
Int_t(0.66 * MarkerSizeReduced + 0.5);
3637 Int_t im2 =
Int_t(2.00 * MarkerSizeReduced + 0.5);
3638 Int_t im3 =
Int_t(2.66 * MarkerSizeReduced + 0.5);
3639 Int_t im4 =
Int_t(1.33 * MarkerSizeReduced + 0.5);
3663 }
else if (markerstyle == 32) {
3665 shape[0].x = 0; shape[0].y = im;
3666 shape[1].x = im; shape[1].y = -im;
3667 shape[2].x = -im; shape[2].y = -im;
3668 shape[3].x = 0; shape[3].y = im;
3670 }
else if (markerstyle == 33) {
3672 Int_t imx =
Int_t(2.66*MarkerSizeReduced + 0.5);
3673 shape[0].x =-imx; shape[0].y = 0;
3674 shape[1].x = 0; shape[1].y = -im;
3675 shape[2].x = imx; shape[2].y = 0;
3676 shape[3].x = 0; shape[3].y = im;
3677 shape[4].x =-imx; shape[4].y = 0;
3679 }
else if (markerstyle == 34) {
3681 Int_t imx =
Int_t(1.33*MarkerSizeReduced + 0.5);
3682 shape[0].x = -im; shape[0].y =-imx;
3683 shape[1].x =-imx; shape[1].y =-imx;
3684 shape[2].x =-imx; shape[2].y = -im;
3685 shape[3].x = imx; shape[3].y = -im;
3686 shape[4].x = imx; shape[4].y =-imx;
3687 shape[5].x = im; shape[5].y =-imx;
3688 shape[6].x = im; shape[6].y = imx;
3689 shape[7].x = imx; shape[7].y = imx;
3690 shape[8].x = imx; shape[8].y = im;
3691 shape[9].x =-imx; shape[9].y = im;
3692 shape[10].x=-imx; shape[10].y= imx;
3693 shape[11].x= -im; shape[11].y= imx;
3694 shape[12].x= -im; shape[12].y=-imx;
3696 }
else if (markerstyle == 35) {
3698 shape[0].x = -im; shape[0].y = -im;
3699 shape[1].x = im; shape[1].y = -im;
3700 shape[2].x = im; shape[2].y = im;
3701 shape[3].x = -im; shape[3].y = im;
3702 shape[4].x = -im; shape[4].y = -im;
3703 shape[5].x = im; shape[5].y = im;
3704 shape[6].x = -im; shape[6].y = im;
3705 shape[7].x = im; shape[7].y = -im;
3707 }
else if (markerstyle == 36) {
3709 shape[0].x =-im; shape[0].y = 0;
3710 shape[1].x = 0; shape[1].y = -im;
3711 shape[2].x = im; shape[2].y = 0;
3712 shape[3].x = 0; shape[3].y = im;
3713 shape[4].x =-im; shape[4].y = 0;
3714 shape[5].x = im; shape[5].y = 0;
3715 shape[6].x = 0; shape[6].y = im;
3716 shape[7].x = 0; shape[7].y =-im;
3718 }
else if (markerstyle == 37) {
3720 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3721 shape[0].x = 0; shape[0].y = 0;
3722 shape[1].x =-im2; shape[1].y = im;
3723 shape[2].x = -im; shape[2].y = 0;
3724 shape[3].x = 0; shape[3].y = 0;
3725 shape[4].x =-im2; shape[4].y = -im;
3726 shape[5].x = im2; shape[5].y = -im;
3727 shape[6].x = 0; shape[6].y = 0;
3728 shape[7].x = im; shape[7].y = 0;
3729 shape[8].x = im2; shape[8].y = im;
3730 shape[9].x = 0; shape[9].y = 0;
3732 }
else if (markerstyle == 38) {
3734 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3735 shape[0].x = -im; shape[0].y = 0;
3736 shape[1].x = -im; shape[1].y =-im2;
3737 shape[2].x =-im2; shape[2].y =-im;
3738 shape[3].x = im2; shape[3].y = -im;
3739 shape[4].x = im; shape[4].y =-im2;
3740 shape[5].x = im; shape[5].y = im2;
3741 shape[6].x = im2; shape[6].y = im;
3742 shape[7].x =-im2; shape[7].y = im;
3743 shape[8].x = -im; shape[8].y = im2;
3744 shape[9].x = -im; shape[9].y = 0;
3745 shape[10].x = im; shape[10].y = 0;
3746 shape[11].x = 0; shape[11].y = 0;
3747 shape[12].x = 0; shape[12].y = -im;
3748 shape[13].x = 0; shape[13].y = im;
3749 shape[14].x = 0; shape[14].y = 0;
3751 }
else if (markerstyle == 39) {
3753 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3754 shape[0].x = 0; shape[0].y = 0;
3755 shape[1].x =-im2; shape[1].y = im;
3756 shape[2].x = -im; shape[2].y = 0;
3757 shape[3].x = 0; shape[3].y = 0;
3758 shape[4].x =-im2; shape[4].y = -im;
3759 shape[5].x = im2; shape[5].y = -im;
3760 shape[6].x = 0; shape[6].y = 0;
3761 shape[7].x = im; shape[7].y = 0;
3762 shape[8].x = im2; shape[8].y = im;
3764 }
else if (markerstyle == 40) {
3766 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3767 shape[0].x = 0; shape[0].y = 0;
3768 shape[1].x = im2; shape[1].y = im;
3769 shape[2].x = im; shape[2].y = im2;
3770 shape[3].x = 0; shape[3].y = 0;
3771 shape[4].x = im; shape[4].y = -im2;
3772 shape[5].x = im2; shape[5].y = -im;
3773 shape[6].x = 0; shape[6].y = 0;
3774 shape[7].x = -im2; shape[7].y = -im;
3775 shape[8].x = -im; shape[8].y = -im2;
3776 shape[9].x = 0; shape[9].y = 0;
3777 shape[10].x = -im; shape[10].y = im2;
3778 shape[11].x = -im2; shape[11].y = im;
3779 shape[12].x = 0; shape[12].y = 0;
3781 }
else if (markerstyle == 41) {
3783 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3784 shape[0].x = 0; shape[0].y = 0;
3785 shape[1].x = im2; shape[1].y = im;
3786 shape[2].x = im; shape[2].y = im2;
3787 shape[3].x = 0; shape[3].y = 0;
3788 shape[4].x = im; shape[4].y = -im2;
3789 shape[5].x = im2; shape[5].y = -im;
3790 shape[6].x = 0; shape[6].y = 0;
3791 shape[7].x = -im2; shape[7].y = -im;
3792 shape[8].x = -im; shape[8].y = -im2;
3793 shape[9].x = 0; shape[9].y = 0;
3794 shape[10].x = -im; shape[10].y = im2;
3795 shape[11].x = -im2; shape[11].y = im;
3796 shape[12].x = 0; shape[12].y = 0;
3798 }
else if (markerstyle == 42) {
3801 shape[0].x= 0; shape[0].y= im;
3802 shape[1].x= -imx; shape[1].y= imx;
3803 shape[2].x = -im; shape[2].y = 0;
3804 shape[3].x = -imx; shape[3].y = -imx;
3805 shape[4].x = 0; shape[4].y = -im;
3806 shape[5].x = imx; shape[5].y = -imx;
3807 shape[6].x = im; shape[6].y = 0;
3808 shape[7].x= imx; shape[7].y= imx;
3809 shape[8].x= 0; shape[8].y= im;
3811 }
else if (markerstyle == 43) {
3814 shape[0].x = 0; shape[0].y = im;
3815 shape[1].x = -imx; shape[1].y = imx;
3816 shape[2].x = -im; shape[2].y = 0;
3817 shape[3].x = -imx; shape[3].y = -imx;
3818 shape[4].x = 0; shape[4].y = -im;
3819 shape[5].x = imx; shape[5].y = -imx;
3820 shape[6].x = im; shape[6].y = 0;
3821 shape[7].x = imx; shape[7].y = imx;
3822 shape[8].x = 0; shape[8].y = im;
3824 }
else if (markerstyle == 44) {
3826 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3827 shape[0].x = 0; shape[0].y = 0;
3828 shape[1].x = im2; shape[1].y = im;
3829 shape[2].x = -im2; shape[2].y = im;
3830 shape[3].x = im2; shape[3].y = -im;
3831 shape[4].x = -im2; shape[4].y = -im;
3832 shape[5].x = 0; shape[5].y = 0;
3833 shape[6].x = im; shape[6].y = im2;
3834 shape[7].x = im; shape[7].y = -im2;
3835 shape[8].x = -im; shape[8].y = im2;
3836 shape[9].x = -im; shape[9].y = -im2;
3837 shape[10].x = 0; shape[10].y = 0;
3839 }
else if (markerstyle == 45) {
3841 Int_t im0 =
Int_t(0.4*MarkerSizeReduced + 0.5);
3842 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3843 shape[0].x = im0; shape[0].y = im0;
3844 shape[1].x = im2; shape[1].y = im;
3845 shape[2].x = -im2; shape[2].y = im;
3846 shape[3].x = -im0; shape[3].y = im0;
3847 shape[4].x = -im; shape[4].y = im2;
3848 shape[5].x = -im; shape[5].y = -im2;
3849 shape[6].x = -im0; shape[6].y = -im0;
3850 shape[7].x = -im2; shape[7].y = -im;
3851 shape[8].x = im2; shape[8].y = -im;
3852 shape[9].x = im0; shape[9].y = -im0;
3853 shape[10].x = im; shape[10].y = -im2;
3854 shape[11].x = im; shape[11].y = im2;
3855 shape[12].x = im0; shape[12].y = im0;
3857 }
else if (markerstyle == 46) {
3859 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3860 shape[0].x = 0; shape[0].y = im2;
3861 shape[1].x = -im2; shape[1].y = im;
3862 shape[2].x = -im; shape[2].y = im2;
3863 shape[3].x = -im2; shape[3].y = 0;
3864 shape[4].x = -im; shape[4].y = -im2;
3865 shape[5].x = -im2; shape[5].y = -im;
3866 shape[6].x = 0; shape[6].y = -im2;
3867 shape[7].x = im2; shape[7].y = -im;
3868 shape[8].x = im; shape[8].y = -im2;
3869 shape[9].x = im2; shape[9].y = 0;
3870 shape[10].x = im; shape[10].y = im2;
3871 shape[11].x = im2; shape[11].y = im;
3872 shape[12].x = 0; shape[12].y = im2;
3874 }
else if (markerstyle == 47) {
3876 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3877 shape[0].x = 0; shape[0].y = im2;
3878 shape[1].x = -im2; shape[1].y = im;
3879 shape[2].x = -im; shape[2].y = im2;
3880 shape[3].x = -im2; shape[3].y = 0;
3881 shape[4].x = -im; shape[4].y = -im2;
3882 shape[5].x = -im2; shape[5].y = -im;
3883 shape[6].x = 0; shape[6].y = -im2;
3884 shape[7].x = im2; shape[7].y = -im;
3885 shape[8].x = im; shape[8].y = -im2;
3886 shape[9].x = im2; shape[9].y = 0;
3887 shape[10].x = im; shape[10].y = im2;
3888 shape[11].x = im2; shape[11].y = im;
3889 shape[12].x = 0; shape[12].y = im2;
3891 }
else if (markerstyle == 48) {
3893 Int_t im2 =
Int_t(2.0*MarkerSizeReduced + 0.5);
3894 shape[0].x = 0; shape[0].y = im2*1.005;
3895 shape[1].x = -im2; shape[1].y = im;
3896 shape[2].x = -im; shape[2].y = im2;
3897 shape[3].x = -im2; shape[3].y = 0;
3898 shape[4].x = -im; shape[4].y = -im2;
3899 shape[5].x = -im2; shape[5].y = -im;
3900 shape[6].x = 0; shape[6].y = -im2;
3901 shape[7].x = im2; shape[7].y = -im;
3902 shape[8].x = im; shape[8].y = -im2;
3903 shape[9].x = im2; shape[9].y = 0;
3904 shape[10].x = im; shape[10].y = im2;
3905 shape[11].x = im2; shape[11].y = im;
3906 shape[12].x = 0; shape[12].y = im2*0.995;
3907 shape[13].x = im2*0.995; shape[13].y = 0;
3908 shape[14].x = 0; shape[14].y = -im2*0.995;
3909 shape[15].x = -im2*0.995; shape[15].y = 0;
3910 shape[16].x = 0; shape[16].y = im2*0.995;
3912 }
else if (markerstyle == 49) {
3914 Int_t imx =
Int_t(1.33*MarkerSizeReduced + 0.5);
3915 shape[0].x =-imx; shape[0].y =-imx*1.005;
3916 shape[1].x =-imx; shape[1].y = -im;
3917 shape[2].x = imx; shape[2].y = -im;
3918 shape[3].x = imx; shape[3].y =-imx;
3919 shape[4].x = im; shape[4].y =-imx;
3920 shape[5].x = im; shape[5].y = imx;
3921 shape[6].x = imx; shape[6].y = imx;
3922 shape[7].x = imx; shape[7].y = im;
3923 shape[8].x =-imx; shape[8].y = im;
3924 shape[9].x =-imx; shape[9].y = imx;
3925 shape[10].x = -im; shape[10].y = imx;
3926 shape[11].x = -im; shape[11].y =-imx;
3927 shape[12].x =-imx; shape[12].y =-imx*0.995;
3928 shape[13].x =-imx; shape[13].y = imx;
3929 shape[14].x = imx; shape[14].y = imx;
3930 shape[15].x = imx; shape[15].y =-imx;
3931 shape[16].x =-imx; shape[16].y =-imx*1.005;
3949 Int_t depth = gdk_visual_get_best_depth();
3951 if (depth <= 8)
return;
3952 if (percent == 0)
return;
3955 ULong_t *orgcolors = 0, *tmpc = 0;
3956 Int_t maxcolors = 0, ncolors, ntmpc = 0;
3959 if (
gCws->new_colors) {
3960 tmpc =
gCws->new_colors;
3961 ntmpc =
gCws->ncolors;
3964 GdkImage *image = gdk_image_get((GdkDrawable*)
gCws->drawing, 0, 0,
3972 CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
3976 gdk_image_unref(image);
3977 ::operator
delete(orgcolors);
3993 gdk_draw_image(
gCws->drawing,
gGCpxmp, (GdkImage *)image,
3994 0, 0, 0, 0,
gCws->width,
gCws->height);
3999 gdk_colors_free((GdkColormap *)
fColormap, tmpc, ntmpc, 0);
4002 gdk_image_unref(image);
4003 ::operator
delete(orgcolors);
4013 if (ncolors <= 0)
return;
4014 GdkColor *xcol =
new GdkColor[ncolors];
4017 for (i = 0; i < ncolors; i++) {
4018 xcol[i].pixel = orgcolors[i];
4019 xcol[i].red = xcol[i].green = xcol[i].blue = 0;
4022 GdkColorContext *cc;
4023 cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)
fColormap);
4024 gdk_color_context_query_colors(cc, xcol, ncolors);
4025 gdk_color_context_free(cc);
4030 for (i = 0; i < ncolors; i++) {
4031 val = xcol[i].red + add;
4036 val = xcol[i].green + add;
4041 val = xcol[i].blue + add;
4047 ret = gdk_color_alloc((GdkColormap *)
fColormap, &xcol[i]);
4051 "failed to allocate color %hd, %hd, %hd", xcol[i].red,
4052 xcol[i].green, xcol[i].blue);
4058 gCws->ncolors = ncolors;
4060 for (i = 0; i < ncolors; i++) {
4061 gCws->new_colors[i] = xcol[i].pixel;
4072 for (
int i = 0; i < ncolors; i++) {
4073 if (pixel == orgcolors[i])
return i;
4075 Error(
"FindColor",
"did not find color, should never happen!");
4093 xcol.pixel = RGB(xcol.red, xcol.green, xcol.blue);
4098 if (col.
color.red == xcol.red && col.
color.green == xcol.green &&
4099 col.
color.blue == xcol.blue)
4102 gdk_colormap_free_colors((GdkColormap *)
fColormap,
4103 (GdkColor *)&col, 1);
4109 col.
color.pixel = xcol.pixel;
4110 col.
color.red = xcol.red;
4111 col.
color.green = xcol.green;
4112 col.
color.blue = xcol.blue;
4125 if (talign==current)
return;
4128 Int_t txalh = talign / 10;
4129 Int_t txalv = talign % 10;
4184 static Int_t current = 0;
4186 if ((cindex < 0) || (
Int_t(cindex)==current))
return;
4191 gdk_gc_get_values(
gGCtext, &values);
4192 gdk_gc_set_foreground(
gGCinvt, &values.background);
4193 gdk_gc_set_background(
gGCinvt, &values.foreground);
4195 current =
Int_t(cindex);
4236 dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)
gCws->window);
4238 dw = (HWND) GDK_DRAWABLE_XID((GdkWindow *)
id);
4240 tmp.x = ix > 0 ? ix : cpt.x;
4241 tmp.y = iy > 0 ? iy : cpt.y;
4242 ClientToScreen(dw, &tmp);
4243 SetCursorPos(tmp.x, tmp.y);
4279 void (*get_scline) (
int,
int,
Byte_t *),
4283 int GIFinfo(
Byte_t * GIFarr,
int *Width,
int *Height,
int *Ncols);
4292 for (
int i = 0; i <
width; i++) {
4318 Int_t maxcolors = 0, ncolors;
4325 CollectImageColors(pixel, orgcolors, ncolors, maxcolors);
4330 GdkColor *xcol =
new GdkColor[ncolors];
4333 for (i = 0; i < ncolors; i++) {
4334 xcol[i].pixel = orgcolors[i];
4336 xcol[i].red = GetRValue(xcol[i].pixel);
4337 xcol[i].green = GetGValue(xcol[i].pixel);
4338 xcol[i].blue = GetBValue(xcol[i].pixel);
4341 GdkColorContext *cc;
4342 cc = gdk_color_context_new(gdk_visual_get_system(), (GdkColormap *)
fColormap);
4343 gdk_color_context_query_colors(cc, xcol, ncolors);
4344 gdk_color_context_free(cc);
4350 B =
new Int_t[ncolors];
4352 for (i = 0; i < ncolors; i++) {
4354 G[i] = xcol[i].green;
4355 B[i] = xcol[i].blue;
4370 ::operator
delete(orgcolors);
4378 Byte_t scline[2000],
r[256],
b[256],
g[256];
4380 Int_t ncol, maxcol, i;
4386 gGifImage = gdk_image_get((GdkDrawable*)
gCws->drawing, 0, 0,
4394 "can not create GIF of image containing more than 256 colors");
4402 for (i = 0; i < ncol; i++) {
4403 if (maxcol <
R[i]) maxcol =
R[i];
4404 if (maxcol <
G[i]) maxcol =
G[i];
4405 if (maxcol < B[i]) maxcol = B[i];
4411 for (i = 0; i < ncol; i++) {
4412 r[i] =
R[i] * 255 / maxcol;
4413 g[i] =
G[i] * 255 / maxcol;
4414 b[i] = B[i] * 255 / maxcol;
4426 Error(
"WriteGIF",
"cannot write file: %s",
name);
4443 const int MAX_SEGMENT = 20;
4444 int i,
n,
x,
y, xcur,
x1,
x2, y1, y2;
4445 unsigned char *jimg, *jbase, icol;
4447 GdkSegment lines[256][MAX_SEGMENT];
4451 id = (GdkDrawable*)wid;
4456 for (i = 0; i < 256; i++) nlines[i] = 0;
4459 y1 = y0 + ny -
ymax - 1;
4461 y2 = y0 + ny -
ymin - 1;
4462 jbase = image + (
ymin - 1) * nx +
xmin;
4464 for (
y = y2;
y >= y1;
y--) {
4467 for (jimg = jbase, icol = *jimg++,
x =
x1 + 1;
x <=
x2; jimg++,
x++) {
4468 if (icol != *jimg) {
4469 if (icol != itran) {
4471 lines[icol][
n].x1 = xcur;
4472 lines[icol][
n].y1 =
y;
4473 lines[icol][
n].x2 =
x - 1;
4474 lines[icol][
n].y2 =
y;
4475 if (nlines[icol] == MAX_SEGMENT) {
4478 (GdkSegment *) &lines[icol][0], MAX_SEGMENT);
4486 if (icol != itran) {
4488 lines[icol][
n].x1 = xcur;
4489 lines[icol][
n].y1 =
y;
4490 lines[icol][
n].x2 =
x - 1;
4491 lines[icol][
n].y2 =
y;
4492 if (nlines[icol] == MAX_SEGMENT) {
4495 (GdkSegment *)&lines[icol][0], MAX_SEGMENT);
4501 for (i = 0; i < 256; i++) {
4502 if (nlines[i] != 0) {
4505 (GdkSegment *)&lines[icol][0], nlines[i]);
4518 unsigned char *GIFarr, *PIXarr,
R[256],
G[256], B[256], *j1, *j2, icol;
4519 int i, j, k,
width, height, ncolor, irep, offset;
4523 fd = fopen(
file,
"r+b");
4525 Error(
"ReadGIF",
"unable to open GIF file");
4530 filesize =
Seek_t(ftell(fd));
4533 if (!(GIFarr = (
unsigned char *)
calloc(filesize + 256, 1))) {
4535 Error(
"ReadGIF",
"unable to allocate array for gif");
4539 if (fread(GIFarr, filesize, 1, fd) != 1) {
4541 Error(
"ReadGIF",
"GIF file read failed");
4552 if (!(PIXarr = (
unsigned char *)
calloc((
width * height), 1))) {
4553 Error(
"ReadGIF",
"unable to allocate array for image");
4565 for (i = 0; i < ncolor; i++) {
4575 for (i = 1; i <= height / 2; i++) {
4576 j1 = PIXarr + (i - 1) *
width;
4577 j2 = PIXarr + (height - i) *
width;
4578 for (k = 0; k <
width; k++) {
4586 PutImage(offset, -1, x0, y0,
width, height, 0, 0,
width-1, height-1, PIXarr, pic);
4588 if (pic)
return pic;
4601 gdk_window_show((GdkWindow *)
id);
4602 if ((GDK_DRAWABLE_TYPE((GdkWindow *)
id) != GDK_WINDOW_TEMP) &&
4604 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
4605 ::SetForegroundWindow(window);
4616 EnumChildWindows((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id),
4617 EnumChildProc, (LPARAM) NULL);
4627 HWND hwnd = ::GetForegroundWindow();
4628 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
4629 gdk_window_show((GdkWindow *)
id);
4630 if (GDK_DRAWABLE_TYPE((GdkWindow *)
id) != GDK_WINDOW_TEMP) {
4631 ::BringWindowToTop(window);
4632 if (GDK_DRAWABLE_TYPE((GdkWindow *)
id) != GDK_WINDOW_CHILD)
4633 ::SetForegroundWindow(window);
4639 HWND fore = ::GetForegroundWindow();
4640 ::GetWindowRect(fore, &r2);
4641 if (!::IntersectRect(&r3, &r2, &r1)) {
4654 gdk_window_hide((GdkWindow *)
id);
4666 gdk_window_hide((GdkWindow *)
id);
4667 gdk_window_destroy((GdkDrawable *)
id,
kTRUE);
4677 gdk_window_destroy((GdkDrawable *)
id,
kFALSE);
4687 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
4688 if (GDK_DRAWABLE_TYPE((GdkWindow *)
id) == GDK_WINDOW_TEMP) {
4689 ::SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0,
4690 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4693 ::BringWindowToTop(window);
4694 if (GDK_DRAWABLE_TYPE((GdkWindow *)
id) != GDK_WINDOW_CHILD)
4695 ::SetForegroundWindow(window);
4706 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
4707 ::SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0,
4708 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
4718 gdk_window_move((GdkDrawable *)
id,
x,
y);
4729 gdk_window_move_resize((GdkWindow *)
id,
x,
y, w,
h);
4742 gdk_window_resize((GdkWindow *)
id, w,
h);
4752 gdk_window_lower((GdkWindow *)
id);
4764 gdk_window_reparent((GdkWindow *)
id, (GdkWindow *)pid,
x,
y);
4776 back.red = GetRValue(color);
4777 back.green = GetGValue(color);
4778 back.blue = GetBValue(color);
4780 gdk_window_set_background((GdkWindow *)
id, &back);
4790 gdk_window_set_back_pixmap((GdkWindow *)
id, (GdkPixmap *) pxm, 0);
4802 GdkWindowAttr xattr;
4804 GdkColor background_color;
4809 xattr.window_type = GDK_WINDOW_CHILD;
4811 xattr.window_type = GDK_WINDOW_TOPLEVEL;
4814 xattr.window_type = GDK_WINDOW_DIALOG;
4817 xattr.window_type = GDK_WINDOW_TEMP;
4819 newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4823 xattr.wclass = GDK_INPUT_OUTPUT;
4824 xattr.event_mask = 0L;
4825 xattr.event_mask |= GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
4826 GDK_PROPERTY_CHANGE_MASK;
4838 xattr.colormap = gdk_colormap_get_system();
4839 xattr.cursor = NULL;
4840 xattr.override_redirect =
TRUE;
4841 if ((xattr.y > 0) && (xattr.x > 0)) {
4842 xmask = GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP |
4843 GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4845 xmask = GDK_WA_COLORMAP | GDK_WA_WMCLASS | GDK_WA_NOREDIR;
4847 if (visual != NULL) {
4848 xattr.visual = (GdkVisual *) visual;
4849 xmask |= GDK_WA_VISUAL;
4851 xattr.visual = gdk_visual_get_system();
4852 xmask |= GDK_WA_VISUAL;
4854 xattr.window_type = GDK_WINDOW_CHILD;
4856 xattr.window_type = GDK_WINDOW_TOPLEVEL;
4859 xattr.window_type = GDK_WINDOW_DIALOG;
4862 xattr.window_type = GDK_WINDOW_TEMP;
4864 newWin = gdk_window_new((GdkWindow *) parent, &xattr, xmask);
4865 gdk_window_set_events(newWin, (GdkEventMask) 0L);
4868 gdk_window_set_decorations(newWin,
4869 (GdkWMDecoration) GDK_DECOR_BORDER);
4874 gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 0);
4876 gdk_window_set_back_pixmap(newWin, (GdkPixmap *) GDK_NONE, 1);
4878 gdk_window_set_back_pixmap(newWin,
4879 (GdkPixmap *) attr->
4880 fBackgroundPixmap, 0);
4888 gdk_window_set_background(newWin, &background_color);
4892 ::SetClassLong((HWND)GDK_DRAWABLE_XID(newWin), GCL_HCURSOR,
4906 lxemask |= GDK_KEY_PRESS_MASK;
4909 lxemask |= GDK_KEY_RELEASE_MASK;
4912 lxemask |= GDK_BUTTON_PRESS_MASK;
4915 lxemask |= GDK_BUTTON_RELEASE_MASK;
4918 lxemask |= GDK_POINTER_MOTION_MASK;
4921 lxemask |= GDK_BUTTON_MOTION_MASK;
4924 lxemask |= GDK_EXPOSURE_MASK;
4927 lxemask |= GDK_STRUCTURE_MASK;
4930 lxemask |= GDK_ENTER_NOTIFY_MASK;
4933 lxemask |= GDK_LEAVE_NOTIFY_MASK;
4936 lxemask |= GDK_FOCUS_CHANGE_MASK;
4938 xemask = (
UInt_t) lxemask;
4941 if ((xemask & GDK_KEY_PRESS_MASK)) {
4944 if ((xemask & GDK_KEY_RELEASE_MASK)) {
4947 if ((xemask & GDK_BUTTON_PRESS_MASK)) {
4950 if ((xemask & GDK_BUTTON_RELEASE_MASK)) {
4953 if ((xemask & GDK_POINTER_MOTION_MASK)) {
4956 if ((xemask & GDK_BUTTON_MOTION_MASK)) {
4959 if ((xemask & GDK_EXPOSURE_MASK)) {
4962 if ((xemask & GDK_STRUCTURE_MASK)) {
4965 if ((xemask & GDK_ENTER_NOTIFY_MASK)) {
4968 if ((xemask & GDK_LEAVE_NOTIFY_MASK)) {
4971 if ((xemask & GDK_FOCUS_CHANGE_MASK)) {
4982 GdkWindowAttr & xattr)
4988 xmask |= GDK_WA_NOREDIR;
4994 xattr.event_mask = xmsk;
4997 xmask |= GDK_WA_COLORMAP;
4998 xattr.colormap = (GdkColormap *) attr->
fColormap;
5001 xmask |= GDK_WA_CURSOR;
5003 xattr.cursor = (GdkCursor *) attr->
fCursor;
5006 xattr.wclass = GDK_INPUT_OUTPUT;
5022 xmask |= GDK_GC_FUNCTION;
5025 xgval.function = GDK_CLEAR;
5028 xgval.function = GDK_AND;
5031 xgval.function = GDK_AND_REVERSE;
5034 xgval.function = GDK_COPY;
5037 xgval.function = GDK_AND_INVERT;
5040 xgval.function = GDK_NOOP;
5043 xgval.function = GDK_XOR;
5046 xgval.function = GDK_OR;
5049 xgval.function = GDK_EQUIV;
5052 xgval.function = GDK_INVERT;
5055 xgval.function = GDK_OR_REVERSE;
5058 xgval.function = GDK_COPY_INVERT;
5061 xgval.function = GDK_OR_INVERT;
5064 xgval.function = GDK_NAND;
5067 xgval.function = GDK_SET;
5072 xmask |= GDK_GC_SUBWINDOW;
5074 xgval.subwindow_mode = GDK_INCLUDE_INFERIORS;
5076 xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN;
5080 xmask |= GDK_GC_FOREGROUND;
5082 xgval.foreground.red = GetRValue(gval.
fForeground);
5083 xgval.foreground.green = GetGValue(gval.
fForeground);
5084 xgval.foreground.blue = GetBValue(gval.
fForeground);
5087 xmask |= GDK_GC_BACKGROUND;
5089 xgval.background.red = GetRValue(gval.
fBackground);
5090 xgval.background.green = GetGValue(gval.
fBackground);
5091 xgval.background.blue = GetBValue(gval.
fBackground);
5094 xmask |= GDK_GC_LINE_WIDTH;
5098 xmask |= GDK_GC_LINE_STYLE;
5099 xgval.line_style = (GdkLineStyle) gval.
fLineStyle;
5102 xmask |= GDK_GC_CAP_STYLE;
5103 xgval.cap_style = (GdkCapStyle) gval.
fCapStyle;
5106 xmask |= GDK_GC_JOIN_STYLE;
5107 xgval.join_style = (GdkJoinStyle) gval.
fJoinStyle;
5110 xmask |= GDK_GC_FILL;
5114 xmask |= GDK_GC_TILE;
5115 xgval.tile = (GdkPixmap *) gval.
fTile;
5118 xmask |= GDK_GC_STIPPLE;
5119 xgval.stipple = (GdkPixmap *) gval.
fStipple;
5122 xmask |= GDK_GC_TS_X_ORIGIN;
5126 xmask |= GDK_GC_TS_Y_ORIGIN;
5130 xmask |= GDK_GC_FONT;
5131 xgval.font = (GdkFont *) gval.
fFont;
5134 xmask |= GDK_GC_EXPOSURES;
5138 xmask |= GDK_GC_CLIP_X_ORIGIN;
5142 xmask |= GDK_GC_CLIP_Y_ORIGIN;
5146 xmask |= GDK_GC_CLIP_MASK;
5147 xgval.clip_mask = (GdkPixmap *) gval.
fClipMask;
5153 if ((xmask & GDK_GC_FUNCTION)) {
5156 switch (xgval.function) {
5163 case GDK_AND_REVERSE:
5169 case GDK_AND_INVERT:
5187 case GDK_OR_REVERSE:
5190 case GDK_COPY_INVERT:
5204 if (xmask & GDK_GC_SUBWINDOW) {
5206 if (xgval.subwindow_mode == GDK_INCLUDE_INFERIORS)
5211 if ((xmask & GDK_GC_FOREGROUND)) {
5215 if ((xmask & GDK_GC_BACKGROUND)) {
5219 if ((xmask & GDK_GC_LINE_WIDTH)) {
5223 if ((xmask & GDK_GC_LINE_STYLE)) {
5227 if ((xmask & GDK_GC_CAP_STYLE)) {
5231 if ((xmask & GDK_GC_JOIN_STYLE)) {
5235 if ((xmask & GDK_GC_FILL)) {
5239 if ((xmask & GDK_GC_TILE)) {
5243 if ((xmask & GDK_GC_STIPPLE)) {
5247 if ((xmask & GDK_GC_TS_X_ORIGIN)) {
5251 if ((xmask & GDK_GC_TS_Y_ORIGIN)) {
5255 if ((xmask & GDK_GC_FONT)) {
5259 if ((xmask & GDK_GC_EXPOSURES)) {
5263 if ((xmask & GDK_GC_CLIP_X_ORIGIN)) {
5267 if ((xmask & GDK_GC_CLIP_Y_ORIGIN)) {
5271 if ((xmask & GDK_GC_CLIP_MASK)) {
5286 RECT rcClient, rcWind;
5287 ::GetClientRect((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id), &rcClient);
5288 ::GetWindowRect((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id), &rcWind);
5290 gdk_window_get_geometry((GdkWindow *)
id, &attr.
fX, &attr.
fY,
5292 attr.
fX = ((rcWind.right - rcWind.left) - rcClient.right) / 2;
5293 attr.
fY = ((rcWind.bottom - rcWind.top) - rcClient.bottom) - attr.
fX;
5298 attr.
fVisual = gdk_window_get_visual((GdkWindow *)
id);
5305 if (!gdk_window_is_visible((GdkWindow *)
id)) {
5307 }
else if (!gdk_window_is_viewable((GdkWindow *)
id)) {
5313 UInt_t tmp_mask = (
UInt_t)gdk_window_get_events((GdkWindow *)
id);
5333 return gdk_visual_get_best_depth();
5343 GdkAtom
a = gdk_atom_intern((
const gchar *) atom_name, only_if_exist);
5345 if (
a == None)
return kNone;
5355 return (
Window_t) GDK_ROOT_PARENT();
5365 return (
Window_t)gdk_window_get_parent((GdkWindow *)
id);
5375 char family[100], weight[32], slant[32], fontname[256];
5376 Int_t n1, pixel, numfields;
5378 numfields = sscanf(font_name,
"%s -%d%n", family, &pixel, &n1);
5379 if (numfields == 2) {
5380 sprintf(weight,
"medium");
5381 if (strstr(font_name,
"bold"))
5382 sprintf(weight,
"bold");
5384 if (strstr(font_name,
"italic"))
5386 sprintf(fontname,
"-*-%s-%s-%s-*-*-%d-*-*-*-*-*-iso8859-1",
5387 family, weight, slant, pixel);
5390 sprintf(fontname,
"%s", font_name);
5400 return (
FontH_t)gdk_font_ref((GdkFont *) fs);
5410 gdk_font_unref((GdkFont *) fs);
5426 xgval.subwindow_mode = GDK_CLIP_BY_CHILDREN;
5428 GdkGC *gc = gdk_gc_new_with_values((GdkDrawable *)
id,
5429 &xgval, (GdkGCValuesMask)xmask);
5447 gdk_gc_set_foreground((GdkGC *) gc, &xgval.foreground);
5450 gdk_gc_set_background((GdkGC *) gc, &xgval.background);
5453 gdk_gc_set_font((GdkGC *) gc, xgval.font);
5456 gdk_gc_set_function((GdkGC *) gc, xgval.function);
5459 gdk_gc_set_fill((GdkGC *) gc, xgval.fill);
5462 gdk_gc_set_tile((GdkGC *) gc, xgval.tile);
5465 gdk_gc_set_stipple((GdkGC *) gc, xgval.stipple);
5468 gdk_gc_set_ts_origin((GdkGC *) gc, xgval.ts_x_origin,
5472 gdk_gc_set_clip_origin((GdkGC *) gc, xgval.clip_x_origin,
5473 xgval.clip_y_origin);
5476 gdk_gc_set_clip_mask((GdkGC *) gc, xgval.clip_mask);
5479 gdk_gc_set_exposures((GdkGC *) gc, xgval.graphics_exposures);
5482 gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_WIDTH);
5485 gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_LINE_STYLE);
5488 gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_CAP_STYLE);
5491 gdk_gc_set_values((GdkGC *) gc, &xgval, GDK_GC_JOIN_STYLE);
5494 gdk_gc_set_subwindow((GdkGC *) gc, xgval.subwindow_mode);
5516 gdk_gc_copy((GdkGC *)
dest, (GdkGC *)
org);
5524 gdk_gc_unref((GdkGC *) gc);
5541 GdkWindow *wid = (GdkWindow *)
id;
5542 if (!
id) wid = GDK_ROOT_PARENT();
5544 return (
Pixmap_t) gdk_pixmap_new(wid, w,
h, gdk_visual_get_best_depth());
5556 GdkColor fore, back;
5557 fore.pixel = forecolor;
5558 fore.red = GetRValue(forecolor);
5559 fore.green = GetGValue(forecolor);
5560 fore.blue = GetBValue(forecolor);
5562 back.pixel = backcolor;
5563 back.red = GetRValue(backcolor);
5564 back.green = GetGValue(backcolor);
5565 back.blue = GetBValue(backcolor);
5567 GdkWindow *wid = (GdkWindow *)
id;
5568 if (!
id) wid = GDK_ROOT_PARENT();
5570 return (
Pixmap_t) gdk_pixmap_create_from_data(wid, (
char *) bitmap,
width,
5571 height, depth, &fore, &back);
5580 GdkWindow *wid = (GdkWindow *)
id;
5581 if (!
id) wid = GDK_ROOT_PARENT();
5584 (
char *)bitmap,
width, height);
5593 gdk_pixmap_unref((GdkPixmap *) pmap);
5606 GdkBitmap *gdk_pixmap_mask;
5607 if (strstr(filename,
".xpm") || strstr(filename,
".XPM")) {
5608 GdkWindow *wid = (GdkWindow *)
id;
5609 if (!
id) wid = GDK_ROOT_PARENT();
5611 pict = (
Pixmap_t) gdk_pixmap_create_from_xpm(wid, &gdk_pixmap_mask, 0,
5613 pict_mask = (
Pixmap_t) gdk_pixmap_mask;
5614 }
else if (strstr(filename,
".gif") || strstr(filename,
".GIF")) {
5615 pict =
ReadGIF(0, 0, filename,
id);
5619 gdk_drawable_get_size((GdkPixmap *) pict, (
int *) &attr.
fWidth,
5640 GdkBitmap *gdk_pixmap_mask;
5641 GdkWindow *wid = (GdkWindow *)
id;
5642 if (!
id) wid = GDK_ROOT_PARENT();
5644 pict = (
Pixmap_t) gdk_pixmap_create_from_xpm_d(wid, &gdk_pixmap_mask, 0,
5646 pict_mask = (
Pixmap_t) gdk_pixmap_mask;
5664 GdkPixmap *pxm = gdk_pixmap_create_from_xpm(NULL, NULL, NULL, filename);
5667 if (pxm==NULL)
return kFALSE;
5669 HBITMAP hbm = (HBITMAP)GDK_DRAWABLE_XID(pxm);
5672 ret = ::GetObject(hbm,
sizeof(HBITMAP), (LPVOID)&bitmap);
5673 ret_data = (
char ***)&bitmap.bmBits;
5674 gdk_pixmap_unref(pxm);
5696 for (i = 0; i <
n; i++) {
5697 dashes[i] = (gint8) dash_list[i];
5699 for (i =
n; i < 32; i++) {
5700 dashes[i] = (gint8) 0;
5703 gdk_gc_set_dashes((GdkGC *) gc, offset, dashes,
n);
5711 xcolor.pixel = color->
fPixel;
5712 xcolor.red = color->
fRed;
5713 xcolor.green = color->
fGreen;
5714 xcolor.blue = color->
fBlue;
5729 if (gdk_color_parse((
char *)cname, &xc)) {
5730 color.
fPixel = xc.pixel = RGB(xc.red, xc.green, xc.blue);
5731 color.
fRed = xc.red;
5733 color.
fBlue = xc.blue;
5749 xc.red = color.
fRed;
5751 xc.blue = color.
fBlue;
5753 status = gdk_colormap_alloc_color((GdkColormap *) cmap, &xc,
FALSE,
TRUE);
5769 GdkColorContext *cc = gdk_color_context_new(gdk_visual_get_system(),
fColormap);
5770 gdk_color_context_query_color(cc, &xc);
5771 gdk_color_context_free(cc);
5774 color.
fRed = xc.red;
5776 color.
fBlue = xc.blue;
5802 tev.
fX = tev.
fY = 0;
5813 TGWin32MainThread::LockMSG();
5815 Bool_t r = gdk_check_typed_window_event((GdkWindow *)
id, xev.type, &xev);
5818 TGWin32MainThread::UnlockMSG();
5828 if (!ev || !
id)
return;
5830 TGWin32MainThread::LockMSG();
5833 gdk_event_put(&xev);
5834 TGWin32MainThread::UnlockMSG();
5844 TGWin32MainThread::LockMSG();
5845 ret = (
Int_t)gdk_event_queue_find_first();
5846 TGWin32MainThread::UnlockMSG();
5858 TGWin32MainThread::LockMSG();
5859 GdkEvent *xev = gdk_event_unqueue();
5864 TGWin32MainThread::UnlockMSG();
5868 gdk_event_free (xev);
5869 TGWin32MainThread::UnlockMSG();
5880 xstate = GDK_MODIFIER_MASK;
5891 switch (event.type) {
5892 case GDK_MOTION_NOTIFY:
5893 event.motion.time = time;
5894 case GDK_BUTTON_PRESS:
5895 case GDK_2BUTTON_PRESS:
5896 case GDK_3BUTTON_PRESS:
5897 case GDK_BUTTON_RELEASE:
5899 event.button.time = time;
5901 case GDK_KEY_RELEASE:
5902 event.key.time = time;
5903 case GDK_ENTER_NOTIFY:
5904 case GDK_LEAVE_NOTIFY:
5905 event.crossing.time = time;
5906 case GDK_PROPERTY_NOTIFY:
5907 event.property.time = time;
5908 case GDK_SELECTION_CLEAR:
5909 case GDK_SELECTION_REQUEST:
5910 case GDK_SELECTION_NOTIFY:
5911 event.selection.time = time;
5912 case GDK_PROXIMITY_IN:
5913 case GDK_PROXIMITY_OUT:
5914 event.proximity.time = time;
5915 case GDK_DRAG_ENTER:
5916 case GDK_DRAG_LEAVE:
5917 case GDK_DRAG_MOTION:
5918 case GDK_DRAG_STATUS:
5919 case GDK_DROP_START:
5920 case GDK_DROP_FINISHED:
5921 event.dnd.time = time;
5935 xev.type = GDK_NOTHING;
5937 xev.type = GDK_KEY_PRESS;
5939 xev.type = GDK_KEY_RELEASE;
5941 xev.type = GDK_BUTTON_PRESS;
5943 xev.type = GDK_BUTTON_RELEASE;
5945 xev.type = GDK_MOTION_NOTIFY;
5947 xev.type = GDK_ENTER_NOTIFY;
5949 xev.type = GDK_LEAVE_NOTIFY;
5951 xev.type = GDK_EXPOSE;
5953 xev.type = GDK_CONFIGURE;
5957 xev.type = GDK_UNMAP;
5959 xev.type = GDK_DESTROY;
5961 xev.type = GDK_CLIENT_EVENT;
5963 xev.type = GDK_SELECTION_CLEAR;
5965 xev.type = GDK_SELECTION_REQUEST;
5967 xev.type = GDK_SELECTION_NOTIFY;
5969 xev.any.type = xev.type;
5972 xev.any.window = (GdkWindow *) ev.
fWindow;
5975 xev.type = GDK_FOCUS_CHANGE;
5976 xev.focus_change.type = xev.type;
5977 xev.focus_change.window = (GdkWindow *) ev.
fWindow;
5978 xev.focus_change.in =
TRUE;
5981 xev.type = GDK_FOCUS_CHANGE;
5982 xev.focus_change.type = xev.type;
5983 xev.focus_change.window = (GdkWindow *) ev.
fWindow;
5984 xev.focus_change.in =
FALSE;
5987 xev.key.window = (GdkWindow *) ev.
fWindow;
5988 xev.key.type = xev.type;
5990 xev.key.keyval = ev.
fCode;
5993 xev.button.window = (GdkWindow *) ev.
fWindow;
5994 xev.button.type = xev.type;
5995 xev.button.x = ev.
fX;
5996 xev.button.y = ev.
fY;
5997 xev.button.x_root = ev.
fXRoot;
5998 xev.button.y_root = ev.
fYRoot;
6000 xev.button.button = ev.
fCode;
6003 xev.selection.window = (GdkWindow *) ev.
fUser[0];
6004 xev.selection.requestor = (guint32) ev.
fUser[0];
6005 xev.selection.selection = (GdkAtom) ev.
fUser[1];
6006 xev.selection.target = (GdkAtom) ev.
fUser[2];
6007 xev.selection.property = (GdkAtom) ev.
fUser[3];
6008 xev.selection.type = xev.type;
6012 xev.type = GDK_DELETE;
6013 xev.any.type = xev.type;
6014 xev.any.window = (GdkWindow *) ev.
fWindow;
6016 xev.client.window = (GdkWindow *) ev.
fWindow;
6017 xev.client.type = xev.type;
6018 xev.client.message_type = (GdkAtom) ev.
fHandle;
6019 xev.client.data_format = ev.
fFormat;
6020 xev.client.data.l[0] = ev.
fUser[0];
6021 if (
sizeof(ev.
fUser[0]) > 4) {
6023 xev.client.data.l[3]);
6025 xev.client.data.l[4]);
6027 xev.client.data.l[1] = ev.
fUser[1];
6028 xev.client.data.l[2] = ev.
fUser[2];
6029 xev.client.data.l[3] = ev.
fUser[3];
6030 xev.client.data.l[4] = ev.
fUser[4];
6035 xev.motion.window = (GdkWindow *) ev.
fWindow;
6036 xev.motion.type = xev.type;
6037 xev.motion.x = ev.
fX;
6038 xev.motion.y = ev.
fY;
6039 xev.motion.x_root = ev.
fXRoot;
6040 xev.motion.y_root = ev.
fYRoot;
6043 xev.crossing.window = (GdkWindow *) ev.
fWindow;
6044 xev.crossing.type = xev.type;
6045 xev.crossing.x = ev.
fX;
6046 xev.crossing.y = ev.
fY;
6047 xev.crossing.x_root = ev.
fXRoot;
6048 xev.crossing.y_root = ev.
fYRoot;
6049 xev.crossing.mode = (GdkCrossingMode) ev.
fCode;
6053 xev.expose.window = (GdkWindow *) ev.
fWindow;
6054 xev.expose.type = xev.type;
6055 xev.expose.area.x = ev.
fX;
6056 xev.expose.area.y = ev.
fY;
6057 xev.expose.area.width = ev.
fWidth;
6058 xev.expose.area.height = ev.
fHeight;
6059 xev.expose.count = ev.
fCount;
6062 xev.configure.window = (GdkWindow *) ev.
fWindow;
6063 xev.configure.type = xev.type;
6064 xev.configure.x = ev.
fX;
6065 xev.configure.y = ev.
fY;
6066 xev.configure.width = ev.
fWidth;
6067 xev.configure.height = ev.
fHeight;
6070 xev.selection.window = (GdkWindow *) ev.
fWindow;
6071 xev.selection.type = xev.type;
6072 xev.selection.selection = ev.
fUser[0];
6075 xev.selection.window = (GdkWindow *) ev.
fUser[0];
6076 xev.selection.type = xev.type;
6077 xev.selection.selection = ev.
fUser[1];
6078 xev.selection.target = ev.
fUser[2];
6079 xev.selection.property = ev.
fUser[3];
6082 xev.any.window = (GdkWindow *) ev.
fWindow;
6084 if (xev.type != GDK_CLIENT_EVENT)
6089 if (xev.type == GDK_KEY_PRESS)
6091 if (xev.type == GDK_KEY_RELEASE)
6093 if (xev.type == GDK_BUTTON_PRESS)
6095 if (xev.type == GDK_BUTTON_RELEASE)
6097 if (xev.type == GDK_MOTION_NOTIFY)
6099 if (xev.type == GDK_ENTER_NOTIFY)
6101 if (xev.type == GDK_LEAVE_NOTIFY)
6103 if (xev.type == GDK_EXPOSE)
6105 if (xev.type == GDK_CONFIGURE)
6107 if (xev.type == GDK_MAP)
6109 if (xev.type == GDK_UNMAP)
6111 if (xev.type == GDK_DESTROY)
6113 if (xev.type == GDK_SELECTION_CLEAR)
6115 if (xev.type == GDK_SELECTION_REQUEST)
6117 if (xev.type == GDK_SELECTION_NOTIFY)
6121 ev.
fTime = gdk_event_get_time((GdkEvent *)&xev);
6124 if ((xev.type == GDK_MAP) || (xev.type == GDK_UNMAP)) {
6127 if (xev.type == GDK_DELETE) {
6133 if (
sizeof(ev.
fUser[0]) > 4) {
6134 AsmLong(xev.client.data.l[1], xev.client.data.l[3],
6136 AsmLong(xev.client.data.l[2], xev.client.data.l[4],
6145 if (xev.type == GDK_DESTROY) {
6150 if (xev.type == GDK_FOCUS_CHANGE) {
6154 if (xev.focus_change.in ==
TRUE) {
6163 ev.
fCode = xev.key.keyval;
6164 ev.
fUser[1] = xev.key.length;
6165 if (xev.key.length > 0) ev.
fUser[2] = xev.key.string[0];
6166 if (xev.key.length > 1) ev.
fUser[3] = xev.key.string[1];
6167 if (xev.key.length > 2) ev.
fUser[4] = xev.key.string[2];
6168 HWND tmpwin = (HWND) GetWindow((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.key.window), GW_CHILD);
6170 ev.
fUser[0] = (
ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
6177 ev.
fX = xev.button.x;
6178 ev.
fY = xev.button.y;
6179 ev.
fXRoot = xev.button.x_root;
6180 ev.
fYRoot = xev.button.y_root;
6182 ev.
fCode = xev.button.button;
6184 tpoint.x = xev.button.x;
6185 tpoint.y = xev.button.y;
6186 HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.button.window), tpoint);
6188 ev.
fUser[0] = (
ULong_t) gdk_xid_table_lookup((HANDLE)tmpwin);
6195 ev.
fX = xev.motion.x;
6196 ev.
fY = xev.motion.y;
6197 ev.
fXRoot = xev.motion.x_root;
6198 ev.
fYRoot = xev.motion.y_root;
6202 tpoint.x = xev.button.x;
6203 tpoint.y = xev.button.y;
6204 HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.motion.window), tpoint);
6206 ev.
fUser[0] = (
ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
6213 ev.
fX = xev.crossing.x;
6214 ev.
fY = xev.crossing.y;
6215 ev.
fXRoot = xev.crossing.x_root;
6216 ev.
fYRoot = xev.crossing.y_root;
6217 ev.
fCode = xev.crossing.mode;
6222 ev.
fX = xev.expose.area.x;
6223 ev.
fY = xev.expose.area.y;
6224 ev.
fWidth = xev.expose.area.width;
6225 ev.
fHeight = xev.expose.area.height;
6226 ev.
fCount = xev.expose.count;
6230 ev.
fX = xev.configure.x;
6231 ev.
fY = xev.configure.y;
6232 ev.
fWidth = xev.configure.width;
6233 ev.
fHeight = xev.configure.height;
6235 if (xev.type == GDK_CLIENT_EVENT) {
6238 ev.
fHandle = xev.client.message_type;
6239 ev.
fFormat = xev.client.data_format;
6240 ev.
fUser[0] = xev.client.data.l[0];
6241 if (
sizeof(ev.
fUser[0]) > 4) {
6242 AsmLong(xev.client.data.l[1], xev.client.data.l[3],
6244 AsmLong(xev.client.data.l[2], xev.client.data.l[4],
6247 ev.
fUser[1] = xev.client.data.l[1];
6248 ev.
fUser[2] = xev.client.data.l[2];
6249 ev.
fUser[3] = xev.client.data.l[3];
6250 ev.
fUser[4] = xev.client.data.l[4];
6255 ev.
fUser[0] = xev.selection.selection;
6260 ev.
fUser[1] = xev.selection.selection;
6261 ev.
fUser[2] = xev.selection.target;
6262 ev.
fUser[3] = xev.selection.property;
6267 ev.
fUser[1] = xev.selection.selection;
6268 ev.
fUser[2] = xev.selection.target;
6269 ev.
fUser[3] = xev.selection.property;
6271 if (xev.type == GDK_SCROLL) {
6273 if (xev.scroll.direction == GDK_SCROLL_UP) {
6275 }
else if (xev.scroll.direction == GDK_SCROLL_DOWN) {
6279 ev.
fX = xev.scroll.x;
6280 ev.
fY = xev.scroll.y;
6281 ev.
fXRoot = xev.scroll.x_root;
6282 ev.
fYRoot = xev.scroll.y_root;
6284 tpoint.x = xev.scroll.x;
6285 tpoint.y = xev.scroll.y;
6286 HWND tmpwin = ChildWindowFromPoint((HWND) GDK_DRAWABLE_XID((GdkWindow *)xev.scroll.window), tpoint);
6288 ev.
fUser[0] = (
ULong_t)gdk_xid_table_lookup((HANDLE)tmpwin);
6313 if (!src || !
dest)
return;
6315 gdk_window_copy_area((GdkDrawable *)
dest, (GdkGC *) gc, dest_x, dest_y,
6316 (GdkDrawable *) src, src_x, src_y,
width, height);
6333 gdk_window_set_events((GdkWindow *)
id, (GdkEventMask) xevmask);
6340 gdk_window_set_background((GdkWindow *)
id, &color);
6345 gdk_window_set_back_pixmap((GdkWindow *)
id,
6349 gdk_window_set_cursor((GdkWindow *)
id, (GdkCursor *) attr->
fCursor);
6352 gdk_window_set_colormap((GdkWindow *)
id,(GdkColormap *) attr->
fColormap);
6356 gdk_window_set_decorations((GdkWindow *)
id,
6357 (GdkWMDecoration) GDK_DECOR_BORDER);
6372 gdk_property_change((GdkWindow *)
id, (GdkAtom) property,
6373 (GdkAtom)
type, 8, GDK_PROP_MODE_REPLACE, data,len);
6384 gdk_draw_line((GdkDrawable *)
id, (GdkGC *) gc,
x1, y1,
x2, y2);
6394 gdk_window_clear_area((GdkWindow *)
id,
x,
y, w,
h);
6405 prop = (
Atom_t) gdk_atom_intern(
"WM_DELETE_WINDOW",
FALSE);
6407 W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *)
id),
6408 prop,
XA_ATOM, 32, GDK_PROP_MODE_REPLACE,
6418 gdk_key_repeat_restore();
6420 gdk_key_repeat_disable();
6437 gdk_key_grab(keycode, (GdkEventMask)xmod, (GdkWindow *)
id);
6439 gdk_key_ungrab(keycode, (GdkEventMask)xmod, (GdkWindow *)
id);
6462 gdk_button_grab(button, xmod, ( GdkWindow *)
id, 1, (GdkEventMask)xevmask,
6463 (GdkWindow*)confine, (GdkCursor*)cursor);
6465 gdk_button_ungrab(button, xmod, ( GdkWindow *)
id);
6481 if(!::IsWindowVisible((HWND)GDK_DRAWABLE_XID(
id)))
return;
6482 gdk_pointer_grab((GdkWindow *)
id, owner_events, (GdkEventMask) xevmask,
6483 (GdkWindow *) confine, (GdkCursor *) cursor,
6486 gdk_pointer_ungrab(GDK_CURRENT_TIME);
6498 gdk_window_set_title((GdkWindow *)
id,
name);
6508 gdk_window_set_icon_name((GdkWindow *)
id,
name);
6518 gdk_window_set_icon((GdkWindow *)
id, NULL, (GdkPixmap *)pic, (GdkPixmap *)pic);
6521#define safestrlen(s) ((s) ? strlen(s) : 0)
6535 prop = gdk_atom_intern(
"WM_CLASS",
kFALSE);
6540 if ((class_string = s =
6541 (
char *)
malloc((
unsigned) (len_nm + len_cl + 2)))) {
6543 strcpy(s, resourceName);
6548 strcpy(s, className);
6553 W32ChangeProperty((HWND) GDK_DRAWABLE_XID((GdkWindow *)
id),
6555 GDK_PROP_MODE_REPLACE,
6556 (
unsigned char *) class_string,
6557 len_nm + len_cl + 2);
6570 gdk_window_set_decorations((GdkDrawable *)
id, (GdkWMDecoration) value);
6571 gdk_window_set_functions((GdkDrawable *)
id, (GdkWMFunction) funcs);
6581 gdk_window_move((GdkDrawable *)
id,
x,
y);
6591 gdk_window_resize((GdkWindow *)
id, w,
h);
6605 GdkWindowHints flags;
6607 flags = (GdkWindowHints) (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE |
6608 GDK_HINT_RESIZE_INC);
6609 hints.min_width = (
Int_t) wmin;
6610 hints.max_width = (
Int_t) wmax;
6611 hints.min_height = (
Int_t) hmin;
6612 hints.max_height = (
Int_t) hmax;
6613 hints.width_inc = (
Int_t) winc;
6614 hints.height_inc = (
Int_t) hinc;
6616 gdk_window_set_geometry_hints((GdkWindow *)
id, (GdkGeometry *) &hints,
6617 (GdkWindowHints) flags);
6629 Int_t xstate = NormalState;
6632 xstate = NormalState;
6634 xstate = IconicState;
6636 hints.flags = StateHint;
6637 hints.initial_state = xstate;
6639 XSetWMHints((GdkWindow *)
id, &hints);
6650 gdk_window_set_transient_for((GdkWindow *)
id, (GdkWindow *) main_id);
6657 const char *s,
Int_t len)
6662 gdk_gc_get_values((GdkGC *) gc, &values);
6664 (GdkGC *) gc,
x,
y, (
const gchar *)s, len);
6672 return gdk_text_width((GdkFont *)font, s, len);
6679 Int_t & max_descent)
6681 GdkFont *
f = (GdkFont *) font;
6682 max_ascent =
f->ascent;
6683 max_descent =
f->descent;
6696 gdk_gc_get_values((GdkGC *) gc, &xgval);
6714 gdk_font_unref((GdkFont *) fs);
6724 gdk_window_clear((GdkDrawable *)
id);
6784 gdk_window_set_events((GdkWindow *)
id, (GdkEventMask)xevmask);
6792 HWND hwnd = ::GetFocus();
6793 return (
Window_t) gdk_xid_table_lookup(hwnd);
6803 HWND hwnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
6813 return (
Window_t)gdk_selection_owner_get(gClipboardAtom);
6824 gdk_selection_owner_set((GdkWindow *)
id, gClipboardAtom, GDK_CURRENT_TIME, 0);
6842 gdk_selection_convert((GdkWindow *)
id, clipboard,
6843 gdk_atom_intern(
"GDK_TARGET_STRING", 0), when);
6855 _lookup_string(event, buf, buflen);
6858 keysym = (
Int_t) ks;
6868 xkeysym = GDK_VoidSymbol;
6874 for (
int i = 0;
gKeyMap[i].fKeySym; i++) {
6884 if (xkeysym < 127) {
6886 }
else if (xkeysym >= GDK_F1 && xkeysym <= GDK_F35) {
6887 keysym =
kKey_F1 + (xkeysym - GDK_F1);
6888 }
else if (xkeysym >= GDK_KP_0 && xkeysym <= GDK_KP_9) {
6889 keysym =
kKey_0 + (xkeysym - GDK_KP_0);
6891 for (
int i = 0;
gKeyMap[i].fXKeySym; i++) {
6892 if (xkeysym ==
gKeyMap[i].fXKeySym) {
6911 int nread, actual_format;
6913 nread = gdk_selection_property_get((GdkWindow *)
id,
6914 (
unsigned char **) &data,
6915 (GdkAtom *) & atom, &actual_format);
6917 if ((nread == 0) || (data == NULL)) {
6922 text.Insert(0, (
const char *) data);
6927 gdk_property_delete((GdkWindow *)
id,
6928 gdk_atom_intern(
"GDK_SELECTION",
FALSE));
6942 if (!src || !
dest)
return;
6944 HWND sw, dw, ch = NULL;
6946 sw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)src);
6947 dw = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
dest);
6950 ::MapWindowPoints(sw,
6954 ch = ::ChildWindowFromPointEx(dw, point, CWP_SKIPDISABLED | CWP_SKIPINVISIBLE);
6955 child = (
Window_t)gdk_xid_table_lookup(ch);
6974 if (GDK_DRAWABLE_TYPE(
id) == GDK_DRAWABLE_PIXMAP) {
6976 gdk_drawable_get_size((GdkDrawable *)
id, (
int*)&w, (
int*)&
h);
6979 gdk_window_get_geometry((GdkDrawable *)
id, &
x, &
y, (
int*)&w,
7021 window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)
id);
7022 rootw = (
Window_t)GDK_ROOT_PARENT();
7023 ::GetCursorPos(&currPt);
7024 chw = ::WindowFromPoint(currPt);
7025 childw = (
Window_t)gdk_xid_table_lookup(chw);
7029 ::ScreenToClient(window, &currPt);
7033 ::GetKeyboardState (kbd);
7035 if (kbd[VK_SHIFT] & 0x80) {
7036 umask |= GDK_SHIFT_MASK;
7038 if (kbd[VK_CAPITAL] & 0x80) {
7039 umask |= GDK_LOCK_MASK;
7041 if (kbd[VK_CONTROL] & 0x80) {
7042 umask |= GDK_CONTROL_MASK;
7044 if (kbd[VK_MENU] & 0x80) {
7045 umask |= GDK_MOD1_MASK;
7047 if (kbd[VK_LBUTTON] & 0x80) {
7048 umask |= GDK_BUTTON1_MASK;
7050 if (kbd[VK_MBUTTON] & 0x80) {
7051 umask |= GDK_BUTTON2_MASK;
7053 if (kbd[VK_RBUTTON] & 0x80) {
7054 umask |= GDK_BUTTON3_MASK;
7067 fore.pixel = foreground;
7068 fore.red = GetRValue(foreground);
7069 fore.green = GetGValue(foreground);
7070 fore.blue = GetBValue(foreground);
7071 gdk_gc_set_foreground((GdkGC *) gc, &fore);
7083 GdkRectangle *grects =
new GdkRectangle[
n];
7085 for (i = 0; i <
n; i++) {
7086 grects[i].x =
x+recs[i].
fX;
7087 grects[i].y =
y+recs[i].
fY;
7088 grects[i].width = recs[i].
fWidth;
7089 grects[i].height = recs[i].
fHeight;
7092 for (i = 0; i <
n; i++) {
7093 gdk_gc_set_clip_rectangle((GdkGC *)gc, (GdkRectangle*)recs);
7113 return (
Region_t) gdk_region_new();
7121 gdk_region_destroy((GdkRegion *) reg);
7134 dest = (
Region_t) gdk_region_union_with_rect((GdkRegion *) src, &
r);
7144 winding ? GDK_WINDING_RULE : GDK_EVEN_ODD_RULE);
7153 result = (
Region_t) gdk_regions_union((GdkRegion *) rega, (GdkRegion *) regb);
7163 result = (
Region_t) gdk_regions_intersect((GdkRegion *) rega,(GdkRegion *) regb);
7171 result = (
Region_t)gdk_regions_subtract((GdkRegion *) rega,(GdkRegion *) regb);
7180 result = (
Region_t) gdk_regions_xor((GdkRegion *) rega, (GdkRegion *) regb);
7188 return (
Bool_t) gdk_region_empty((GdkRegion *) reg);
7196 return (
Bool_t) gdk_region_point_in((GdkRegion *) reg,
x,
y);
7204 return (
Bool_t) gdk_region_equal((GdkRegion *) rega, (GdkRegion *) regb);
7213 gdk_region_get_clipbox((GdkRegion *) reg, &
r);
7225 char foundry[32], family[100], weight[32], slant[32], font_name[256];
7227 Int_t n1, fontcount = 0;
7229 sscanf(fontname,
"-%30[^-]-%100[^-]-%30[^-]-%30[^-]-%n",
7230 foundry, family, weight, slant, &n1);
7232 if(!stricmp(weight,
"medium")) {
7233 sprintf(weight,
"normal");
7236 sprintf(font_name,
"-%s-%s-%s-%s-*", foundry, family, weight, slant);
7237 fontlist = gdk_font_list_new(font_name, &fontcount);
7240 if (fontcount > 0)
return fontlist;
7249 gdk_font_list_free(fontlist);
7257 return (
Drawable_t) gdk_image_new(GDK_IMAGE_SHARED, gdk_visual_get_best(),
7266 width = ((GdkImage*)
id)->width;
7267 height = ((GdkImage*)
id)->height;
7277 GdkImage *image = (GdkImage *)
id;
7278 if (image->depth == 1) {
7280 ((
UChar_t *) image->mem)[
y * image->bpl + (
x >> 3)] |= (1 << (7 - (
x & 0x7)));
7282 ((
UChar_t *) image->mem)[
y * image->bpl + (
x >> 3)] &= ~(1 << (7 - (
x & 0x7)));
7285 UChar_t *pixelp = (
UChar_t *) image->mem +
y * image->bpl +
x * image->bpp;
7287 switch (image->bpp) {
7291 pixelp[2] = ((pixel >> 16) & 0xFF);
7293 pixelp[1] = ((pixel >> 8) & 0xFF);
7295 pixelp[0] = (pixel & 0xFF);
7308 gdk_draw_image((GdkDrawable *)
id, (GdkGC *)gc, (GdkImage *)img,
7309 x,
y, dx, dy, w,
h);
7318 gdk_image_unref((GdkImage *)img);
7336 HGDIOBJ oldbitmap1, oldbitmap2;
7340 unsigned char *ret = 0;
7342 if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7343 hdc = ::CreateCompatibleDC(NULL);
7344 oldbitmap1 = ::SelectObject(hdc, GDK_DRAWABLE_XID(wid));
7345 ::GetObject(GDK_DRAWABLE_XID(wid),
sizeof(BITMAP), &bm);
7347 hdc = ::GetDC((HWND)GDK_DRAWABLE_XID(wid));
7349 memdc = ::CreateCompatibleDC(hdc);
7351 bmi.bmiHeader.biSize =
sizeof(BITMAPINFOHEADER);
7352 bmi.bmiHeader.biWidth =
width;
7353 bmi.bmiHeader.biHeight = -1 * (
int)(height);
7354 bmi.bmiHeader.biPlanes = 1;
7355 bmi.bmiHeader.biBitCount = 32;
7356 bmi.bmiHeader.biCompression = BI_RGB;
7357 bmi.bmiHeader.biSizeImage = 0;
7358 bmi.bmiHeader.biXPelsPerMeter = bmi.bmiHeader.biYPelsPerMeter = 0;
7359 bmi.bmiHeader.biClrUsed = 0;
7360 bmi.bmiHeader.biClrImportant = 0;
7362 ximage = ::CreateDIBSection(hdc, (BITMAPINFO *) &bmi, DIB_RGB_COLORS, &bmbits, NULL, 0);
7364 if (ximage && bmbits) {
7365 oldbitmap2 = ::SelectObject(memdc, ximage);
7366 ::BitBlt(memdc,
x,
y,
width, height, hdc, 0, 0, SRCCOPY);
7367 ::SelectObject(memdc, oldbitmap2);
7370 if (GDK_DRAWABLE_TYPE(wid) == GDK_DRAWABLE_PIXMAP) {
7371 ::SelectObject(hdc, oldbitmap1);
7374 ::ReleaseDC((HWND)GDK_DRAWABLE_XID(wid), hdc);
7376 if (ximage && bmbits) {
7378 ret =
new unsigned char[sz];
7379 memcpy(ret, bmbits, sz);
7380 ::DeleteObject(ximage);
7394 BITMAPINFO bmp_info;
7395 bmp_info.bmiHeader.biSize =
sizeof(BITMAPINFOHEADER);
7396 bmp_info.bmiHeader.biWidth =
width;
7397 bmp_info.bmiHeader.biHeight = -1 * (
int)(height);
7398 bmp_info.bmiHeader.biPlanes = 1;
7399 bmp_info.bmiHeader.biBitCount = 32;
7400 bmp_info.bmiHeader.biCompression = BI_RGB;
7401 bmp_info.bmiHeader.biSizeImage = 0;
7402 bmp_info.bmiHeader.biClrUsed = 0;
7403 bmp_info.bmiHeader.biXPelsPerMeter = 0L;
7404 bmp_info.bmiHeader.biYPelsPerMeter = 0L;
7405 bmp_info.bmiHeader.biClrImportant = 0;
7406 bmp_info.bmiColors[0].rgbRed = 0;
7407 bmp_info.bmiColors[0].rgbGreen = 0;
7408 bmp_info.bmiColors[0].rgbBlue = 0;
7409 bmp_info.bmiColors[0].rgbReserved = 0;
7411 HDC hdc = ::GetDC(NULL);
7412 HBITMAP hbitmap = ::CreateDIBitmap(hdc, &bmp_info.bmiHeader, CBM_INIT,
7413 (
void *)bits, &bmp_info, DIB_RGB_COLORS);
7414 ::ReleaseDC(NULL, hdc);
7420 ::SetBitmapDimensionEx(hbitmap,
width, height, &size);
7422 return (
Pixmap_t)gdk_pixmap_foreign_new((guint32)hbitmap);
7430 HBITMAP hBmp =
reinterpret_cast<HBITMAP
>(pix);
7433 SetBitmapDimensionEx(hBmp, w,
h, &sz);
7434 GdkPixmap *newPix = gdk_pixmap_foreign_new(
reinterpret_cast<guint32
>(hBmp));
7455 gCws->window = newPix;
7458 gCws->double_buffer = 0;
7463 gCws->new_colors = 0;
7490 newsize *
sizeof(XWindow_t),
7502 gCws->window = gdk_window_foreign_new((guint32)qwid);
7506 gCws->double_buffer = 0;
7511 gCws->new_colors = 0;
7526 gdk_pixmap_unref(
gCws->buffer);
7528 if (
gCws->new_colors) {
7529 gdk_colormap_free_colors((GdkColormap *)
fColormap,
7530 (GdkColor *)
gCws->new_colors,
gCws->ncolors);
7532 delete []
gCws->new_colors;
7533 gCws->new_colors = 0;
7558 gdk_window_shape_combine_mask((GdkWindow *)
id, (GdkBitmap *) mask,
x,
y);
7566 return (
UInt_t)gdk_screen_width_mm();
7576 HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7577 Atom_t atom = (
Atom_t)GetProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7579 GlobalDeleteAtom(atom);
7581 RemoveProp(hWnd,(LPCTSTR)MAKELONG(prop,0));
7591 unsigned char **prop_list)
7597 HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7604 if (prop == dndproxy)
7606 if (prop == dndtypelist) {
7608 *prop_list = (
unsigned char *)GetProp(hWnd, (LPCTSTR)MAKELONG(prop,0));
7609 for (
n = 0; prop_list[
n];
n++);
7614 if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7617 hdata = GetClipboardData(CF_PRIVATEFIRST);
7618 ptr = (
UChar_t *)GlobalLock(hdata);
7619 length = GlobalSize(hdata);
7621 for (i = 0; i < length; i++) {
7624 GlobalUnlock(hdata);
7627 *bytes = *nitems = length;
7643 gdk_window_set_cursor((GdkWindow *) win, (GdkCursor *)cur);
7654 static UINT gdk_selection_notify_msg =
7655 RegisterWindowMessage(
"gdk-selection-notify");
7656 HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7657 if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)win))) {
7660 hdata = GetClipboardData(CF_PRIVATEFIRST);
7667 PostMessage(hWnd, gdk_selection_notify_msg, sel, target);
7675 static UINT gdk_selection_request_msg =
7676 RegisterWindowMessage(
"gdk-selection-request");
7677 HWND hWnd = (HWND)GDK_DRAWABLE_XID((GdkWindow *)owner);
7678 OpenClipboard(hWnd);
7682 ::PostMessage(hWnd, gdk_selection_request_msg, sel, 0);
7697 if (data == 0 || len == 0)
7699 if (!OpenClipboard((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id))) {
7702 hdata = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 1);
7703 ptr = (
UChar_t *)GlobalLock(hdata);
7704 for (i = 0; i < len; i++) {
7707 GlobalUnlock(hdata);
7708 SetClipboardData(CF_PRIVATEFIRST, hdata);
7717 SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)win),
7718 (LPCTSTR)MAKELONG(prop,0),
7728 int x,
int y,
int maxd)
7741 hwnd = ::ChildWindowFromPointEx((HWND)GDK_DRAWABLE_XID((GdkWindow *)root),
7744 GetWindowRect(hwnd, &rect);
7745 if (PtInRect(&rect, cpt)) {
7746 if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7747 win = (
Window_t) gdk_xid_table_lookup(hwnd);
7748 if (win && win != dragwin && win != input)
7755 ::MapWindowPoints(NULL, hwndt, &point, 1);
7756 hwndc = ChildWindowFromPoint (hwndt, point);
7757 if (GetProp(hwnd,(LPCTSTR)MAKELONG(dndaware,0))) {
7758 win = (
Window_t) gdk_xid_table_lookup(hwndc);
7759 if (win && win != dragwin && win != input)
7764 else if (hwndc == hwndt)
7768 if (GetProp(hwndt,(LPCTSTR)MAKELONG(dndaware,0))) {
7769 win = (
Window_t) gdk_xid_table_lookup(hwndt);
7770 if (win && win != dragwin && win != input)
7775 hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
7790 HWND window = (HWND)GDK_DRAWABLE_XID((GdkWindow *)win);
7792 version = (
Atom_t)GetProp(window,(LPCTSTR)MAKELONG(dndaware,0));
7793 if (version)
return kTRUE;
7808 DWORD dwStyle = GetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id),
7810 SetWindowLong((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id), GWL_EXSTYLE,
7811 dwStyle | WS_EX_ACCEPTFILES);
7813 SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id),
7814 (LPCTSTR)MAKELONG(dndaware,0),
7819 for (
n = 0; typelist[
n];
n++);
7821 SetProp((HWND)GDK_DRAWABLE_XID((GdkWindow *)
id),
7822 (LPCTSTR)MAKELONG(dndtypelist,0),
const Int_t kPropMotifWMHintsElements
static KeySymbolMap_t gKeyMap[]
const ULong_t kMWMHintsInputMode
const ULong_t kMWMHintsDecorations
const Int_t kPropMWMHintElements
const ULong_t kMWMHintsFunctions
void AsmLong(Long_t i1, Long_t i2, Long_t &ll)
void SplitLong(Long_t ll, Long_t &i1, Long_t &i2)
const Mask_t kWAOverrideRedirect
const Mask_t kGCBackground
const Mask_t kGCForeground
const Mask_t kGCLineStyle
const Mask_t kGCSubwindowMode
const Mask_t kGCLineWidth
Handle_t Cursor_t
Cursor handle.
const Mask_t kButtonMotionMask
const Mask_t kGCClipXOrigin
const Mask_t kFocusChangeMask
ULong_t Handle_t
Generic resource handle.
const Mask_t kButtonPressMask
Handle_t FontH_t
Font handle (as opposed to Font_t which is an index)
const Mask_t kExposureMask
const Mask_t kWAEventMask
const Mask_t kGCFillStyle
const Mask_t kGCJoinStyle
const Mask_t kKeyReleaseMask
const Mask_t kWABackPixel
Handle_t Display_t
Display handle.
const Mask_t kAnyModifier
@ kGXorReverse
src OR NOT dst
@ kGXnand
NOT src OR NOT dst.
@ kGXandReverse
src AND NOT dst
@ kGXorInverted
NOT src OR dst.
@ kGXandInverted
NOT src AND dst.
@ kGXequiv
NOT src XOR dst.
@ kGXcopyInverted
NOT src.
Handle_t Pixmap_t
Pixmap handle.
const Mask_t kKeyPressMask
ULong_t Time_t
Event time.
EInitialState
Initial window mapping state.
const Mask_t kGCTileStipXOrigin
Handle_t Drawable_t
Drawable handle.
const Mask_t kPointerMotionMask
Handle_t Colormap_t
Colormap handle.
const Mask_t kLeaveWindowMask
const Mask_t kStructureNotifyMask
const Handle_t kParentRelative
Handle_t GContext_t
Graphics context handle.
UInt_t Mask_t
Structure mask type.
const Mask_t kButtonReleaseMask
const Mask_t kGCGraphicsExposures
const Mask_t kGCClipYOrigin
Handle_t Region_t
Region handle.
const Mask_t kEnterWindowMask
Handle_t FontStruct_t
Pointer to font structure.
const Mask_t kGCTileStipYOrigin
EMouseButton
Button names.
Handle_t Window_t
Window handle.
const Mask_t kWABackPixmap
const Mask_t kWABorderWidth
#define R(a, b, c, d, e, f, g, h, i)
const unsigned char gStipples[26][32]
static const double x2[5]
static const double x1[5]
const ULong_t kBitsPerByte
R__EXTERN TApplication * gApplication
include TDocParser_001 C image html pict1_TDocParser_001 png width
void gdk_win32_draw_segments(GdkDrawable *drawable, GdkGC *gc, GdkSegment *segs, gint nsegs)
int GIFdecode(Byte_t *GIFarr, Byte_t *PIXarr, int *Width, int *Height, int *Ncols, Byte_t *R, Byte_t *G, Byte_t *B)
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)
#define XDND_PROTOCOL_VERSION
int GIFinfo(Byte_t *GIFarr, int *Width, int *Height, int *Ncols)
static void GetPixel(int y, int width, Byte_t *scline)
Get pixels in line y and put in array scline.
static void _set_event_time(GdkEvent &event, UInt_t time)
void gdk_win32_draw_text(GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, const gchar *text, gint text_length)
void gdk_win32_draw_polygon(GdkDrawable *drawable, GdkGC *gc, gint filled, GdkPoint *points, gint npoints)
void gdk_win32_draw_lines(GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints)
void gdk_win32_draw_points(GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints)
static GdkImage * gGifImage
static void PutByte(Byte_t b)
Put byte b in output stream.
void gdk_win32_draw_arc(GdkDrawable *drawable, GdkGC *gc, gint filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2)
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))
void gdk_win32_draw_rectangle(GdkDrawable *drawable, GdkGC *gc, gint filled, gint x, gint y, gint width, gint height)
static int gMarkerJoinStyle
static int gMarkerLineStyle
static ULong_t gKeybdMask
static Pixmap gFillPattern
static struct @56 gMarker
static Cursor gNullCursor
const char null_cursor_bits[]
static char gDashList[10]
const Int_t kBIGGEST_RGB_VALUE
static ULong_t gMouseMask
static GC gGClist[kMAXGC]
static int gMarkerLineWidth
static int gMarkerCapStyle
static XFontStruct * gTextFont
R__EXTERN TStyle * gStyle
R__EXTERN TSystem * gSystem
R__EXTERN TVirtualX *(* gPtr2VirtualX)()
R__EXTERN Atom_t gWM_DELETE_WINDOW
R__EXTERN TWin32SplashThread * gSplash
R__EXTERN ULong_t gConsoleWindow
virtual Color_t GetFillColor() const
Return the fill area color.
Style_t fFillStyle
Fill area style.
Color_t fFillColor
Fill area color.
Width_t fLineWidth
Line width.
Style_t fLineStyle
Line style.
Color_t fLineColor
Line color.
Color_t fMarkerColor
Marker color.
static Width_t GetMarkerLineWidth(Style_t style)
Internal helper function that returns the line width of the given marker style (0 = filled marker)
Size_t fMarkerSize
Marker size.
Style_t fMarkerStyle
Marker style.
static Style_t GetMarkerStyleBase(Style_t style)
Internal helper function that returns the corresponding marker style with line width 1 for the given ...
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Float_t fTextAngle
Text angle.
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Font_t fTextFont
Text font.
Float_t fTextSize
Text size.
The color creation and management class.
static Int_t GetColor(const char *hexcolor)
Static method returning color number for color specified by hex color string of form: "#rrggbb",...
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Bool_t Next(ULong64_t &hash, Long64_t &key, Long64_t &value)
Get next entry from TExMap. Returns kFALSE at end of map.
This class stores a (key,value) pair using an external hash.
void Add(ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table. The key should be unique.
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Proxy classes provide thread-safe interface to global objects.
static ULong_t fgPingMessageId
ping message ID
static void GlobalUnlock()
unlock any proxy (client thread)
static UInt_t fMaxResponseTime
max period for waiting response from server thread
static void GlobalLock()
lock any proxy (client thread)
static ULong_t fgUserThreadId
user (e.g. python) thread ID
static ULong_t fgPostMessageId
post message ID
static ULong_t fgMainThreadId
main thread ID
virtual void ExecuteCallBack(Bool_t sync)
Executes all batched callbacks and the latest callback This method is executed by server thread.
static TVirtualX * fgRealObject
static TVirtualX * ProxyObject()
static TVirtualX * RealObject()
This class is the basic interface to the Win32 graphics system.
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).
void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectangle_t *recs, Int_t n)
Set clipping rectangles in graphics context.
void MapWindow(Window_t id)
Map window on screen.
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.
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.
void MapModifierState(UInt_t &state, UInt_t &xstate, Bool_t tox=kTRUE)
Map modifier key state to or from X.
void CloseWindow1()
Delete current window.
void SetClassHints(Window_t id, char *className, char *resourceName)
Set the windows class and resource name.
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...
void DestroyWindow(Window_t id)
Destroy window.
void IntersectRegion(Region_t rega, Region_t regb, Region_t result)
Compute the intersection of rega and regb and return result region.
void SetIconPixmap(Window_t id, Pixmap_t pic)
Set pixmap the WM can use when the window is iconized.
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.
void SetMarkerSize(Float_t markersize)
Set marker size index.
void MapSetWindowAttributes(SetWindowAttributes_t *attr, ULong_t &xmask, GdkWindowAttr &xattr)
Map a SetWindowAttributes_t to a GdkWindowAttr structure.
void SetClipOFF(Int_t wid)
Turn off the clipping for the window wid.
void SetClipRegion(Int_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h)
Set clipping region for the window wid.
void SetCharacterUp(Float_t chupx, Float_t chupy)
Set character up vector.
void DrawFillArea(Int_t n, TPoint *xy)
Fill area described by polygon.
void SendEvent(Window_t id, Event_t *ev)
Send event ev to window id.
void QueryColor(Colormap_t cmap, ColorStruct_t &color)
Fill in the primary color components for a specific pixel value.
void GetPasteBuffer(Window_t id, Atom_t atom, TString &text, Int_t &nchar, Bool_t del)
Get contents of paste buffer atom into string.
void SetInputFocus(Window_t id)
Set keyboard input focus to window id.
void SubtractRegion(Region_t rega, Region_t regb, Region_t result)
Subtract rega from regb.
void SetForeground(GContext_t gc, ULong_t foreground)
Set foreground color in graphics context (shortcut for ChangeGC with only foreground mask set).
void MoveWindow(Int_t wid, Int_t x, Int_t y)
Move the window wid.
Int_t EventsPending()
Returns number of pending events.
const char * DisplayName(const char *dpyName=0)
Return hostname on which the display is opened.
Int_t TextWidth(FontStruct_t font, const char *s, Int_t len)
Return length of string in pixels. Size depends on font.
void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMode mode)
Draw a box.
void UnmapWindow(Window_t id)
Unmap window from screen.
void ClearWindow()
Clear current window.
void SetTextFont(Font_t fontnumber)
Set specified font.
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.
Float_t fCharacterUpY
Character Up vector along Y.
Bool_t EqualRegion(Region_t rega, Region_t regb)
Returns true if two regions are equal.
void FillPolygon(Window_t id, GContext_t gc, Point_t *points, Int_t npnt)
FillPolygon fills the region closed by the specified path.
void UnionRegion(Region_t rega, Region_t regb, Region_t result)
Compute the union of rega and regb and return result region.
Bool_t SetSelectionOwner(Window_t, Atom_t &)
Assigns owner of Clipboard.
void ChangeGC(GContext_t gc, GCValues_t *gval)
Change entries in an existing graphics context, gc, by values from gval.
void SetWMSize(Window_t id, UInt_t w, UInt_t h)
Tells window manager the desired size of window "id".
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.
void RenderString(Int_t x, Int_t y, ETextMode mode)
Perform the string rendering in the pad.
Int_t fDepth
Number of color planes.
void SetWMTransientHint(Window_t id, Window_t main_id)
Tell window manager that window is a transient window of gdk_parent_root.
void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b)
Set color intensities for given color index.
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.
Float_t fTextMagnitude
Text Magnitude.
void GetFontProperties(FontStruct_t font, Int_t &max_ascent, Int_t &max_descent)
Return some font properties.
void SetLineType(Int_t n, Int_t *dash)
Set line type.
void DestroySubwindows(Window_t id)
Destroy all internal subwindows.
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.
void NextEvent(Event_t &event)
Copies first pending event from event queue to Event_t structure and removes event from queue.
void SetOpacity(Int_t percent)
Set opacity of a window.
void Align(void)
Compute alignment variables.
GdkImage * GetBackground(Int_t x, Int_t y, UInt_t w, UInt_t h)
Get the background of the current window in an XImage.
Region_t CreateRegion()
Create a new empty region.
void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2)
Draw a line.
Pixmap_t CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height)
create an image from RGB data.
Atom_t InternAtom(const char *atom_name, Bool_t only_if_exist)
Return atom handle for atom_name.
Bool_t fMarkerStyleModified
void DeleteProperty(Window_t, Atom_t &)
Deletes the specified property on the specified window.
TGWin32()
Default constructor.
void ResizeWindow(Int_t wid)
Resize the current window if necessary.
Int_t ResizePixmap(Int_t wid, UInt_t w, UInt_t h)
Resize a pixmap.
void IconifyWindow(Window_t id)
Iconify the window.
void SetColor(GdkGC *gc, Int_t ci)
Set the foreground color in GdkGC.
void SetWMPosition(Window_t id, Int_t x, Int_t y)
Tells the window manager the desired position [x,y] of window "id".
GdkColormap * fColormap
Default colormap, 0 if b/w.
void GetPlanes(Int_t &nplanes)
Get maximum number of planes.
Int_t InitWindow(ULong_t window)
Open window and return window number.
Region_t PolygonRegion(Point_t *points, Int_t np, Bool_t winding)
Create region for the polygon defined by the points array.
Bool_t fFillStyleModified
void CloseWindow()
Delete current window.
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).
void RaiseWindow(Window_t id)
Put window on top of window stack.
void SetUserThreadId(ULong_t id)
Set user thread id.
Int_t fBlueDiv
Blue value divider.
void FreeFontStruct(FontStruct_t fs)
Free font structure returned by GetFontStruct().
void DeleteGC(GContext_t gc)
Explicitely delete a graphics context.
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.
void SetWindowBackgroundPixmap(Window_t id, Pixmap_t pxm)
Set pixmap as window background.
Bool_t CheckEvent(Window_t id, EGEventType type, Event_t &ev)
Check if there is for window "id" an event of type "type".
Int_t fGreenShift
Bits to left shift green.
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.
void SetTextSize(Float_t textsize)
Set current text size.
void SetTypeList(Window_t win, Atom_t prop, Atom_t *typelist)
Add the list of drag and drop types to the Window win.
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.
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.
virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess)
Return the size of a character string.
Window_t GetDefaultRootWindow() const
Return handle to the default root window created when calling XOpenDisplay().
void SetDoubleBufferOFF()
Turn double buffer mode off.
Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h)
Register a window created by Qt as a ROOT window (like InitWindow()).
void SetLineStyle(Style_t linestyle)
Set line style.
Int_t GetDoubleBuffer(Int_t wid)
Query the double buffer value for the window wid.
void CloseDisplay()
close display (terminate server/gMainThread thread)
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.
void MapEventMask(UInt_t &emask, UInt_t &xemask, Bool_t tox=kTRUE)
Map event mask to or from gdk.
Float_t fCharacterUpX
Character Up vector along X.
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.
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,...
void CopyGC(GContext_t org, GContext_t dest, Mask_t mask)
Copies graphics context from org to dest.
void MapRaised(Window_t id)
Map window on screen and put on top of all windows.
void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos)
Copy the pixmap wid at the position xpos, ypos in the current window.
Bool_t fPenModified
line syle || width modified
void DeletePixmap(Pixmap_t pmap)
Explicitely delete pixmap resource.
void SelectWindow(Int_t wid)
Select window to which subsequent output is directed.
void QueryPointer(Int_t &ix, Int_t &iy)
Query pointer position.
void SetFillColor(Color_t cindex)
Set color index for fill areas.
void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text, ETextMode mode)
Draw text using TrueType fonts.
Bool_t fHasTTFonts
True when TrueType fonts are used.
void DeleteFont(FontStruct_t fs)
Explicitely delete font structure obtained with LoadQueryFont().
void MapEvent(Event_t &ev, GdkEvent &xev, Bool_t tox=kTRUE)
Map Event_t structure to gdk_event structure.
void DrawPolyMarker(Int_t n, TPoint *xy)
Draw n markers with the current attributes at position x, y.
void DrawPolyLine(Int_t n, TPoint *xy)
Draw a line through all points.
void UpdateLineStyle()
Update line style.
void SelectInput(Window_t id, UInt_t evmask)
Defines which input events the window is interested in.
Int_t fRedShift
Bits to left shift red, -1 if no TrueColor visual.
Bool_t IsVisible(Int_t x, Int_t y, UInt_t w, UInt_t h)
Test if there is really something to render.
void DestroyRegion(Region_t reg)
Destroy region.
Int_t FindColor(ULong_t pixel, ULong_t *orgcolors, Int_t ncolors)
Returns index in orgcolors (and new_colors) for pixel.
void UpdateFillStyle()
Set fill area style index.
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.
void SetDoubleBuffer(Int_t wid, Int_t mode)
Set the double buffer on/off on window wid.
void UpdateWindow(Int_t mode)
Update display.
void LowerWindow(Window_t id)
Lower window so it lays below all its siblings.
void WMDeleteNotify(Window_t id)
Tell WM to send message when window is closed via WM.
Window_t GetInputFocus()
Returns the window id of the window having the input focus.
void DeleteImage(Drawable_t img)
Deallocates the memory associated with the image img.
Bool_t fLineColorModified
Int_t WriteGIF(char *name)
Writes the current window into GIF file.
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.
Int_t GetDepth() const
Get maximum number of planes.
void GetWindowAttributes(Window_t id, WindowAttributes_t &attr)
Get window attributes and return filled in attributes structure.
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.
void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
Return position and size of window wid.
void SetDNDAware(Window_t win, Atom_t *typelist)
Add XdndAware property and the list of drag and drop types to the Window win.
Int_t fScreenNumber
Screen number.
void Warp(Int_t ix, Int_t iy, Window_t id=0)
Set pointer position.
Drawable_t CreateImage(UInt_t width, UInt_t height)
Allocates the memory needed for an drawable.
Cursor_t CreateCursor(ECursor cursor)
Create cursor handle (just return cursor from cursor pool fCursors).
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.
void DrawRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw a rectangle outline.
Int_t AddPixmap(ULong_t pix, UInt_t w, UInt_t h)
register pixmap created by TGWin32GLManager
void SetMarkerType(Int_t type, Int_t n, GdkPoint *xy)
Set marker type.
Int_t OpenPixmap(UInt_t w, UInt_t h)
Open a new pixmap.
void SetDoubleBufferON()
Turn double buffer mode on.
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.
void SetKeyAutoRepeat(Bool_t on=kTRUE)
Turn key auto repeat on or off.
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.
void SetFillStyle(Style_t style)
Set fill area style.
void SetMWMHints(Window_t id, UInt_t value, UInt_t funcs, UInt_t input)
Set decoration style for MWM-compatible wm (mwm, ncdwm, fvwm?).
TObject * fRefreshTimer
TGWin32RefreshTimer for GUI thread message handler.
void SetCursor(Int_t win, ECursor cursor)
Set the cursor.
char ** ListFonts(const char *fontname, Int_t max, Int_t &count)
Return list of font names matching "fontname".
void QueryColors(GdkColormap *cmap, GdkColor *colors, Int_t ncolors)
Returns the current RGB value for the pixel in the XColor structure.
void GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab=kTRUE)
Establish passive grab on a certain key.
Window_t GetPrimarySelectionOwner()
Returns the window id of the current owner of the primary selection.
void MapColorStruct(ColorStruct_t *color, GdkColor &xcolor)
Map a ColorStruct_t to a XColor structure.
void SetWindowName(Window_t id, char *name)
Set window name.
FontH_t GetFontHandle(FontStruct_t fs)
Return handle to font described by font structure.
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...
void SetTextColor(Color_t cindex)
Set color index for text.
void SetWindowBackground(Window_t id, ULong_t color)
Set the window background color.
FT_Vector fAlign
alignment vector
Bool_t IsCmdThread() const
returns kTRUE if we are inside cmd/server thread
Int_t fTextAlignH
Text Alignment Horizontal.
Handle_t fXEvent
Current native (GDK) event.
void RemovePixmap(GdkDrawable *pix)
Remove the pixmap pix.
void GetGCValues(GContext_t gc, GCValues_t &gval)
Get current values from graphics context gc.
Bool_t fFillColorModified
Int_t fRedDiv
Red value divider, -1 if no TrueColor visual.
void SetIconName(Window_t id, char *name)
Set window icon name.
Bool_t fMarkerColorModified
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.
void DeletePictureData(void *data)
Delete picture data created by the function ReadPictureDataFromFile.
GdkGC * GetGC(Int_t which) const
Return desired Graphics Context ("which" maps directly on gGCList[]).
void ConvertSelection(Window_t, Atom_t &, Atom_t &, Atom_t &, Time_t &)
Get Clipboard data.
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...
void SetLineColor(Color_t cindex)
Set color index for lines.
XColor_t & GetColor(Int_t cid)
Return reference to internal color structure associated to color index cid.
Int_t OpenDisplay(const char *dpyName=0)
Open the display. Return -1 if the opening fails, 0 when ok.
void SetDashes(GContext_t gc, Int_t offset, const char *dash_list, Int_t n)
Specify a dash pattertn.
void FreeFontNames(char **fontlist)
Frees the specified the array of strings "fontlist".
Bool_t ParseColor(Colormap_t cmap, const char *cname, ColorStruct_t &color)
Parse string cname containing color name, like "green" or "#00FF00".
void SetDrawMode(EDrawMode mode)
Set the drawing mode.
Int_t fTextAlign
Text alignment (set in SetTextAlign)
void SetMarkerColor(Color_t cindex)
Set color index for markers.
Bool_t Init(void *display=0)
Initialize Win32 system. Returns kFALSE in case of failure.
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...
FontStruct_t GetFontStruct(FontH_t fh)
Retrieve associated font structure once we have the font handle.
void GetCharacterUp(Float_t &chupx, Float_t &chupy)
Return character up vector.
void SetLineWidth(Width_t width)
Set line width.
void RescaleWindow(Int_t wid, UInt_t w, UInt_t h)
Rescale the window wid.
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...
void SetMarkerStyle(Style_t markerstyle)
Set marker style.
Int_t RequestString(Int_t x, Int_t y, char *text)
Request a string.
void SetWMState(Window_t id, EInitialState state)
Set the initial state of the window. Either kNormalState or kIconicState.
void MapSubwindows(Window_t id)
Maps all subwindows for the specified window "id" in top-to-bottom stacking order.
void GetRegionBox(Region_t reg, Rectangle_t *)
Return smallest enclosing rectangle.
Int_t fMaxNumberOfWindows
Maximum number of windows.
void RemoveWindow(ULong_t qwid)
Remove a window created by Qt (like CloseWindow1()).
Bool_t ReadPictureDataFromFile(const char *filename, char ***ret_data)
Read picture data from file and store in ret_data.
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.
void MoveResizeWindow(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h)
Move and resize a window.
UInt_t ScreenWidthMM() const
Returns the width of the screen in millimeters.
void MapKeySym(UInt_t &keysym, UInt_t &xkeysym, Bool_t tox=kTRUE)
Map to and from X key symbols.
void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t *attr)
Change window attributes.
Bool_t AllocColor(GdkColormap *cmap, GdkColor *color)
Allocate color in colormap.
void SetTextAlign(Short_t talign=11)
Set text alignment.
Int_t RequestLocator(Int_t mode, Int_t ctyp, Int_t &x, Int_t &y)
Request Locator position.
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...
Int_t KeysymToKeycode(UInt_t keysym)
Convert a keysym to the appropriate keycode.
void ClosePixmap()
Delete current pixmap.
Window_t GetCurrentWindow() const
Return current window pointer. Protected method used by TGWin32TTF.
Bool_t EmptyRegion(Region_t reg)
Return true if the region is empty.
void XorRegion(Region_t rega, Region_t regb, Region_t result)
Calculate the difference between the union and intersection of two regions.
void Bell(Int_t percent)
Sets the sound bell. Percent is loudness from -100% to 100%.
void SetPrimarySelectionOwner(Window_t id)
Makes the window id the current owner of the primary selection.
Bool_t PointInRegion(Int_t x, Int_t y, Region_t reg)
Returns true if the point x,y is in the region.
Int_t fBlueShift
Bits to left shift blue.
GdkCursor * fCursors[kNumCursors]
List of cursors.
FontStruct_t LoadQueryFont(const char *font_name)
Load font and query font.
void ChangeActivePointerGrab(Window_t, UInt_t, Cursor_t)
Changes the active cursor of the specified window.
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.
Window_t GetParent(Window_t id) const
Return the parent of the window.
void ChangeProperties(Window_t id, Atom_t property, Atom_t type, Int_t format, UChar_t *data, Int_t len)
Put data into Clipboard.
Bool_t CreatePictureFromData(Drawable_t id, char **data, Pixmap_t &pict, Pixmap_t &pict_mask, PictureAttributes_t &attr)
Create a pixture pixmap from data.
void FreeColor(Colormap_t cmap, ULong_t pixel)
Free color cell with specified pixel value.
Window_t GetWindowID(Int_t wid)
Return the X11 window identifier.
virtual ~TGWin32()
destructor.
Int_t fTextAlignV
Text Alignment Vertical.
Bool_t fUseSysPointers
True when using system mouse pointers.
XWindow_t * fWindows
List of windows.
void GetImageSize(Drawable_t id, UInt_t &width, UInt_t &height)
Returns the width and height of the image id.
Int_t fGreenDiv
Green value divider.
void Update(Int_t mode=0)
Flush (mode = 0, default) or synchronize (mode = 1) X output buffer.
void WritePixmap(Int_t wid, UInt_t w, UInt_t h, char *pxname)
Write the pixmap wid in the bitmap file pxname.
void SetInput(Int_t inp)
Set input on or off.
ULong_t GetPixel(Color_t cindex)
Return pixel value associated to specified ROOT color number.
Display_t GetDisplay() const
Returns handle to display (might be useful in some cases where direct X11 manipulation outside of TVi...
void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b)
Get rgb values for color "index".
void Sync(Int_t mode)
Set synchronisation on or off.
TExMap * fColors
Hash list of colors.
void UnionRectWithRegion(Rectangle_t *rect, Region_t src, Region_t dest)
Union of rectangle with a region.
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.
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
virtual void SetName(const char *name)
Set the name of the TNamed.
Int_t GetEntries() const
Return the number of objects in array (i.e.
TObject * At(Int_t idx) const
Collectable string class.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
static void * Alloc(size_t size)
Allocate a block of memory, that later can be resized using TStorage::ReAlloc().
static void * ReAlloc(void *vp, size_t size)
Reallocate (i.e.
static void Dealloc(void *ptr)
De-allocate block of memory, that was allocated via TStorage::Alloc().
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
const char * GetLineStyleString(Int_t i=1) const
Return line style string (used by PostScript).
void Beep(Int_t freq=-1, Int_t duration=-1, Bool_t setDefault=kFALSE)
Beep for duration milliseconds with a tone of frequency freq.
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
virtual TTimer * RemoveTimer(TTimer *t)
Remove timer from list of system timers.
TTF helper class containing glyphs description.
FT_Glyph fImage
glyph image
static Bool_t IsInitialized()
static void PrepareString(const char *string)
Put the characters in "string" in the "glyphs" array.
static void Init()
Initialise the TrueType fonts interface.
static void LayoutGlyphs()
Compute the glyphs positions, fgAscent and fgWidth (needed for alignment).
static void SetSmoothing(Bool_t state)
Set smoothing (anti-aliasing) flag.
static void SetRotationMatrix(Float_t angle)
Set the rotation matrix used to rotate the font outlines.
static void SetTextFont(Font_t fontnumber)
Set specified font.
static void GetTextExtent(UInt_t &w, UInt_t &h, char *text)
Get width (w) and height (h) when text is horizontal.
static TTGlyph * GetGlyphs()
static Int_t GetNumGlyphs()
static const FT_BBox & GetBox()
static Bool_t GetSmoothing()
static void SetTextSize(Float_t textsize)
Set current text size.
static FT_Matrix * GetRotMatrix()
Handles synchronous and a-synchronous timer events.
void Reset()
Reset the timer.
virtual Bool_t Notify()
Notify when timer times out.
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Short_t Max(Short_t a, Short_t b)
Double_t Floor(Double_t x)
Double_t Sqrt(Double_t x)
Short_t Min(Short_t a, Short_t b)
ULong_t fPixel
color pixel value (index in color table)
UShort_t fRed
red component (0..65535)
UShort_t fGreen
green component (0..65535)
UShort_t fBlue
blue component (0..65535)
EGEventType fType
of event (see EGEventType)
Int_t fY
pointer x, y coordinates in event window
Bool_t fSendEvent
true if event came from SendEvent
Handle_t fHandle
general resource handle (used for atoms or windows)
Int_t fFormat
Next fields only used by kClientMessageEvent.
UInt_t fHeight
width and height of exposed area
Int_t fCount
if non-zero, at least this many more exposes
Window_t fWindow
window reported event is relative to
UInt_t fState
key or button mask
Int_t fYRoot
coordinates relative to root
Long_t fUser[5]
5 longs can be used by client message events NOTE: only [0], [1] and [2] may be used.
Time_t fTime
time event event occurred in ms
UInt_t fCode
key or button code
Graphics context structure.
ULong_t fBackground
background pixel
Pixmap_t fClipMask
bitmap clipping; other calls for rects
Int_t fClipXOrigin
origin for clipping
Int_t fLineWidth
line width
Pixmap_t fStipple
stipple 1 plane pixmap for stippling
Mask_t fMask
bit mask specifying which fields are valid
Int_t fLineStyle
kLineSolid, kLineOnOffDash, kLineDoubleDash
Pixmap_t fTile
tile pixmap for tiling operations
Bool_t fGraphicsExposures
boolean, should exposures be generated
Int_t fJoinStyle
kJoinMiter, kJoinRound, kJoinBevel
ULong_t fForeground
foreground pixel
Int_t fFillStyle
kFillSolid, kFillTiled, kFillStippled, kFillOpaeueStippled
FontH_t fFont
default text font for text operations
Int_t fTsXOrigin
offset for tile or stipple operations
EGraphicsFunction fFunction
logical operation
Int_t fCapStyle
kCapNotLast, kCapButt, kCapRound, kCapProjecting
Int_t fSubwindowMode
kClipByChildren, kIncludeInferiors
UInt_t fHeight
height of picture
UInt_t fWidth
width of picture
Point structure (maps to the X11 XPoint structure)
Rectangle structure (maps to the X11 XRectangle structure)
Used for drawing line segments (maps to the X11 XSegments structure)
Attributes that can be used when creating or changing a window.
UInt_t fBorderWidth
border width in pixels
Long_t fEventMask
set of events that should be saved
Pixmap_t fBackgroundPixmap
background or kNone or kParentRelative
Bool_t fOverrideRedirect
boolean value for override-redirect
Mask_t fMask
bit mask specifying which fields are valid
ULong_t fBackgroundPixel
background pixel
Cursor_t fCursor
cursor to be displayed (or kNone)
Colormap_t fColormap
color map to be associated with window
Window attributes that can be inquired.
Window_t fRoot
root of screen containing window
Int_t fMapState
kIsUnmapped, kIsUnviewable, kIsViewable
Long_t fYourEventMask
my event mask
Int_t fHeight
width and height of window
Bool_t fMapInstalled
boolean, is color map currently installed
Int_t fBorderWidth
border width of window
Colormap_t fColormap
color map to be associated with window
Int_t fClass
kInputOutput, kInputOnly
void * fVisual
the associated visual structure
Int_t fBackingStore
kNotUseful, kWhenMapped, kAlways
Int_t fY
location of window
Int_t fDepth
depth of window
Bool_t fOverrideRedirect
boolean value for override-redirect
Bool_t fSaveUnder
boolean, should bits under be saved?
Description of a X11 color.
Bool_t fDefined
true if pixel value is defined
#define dest(otri, vertexptr)
#define org(otri, vertexptr)
int GIFdecode(byte *GIFarr, byte *PIXarr, int *Width, int *Height, int *Ncols, byte *R, byte *G, byte *B)
int GIFinfo(byte *GIFarr, int *Width, int *Height, int *Ncols)
long GIFencode(void *int, void *int, void *int, R, G, B, ScLine, void *get_scline, pb)