home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_simple.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  9KB  |  408 lines
  1.  
  2. #include "Xlib_private.h"
  3.  
  4. /*
  5.  * These are all functions where macros already exist
  6.  */
  7.  
  8. Window XDefaultRootWindow(Display* display)
  9. {
  10.     DBUG_ENTER("XDefaultRootWindow")
  11.     Window root = DefaultRootWindow(display);
  12.     DBUG_RETURN(root);
  13. }
  14.  
  15. Screen *XScreenOfDisplay(Display* display, int screen_number) 
  16. {
  17.     DBUG_ENTER("XScreenOfDisplay")
  18.     Screen *screen = ScreenOfDisplay(display, screen_number);
  19.     DBUG_RETURN(screen);
  20. }
  21.  
  22. Window XRootWindow(Display* display, int screen_number)
  23. {
  24.     DBUG_ENTER("XRootWindow")
  25.     Window root = RootWindow(display, screen_number);
  26.     DBUG_RETURN(root);
  27. }
  28.  
  29. Visual *XDefaultVisual(Display* display, int screen_number)
  30. {
  31.     DBUG_ENTER("XDefaultVisual")
  32.     Visual *visual = DefaultVisual(display, screen_number);
  33.     DBUG_RETURN(visual);
  34. }
  35.  
  36. GC XDefaultGC(Display* display, int screen_number)
  37. {
  38.     DBUG_ENTER("XDefaultGC")
  39.     GC gc = DefaultGC(display, screen_number);
  40.     DBUG_RETURN(gc);
  41. }
  42.  
  43. unsigned long XBlackPixel(Display* display, int screen_number)
  44. {
  45.     DBUG_ENTER("XBlackPixel")
  46.     unsigned long black = BlackPixel(display, screen_number);
  47.     DBUG_RETURN(black);
  48. }
  49.  
  50. unsigned long XWhitePixel(Display* display, int screen_number)
  51. {
  52.     DBUG_ENTER("XWhitePixel")
  53.     unsigned long white = WhitePixel(display, screen_number);
  54.     DBUG_RETURN(white);
  55. }
  56.  
  57. int XDisplayWidth(Display* display, int screen_number)
  58. {
  59.     DBUG_ENTER("XDisplayWidth")
  60.     int width = DisplayWidth(display, screen_number);
  61.     DBUG_RETURN(width);
  62. }
  63.  
  64. int XDisplayWidthMM(Display* display, int screen_number)
  65. {
  66.     DBUG_ENTER("XDisplayWidthMM")
  67.     int width = DisplayWidthMM(display, screen_number);
  68.     DBUG_RETURN(width);
  69. }
  70.  
  71. int XDisplayHeight(Display* display, int screen_number)
  72. {
  73.     DBUG_ENTER("XDisplayHeight")
  74.     int height = DisplayHeight(display, screen_number);
  75.     DBUG_RETURN(height);
  76. }
  77.  
  78. int XDisplayHeightMM(Display* display, int screen_number)
  79. {
  80.     DBUG_ENTER("XDisplayHeightMM")
  81.     int height = DisplayHeightMM(display, screen_number);
  82.     DBUG_RETURN(height);
  83. }
  84.  
  85. int XDisplayPlanes(Display* display, int screen_number)
  86. {
  87.     DBUG_ENTER("XDisplayPlanes")
  88.     int planes = DisplayPlanes(display, screen_number);
  89.     DBUG_RETURN(planes);
  90. }
  91.  
  92. int XDefaultDepth(Display* display, int screen_number)
  93. {
  94.     DBUG_ENTER("XDefaultDepth")
  95.     int result = DefaultDepth(display, screen_number);
  96.     DBUG_RETURN(result);
  97. }
  98.  
  99. Screen *XDefaultScreenOfDisplay(Display* display)
  100. {
  101.     DBUG_ENTER("XDefaultScreenOfData")
  102.     Screen *result = DefaultScreenOfDisplay(display);
  103.     DBUG_RETURN(result);
  104. }
  105.  
  106. int XDefaultScreen(Display* display)
  107. {
  108.     DBUG_ENTER("XDefaultScreen")
  109.     int result = DefaultScreen(display);
  110.     DBUG_RETURN(result);
  111. }
  112.  
  113. int XConnectionNumber(Display* display)
  114. {
  115.     DBUG_ENTER("XConnectionNumber")
  116.     int result = ConnectionNumber(display);
  117.     DBUG_RETURN(result);
  118. }
  119.  
  120. unsigned long XAllPlanes(void)
  121. {
  122.     DBUG_ENTER("XAllPlanes")
  123.     unsigned long result = AllPlanes;
  124.     DBUG_RETURN(result);
  125. }
  126.  
  127. int XQLength(Display* display)
  128. {
  129.     DBUG_ENTER("XQLength")
  130.     int result = QLength(display);
  131.     DBUG_RETURN(result);
  132. }
  133.  
  134. int XDisplayCells(Display* display, int screen_number)
  135. {
  136.     DBUG_ENTER("XDisplayCells")
  137.     int result = DisplayCells(display, screen_number);
  138.     DBUG_RETURN(result);
  139. }
  140.  
  141. int XScreenCount(Display* display)
  142. {
  143.     DBUG_ENTER("XScreenCount")
  144.     int result = ScreenCount(display);
  145.     DBUG_RETURN(result);
  146. }
  147.  
  148. char *XDisplayString(Display* display)
  149. {
  150.     DBUG_ENTER("XDisplayString")
  151.     char *result = DisplayString(display);
  152.     DBUG_RETURN(result);
  153. }
  154.  
  155. Colormap XDefaultColormap(Display* display, int screen_number)
  156. {
  157.     DBUG_ENTER("XDefaultColormap")
  158.     Colormap result = DefaultColormap(display, screen_number);
  159.     DBUG_RETURN(result);
  160. }
  161.  
  162. Colormap XDefaultColormapOfScreen(Screen* screen)
  163. {
  164.     DBUG_ENTER("XDefaultColormapOfScreen")
  165.     Colormap result = DefaultColormapOfScreen(screen);
  166.     DBUG_RETURN(result);
  167. }
  168.  
  169. int XBitmapUnit(Display* display)
  170. {
  171.     DBUG_ENTER("XBitmapUnit")
  172.     int result = BitmapUnit(display);
  173.     DBUG_RETURN(result);
  174. }
  175.  
  176. int XBitmapBitOrder(Display* display)
  177. {
  178.     DBUG_ENTER("XBitmapBitOrder")
  179.     int result = BitmapBitOrder(display);
  180.     DBUG_RETURN(result);
  181. }
  182.  
  183. int XBitmapPad(Display* display)
  184. {
  185.     DBUG_ENTER("XBitmapPad")
  186.     int result = BitmapPad(display);
  187.     DBUG_RETURN(result);
  188. }
  189.  
  190. int XImageByteOrder(Display* display)
  191. {
  192.     DBUG_ENTER("XImageByteOrder")
  193.     int result = ImageByteOrder(display);
  194.     DBUG_RETURN(result);
  195. }
  196.  
  197. unsigned long XNextRequest(Display* display)
  198. {
  199.     DBUG_ENTER("XNextRequest")
  200.     unsigned long result = NextRequest(display);
  201.     DBUG_RETURN(result);
  202. }
  203.  
  204. unsigned long XLastKnownRequestProcessed(Display* display)
  205. {
  206.     DBUG_ENTER("XLastKnownRequestProcessed")
  207.     unsigned long result = LastKnownRequestProcessed(display);
  208.     DBUG_RETURN(result);
  209. }
  210.  
  211. Display *XDisplayOfScreen(Screen* screen)
  212. {
  213.     DBUG_ENTER("XDisplayOfScreen")
  214.     Display *result = DisplayOfScreen(screen);
  215.     DBUG_RETURN(result);
  216. }
  217.  
  218. Window XRootWindowOfScreen(Screen* screen)
  219. {
  220.     DBUG_ENTER("XRootWindowOfScreen")
  221.     Window result = RootWindowOfScreen(screen);
  222.     DBUG_RETURN(result);
  223. }
  224.  
  225. unsigned long XBlackPixelOfScreen(Screen* screen)
  226. {
  227.     DBUG_ENTER("XBlackPixelOfScreen")
  228.     unsigned long result = BlackPixelOfScreen(screen);
  229.     DBUG_RETURN(result);
  230. }
  231.  
  232. unsigned long XWhitePixelOfScreen(Screen* screen)
  233. {
  234.     DBUG_ENTER("XWhitePixelOfScreen")
  235.     unsigned long result = WhitePixelOfScreen(screen);
  236.     DBUG_RETURN(result);
  237. }
  238.  
  239. int XDefaultDepthOfScreen(Screen* screen)
  240. {
  241.     DBUG_ENTER("XDefaultDepthOfScreen")
  242.     int result = DefaultDepthOfScreen(screen);
  243.     DBUG_RETURN(result);
  244. }
  245.  
  246. GC XDefaultGCOfScreen(Screen* screen)
  247. {
  248.     DBUG_ENTER("XDefaultGCOfScreen")
  249.     GC result = DefaultGCOfScreen(screen);
  250.     DBUG_RETURN(result);
  251. }
  252.  
  253. Visual *XDefaultVisualOfScreen(Screen* screen)
  254. {
  255.     DBUG_ENTER("XDefaultVisualOfScreen")
  256.     Visual *result = DefaultVisualOfScreen(screen);
  257.     DBUG_RETURN(result);
  258. }
  259.  
  260. int XWidthMMOfScreen(Screen* screen)
  261. {
  262.     DBUG_ENTER("XWidthMMOfScreen")
  263.     int result = WidthMMOfScreen(screen);
  264.     DBUG_RETURN(result);
  265. }
  266.  
  267. int XWidthOfScreen(Screen* screen)
  268. {
  269.     DBUG_ENTER("XWidthOfScreen")
  270.     int result = WidthOfScreen(screen);
  271.     DBUG_RETURN(result);
  272. }
  273.  
  274. int XHeightMMOfScreen(Screen* screen)
  275. {
  276.     DBUG_ENTER("XHeightMMOfScreen")
  277.     int result = HeightMMOfScreen(screen);
  278.     DBUG_RETURN(result);
  279. }
  280.  
  281. int XHeightOfScreen(Screen* screen)
  282. {
  283.     DBUG_ENTER("XHeightOfScreen")
  284.     int result = HeightOfScreen(screen);
  285.     DBUG_RETURN(result);
  286. }
  287.  
  288. int XPlanesOfScreen(Screen* screen)
  289. {
  290.     DBUG_ENTER("XPlanesOfScreen")
  291.     int result = PlanesOfScreen(screen);
  292.     DBUG_RETURN(result);
  293. }
  294.  
  295. int XCellsOfScreen(Screen* screen)
  296. {
  297.     DBUG_ENTER("XCellsOfScreen")
  298.     int result = CellsOfScreen(screen);
  299.     DBUG_RETURN(result);
  300. }
  301.  
  302. int XMaxCmapsOfScreen(Screen* screen)
  303. {
  304.     DBUG_ENTER("XMaxCmapsOfScreen")
  305.     int result = MaxCmapsOfScreen(screen);
  306.     DBUG_RETURN(result);
  307. }
  308.  
  309. int XMinCmapsOfScreen(Screen* screen)
  310. {
  311.     DBUG_ENTER("XMinCmapsOfScreen")
  312.     int result = MinCmapsOfScreen(screen);
  313.     DBUG_RETURN(result);
  314. }
  315.  
  316. Bool XDoesSaveUnders(Screen* screen)
  317. {
  318.     DBUG_ENTER("XDoesSaveUnders")
  319.     Bool result = DoesSaveUnders(screen);
  320.     DBUG_RETURN(result);
  321. }
  322.  
  323. int XDoesBackingStore(Screen* screen)
  324. {
  325.     DBUG_ENTER("XDoesBackingStore")
  326.     int result = DoesBackingStore(screen);
  327.     DBUG_RETURN(result);
  328. }
  329.  
  330. long XEventMaskOfScreen(Screen* screen)
  331. {
  332.     DBUG_ENTER("XEventMaskOfScreen")
  333.     long result = EventMaskOfScreen(screen);
  334.     DBUG_RETURN(result);
  335. }
  336.  
  337. int XScreenNumberOfScreen (scr)
  338.     register Screen *scr;
  339. {
  340.     DBUG_ENTER("XScreenNumberOfScreen")
  341.     register Display *dpy = scr->display;
  342.     register Screen *dpyscr = dpy->screens;
  343.     register int i;
  344.  
  345.     for (i = 0; i < dpy->nscreens; i++, dpyscr++) {
  346.     if (scr == dpyscr) DBUG_RETURN(i);
  347.     }
  348.     DBUG_RETURN(-1);
  349. }
  350.  
  351. /*
  352.  * These macros are used to give some sugar to the image routines so that
  353.  * naive people are more comfortable with them.
  354.  */
  355. #undef XDestroyImage
  356. int XDestroyImage(ximage)
  357.     XImage *ximage;
  358. {
  359.     DBUG_ENTER("XDestroyImage")
  360.     int result = (*((ximage)->f.destroy_image))((ximage));
  361.     DBUG_RETURN(result);
  362. }
  363. #undef XGetPixel
  364. unsigned long XGetPixel(ximage, x, y)
  365.     XImage *ximage;
  366.     int x, y;
  367. {
  368.     DBUG_ENTER("XGetPixel")
  369.     unsigned long result = (*((ximage)->f.get_pixel))((ximage), (x), (y));
  370.     DBUG_RETURN(result);
  371. }
  372. #undef XPutPixel
  373. int XPutPixel(ximage, x, y, pixel)
  374.     XImage *ximage;
  375.     int x, y;
  376.     unsigned long pixel;
  377. {
  378.     DBUG_ENTER("XPutPixel")
  379.     int result = (*((ximage)->f.put_pixel))((ximage), (x), (y), (pixel));
  380.     DBUG_RETURN(result);
  381. }
  382. #undef XSubImage
  383. XImage *XSubImage(ximage, x, y, width, height)
  384.     XImage *ximage;
  385.     int x, y;
  386.     unsigned int width, height;
  387. {
  388.     DBUG_ENTER("XSubImage")
  389.     XImage *result = (*((ximage)->f.sub_image))((ximage), (x),
  390.         (y), (width), (height));
  391.     DBUG_RETURN(result);
  392. }
  393. #undef XAddPixel
  394. int XAddPixel(ximage, value)
  395.     XImage *ximage;
  396.     long value;
  397. {
  398.     DBUG_ENTER("XAddPixel")
  399.     int result = (*((ximage)->f.add_pixel))((ximage), (value));
  400.     DBUG_RETURN(result);
  401. }
  402.  
  403.  
  404.  
  405.  
  406.  
  407.  
  408.