home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_misc.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  9KB  |  353 lines
  1.  
  2. #include "Xlib_private.h"
  3. #include <netdb.h>
  4.  
  5. HAB pmctls_hab;
  6.  
  7. Colormap Xlib_CreateDefaultColormap(Display *dpy);
  8.  
  9. Screen *new_screen(Display *display)
  10. {
  11.     DBUG_ENTER("new_screen")
  12.     Screen *tmpscreen;
  13.     XGCValues values;
  14.     HPS hps;
  15.     HDC hdc;
  16.     LONG res[2];
  17.  
  18.     DBUG_POINT("calloc");
  19.         tmpscreen = calloc(1,sizeof(Screen));
  20.     if (!tmpscreen) {
  21.         fprintf(stderr,"new_screen: malloc failed!");
  22.         abort();
  23.     } else
  24.     DBUG_POINT("1");
  25.  
  26.         /* Fill in the screen structure */
  27.         tmpscreen->display = display;
  28.         tmpscreen->root = hwndDesktop;
  29.         tmpscreen->height = WinQuerySysValue(hwndDesktop,SV_CYSCREEN);
  30.         tmpscreen->width = WinQuerySysValue(hwndDesktop,SV_CXSCREEN);
  31.  
  32.     hps = WinGetScreenPS(hwndDesktop);
  33.     hdc = GpiQueryDevice(hps);
  34.     DevQueryCaps(hdc, CAPS_HORIZONTAL_FONT_RES, 2, res);
  35.     WinReleasePS(hps);
  36.  
  37.     tmpscreen->mwidth = (tmpscreen->width * 3048) / (125 * res[0] - 3000);
  38.     tmpscreen->mheight = (tmpscreen->height * 3048) / (125 * res[1] - 3000);
  39.  
  40.         /* Not too sure about depths */
  41.         tmpscreen->ndepths = 1;
  42.     DBUG_POINT("Xmalloc");
  43.         tmpscreen->depths = (Depth *)Xcalloc(1,sizeof(Depth));
  44.     if (!tmpscreen->depths) {
  45.         printf("new_screen: Xmalloc failed!\n");
  46.         abort();
  47.     }
  48.         tmpscreen->root_depth = 24;
  49.     tmpscreen->depths->depth = 24;
  50.     tmpscreen->depths->nvisuals = 1;
  51.     DBUG_POINT("Xmalloc");
  52.     tmpscreen->depths->visuals = (Visual *)Xcalloc(1,sizeof(Visual));
  53.     tmpscreen->depths->visuals->ext_data = NULL;
  54.     tmpscreen->depths->visuals->visualid = (VisualID)mainhab;
  55.     tmpscreen->depths->visuals->class = TrueColor;
  56.     tmpscreen->depths->visuals->red_mask =
  57.     tmpscreen->depths->visuals->green_mask =
  58.     tmpscreen->depths->visuals->blue_mask = 0xff00;
  59.     tmpscreen->depths->visuals->bits_per_rgb = 8;
  60.     tmpscreen->depths->visuals->map_entries = 0;
  61.  
  62.     tmpscreen->root_visual = tmpscreen->depths->visuals;
  63.  
  64.         /* Get the colormap of the root window (HWND_DESKTOP) */
  65.         tmpscreen->cmap = Xlib_CreateDefaultColormap(display);
  66.  
  67.     values.background = tmpscreen->white_pixel = 0x00ffffffL;
  68.     values.foreground = tmpscreen->black_pixel = 0x00000000L;
  69.     
  70.     tmpscreen->default_gc = XCreateGC(display, tmpscreen->root, 
  71.             GCForeground | GCBackground, &values);
  72.  
  73.         DBUG_RETURN(tmpscreen);
  74. }
  75.  
  76. int free_screen(Screen* screen)
  77. {
  78.     DBUG_ENTER("free_screen")
  79.     if (screen) free(screen);
  80.     DBUG_RETURN(True);
  81. }
  82.  
  83. XExtData *new_xextdata(void)
  84. {
  85.     DBUG_ENTER("new_xextdata")
  86.     XExtData *tmpxextdata;
  87.  
  88.         tmpxextdata = malloc(sizeof(XExtData));
  89.  
  90.         DBUG_RETURN(tmpxextdata);
  91. }
  92.  
  93. int free_xextdata(XExtData *xextdata)
  94. {
  95.     DBUG_ENTER("free_xextdata")
  96.     if (xextdata) free(xextdata);
  97.     DBUG_RETURN(True);
  98. }
  99.  
  100. Visual *new_visual(void)
  101. {
  102.     DBUG_ENTER("new_visual")
  103.     Visual *tmpvisual;
  104.     
  105.     tmpvisual = malloc(sizeof(Visual));
  106.  
  107.     DBUG_RETURN(tmpvisual);
  108. }
  109.  
  110. int free_visual(Visual *visual)
  111. {
  112.     DBUG_ENTER("free_visual")
  113.     if (visual) free(visual);
  114.     DBUG_RETURN(True);
  115. }
  116.  
  117. int XNoOp(Display* display)
  118. {
  119.     pthread_yield();
  120.     return TRUE;
  121. }
  122.  
  123. int XBell(Display* display, int percent)
  124. {
  125.     if (percent<=50)
  126.         WinAlarm(hwndDesktop, WA_NOTE);
  127.     else
  128.     if (percent<=75)
  129.         WinAlarm(hwndDesktop, WA_WARNING);
  130.     else
  131.         WinAlarm(hwndDesktop, WA_ERROR);
  132.     return TRUE;
  133. }
  134.  
  135. int XAutoRepeatOff(Display* display)
  136. {
  137.     auto_repeat = 0;
  138.     return TRUE;
  139. }
  140.  
  141. int XAutoRepeatOn(Display* display)
  142. {
  143.     auto_repeat = 1;
  144.     return TRUE;
  145. }
  146.  
  147. char *XDisplayName(_Xconst char* display)
  148. {
  149.     char *d;
  150.     if ( display != (char *)NULL && *display != '\0' )
  151.     return( (char*) display );
  152.     if ( (d = getenv( "DISPLAY" )) != (char *)NULL )
  153.     return( d );
  154.     return( "" );
  155. }
  156.  
  157. char *__XOS2RedirRoot(char *fname)
  158. {
  159.     /* This adds a further redirection by allowing the ProjectRoot
  160.      * to be prepended by the content of the envvar X11ROOT.
  161.      * This is for the purpose to move the whole X11 stuff to a different
  162.      * disk drive.
  163.      * The feature was added despite various environment variables
  164.      * because not all file opens respect them.
  165.      */
  166.     static char redirname[300]; /* enough for long filenames */
  167.     char *root;
  168.  
  169.     /* if name does not start with /, assume it is not root-based */
  170.     if (fname==0 || !(fname[0]=='/' || fname[0]=='\\'))
  171.     return fname;
  172.  
  173.     root = (char*)getenv("X11ROOT");
  174.     if (root==0 || 
  175.     ((fname[1]==':') && (isalpha((int)fname[0]))) ||
  176.         (strlen(fname)+strlen(root)+2) > 300)
  177.     return fname;
  178.     sprintf(redirname,"%s%s",root,fname);
  179.     return redirname;
  180. }
  181.  
  182. char *__XOS2RedirRoot1(char *format, char *arg1, char *arg2, char *arg3)
  183. {
  184.     /* this first constructs a name from a format and up to three
  185.      * components, then adds a path
  186.      */
  187.     char buf[300];
  188.     sprintf(buf,format,arg1,arg2,arg3);
  189.     return __XOS2RedirRoot(buf);
  190. }
  191.  
  192. int _XGetHostname(char* buf, int maxlen)
  193. {
  194.     int len;
  195. #ifdef NEED_UTSNAME
  196.     struct utsname name;
  197.     if (maxlen <= 0 || buf == NULL)
  198.     return 0;
  199.     uname (&name);
  200.     len = strlen (name.nodename);
  201.     if (len >= maxlen) len = maxlen - 1;
  202.     strncpy (buf, name.nodename, len);
  203.     buf[len] = '\0';
  204. #else
  205.     if (maxlen <= 0 || buf == NULL)
  206.     return 0;
  207.     buf[0] = '\0';
  208.     (void) gethostname (buf, maxlen);
  209.     buf [maxlen - 1] = '\0';
  210.     len = strlen(buf);
  211. #endif /* NEED_UTSNAME */
  212.     return len;
  213. }
  214.  
  215. long XMaxRequestSize(dpy)
  216.     Display *dpy;
  217. {
  218.     DBUG_ENTER("XMaxRequestSize")
  219.     long result = dpy->max_request_size;
  220.     DBUG_RETURN(result);
  221. }
  222.  
  223. long XExtendedMaxRequestSize(Display *display)
  224. {
  225.    DBUG_ENTER("XExtendedMaxRequestSize");
  226.    DBUG_RETURN(0);
  227. }
  228.  
  229. char *XResourceManagerString(dpy)
  230.     Display *dpy;
  231. {
  232.     DBUG_ENTER("XResourceManagerString")
  233.     char *result = dpy->xdefaults;
  234.     DBUG_RETURN(result);
  235. }
  236.  
  237. unsigned long XDisplayMotionBufferSize(dpy)
  238.     Display *dpy;
  239. {
  240.     DBUG_ENTER("XDisplayMotionBufferSize")
  241.     unsigned long result = dpy->motion_buffer;
  242.     DBUG_RETURN(result);
  243. }
  244.  
  245. int XDisplayKeycodes(dpy, min_keycode_return, max_keycode_return)
  246.     Display *dpy;
  247.     int *min_keycode_return, *max_keycode_return;
  248. {
  249.     DBUG_ENTER("XDisplayKeycodes")
  250.     *min_keycode_return = dpy->min_keycode;
  251.     *max_keycode_return = dpy->max_keycode;
  252.     DBUG_RETURN(1);
  253. }
  254.  
  255. VisualID XVisualIDFromVisual(visual)
  256.     Visual *visual;
  257. {
  258.     DBUG_ENTER("XVisualIDFromVisual")
  259.     VisualID result = visual->visualid;
  260.     DBUG_RETURN(result);
  261. }
  262.  
  263. #if 0
  264. long XExtendedMaxRequestSize(dpy)
  265.     Display *dpy;
  266. {
  267.     return dpy->bigreq_size;
  268. }
  269. #endif
  270.  
  271. char *XScreenResourceString(screen)
  272.     Screen *screen;
  273. {
  274.     DBUG_ENTER("XScreenResourceString")
  275.     Atom prop_name;
  276.     Atom actual_type;
  277.     int actual_format;
  278.     unsigned long nitems;
  279.     unsigned long leftover;
  280.     char *val = NULL;
  281.  
  282.     prop_name = XInternAtom(screen->display, "SCREEN_RESOURCES", True);
  283.     if (prop_name &&
  284.     XGetWindowProperty(screen->display, screen->root, prop_name,
  285.                0L, 100000000L, False,
  286.                XA_STRING, &actual_type, &actual_format,
  287.                &nitems, &leftover,
  288.                (unsigned char **) &val) == Success) {
  289.     if ((actual_type == XA_STRING) && (actual_format == 8))
  290.         DBUG_RETURN(val);
  291.     if (val)
  292.         Xfree(val);
  293.     }
  294.     DBUG_RETURN((char *)NULL);
  295. }
  296.  
  297. /*
  298.  * Given a visual id, find the visual structure for this id on this display.
  299.  */
  300. Visual *_XVIDtoVisual (dpy, id)
  301.     Display *dpy;
  302.     VisualID id;
  303. {
  304.     DBUG_ENTER("_XVIDtoVisual")
  305.     register int i, j, k;
  306.     register Screen *sp;
  307.     register Depth *dp;
  308.     register Visual *vp;
  309.     for (i = 0; i < dpy->nscreens; i++) {
  310.         sp = &dpy->screens[i];
  311.         for (j = 0; j < sp->ndepths; j++) {
  312.             dp = &sp->depths[j];
  313.             /* if nvisuals == 0 then visuals will be NULL */
  314.             for (k = 0; k < dp->nvisuals; k++) {
  315.                 vp = &dp->visuals[k];
  316.                 if (vp->visualid == id) DBUG_RETURN(vp);
  317.             }
  318.         }
  319.     }
  320.     DBUG_RETURN(NULL);
  321. }
  322.  
  323. int _XFreeExtData (XExtData* extension)
  324. {
  325.     DBUG_ENTER("_XFreeExtData")
  326.     XExtData *temp;
  327.     while (extension) {
  328.         if (extension->free_private) 
  329.             (*extension->free_private)(extension);
  330.         else Xfree ((char *)extension->private_data);
  331.         temp = extension->next;
  332.         Xfree ((char *)extension);
  333.         extension = temp;
  334.     }
  335.     DBUG_RETURN(0);
  336. }
  337.  
  338. XGetKeyboardControl (dpy, state)
  339.     register Display *dpy;
  340.     register XKeyboardState *state;
  341.     {
  342.  
  343.     state->key_click_percent = 0;
  344.     state->bell_percent = 50;
  345.     state->bell_pitch = 770;
  346.     state->bell_duration = 200;
  347.     state->led_mask = 0;
  348.     state->global_auto_repeat = auto_repeat;
  349.     SyncHandle();
  350.     return 1;
  351.     }
  352.  
  353.