home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tcltk805.zip / tcl805s.zip / tk8.0.5 / os2 / stubs.c < prev    next >
C/C++ Source or Header  |  1999-04-23  |  7KB  |  400 lines
  1. #include <X11/X.h>
  2. #include <X11/Xlib.h>
  3. #include <stdio.h>
  4. #include <tkInt.h>
  5. #include <tkPort.h>
  6. #include <tkInt.h>
  7.  
  8. /*
  9.  * Undocumented Xlib internal function
  10.  */
  11.  
  12. _XInitImageFuncPtrs(XImage *image)
  13. {
  14.     return 0;
  15. }
  16.  
  17. /*
  18.  * From Xutil.h
  19.  */
  20.  
  21. void
  22. XSetWMClientMachine(display, w, text_prop)
  23.     Display* display;
  24.     Window w;
  25.     XTextProperty* text_prop;
  26. {
  27. }
  28.  
  29. Status
  30. XStringListToTextProperty(list, count, text_prop_return)
  31.     char** list;
  32.     int count;
  33.     XTextProperty* text_prop_return;
  34. {
  35.     return (Status) NULL;
  36. }
  37.  
  38. /*
  39.  * From Xlib.h
  40.  */
  41.  
  42. void
  43. XChangeProperty(display, w, property, type, format, mode, data, nelements)
  44.     Display* display;
  45.     Window w;
  46.     Atom property;
  47.     Atom type;
  48.     int format;
  49.     int mode;
  50.     _Xconst unsigned char* data;
  51.     int nelements;
  52. {
  53. }
  54.  
  55. Cursor
  56. XCreateGlyphCursor(display, source_font, mask_font, source_char, mask_char,
  57.     foreground_color, background_color)
  58.     Display* display;
  59.     Font source_font;
  60.     Font mask_font;
  61.     unsigned int source_char;
  62.     unsigned int mask_char;
  63.     XColor* foreground_color;
  64.     XColor* background_color;
  65. {
  66.     return 1;
  67. }
  68.  
  69. XIC
  70. XCreateIC()
  71. {
  72.     return 0;
  73. }
  74.  
  75. Cursor
  76. XCreatePixmapCursor(display, source, mask, foreground_color,
  77.     background_color, x, y)
  78.     Display* display;
  79.     Pixmap source;
  80.     Pixmap mask;
  81.     XColor* foreground_color;
  82.     XColor* background_color;
  83.     unsigned int x;
  84.     unsigned int y;
  85. {
  86.     return 0;
  87. }
  88.  
  89. void
  90. XDeleteProperty(display, w, property)
  91.     Display* display;
  92.     Window w;
  93.     Atom property;
  94. {
  95. }
  96.  
  97. void
  98. XDestroyIC(ic)
  99.     XIC ic;
  100. {
  101. }
  102.  
  103. Bool
  104. XFilterEvent(event, window)
  105.     XEvent* event;
  106.     Window window;
  107. {
  108.     return 0;
  109. }
  110.  
  111. extern void XForceScreenSaver(display, mode)
  112.     Display* display;
  113.     int mode;
  114. {
  115. }
  116.  
  117. void
  118. XFreeCursor(display, cursor)
  119.     Display* display;
  120.     Cursor cursor;
  121. {
  122. }
  123.  
  124. GContext
  125. XGContextFromGC(gc)
  126.     GC gc;
  127. {
  128.     return (GContext) NULL;
  129. }
  130.  
  131. char *
  132. XGetAtomName(display, atom)
  133.     Display* display;
  134.     Atom atom;
  135. {
  136.     return NULL;
  137. }
  138.  
  139. int
  140. XGetWindowAttributes(display, w, window_attributes_return)
  141.     Display* display;
  142.     Window w;
  143.     XWindowAttributes* window_attributes_return;
  144. {
  145.     return 0;
  146. }
  147.  
  148. Status
  149. XGetWMColormapWindows(display, w, windows_return, count_return)
  150.     Display* display;
  151.     Window w;
  152.     Window** windows_return;
  153.     int* count_return;
  154. {
  155.     return 0;
  156. }
  157.  
  158. int
  159. XIconifyWindow(display, w, screen_number)
  160.     Display* display;
  161.     Window w;
  162.     int screen_number;
  163. {
  164.     return 0;
  165. }
  166.  
  167. XHostAddress *
  168. XListHosts(display, nhosts_return, state_return)
  169.     Display* display;
  170.     int* nhosts_return;
  171.     Bool* state_return;
  172. {
  173.     return NULL;
  174. }
  175.  
  176. int
  177. XLookupColor(display, colormap, color_name, exact_def_return,
  178.     screen_def_return)
  179.     Display* display;
  180.     Colormap colormap;
  181.     _Xconst char* color_name;
  182.     XColor* exact_def_return;
  183.     XColor* screen_def_return;
  184. {
  185.     return 0;
  186. }
  187.  
  188. void
  189. XNextEvent(display, event_return)
  190.     Display* display;
  191.     XEvent* event_return;
  192. {
  193. }
  194.  
  195. void
  196. XPutBackEvent(display, event)
  197.     Display* display;
  198.     XEvent* event;
  199. {
  200. }
  201.  
  202. void
  203. XQueryColors(display, colormap, defs_in_out, ncolors)
  204.     Display* display;
  205.     Colormap colormap;
  206.     XColor* defs_in_out;
  207.     int ncolors;
  208. {
  209. }
  210.  
  211. int
  212. XQueryTree(display, w, root_return, parent_return, children_return,
  213.     nchildren_return)
  214.     Display* display;
  215.     Window w;
  216.     Window* root_return;
  217.     Window* parent_return;
  218.     Window** children_return;
  219.     unsigned int* nchildren_return;
  220. {
  221.     return 0;
  222. }
  223.  
  224. void
  225. XRefreshKeyboardMapping(event_map)
  226.     XMappingEvent* event_map;
  227. {
  228. }
  229.  
  230. Window
  231. XRootWindow(display, screen_number)
  232.     Display* display;
  233.     int screen_number;
  234. {
  235.     return (Window) NULL;
  236. }
  237.  
  238. void
  239. XSelectInput(display, w, event_mask)
  240.     Display* display;
  241.     Window w;
  242.     long event_mask;
  243. {
  244. }
  245.  
  246. int
  247. XSendEvent(display, w, propagate, event_mask, event_send)
  248.     Display* display;
  249.     Window w;
  250.     Bool propagate;
  251.     long event_mask;
  252.     XEvent* event_send;
  253. {
  254.     return 0;
  255. }
  256.  
  257. void
  258. XSetCommand(display, w, argv, argc)
  259.     Display* display;
  260.     Window w;
  261.     char** argv;
  262.     int argc;
  263. {
  264. }
  265.  
  266. XErrorHandler
  267. XSetErrorHandler (handler)
  268.     XErrorHandler handler;
  269. {
  270.     return NULL;
  271. }
  272.  
  273. void
  274. XSetIconName(display, w, icon_name)
  275.     Display* display;
  276.     Window w;
  277.     _Xconst char* icon_name;
  278. {
  279. }
  280.  
  281. void
  282. XSetWindowBackground(display, w, background_pixel)
  283.     Display* display;
  284.     Window w;
  285.     unsigned long background_pixel;
  286. {
  287. }
  288.  
  289. void
  290. XSetWindowBackgroundPixmap(display, w, background_pixmap)
  291.     Display* display;
  292.     Window w;
  293.     Pixmap background_pixmap;
  294. {
  295. }
  296.  
  297. void
  298. XSetWindowBorder(display, w, border_pixel)
  299.     Display* display;
  300.     Window w;
  301.     unsigned long border_pixel;
  302. {
  303. }
  304.  
  305. void
  306. XSetWindowBorderPixmap(display, w, border_pixmap)
  307.     Display* display;
  308.     Window w;
  309.     Pixmap border_pixmap;
  310. {
  311. }
  312.  
  313. void
  314. XSetWindowBorderWidth(display, w, width)
  315.     Display* display;
  316.     Window w;
  317.     unsigned int width;
  318. {
  319. }
  320.  
  321. void
  322. XSetWindowColormap(display, w, colormap)
  323.     Display* display;
  324.     Window w;
  325.     Colormap colormap;
  326. {
  327. }
  328.  
  329. Bool
  330. XTranslateCoordinates(display, src_w, dest_w, src_x, src_y, dest_x_return,
  331.     dest_y_return, child_return)
  332.     Display* display;
  333.     Window src_w;
  334.     Window dest_w;
  335.     int src_x;
  336.     int src_y;
  337.     int* dest_x_return;
  338.     int* dest_y_return;
  339.     Window* child_return;
  340. {
  341.     return 0;
  342. }
  343.  
  344. void
  345. XWindowEvent(display, w, event_mask, event_return)
  346.     Display* display;
  347.     Window w;
  348.     long event_mask;
  349.     XEvent* event_return;
  350. {
  351. }
  352.  
  353. int
  354. XWithdrawWindow(display, w, screen_number)
  355.     Display* display;
  356.     Window w;
  357.     int screen_number;
  358. {
  359.     XUnmapWindow(display, w);
  360.     return 1;
  361. }
  362.  
  363. int
  364. XmbLookupString(ic, event, buffer_return, bytes_buffer, keysym_return,
  365.     status_return)
  366.     XIC ic;
  367.     XKeyPressedEvent* event;
  368.     char* buffer_return;
  369.     int bytes_buffer;
  370.     KeySym* keysym_return;
  371.     Status* status_return;
  372. {
  373.     return 0;
  374. }
  375.  
  376. int
  377. XGetWindowProperty(display, w, property, long_offset, long_length, delete,
  378.     req_type, actual_type_return, actual_format_return, nitems_return,
  379.     bytes_after_return, prop_return)
  380.     Display* display;
  381.     Window w;
  382.     Atom property;
  383.     long long_offset;
  384.     long long_length;
  385.     Bool delete;
  386.     Atom req_type;
  387.     Atom* actual_type_return;
  388.     int* actual_format_return;
  389.     unsigned long* nitems_return;
  390.     unsigned long* bytes_after_return;
  391.     unsigned char** prop_return;
  392. {
  393.     *actual_type_return = None;
  394.     *actual_format_return = 0;
  395.     *nitems_return = 0;
  396.     *bytes_after_return = 0;
  397.     *prop_return = NULL;
  398.     return BadValue;            /* failure */
  399. }
  400.