static void
mytest(Widget w, XtPointer p, XtPointer s)
{
Pixel fg, bg;
int height, width;
Pixmap pixmap;
printf("hi\n");
XtVaGetValues(w,
XmNwidth, &width,
XmNheight, &height,
NULL);
printf("height == %d, width == %d\n", height, width);
fg = XBlackPixelOfScreen(XtScreen(w));
bg = XWhitePixelOfScreen(XtScreen(w));
pixmap = XmGetPixmap(XtScreen(w), "xlogo64", fg, bg);
XtVaSetValues(w,
XmNwidth, 0,
XmNheight, 0,
XmNlabelPixmap, pixmap,
XmNlabelType,XmPIXMAP,
NULL);
XtVaGetValues(w,
XmNwidth, &width,
XmNheight, &height,
NULL);
printf("height == %d, width == %d\n", height, width);
}
int
main(int argc, char **argv)
{
XtAppContext theApp;
Widget label;
Pixel fg,bg;
toplevel = XtVaAppInitialize(&theApp, "drawingArea", NULL, 0,
&argc, argv, NULL, NULL);
label= XtVaCreateManagedWidget("Button1",
xmPushButtonWidgetClass, toplevel,
NULL);
XtRealizeWidget(toplevel);
theDisplay = XtDisplay(toplevel);
theRootWindow = XDefaultRootWindow(theDisplay);
fg = XBlackPixelOfScreen(DefaultScreenOfDisplay(theDisplay));
bg = XWhitePixelOfScreen(DefaultScreenOfDisplay(theDisplay));
Pix = XmGetPixmap(DefaultScreenOfDisplay(theDisplay),
"xlogo64",
fg, bg);
XtVaSetValues(label,
XmNlabelPixmap,Pix,
XmNlabelType,XmPIXMAP,
NULL);
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight, 0, 0, 54, 25, 0,0,0, /* Form */
CWWidth | CWHeight | CWX | CWY, 45, 30, 30, 25, 0,0,0, /* two */
};
PrintDetails(toplevel, Expected);
}
fprintf(stderr, "Button %p VendorExt %p ButtonFontList %p TextFontList %p (r %p) LabelFontList %p\n",
label,
_LtFindVendorExt(label),
((XmVendorShellExtObject)_LtFindVendorExt(label))->vendor.button_font_list,
((XmVendorShellExtObject)_LtFindVendorExt(label))->vendor.text_font_list,
((XmVendorShellExtObject)_LtFindVendorExt(label))->vendor.label_font_list,
((XmVendorShellExtObject)_LtFindVendorExt(label))->vendor.text_font_list->renditions[0]);
LessTifTestMainLoop(toplevel);
/*
XtAppMainLoop(theApp);
*/
exit(0);
}
///////////////////////////////////////////////////////////////////////
/// Function: AttachBlackOfScreen
///
/// Author: $author$
/// Date: 2/8/2013
///////////////////////////////////////////////////////////////////////
virtual XosError AttachBlackOfScreen(Screen* xScreen, bool onlyFreed=false)
{
XosError error = XOS_ERROR_FAILED;
XosError error2;
if ((error2 = Freed(onlyFreed)))
return error2;
if ((xScreen)) {
Attach(XBlackPixelOfScreen(xScreen));
error = XOS_ERROR_NONE;
}
return error;
}
LispObj *
Lisp_XBlackPixelOfScreen(LispBuiltin *builtin)
/*
x-black-pixel-of-screen screen
*/
{
LispObj *screen;
screen = ARGUMENT(0);
if (!CHECKO(screen, x11Screen_t))
LispDestroy("%s: cannot convert %s to Screen*",
STRFUN(builtin), STROBJ(screen));
return (INTEGER(XBlackPixelOfScreen((Screen*)(screen->data.opaque.data))));
}
int
main(int argc, char **argv)
{
XtAppContext theApp;
Widget toplevel;
Widget butt;
Pixmap pixmap;
Pixel fg, bg;
toplevel = XtVaAppInitialize(&theApp, "test3", NULL, 0,
&argc, argv, NULL, NULL);
fg = XBlackPixelOfScreen(DefaultScreenOfDisplay(XtDisplay(toplevel)));
bg = XWhitePixelOfScreen(DefaultScreenOfDisplay(XtDisplay(toplevel)));
pixmap = XmGetPixmap(DefaultScreenOfDisplay(XtDisplay(toplevel)),
"xlogo64", fg, bg);
if (pixmap == XmUNSPECIFIED_PIXMAP)
printf("Pixmap unspecified\n");
butt= XtVaCreateManagedWidget("Button1", xmDrawnButtonWidgetClass, toplevel,
XmNwidth, 100,
XmNheight, 100,
XmNshadowThickness, 4,
XmNshadowType, XmSHADOW_ETCHED_OUT,
XmNlabelType, XmPIXMAP,
XmNlabelPixmap, pixmap,
NULL);
XtRealizeWidget(toplevel);
/* Note: the following values are the result of
* querying the current geometry.
*/
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight , 0, 0, 100, 100, 0,0,0, /* Button1 */
};
/* toplevel should be replaced with to correct applicationShell */
PrintDetails(toplevel, Expected);
}
LessTifTestMainLoop(toplevel);
exit(0);
}
int
main(int argc, char **argv)
{
XtAppContext theApp;
Widget toplevel;
Widget butt;
Pixmap Pix;
Display *theDisplay;
Window theRootWindow;
Pixel fg,bg;
Dimension mt, mb, ml, mr, mw, mh, st, ht;
XtWidgetGeometry geo;
toplevel = XtVaAppInitialize(&theApp, "toggle1", NULL, 0,
&argc, argv, NULL, NULL);
butt= XtVaCreateManagedWidget("Button1", xmToggleButtonWidgetClass, toplevel,
#if 0
XmNindicatorOn, False,
#endif
XmNshadowThickness, 5,
XmNfillOnSelect, True,
NULL);
XtAddCallback(butt,XmNvalueChangedCallback,HiCB,NULL);
XtRealizeWidget(toplevel);
theDisplay = XtDisplay(toplevel);
theRootWindow = XDefaultRootWindow(theDisplay);
fg = XBlackPixelOfScreen(DefaultScreenOfDisplay(theDisplay));
bg = XWhitePixelOfScreen(DefaultScreenOfDisplay(theDisplay));
Pix = XmGetPixmap(DefaultScreenOfDisplay(theDisplay),
"xlogo64",
fg, bg);
if (Pix == XmUNSPECIFIED_PIXMAP)
printf("PIX IS UNSPECIFIED\n");
XtVaGetValues(butt,
XmNmarginTop, &mt, XmNmarginBottom, &mb,
XmNmarginLeft, &ml, XmNmarginRight, &mr,
XmNmarginWidth, &mw, XmNmarginHeight, &mh,
XmNshadowThickness, &st, XmNhighlightThickness, &ht,
NULL);
printf("%d %d %d %d %d %d %d %d\n",
mt, mb, ml, mr, mw, mh, st, ht);
XtVaSetValues(butt,
#if 0
XmNlabelPixmap,Pix,
#endif
XmNlabelType, XmPIXMAP,
NULL);
Pix = XmGetPixmap(DefaultScreenOfDisplay(theDisplay),
"woman",
fg, bg);
XtVaGetValues(butt,
XmNmarginTop, &mt, XmNmarginBottom, &mb,
XmNmarginLeft, &ml, XmNmarginRight, &mr,
XmNmarginWidth, &mw, XmNmarginHeight, &mh,
XmNshadowThickness, &st, XmNhighlightThickness, &ht,
NULL);
printf("%d %d %d %d %d %d %d %d\n",
mt, mb, ml, mr, mw, mh, st, ht);
XtVaSetValues(butt,
XmNselectPixmap, Pix,
NULL);
XtQueryGeometry(butt, NULL, &geo);
printf("toggle wants: %d %d has %d %d\n",
geo.width, geo.height, XtWidth(butt), XtHeight(butt));
XtVaGetValues(butt,
XmNmarginTop, &mt, XmNmarginBottom, &mb,
XmNmarginLeft, &ml, XmNmarginRight, &mr,
XmNmarginWidth, &mw, XmNmarginHeight, &mh,
XmNshadowThickness, &st, XmNhighlightThickness, &ht,
NULL);
printf("%d %d %d %d %d %d %d %d\n",
mt, mb, ml, mr, mw, mh, st, ht);
/* Note: the following values are the result of
* querying the current geometry.
*/
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight , 387, 402, 77, 45, 0,0,0, /* Button1 */
};
/* toplevel should be replaced with to correct applicationShell */
PrintDetails(toplevel, Expected);
}
LessTifTestMainLoop(toplevel);
exit(0);
}
int initsystem(void) /* retourne 1 si initialisation reussie */
{
int i;
int windowW;
int windowH;
XSetWindowAttributes xswa;
XGCValues xgcv;
XSizeHints xsh;
windowW=WIDTH*RATIO;
windowH=HEIGHT*RATIO;
display=XOpenDisplay(0);
if (!display) return(0);
else
{
mousek=0;
XAutoRepeatOff(display);
timestart=last=systime();
screen=XDefaultScreenOfDisplay(display);
rdepth=sdepth=XDefaultDepthOfScreen(screen);
if (emulmono) sdepth=1;
XSynchronize(display,0);
black=XBlackPixelOfScreen(screen);
white=XWhitePixelOfScreen(screen);
colormap=XDefaultColormapOfScreen(screen);
visual=XDefaultVisualOfScreen(screen);
xswa.event_mask=VisibilityChangeMask;
xswa.background_pixel=black;
xswa.border_pixel=white;
xswa.override_redirect=0;
xswa.backing_store=Always;
xswa.bit_gravity=StaticGravity;
xswa.win_gravity=CenterGravity;
window=XCreateWindow(display,XRootWindowOfScreen(screen),
randval(50),randval(100),windowW,windowH,0,
XDefaultDepthOfScreen(screen),InputOutput,
XDefaultVisualOfScreen(screen),
CWWinGravity|CWBitGravity|CWBackingStore|CWEventMask|
CWBackPixel|CWOverrideRedirect|CWBorderPixel,&xswa);
if (sdepth!=1)
xcolormap=XCreateColormap(display,window,
visual,AllocAll);
xgcv.foreground = white;
xgcv.background = black;
gc=XCreateGC(display,window,GCForeground | GCBackground,&xgcv);
XSetGraphicsExposures(display,gc,False);
/* CAPITAL!!! : evite d'accumuler sans cesse des expose events */
xsh.x=0;
xsh.y=0;
xsh.width=windowW;
xsh.height=windowH;
xsh.min_width=windowW;
xsh.max_width=windowW;
xsh.min_height=windowH;
xsh.max_height=windowH;
xsh.flags=PPosition|PSize|PMinSize|PMaxSize;
XSetNormalHints(display, window, &xsh);
XStoreName(display,window,"");
XMapWindow(display, window);
XSelectInput(display,window,PointerMotionMask|ButtonPressMask|
ButtonReleaseMask|KeyPressMask|KeyReleaseMask);
XFlush(display);
XSync(display,0);
for (i=0; i<(NBCOLORS+2); i++)
{
if (i&1) pixels[i]=white;
else pixels[i]=black;
if (i==NBCOLORS) pixels[i]=0;
if (i==(NBCOLORS+1)) pixels[i]=(1<<rdepth)-1;
xgcv.foreground=pixels[i];
xgcv.background=black;
gctab[i]=XCreateGC(display,window,
GCForeground|GCBackground,&xgcv);
XSetFunction(display,gctab[i],GXcopy);
XSetFillStyle(display,gctab[i],FillSolid);
}
ecran[0]=XCreatePixmap(display,window,windowW,windowH,rdepth);
ecran[1]=XCreatePixmap(display,window,windowW,windowH,rdepth);
for(i=0; i<9; i++)
graypixmap[i]=XCreatePixmapFromBitmapData(display,window,
&graypat[i][0],8,8,white,black,rdepth);
setpalette(egapal);
cls();
swap();
cls();
empty();
waitdelay(500);
return(1);
}
}
/*--------------------------------------------------------*/
void open_gwindow_( )
{
/*
* create new graphics window on first entry....
*/
int font,black,white;
int scr_width,scr_height;
int j;
unsigned long valuemask;
static int depth; /* number of planes */
static Visual *visual; /*VISUAL TYPE */
static XSizeHints win_position; /*position and size for
window manager.*/
/*
* initialize display id and screen id....
*/
disp_id = XOpenDisplay(0);
if (!disp_id) {
printf("Display not opened!\n");
exit(-1);
}
/*
* next instruction for debugging only....
*/
/* XSynchronize(disp_id, 1); */
screen_id = XDefaultScreenOfDisplay(disp_id);
root_win_id = XRootWindowOfScreen(screen_id);
black = XBlackPixelOfScreen(screen_id);
white = XWhitePixelOfScreen(screen_id);
scr_width = XWidthOfScreen(screen_id);
scr_height = XHeightOfScreen(screen_id);
depth = XDefaultDepthOfScreen(screen_id);
visual = XDefaultVisualOfScreen(screen_id);
/*
* set up backing store....
*/
valuemask = CWBitGravity | CWBackingStore | CWBackPixel;
setwinattr.bit_gravity = SouthWestGravity;
setwinattr.backing_store = Always;
setwinattr.background_pixel = white;
/*
* create the window....
*/
win_id = XCreateWindow(disp_id,
root_win_id,
scr_width - win_width - 15,
scr_height - win_height - 35,
win_width,
win_height,
10,
depth,
InputOutput,
visual,
valuemask,
&setwinattr);
/* WMHints structure */
win_position.x = scr_width - win_width - 15;
win_position.y = scr_height - win_height - 35;
win_position.width = win_width;
win_position.height = win_height;
win_position.flags=USPosition|USSize;
XSetWMNormalHints(disp_id, win_id, &win_position);
XStoreName(disp_id, win_id, WINDNAME);
/*
* get named color values....
*/
color[1] = define_color_("BLUE");
color[2] = define_color_("DEEP SKY BLUE");
color[3] = define_color_("LIGHT SKY BLUE");
color[4] = define_color_("SEA GREEN");
color[5] = define_color_("MEDIUM SEA GREEN");
color[6] = define_color_("GREEN");
color[7] = define_color_("BROWN");
color[8] = define_color_("CHOCOLATE");
color[9] = define_color_("SANDY BROWN");
color[10] = define_color_("RED");
color[11] = define_color_("CORAL");
color[12] = define_color_("ORANGE");
color[13] = define_color_("YELLOW3");
color[14] = define_color_("YELLOW2");
color[15] = define_color_("YELLOW");
color[16] = define_color_("PEACH PUFF");
color[17] = define_color_("PAPAYA WHIP");
color[18] = define_color_("OLD LACE");
color[19] = white;
color[20] = black;
color[21] = black;
/*
* create graphics context....
*/
xgcvl.background = color[19];
xgcvl.foreground = color[20];
gc_id = XCreateGC(disp_id, win_id, GCForeground | GCBackground, &xgcvl);
xgcvl.function = GXinvert;
gc_comp_id = XCreateGC(disp_id, win_id, GCFunction, &xgcvl);
/*
* load the font for text writing....
*/
font = XLoadFont(disp_id, FONTNAME);
XSetFont(disp_id, gc_id, font);
/* Map the window.... */
XSelectInput(disp_id,win_id,ExposureMask|VisibilityChangeMask);
XMapRaised(disp_id,win_id);
/*
* Wait for the window to be raised. Some X servers do not
* generate an initial expose event, so also check the visibility
* event.
*/
XMaskEvent(disp_id,ExposureMask|VisibilityChangeMask,&event);
XSelectInput(disp_id,win_id,0);
XSync(disp_id,1);
}
unsigned screen::IMPL::black_pixel() const
{
return XBlackPixelOfScreen( _xscrn );
}
int main (int argc, char* argv[])
{
/* Determine number of iterations. */
if (2 != argc)
{
printf("usage: %s <num-iterations>\n", argv[0]);
exit(1);
}
int numIterations = atoi(argv[1]);
int returnCode = 0;
Display* xDisplay = NULL;
Window xWindow = 0;
Picture xPictureWindow = 0;
Pixmap xPixmapMain = 0;
Picture xPictureMain = 0;
Pixmap xPixmapOverlay = 0;
Picture xPictureOverlay = 0;
Pixmap xPixmapMask = 0;
Picture xPictureMask = 0;
GC gcMask = 0;
/* Access X display. */
if (NULL == (xDisplay = XOpenDisplay(NULL)))
{
printf("XOpenDisplay(NULL) failed\n");
returnCode = 1;
goto error;
}
/* Access info about the screen. */
Screen* xScreen = XDefaultScreenOfDisplay(xDisplay);
GC gc = XDefaultGCOfScreen(xScreen);
Colormap xColormap = XDefaultColormapOfScreen(xScreen);
/* Create main X window */
xWindow = XCreateSimpleWindow(
xDisplay,
RootWindow(xDisplay, 0),
0, 0,
IMAGE_WIDTH*2,
IMAGE_HEIGHT*2,
0,
BlackPixel(xDisplay, 0),
BlackPixel(xDisplay, 0));
if (0 == xWindow)
{
printf("XCreateSimpleWindow failed\n");
returnCode = 1;
goto error;
}
XMapWindow(xDisplay, xWindow);
XSync(xDisplay, False);
/* Get the attributes associated with the main window. */
XWindowAttributes xWindowAttr;
if (!XGetWindowAttributes(xDisplay, xWindow, &xWindowAttr))
{
printf("XGetWindowAttributes failed\n");
returnCode = 1;
goto error;
}
/* Find the X render picture format associated with the visual */
/* for the main window */
XRenderPictFormat* xRenderPictFormatWindow =
XRenderFindVisualFormat(xDisplay, xWindowAttr.visual);
if (NULL == xRenderPictFormatWindow)
{
printf("XRenderFindVisualFormat failed\n");
returnCode = 1;
goto error;
}
/* Find the X render picture format associated with 8 bit alpha. */
XRenderPictFormat xRenderPictFormatTemplate;
xRenderPictFormatTemplate.depth = 8;
xRenderPictFormatTemplate.type = PictTypeDirect;
xRenderPictFormatTemplate.direct.alphaMask = 0x0FF;
unsigned long xRenderPictFormatTemplateMask =
PictFormatDepth | PictFormatType | PictFormatAlphaMask;
XRenderPictFormat* xRenderPictFormatMask =
XRenderFindFormat(
xDisplay,
xRenderPictFormatTemplateMask,
&xRenderPictFormatTemplate,
0);
if (NULL == xRenderPictFormatMask)
{
printf("XRenderFindFormat failed\n");
returnCode = 1;
goto error;
}
/* Create X render picture associated with the screen. */
/* Having the same visual format as the window. */
xPictureWindow = XRenderCreatePicture(
xDisplay,
xWindow,
xRenderPictFormatWindow,
0,
NULL);
if (0 == xPictureWindow)
{
printf("XRenderCreatePicture (window) failed\n");
returnCode = 1;
goto error;
}
/* Create backing pixmap for the main window. */
xPixmapMain = XCreatePixmap(
xDisplay,
xWindow,
xWindowAttr.width,
xWindowAttr.height,
xWindowAttr.depth);
if (0 == xPixmapMain)
{
printf("XCreatePixmap (main) failed\n");
returnCode = 1;
goto error;
}
/* Create X render picture associated with the backing pixmap. */
/* Having the same visual format as the window. */
xPictureMain = XRenderCreatePicture(
xDisplay,
xPixmapMain,
xRenderPictFormatWindow,
0,
NULL);
if (0 == xPictureMain)
{
printf("XRenderCreatePicture (main) failed\n");
returnCode = 1;
goto error;
}
/* Draw concentric rectangles of different gray. */
unsigned i;
for (i = 0; i < 256; ++i)
{
float fGray = i / 255.0;
/* Find the color gray. */
XcmsColor xColorGray;
xColorGray.spec.RGBi.red = fGray;
xColorGray.spec.RGBi.green = fGray;
xColorGray.spec.RGBi.blue = fGray;
xColorGray.format = XcmsRGBiFormat;
if (0 == XcmsAllocColor(
xDisplay,
xColormap,
&xColorGray,
XcmsRGBFormat))
{
printf("XcmsAllocColor failed\n");
returnCode = 1;
goto error;
}
/* Change the drawing color for the main window. */
XSetForeground(xDisplay, gc, xColorGray.pixel);
XDrawRectangle(
xDisplay,
xPixmapMain,
gc,
i, i,
(IMAGE_WIDTH - i) * 2 - 1,
(IMAGE_HEIGHT - i) * 2 - 1);
}
XRenderComposite(
xDisplay,
PictOpSrc,
xPictureMain, /* src */
0, /* mask */
xPictureWindow, /* dst */
0, 0, /* src (x,y) */
0, 0, /* mask (x,y) */
0, 0, /* dst (x,y) */
xWindowAttr.width,
xWindowAttr.height);
XSync(xDisplay, False);
/* Create pixmap for the overlay content. */
xPixmapOverlay = XCreatePixmap(
xDisplay,
xWindow,
IMAGE_WIDTH,
IMAGE_HEIGHT,
xWindowAttr.depth);
if (0 == xPixmapOverlay)
{
printf("XCreatePixmap (overlay) failed\n");
returnCode = 1;
goto error;
}
/* Create X render picture assocaited with the overlay pixmap. */
/* Having the same visual format as the window. */
xPictureOverlay = XRenderCreatePicture(
xDisplay,
xPixmapOverlay,
xRenderPictFormatWindow,
0,
NULL);
if (0 == xPictureOverlay)
{
printf("XRenderCreatePicture (overlay) failed\n");
returnCode = 1;
goto error;
}
/* Fill the overlay with black to be used for overlay color. */
XSetForeground(xDisplay, gc, XBlackPixelOfScreen(xScreen));
XFillRectangle(
xDisplay,
xPixmapOverlay,
gc,
0, 0,
IMAGE_WIDTH,
IMAGE_HEIGHT);
/* Create pixmap for the mask content. */
xPixmapMask = XCreatePixmap(
xDisplay,
xWindow,
IMAGE_WIDTH,
IMAGE_HEIGHT,
8);
if (0 == xPixmapMask)
{
printf("XCreatePixmap (mask) failed\n");
returnCode = 1;
goto error;
}
/* Create X render picture assocaited with the mask pixmap. */
xPictureMask = XRenderCreatePicture(
xDisplay,
xPixmapMask,
xRenderPictFormatMask,
0,
NULL);
if (0 == xPictureMask)
{
printf("XRenderCreatePicture (mask) failed\n");
returnCode = 1;
goto error;
}
/* Create a GC to go with mask */
gcMask = XCreateGC(xDisplay, xPixmapMask, 0, NULL);
XSetForeground(xDisplay, gcMask, 0x00000000);
XFillRectangle(
xDisplay,
xPixmapMask,
gcMask,
0, 0,
IMAGE_WIDTH,
IMAGE_HEIGHT);
XSetForeground(xDisplay, gcMask, 0x40404040);
XDrawRectangle(
xDisplay,
xPixmapMask,
gcMask,
0, 0,
IMAGE_WIDTH-1,
IMAGE_HEIGHT-1);
XFillArc(
xDisplay,
xPixmapMask,
gcMask,
100, 100,
100, 100,
0, /* start angle-degrees * 64 */
360 * 64); /* extent angle-degrees * 64 */
Bool bIncX = True;
Bool bIncY = True;
Bool bNextRow = False;
int x = 0;
int y = 0;
struct timeval timeStart;
gettimeofday(&timeStart, NULL);
int iter;
for (iter = 0; iter < numIterations; ++iter)
{
XRenderComposite(
xDisplay,
PictOpSrc,
xPictureMain, /* src */
0, /* mask */
xPictureWindow, /* dst */
x, y, /* src (x,y) */
0, 0, /* mask (x,y) */
x, /* dst x */
y, /* dst y */
IMAGE_WIDTH,
IMAGE_HEIGHT);
if (bNextRow)
{
if (bIncY)
{
if ((y += 10) >= IMAGE_HEIGHT)
{
y = IMAGE_HEIGHT - 1;
bIncY = False;
}
}
else
{
if ((y -= 10) < 0)
{
y = 0;
bIncY = True;
}
}
bNextRow = False;
}
else
{
if (bIncX)
{
if (++x >= IMAGE_WIDTH)
{
x = IMAGE_WIDTH - 1;
bIncX = False;
bNextRow = True;
}
}
else
{
if (--x < 0)
{
x = 0;
bIncX = True;
bNextRow = True;
}
}
}
XRenderComposite(
xDisplay,
PictOpOver,
xPictureOverlay,/* src */
xPictureMask, /* mask */
xPictureWindow, /* dst */
0, 0, /* src (x,y) */
0, 0, /* mask (x,y) */
x, /* dst x */
y, /* dst y */
IMAGE_WIDTH,
IMAGE_HEIGHT);
}
XSync(xDisplay, False);
struct timeval timeEnd;
gettimeofday(&timeEnd, NULL);
double elapsedSec =
getElapsedMicroseconds(&timeStart, &timeEnd) / 1000000L;
double fps = numIterations / elapsedSec;
printf("average update rate = %.1lf FPS\n", fps);
error:
if (0 != gcMask)
{
XFreeGC(xDisplay, gcMask);
gcMask = 0;
}
if (0 != xPictureMask)
{
XRenderFreePicture(xDisplay, xPictureMask);
xPictureMask = 0;
}
if (0 != xPixmapMask)
{
XFreePixmap(xDisplay, xPixmapMask);
xPixmapMask = 0;
}
if (0 != xPictureOverlay)
{
XRenderFreePicture(xDisplay, xPictureOverlay);
xPictureOverlay = 0;
}
if (0 != xPixmapOverlay)
{
XFreePixmap(xDisplay, xPixmapOverlay);
xPixmapOverlay = 0;
}
if (0 != xPictureMain)
{
XRenderFreePicture(xDisplay, xPictureMain);
xPictureMain = 0;
}
if (0 != xPixmapMain)
{
XFreePixmap(xDisplay, xPixmapMain);
xPixmapMain = 0;
}
if (0 != xPictureWindow)
{
XRenderFreePicture(xDisplay, xPictureWindow);
xPictureWindow = 0;
}
if (0 != xWindow)
{
XDestroyWindow(xDisplay, xWindow);
xWindow = 0;
}
if (NULL != xDisplay)
{
XCloseDisplay(xDisplay);
xDisplay = NULL;
}
return returnCode;
}
int
main(int argc, char **argv)
{
XtAppContext theApp;
Widget label;
Pixel fg,bg;
XmFontList fontlist;
toplevel = XtVaAppInitialize(&theApp, "drawingArea", NULL, 0,
&argc, argv, Fallback, NULL);
fontlist = XmFontListAppendEntry(NULL,
XmFontListEntryCreate("MY_FONT",
XmFONT_IS_FONT,
XLoadQueryFont(XtDisplay(toplevel),
"-adobe-helvetica-bold-o-normal--17-0-75-75-p-*-iso8859-1")));
fontlist = XmFontListAppendEntry(fontlist,
XmFontListEntryCreate("MY_FONT1",
XmFONT_IS_FONT,
XLoadQueryFont(XtDisplay(toplevel),
"-adobe-helvetica-bold-r-normal--17-0-75-75-p-*-iso8859-1")));
#if 0
label= XtVaCreateManagedWidget("Button1", xmLabelWidgetClass, toplevel, XmNfontList, fontlist,
NULL);
#else
label= XtVaCreateManagedWidget("Button1", xmLabelWidgetClass, toplevel,
NULL);
#endif
XtRealizeWidget(toplevel);
theDisplay = XtDisplay(toplevel);
theRootWindow = XDefaultRootWindow(theDisplay);
fg = XBlackPixelOfScreen(DefaultScreenOfDisplay(theDisplay));
bg = XWhitePixelOfScreen(DefaultScreenOfDisplay(theDisplay));
Pix = XmGetPixmap(DefaultScreenOfDisplay(theDisplay),
"xlogo64",
fg, bg);
if (Pix == XmUNSPECIFIED_PIXMAP) {
printf("NO PIXMAP!\n");
exit(0);
}
XtVaSetValues(label,
XmNlabelPixmap,Pix,
XmNlabelType,XmPIXMAP,
NULL);
printf("%p\n", XmDragStart(label, NULL, NULL, 0));
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight , 57, 73, 46, 17, 0,0,0, /* Button1 */
};
PrintDetails( toplevel ,Expected);
};
LessTifTestMainLoop( toplevel );
exit(0);
}
