home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / xfedor.zip / XFree86 / src / xfedor / couchex.c < prev    next >
C/C++ Source or Header  |  1998-11-06  |  25KB  |  972 lines
  1. /* Copyright 1989 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  2. /***  COUCHE DE PORTAGE SUR X WINDOW ***/
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. extern int strlen() ;
  7.  
  8. #include <X11/Xlib.h>
  9. #include <X11/Xatom.h>        /* XA_WM_NAME */
  10. #include <X11/cursorfont.h>        /* XC_arrow */
  11. #include <X11/Xutil.h>        /* BitmapSucces */
  12. #include <X11/keysym.h>        /* IsModifierKey */
  13. #include <X11/keysymdef.h>        /* IsModifierKey */
  14.  
  15. #include "couche.h"         /* myEvent, ..CURS, ON */
  16. #include "clientimage.h"    /* ClientImage */
  17.  
  18. #include "X11/xpm.h"        /* PixmapSuccess ...*/
  19.  
  20.  
  21. /*===== VARIABLES EXPORTEES DU MODULE ==============================*/
  22. /* principalement vers myrast.c */
  23.  
  24. Display * Dpl ;
  25. Window root ;
  26. int depth ;
  27. int screen ;
  28. int BackColor ;
  29. int ImaForm ;
  30.  
  31. /*===== VARIABLES LOCALES DU MODULE ==============================*/
  32.  
  33. static GC Gc, GcInv, GcCInv, GcTil, GcPft, GcFontColor, GcColor ; 
  34. static Colormap colormap ;
  35. static Atom WM_Delete_Window;
  36.  
  37.     /* pour la gestion des zones */
  38. #define NBZONE 200
  39. static struct {int zone,mere,xorz,yorz;} Tzone[NBZONE];
  40.  
  41. static XColor fore,back ; /* pour XCreatePixmapCursor */
  42.  
  43. static unsigned long background_pixel, border_pixel ; /* pour wattrib */
  44.  
  45. static XFontStruct * ft ;        /* pour w_centrer */
  46.  
  47. static Cursor ServCurs[5];     /* tableau indic'es par les macros .. CURS */
  48.  
  49. static int argc ;
  50. static char ** argv ;    /* pour XSetStandardProperties */
  51.  
  52. #include "bitmaps/nfmono"           /* fond fenetre mere */
  53. #include "bitmaps/bull"             /* icone arbre bull */
  54.  
  55. static Pixmap bullicon ;
  56.  
  57. static long flagPosition ;
  58.  
  59. #define PIXELGREY -13      /* pour traitement special monochome entre
  60.                   w_color et w_greypixel */
  61. int ErrorStatus ;
  62.  
  63. int NoXError(display, error)
  64. Display        *display;
  65. XErrorEvent    *error;
  66. {
  67.    ErrorStatus = error -> error_code;
  68.    return 0;
  69. }
  70.  
  71. /*--------------------------------------------------------------*/      
  72. /* W_INITIAL */
  73. int w_initial (reverse,display,font1,font2,r_argc,r_argv,geom,imaform)
  74.     int reverse ;
  75.     char  * display ;
  76.     char * font1, * font2 ;
  77.     int r_argc ;
  78.     char ** r_argv ;
  79.         char * geom ;
  80.         int imaform ;   /* determine le format d'image XY ou ZPixmap */
  81.         
  82. {  
  83.          XGCValues xgcv;
  84.      Pixmap MyGrey ;
  85.      long TabGris[8];    /* 16 sur 16 bits */
  86.      int i ;
  87.  
  88.       if ((Dpl = XOpenDisplay(display)) == NULL) {
  89.         fprintf(stderr,"Cannot open display : %s\n",
  90.             XDisplayName(display));
  91.         exit(0);
  92.       }
  93.  
  94. /* XSynchronize(Dpl,1);  use in debug */
  95.  
  96.       screen = DefaultScreen(Dpl) ;
  97.       root = DefaultRootWindow(Dpl);
  98.       depth = DefaultDepth(Dpl,screen) ;
  99.       colormap = DefaultColormap(Dpl,screen) ;
  100.  
  101.       if (imaform == 0) {  /* pas de format specifie : choix hack */
  102.     if (depth > 2) ImaForm = ZPixmap ; else ImaForm = XYPixmap ; 
  103.       } else
  104.       if ((imaform == 2) && (depth != 2)) ImaForm = ZPixmap ; else
  105.     ImaForm = XYPixmap ;
  106.  
  107.       if (reverse == OFF ) {
  108.               xgcv.foreground = BlackPixel(Dpl,screen) ;
  109.          border_pixel = BlackPixel(Dpl,screen) ;
  110.         fore.pixel = BlackPixel(Dpl,screen) ;
  111.           
  112.         xgcv.background = WhitePixel(Dpl,screen) ;
  113.         background_pixel = WhitePixel(Dpl,screen) ;
  114.          back.pixel = WhitePixel(Dpl,screen) ;
  115.     } else {
  116.               xgcv.foreground = WhitePixel(Dpl,screen) ;
  117.         border_pixel = WhitePixel(Dpl,screen) ;
  118.         fore.pixel = WhitePixel(Dpl,screen) ;
  119.           
  120.         xgcv.background = BlackPixel(Dpl,screen) ;
  121.         background_pixel = BlackPixel(Dpl,screen) ;
  122.         back.pixel = BlackPixel(Dpl,screen) ;
  123.       }
  124.  
  125.       BackColor = WhitePixel(Dpl,screen) ;
  126.       XQueryColor(Dpl,colormap,&fore) ;
  127.       XQueryColor(Dpl,colormap,&back) ;
  128.  
  129.     /* init de shapes souris predefinis */
  130.       ServCurs[CURS1]  = XCreateFontCursor(Dpl,XC_dot);
  131.       ServCurs[CURS2]   = XCreateFontCursor(Dpl,XC_plus);
  132.       ServCurs[CURS3] = XCreateFontCursor(Dpl,XC_fleur);
  133.       ServCurs[CURS4]  = XCreateFontCursor(Dpl,XC_left_ptr);
  134.       ServCurs[CURS5]  = XCreateFontCursor(Dpl,XC_sb_h_double_arrow);
  135.  
  136.     /* Creation des Gc de travail globaux */
  137.       xgcv.graphics_exposures = False ;
  138.  
  139.       XSynchronize(Dpl,1);
  140.       ErrorStatus = 0;
  141.       XSetErrorHandler(NoXError);
  142.       xgcv.font = XLoadFont(Dpl,font1);
  143.       if (ErrorStatus) {
  144.       fprintf(stderr,"Can'f find font named \"%s\", try another one with -f1 option\n",font1);
  145.           exit(0);
  146. /*      xgcv.font = XQueryFont(Dpl,DefaultGC(Dpl,screen) -> gid)-> fid; */
  147.       }
  148.       ft = XQueryFont(Dpl,xgcv.font) ;
  149.       Gc = XCreateGC(Dpl,root,GCForeground|GCBackground|GCFont|
  150.                 GCGraphicsExposures, &xgcv);
  151.  
  152.       GcColor = XCreateGC(Dpl,root,GCGraphicsExposures, &xgcv);
  153.  
  154.       GcFontColor = XCreateGC(Dpl,root,GCBackground|GCForeground|
  155.                   GCGraphicsExposures, &xgcv);
  156.  
  157.       ErrorStatus = 0;
  158.       XSetErrorHandler(NoXError);
  159.       xgcv.font = XLoadFont(Dpl,font2);
  160.       if (ErrorStatus) {
  161.       fprintf(stderr,"Can'f find font named \"%s\", try another one with -f2 option\n",font2);
  162.           exit(0);
  163. /*      xgcv.font = XQueryFont(Dpl,DefaultGC(Dpl,screen) -> gid)-> fid; */
  164.       }
  165.       XSynchronize(Dpl,0);
  166.       GcPft = XCreateGC(Dpl,root,GCForeground|GCBackground|GCFont|
  167.                 GCGraphicsExposures, &xgcv);
  168.  
  169.       xgcv.function = GXinvert ;
  170.       GcInv = XCreateGC(Dpl,root,GCForeground|GCBackground|
  171.             GCFunction|GCGraphicsExposures, &xgcv);
  172.  
  173.       xgcv.function = GXcopyInverted ;
  174.       GcCInv = XCreateGC(
  175. Dpl,root,GCForeground|GCBackground|
  176.              GCFunction|GCGraphicsExposures, &xgcv);
  177.  
  178.       for (i=0;i<8;i++) TabGris[i] = 0x5555aaaa ;
  179.       MyGrey = XCreatePixmap(Dpl,root,16,16,depth);
  180.       XFillRectangle(Dpl,MyGrey,GcColor,0,0,16,16);
  181.       XPutImage(Dpl,MyGrey,GcColor,
  182.         XCreateImage(Dpl,DefaultVisual(Dpl,screen),
  183.                  1,XYBitmap,0,(char *)TabGris,16,16,16,0),
  184.         0,0,0,0,16,16);
  185.  
  186.       xgcv.tile = MyGrey ;
  187.       xgcv.fill_style = FillTiled ;
  188.       GcTil = XCreateGC(Dpl,root,GCForeground|GCBackground|
  189.             GCFillStyle|GCTile|GCGraphicsExposures, &xgcv);
  190.  
  191.       argc = r_argc ;
  192.       argv = r_argv ;
  193.  
  194.       bullicon = XCreateBitmapFromData(Dpl,root,
  195.                        (char *)bull_bits,bull_width,bull_height);
  196.  
  197.       if (geom) flagPosition = USPosition ; else
  198.             flagPosition = PPosition ;
  199.  
  200.       return((int)root);
  201. }
  202.    
  203. /*---------------------------------------------------------------------*/
  204. /* W_OUVRIR */
  205. long TransformMask(mask)
  206.     int mask ;
  207. {    int eventmask=0 ;
  208.  
  209.     if (mask & KeyPressed) eventmask |= KeyPressMask ;
  210.     if (mask & ButtonPressed) eventmask |= ButtonPressMask ;
  211.     if (mask & MoveMouse) eventmask |= PointerMotionMask ;
  212.     if (mask & LeaveWindow) eventmask |= LeaveWindowMask ;
  213.     if (mask & EnterWindow) eventmask |= EnterWindowMask ;
  214.     if (mask & ResizeWindow) eventmask |= StructureNotifyMask ;
  215.     if (mask & LeaveZone) eventmask |= LeaveWindowMask ;
  216.     if (mask & EnterZone) eventmask |= EnterWindowMask ;
  217.     return eventmask|ExposureMask|ButtonReleaseMask ;
  218. }
  219.  
  220. int w_ouvrir (wd,x,y,w,h,titre,mlook,eventmask,no_wm)
  221.    int wd ;        /* fenetre mere */
  222.    int x,y,w,h ;    /* dimension + origine */
  223.    char *  titre;       /* titre de la fenetre , ou "" si on veut rien */
  224.    int mlook;         /* look de la souris */
  225.    int eventmask ;    /* masque des evenements */
  226.    int no_wm ;        /* False or True */
  227. { 
  228.     Window wn;
  229.     XSetWindowAttributes wattrib ;
  230.     XSizeHints hints ;
  231.     XWMHints wmhints ;
  232.     XClassHint classhint ;
  233.     int backflag  ;
  234.  
  235.     wattrib.event_mask = TransformMask(eventmask) ;
  236.     wattrib.cursor = ServCurs[mlook] ; 
  237.  
  238.     if ((wd == root) && (no_wm == WMOFF)) {
  239.       wattrib.save_under = False ;
  240.       wattrib.override_redirect = True ;
  241.     } else {
  242.       wattrib.save_under = False ;
  243.       wattrib.override_redirect = False ;
  244.     }
  245.  
  246.     if (eventmask == 0) {  /* moyen de test sur nf_mono */
  247.         Pixmap pix = XCreateBitmapFromData(Dpl,wd,
  248.                 nfmono_bits,nfmono_width,nfmono_height);
  249.         wattrib.background_pixmap = XCreatePixmap(Dpl,wd,
  250.                     nfmono_width,nfmono_height,depth);
  251.         XFillRectangle(Dpl,wattrib.background_pixmap,GcColor,
  252.                    0,0,nfmono_width,nfmono_height);
  253.         XCopyPlane(Dpl,pix,wattrib.background_pixmap,GcColor,0,0,
  254.                     nfmono_width,nfmono_height,0,0,1);
  255.  
  256.         backflag = CWBackPixmap ;
  257.         XFreePixmap(Dpl, pix);
  258.     } else {
  259.         wattrib.background_pixel = background_pixel ;
  260.         backflag = CWBackPixel ;
  261.     }
  262.     wattrib.border_pixel = border_pixel ;
  263.     wattrib.bit_gravity = StaticGravity ;
  264.     wattrib.win_gravity = StaticGravity ;
  265.  
  266.         wn = XCreateWindow(Dpl,wd,x,y,w,h,1,depth,
  267.                InputOutput,CopyFromParent,
  268.                CWOverrideRedirect |  backflag | CWBorderPixel | 
  269.                CWSaveUnder | CWEventMask | CWCursor,
  270.                /*| CWBitGravity | CWWinGravity */
  271.             &wattrib);
  272.  
  273.     /* on a determiner si l'utilisateur a donner un ordre de
  274.        positionnement avec l'option -geometry, dans ce cas le flag
  275.        de position est USPosition, sinon c'est le programme qui
  276.        positionne */ 
  277.     
  278.     if ((wd == root) && (no_wm == WMON)) {
  279.         hints.flags = PPosition|PSize|PMinSize|PMaxSize ;
  280.         hints.x = x ;
  281.         hints.y = y ;
  282.          hints.width = w ;
  283.         hints.height = h ;
  284.         hints.min_width = hints.width ;
  285.         hints.min_height = hints.height ;
  286.         hints.max_width = hints.width ;
  287.         hints.max_height = hints.height ;
  288.         XSetNormalHints(Dpl,wn,&hints);    
  289.  
  290.         XStoreName(Dpl,wn,titre);    
  291.         XSetIconName(Dpl,wn,"XFEDOR");    
  292.         XSetCommand(Dpl,wn,argv,argc);
  293.             
  294.         wmhints.flags = InputHint | IconPixmapHint ;
  295.         wmhints.input = True ;
  296.         wmhints.icon_pixmap = bullicon ;
  297.         XSetWMHints(Dpl,wn,&wmhints);
  298.  
  299.         classhint.res_name = "xfedor" ;
  300.         classhint.res_class = "font_editor" ;
  301.         XSetClassHint(Dpl,wn,&classhint);
  302.  
  303.             WM_Delete_Window = XInternAtom(Dpl, "WM_DELETE_WINDOW", False);
  304.             XSetWMProtocols(Dpl, wn, &WM_Delete_Window, 1); 
  305.     }
  306.     return ((int)wn);
  307. }
  308.    
  309. /*-------------------------------------------------------------*/
  310. /* W_CRZON */
  311. int w_crzon (wd,x1,y1,x2,y2,mlook) 
  312.    int wd ;
  313.    int x1,y1,x2,y2 ;
  314.    int mlook;             /* numero d'icone souris */
  315. {
  316.     Window wn;
  317.     XSetWindowAttributes wattrib ;
  318.     XWindowAttributes watt ;
  319.  
  320.         static int iz = 0 ;
  321.  
  322.     XGetWindowAttributes(Dpl,wd,&watt);
  323.     wattrib.cursor = ServCurs[mlook] ; 
  324.     wattrib.event_mask = watt.your_event_mask ;
  325.  
  326.         wn = XCreateWindow(Dpl,wd,x1,y1,x2-x1,y2-y1,0,0,
  327.                InputOnly,CopyFromParent,CWEventMask|CWCursor,
  328.                &wattrib);
  329.  
  330.     Tzone[iz].zone = wn ;
  331.     Tzone[iz].mere = wd ;    /* gestion des zones pour GetEvent */
  332.           Tzone[iz].xorz = x1 ;
  333.           Tzone[iz].yorz = y1 ;
  334.     iz ++ ;            
  335.         XMapWindow(Dpl,wn);
  336.     return ((int)wn);
  337.         
  338. }
  339.  
  340. /*-------------------------------------------------------------*/
  341. /* W_GETEVENT */
  342. int TransformEvent(xtype)
  343.     int xtype ;
  344. {
  345.     switch(xtype) {
  346.     case KeyPress : return KeyPressed ; 
  347.     case ButtonPress : return ButtonPressed ; 
  348.     case ButtonRelease : return ButtonReleased ; 
  349.     case MotionNotify : return MoveMouse ; 
  350.     case LeaveNotify : return LeaveWindow ; 
  351.     case EnterNotify : return EnterWindow ; 
  352.     case Expose : return Exposure ; 
  353.     case ClientMessage : return CloseWindow ;
  354.     }
  355.    return 0;
  356. }
  357.  
  358. static int
  359. is_del_win_event(XEvent *rep)
  360. {
  361.     return rep->type == ClientMessage &&
  362.         rep->xclient.format == 32 &&
  363.         rep->xclient.data.l[0] == WM_Delete_Window;
  364. }
  365.  
  366. void w_getevent (pev)
  367.    myEvent * pev;
  368.         
  369. {
  370.     XEvent rep ;
  371.     static int ZoneCour = 0 ;
  372.     int i, keysym ;
  373.     char s[1] ;
  374.  
  375.     do {
  376.        XNextEvent(Dpl,&rep) ;
  377.        if (is_del_win_event(&rep))
  378.            break;
  379.            if (rep.type == KeyPress)
  380.            XLookupString((XKeyEvent *)&rep,s,1,(KeySym *)&keysym,NULL);
  381.     } while ( ((rep.type != Expose) || (rep.xexpose.count != 0)) &&
  382.           ((rep.type != KeyPress) || (IsModifierKey(keysym))) &&
  383.           (rep.type != ButtonPress) &&
  384.           (rep.type != ButtonRelease) &&
  385.           (rep.type != MotionNotify) &&
  386.           (rep.type != LeaveNotify) &&
  387.           (rep.type != EnterNotify)) ;
  388.  
  389.     pev->key = (char) keysym ;    
  390.     if ((rep.type == KeyPress) && (pev->key > 96) && (pev->key < 123) &&
  391.         ((rep.xkey.state && ControlMask))) pev->key -= 96 ;
  392.  
  393.         if (rep.type == ButtonPress) XUngrabPointer(Dpl,CurrentTime);
  394.  
  395.     /* recherche dans la liste des fenetres zones pour voir si
  396.         cette fenetre X est une zone a moi */
  397.     for (i=0;((i<NBZONE)&&(Tzone[i].zone!= rep.xany.window));i++) ;
  398.  
  399.     if (i==NBZONE) {    /* window normale */
  400.         pev->window = rep.xany.window ;
  401.         pev->zone = ZoneCour ;
  402.             pev->type = TransformEvent(rep.type) ;
  403.     } else {        /* window = zone */
  404.         pev->window = Tzone[i].mere ;
  405.         pev->zone = rep.xany.window ;
  406.         pev->xz = Tzone[i].xorz ;
  407.         pev->yz = Tzone[i].yorz ;
  408.         if (rep.type == EnterNotify) {
  409.             ZoneCour = pev->zone ;
  410.             pev->type = EnterZone ;
  411.         } else
  412.         if (rep.type == LeaveNotify) {
  413.             ZoneCour = 0 ;
  414.             pev->type = LeaveZone ;
  415.                 } else  pev->type = TransformEvent(rep.type) ;
  416.     }
  417.  
  418.     pev->click = (rep.xbutton.button == 1)? 1:2 ;
  419.     pev->x = rep.xbutton.x ;
  420.     pev->y = rep.xbutton.y ;
  421.  
  422.     if (rep.type == Expose) {
  423.         pev->x = rep.xexpose.x ;
  424.         pev->y = rep.xexpose.y ;
  425.         pev->xz = rep.xexpose.width ;
  426.         pev->yz = rep.xexpose.height ;
  427.     }
  428. }
  429.  
  430. /*--------------------------------------------------------------------*/
  431. /* W_ECRIRE */    
  432. void w_ecrire (wd,chaine,x,y)
  433.    int wd;         /* la fenetre */
  434.    char * chaine ;     /* la chaine a ecrire */
  435.    int x,y ;         /* ou ecrire */
  436. {
  437.       XDrawImageString (Dpl,wd,GcPft,x,y,chaine,strlen(chaine));
  438. }
  439.    
  440. /*--------------------------------------------------------------------*/
  441. /* W_CENTRER */
  442. void w_centrer (wd,chaine,x1,y1,x2,y2)
  443.    int wd; /* la fenetre */
  444.    char * chaine ; /* la chaine a ecrire */
  445.    int x1,y1,x2,y2 ; /* boite  dans laquelle on centre */
  446.  
  447. {    register int x,y,l,len,w,h ;
  448.  
  449.       w = x2 - x1 ;
  450.       h = y2 - y1 ;
  451.       XFillRectangle(Dpl,wd,GcCInv,x1+1,y1+1,w-1,h-1);
  452.       len = strlen(chaine) ;
  453.       do { 
  454.         l = XTextWidth(ft,chaine,len);
  455.     if (l <= w) break ;
  456.     len -- ;
  457.       } while (1) ;
  458.       x = x1 + ((w - l)>>1) ;
  459.       y = y1 + ((h + ft->ascent + ft->descent)>>1)-1 ;
  460.       XDrawString(Dpl,wd,Gc,x,y,chaine,len);
  461. }
  462.    
  463. /*--------------------------------------------------------------------*/
  464. /* W_LINE */
  465. void w_line (wd,x1,y1,x2,y2,mode)
  466.        int wd ;
  467.     int x1,y1,x2,y2;
  468.     int mode ;
  469. {
  470.           XDrawLine(Dpl,wd,(mode==ON)?Gc:GcInv,x1,y1,x2,y2);
  471. }    
  472.  
  473. /*--------------------------------------------------------------------*/
  474. /* W_RECT */
  475. void w_rect (wd,x1,y1,x2,y2,mode)
  476.        int wd ;
  477.     int x1,y1,x2,y2 ;
  478.     int mode ;
  479. {    
  480.          XDrawRectangle(Dpl,wd,(mode==ON)?Gc:GcInv,x1,y1,x2-x1,y2-y1);    
  481. }         
  482.  
  483.  
  484. /*--------------------------------------------------------------------*/ 
  485. /* W_FELLIPS */    
  486. void w_fellips (wd,x1,y1,x2,y2,mode)    
  487.        int wd ;
  488.     int x1,y1,x2,y2 ;
  489.      int mode ;
  490. {
  491.           XFillArc(Dpl,wd,(mode==ON)?Gc:GcInv,x1,y1,x2-x1,y2-y1,0,23040) ;
  492. }
  493.  
  494. /*----------------------------------------------------------------*/
  495. /* W_ELLIPS */
  496. void w_ellips (wd,x1,y1,x2,y2,mode)    
  497.        int wd ;
  498.     int x1,y1,x2,y2 ;
  499.     int mode ;
  500. {
  501.           XDrawArc(Dpl,wd,(mode==ON)?Gc:GcInv,x1,y1,x2-x1,y2-y1,0,23040) ;
  502. }
  503.  
  504. /*--------------------------------------------------------------------*/
  505. /* W_GRIS */
  506. void w_gris (wd,x1,y1,x2,y2) 
  507.        int wd ;
  508.     int x1,y1,x2,y2 ;
  509. {
  510.           XFillRectangle(Dpl,wd,GcTil,x1,y1,x2-x1,y2-y1);
  511. }
  512.  
  513. /*--------------------------------------------------------------------*/
  514. /* W_INV */
  515. void w_inv (wd,x1,y1,x2,y2)
  516.        int wd ;
  517.     int x1,y1,x2,y2 ;
  518. {
  519.           XFillRectangle(Dpl,wd,GcInv,x1,y1,x2-x1,y2-y1);
  520. }
  521.  
  522. /*--------------------------------------------------------------------*/
  523. /* W_FORE */
  524. void w_fore (wd,x1,y1,x2,y2)
  525.        int wd ;
  526.     int x1,y1,x2,y2 ;
  527. {
  528.           XFillRectangle(Dpl,wd,Gc,x1,y1,x2-x1,y2-y1);
  529. }
  530.  
  531. /*--------------------------------------------------------------------*/
  532. /* W_COLOR */
  533. void w_color (wd,x1,y1,x2,y2,color)
  534.        int wd ;
  535.     int x1,y1,x2,y2 ;
  536.         int color ;
  537. {
  538.   if ((depth == 1) && (color == PIXELGREY))
  539.     w_gris(wd,x1,y1,x2,y2) ;
  540.   else
  541.   {
  542.     XSetForeground(Dpl,GcColor,color);
  543.     XFillRectangle(Dpl,wd,GcColor,x1,y1,x2-x1,y2-y1);
  544.   }
  545. }
  546.  
  547. /* ------------------------------------------------------------*/
  548. /* W_POINT */
  549. void w_point(wd,x,y,color)
  550.     int wd ;
  551.     int x,y ;
  552.     int color ;    /* pixel value */
  553. {
  554.         XSetForeground(Dpl,GcColor,color);
  555.     XDrawPoint(Dpl,wd,GcColor,x,y);
  556. }
  557.  
  558. /*---------------------------------------------------------------------*/
  559. /* W_RASTOP */
  560. void w_rastop(ws,wd,sx,sy,w,h,dx,dy)
  561.     int ws,wd ;
  562.     int sx,sy,w,h,dx,dy ;
  563. {
  564.     XCopyArea(Dpl,ws, wd, GcColor, sx, sy, w, h, dx, dy);
  565. }    
  566.  
  567. /*---------------------------------------------------------------------*/
  568. /* W_BITBLT */
  569. void w_bitblt(wd,clientimage,sx,sy,w,h,dx,dy)
  570.     int wd ;
  571.     ClientImage * clientimage ;
  572.     int sx,sy,w,h,dx,dy ;
  573. {
  574.         XPutImage(Dpl,wd,GcFontColor,
  575.           (XImage *) clientimage, 
  576.           sx,sy,dx,dy,w,h);
  577. }
  578.  
  579. /*---------------------------------------------------------------------*/
  580. /* W_PIXEL */
  581. void w_pixel(wd,data,x,y,w,h)
  582.     int wd ;
  583.     char * data ;
  584.     int x,y,w,h ;
  585. {
  586.     Pixmap bm = XCreateBitmapFromData(Dpl,root,data,w,h);
  587.  
  588.     XCopyPlane(Dpl,bm, wd, Gc,0,0,w,h,x,y,1);
  589.     XFreePixmap(Dpl, bm);
  590. }
  591.  
  592. /*--------------------------------------------------------------------*/
  593. /* W_SOURIS */
  594. void w_souris (wd, climafore, climask, w,h,xhot,yhot)    
  595.     int wd ;
  596.         ClientImage * climafore, * climask ;  /* depth 1 */
  597.     int w,h ;
  598.     int xhot, yhot ;
  599. {
  600.     Pixmap pfore1, pmask1 ;
  601.         XGCValues xgcv;
  602.     GC Gc1 ;
  603.  
  604.     pfore1 = XCreatePixmap(Dpl,root,w,h,1);
  605.     pmask1 = XCreatePixmap(Dpl,root,w,h,1);
  606.  
  607.     xgcv.graphics_exposures = False ;
  608.     xgcv.function = GXcopyInverted ;
  609.  
  610.         Gc1 = XCreateGC(Dpl,pfore1,GCFunction|GCGraphicsExposures, &xgcv);
  611.  
  612.  
  613.     XPutImage(Dpl,pfore1,Gc1,
  614.           (XImage*)climafore,
  615.           0,0,0,0,w,h);
  616.     XPutImage(Dpl,pmask1,Gc1,
  617.           (XImage*)climask,
  618.           0,0,0,0,w,h);
  619.  
  620.     XDefineCursor(Dpl,wd,
  621.         XCreatePixmapCursor(Dpl,pfore1,pmask1,&fore,&back,
  622.             (xhot<0)?0:(xhot>w)?w:xhot,
  623.             (yhot<0)?0:(yhot>h)?h:yhot));
  624. }
  625.  
  626. /*--------------------------------------------------------------------*/
  627. /* W_WRITEPIXMAP */
  628. int w_writepixmap (name,clientimage,x,y,w,h)    
  629.     char * name ;
  630.     ClientImage * clientimage ;   /* depth n */
  631.     int x,y,w,h ;
  632.  
  633. {    
  634.     Pixmap p ;
  635.     XpmAttributes icon_attributes ;
  636.  
  637.     if ((w == 0) || (h == 0)) return 0 ;
  638.     p = XCreatePixmap(Dpl,root,w,h,depth);
  639.  
  640.     XPutImage(Dpl,p,GcColor,
  641.           (XImage *) clientimage, 
  642.           x,y,0,0,w,h);
  643.  
  644.     icon_attributes.width = w;
  645.     icon_attributes.height = h;
  646.     icon_attributes.valuemask = XpmSize ;
  647.  
  648.     if (XpmWriteFileFromPixmap (Dpl, name, p, 0, &icon_attributes)
  649.     == XpmSuccess)
  650.     return 1 ; 
  651.     else return 0 ;
  652. }
  653.  
  654. /*--------------------------------------------------------------------*/
  655. /* W_WRITEBITMAP */
  656. int w_writebitmap (name,clientimage,w,h,xhot,yhot)    
  657.     char * name ;
  658.     ClientImage * clientimage ;   /* depth 1 */
  659.     int w,h,xhot,yhot ;
  660. {    Pixmap p ;
  661.         XGCValues xgcv;
  662.     GC Gc1 ;
  663.  
  664.     if ((w == 0) || (h == 0)) return 0 ;
  665.     p = XCreatePixmap(Dpl,root,w,h,1);
  666.  
  667.     xgcv.graphics_exposures = False ;
  668.     xgcv.function = GXcopyInverted ;
  669.  
  670.         Gc1 = XCreateGC(Dpl,p,GCFunction|GCGraphicsExposures, &xgcv);
  671.  
  672.     XPutImage(Dpl,p,Gc1,
  673.           (XImage *) clientimage, 
  674.           0,0,0,0,w,h);
  675.  
  676.           if (XWriteBitmapFile(Dpl,name,p,w,h,xhot,yhot)==BitmapSuccess)
  677.         return 1 ; 
  678.     else    return 0 ;
  679. }
  680.  
  681. /*--------------------------------------------------------------------*/
  682. /* W_READBITMAP */
  683. int w_readbitmap (name,bitmage,w,h,xhot,yhot)    
  684.     char * name ;
  685.         ClientImage * * bitmage ; 
  686.     unsigned int *w,*h;
  687.         int *xhot,*yhot ;
  688. {    
  689.   Pixmap bit ;
  690.  
  691.         if (XReadBitmapFile(Dpl,root,name,w,h,&bit,xhot,yhot)!=BitmapSuccess)
  692.                 return 0 ;
  693.     
  694.     *bitmage = XGetImage(Dpl,bit,0,0,*w,*h,1,XYPixmap) ;
  695.  
  696.     return (1);
  697. }
  698.  
  699. /*--------------------------------------------------------------------*/
  700. /* W_READPIXMAP */
  701. int w_readpixmap (name,bitmage,w,h)    
  702.     char * name ;
  703.         ClientImage * * bitmage ; 
  704.     int *w,*h ;
  705. {    
  706.     Pixmap pix ;
  707.     XpmAttributes icon_attributes;
  708.  
  709.     icon_attributes.valuemask = XpmReturnPixels | XpmSize;
  710.     
  711.     if (XpmReadFileToPixmap(Dpl, root, name, &pix, NULL, &icon_attributes)
  712.     != XpmSuccess)
  713.     return 0 ;
  714.  
  715.     *w =  icon_attributes.width;
  716.     *h =  icon_attributes.height;
  717.     
  718.     *bitmage = XGetImage(Dpl,pix,0,0,*w,*h,AllPlanes,ImaForm) ;
  719.  
  720.     return (1);
  721. }
  722.  
  723. /*------------------------------------------------------------------*/
  724. /* W_CLEARAREA */
  725. void w_cleararea(wd,x1,y1,x2,y2)
  726.          int wd ;
  727.     int x1,y1,x2,y2 ;
  728. {
  729.     XClearArea(Dpl,wd,x1,y1,x2-x1,y2-y1,False);
  730. }
  731.  
  732. /*------------------------------------------------------------------*/
  733. /* W_CLEAR */
  734. void w_clear(wd)
  735.          int wd ;
  736. {
  737.     XClearWindow(Dpl,wd);
  738. }
  739.  
  740. /*---------------------------------------------------------------------*/
  741. /* W_BITMAP */
  742. int w_bitmap(w,h)
  743.     int w,h ;
  744. {
  745.         return (int)XCreatePixmap(Dpl,root,w,h,depth);
  746. }
  747.  
  748. /*------------------------------------------------------------------*/
  749. /* W_MONTRER */
  750. void w_montrer (wd)
  751.         int wd ;
  752. {
  753.   XMapRaised(Dpl,wd);
  754. }
  755.  
  756. /*------------------------------------------------------------------*/
  757. /* W_FLUSH */
  758. void w_flush ()
  759. {
  760.         XSync(Dpl,0);
  761. }
  762.  
  763.                 
  764. /*------------------------------------------------------------------*/
  765. /* W_CACHER */
  766. void w_cacher (wd)
  767.         int wd ;
  768. {
  769.       XUnmapWindow(Dpl,wd);
  770. }
  771.  
  772. /*----------------------------------------------------------------------*/
  773. /* W_RESIZE */
  774. void w_resize(wd,largeur,hauteur)
  775.     int wd;
  776.     int largeur,hauteur ;
  777. {
  778.     XSizeHints hints ;
  779.  
  780.     hints.flags = USSize|PMinSize|PMaxSize ;
  781.     hints.width = largeur ;
  782.     hints.height = hauteur ;
  783.     hints.min_width = largeur ;
  784.     hints.min_height = hauteur ;
  785.     hints.max_width = largeur ;
  786.     hints.max_height = hauteur ;
  787.     XSetNormalHints(Dpl,wd,&hints);
  788.  
  789.     XResizeWindow(Dpl,wd,largeur,hauteur);
  790. }
  791.  
  792. /*------------------------------------------------------------------*/
  793. /*------------------------------------------------------------------*/
  794. /* W_POP */
  795. void w_pop (wd)
  796.         int wd ;
  797. { 
  798.         int px, py ;
  799.     long bidon ;
  800.         Window wind;
  801.     XWindowAttributes watt ;
  802.  
  803.     XGetWindowAttributes(Dpl,wd,&watt);
  804.     XQueryPointer(Dpl,root,&wind,&wind,&px,&py,(int *)&bidon,(int *)&bidon,(unsigned int *)&bidon);
  805.     
  806.     if ((px + watt.width/2) > DisplayWidth(Dpl,screen))
  807.       px = DisplayWidth(Dpl,screen) - watt.width/2 ;
  808.     if ((py + watt.height) > DisplayHeight(Dpl,screen))
  809.       py = DisplayHeight(Dpl,screen) - watt.height ;
  810.  
  811.     XMoveWindow(Dpl,wd,px-watt.width/2,py-7);
  812.     XMapRaised(Dpl,wd);
  813.  
  814. }
  815.  
  816.  
  817. /*----------------------------------------------------------------------*/
  818. /* W_LARGEUR*/
  819. int w_largeur(wd)
  820.     int wd ;
  821. {    XWindowAttributes watt ;
  822.  
  823.     XGetWindowAttributes(Dpl,wd,&watt);
  824.     return(watt.width);
  825. }
  826.  
  827.  
  828. /* ------------------------------------------------------------*/
  829. /* W_STRWIDTH */    
  830. int w_strwidth(s)         /* popup.c l'utilise */
  831.      register char * s;
  832. {  
  833.     return(XTextWidth(ft,s,strlen(s))) ;
  834. }
  835.  
  836. /* ------------------------------------------------------------*/
  837. /* W_CLICK */    
  838.  
  839. Bool fpress (display,event,args)
  840. /** utilisee pour XCheckIfEvent **/
  841.     Display * display ;
  842.     XEvent * event ;
  843.     char * args ;
  844. {
  845.     return ((event->type == ButtonPress)?True:False) ;
  846. }
  847.  
  848.  
  849. int w_click()      /* rends vrai si un event click est arrive */
  850. {  
  851.      XEvent e ;
  852.     return(XCheckIfEvent(Dpl, &e, fpress, NULL) == False);
  853. }
  854.  
  855. /* ------------------------------------------------------------*/
  856. /* W_SETFOCUS */    
  857. void w_setfocus(w)
  858.      int w ;
  859. {
  860.      XSetInputFocus(Dpl,w,RevertToPointerRoot,CurrentTime);
  861. }
  862.  
  863. /* ------------------------------------------------------------*/
  864. /* W_SETROOT */    
  865. void w_setroot(clientimage,x,y,w,h)    
  866.         ClientImage * clientimage ;
  867.     int x,y,w,h ;
  868. {    Pixmap p ;
  869.  
  870.     if (w == 0 ) return ;
  871.     p = w_bitmap(w,h);
  872.  
  873.     XPutImage(Dpl,p,GcColor,
  874.           (XImage *) clientimage, 
  875.           x,y,0,0,w,h);
  876.  
  877.     XSetWindowBackgroundPixmap(Dpl,
  878.                                 RootWindow(Dpl, DefaultScreen(Dpl)),p);
  879.         XClearWindow(Dpl,RootWindow(Dpl, DefaultScreen(Dpl)));
  880.         XFlush(Dpl) ; 
  881. }
  882.  
  883.  
  884. /* ------------------------------------------------------------*/
  885. /* W_NCOLOR */    
  886. int w_ncolor()
  887. /* rends le nombre de couleurs differentes du display */
  888. {
  889.   return DisplayCells(Dpl,screen);
  890.  
  891. }
  892.  
  893.  
  894. /* ------------------------------------------------------------*/
  895. /* W_BLACKPIXEL */    
  896. int w_blackpixel()
  897. /* rends le pixel noir */
  898. {
  899.   return BlackPixel(Dpl,screen);
  900. }
  901.  
  902. /* ------------------------------------------------------------*/
  903. /* W_GREYPIXEL */    
  904. int w_greypixel()
  905. /* rends un pixel gris (compatible w_color) */
  906. {
  907.   XColor def, exact ;
  908.  
  909.   if (depth > 1) {
  910.     XAllocNamedColor(Dpl,colormap,"LightGrey",&def,&exact);
  911.     return def.pixel ;
  912.   } else return PIXELGREY ;
  913. }
  914.  
  915.  
  916. /* ------------------------------------------------------------*/
  917. /* W_CUTBUF */    
  918. char *  w_cutbuf()
  919. /* rends un pointeur sur le cut buffer 0 ou '\0' au moins */
  920. {
  921.   int n,i=0 ;
  922.   char * s ;
  923.   char * buff ;
  924.  
  925.   s = XFetchBytes(Dpl,&n);
  926.   if (s == NULL) buff = (char*) malloc(1) ;
  927.   else {
  928.     buff = (char*) malloc(n+1) ;
  929.     for (i=0 ;i<n ; i++) buff[i] = s[i] ;
  930.   }
  931.   buff[i] = '\0' ;
  932.   return buff ;
  933. }
  934.  
  935. /* ------------------------------------------------------------*/
  936. /* W_NOSAVEUNDER */    
  937. int w_nosaveunder()
  938. {
  939.    return !XDoesSaveUnders(DefaultScreenOfDisplay(Dpl)) ;
  940.  
  941. }
  942.  
  943. /* ------------------------------------------------------------*/
  944. /* W_SETBACK */    
  945. void w_setback(win,pix)    
  946.     int win;
  947.     int pix ;
  948. {
  949.     XSetWindowBackgroundPixmap(Dpl,win,pix);
  950.         XClearWindow(Dpl,win);
  951.         XFlush(Dpl) ; 
  952. }
  953.  
  954. /* ------------------------------------------------------------*/
  955. /* W_CLOSE */    
  956. void w_close()
  957. {
  958.    XCloseDisplay(Dpl);
  959. }
  960.  
  961. /* ------------------------------------------------------------*/
  962. /* W_BACKING */    
  963. void w_backing(wd)
  964.    int wd ;
  965. {
  966.    XSetWindowAttributes wattrib ;
  967.  
  968.    wattrib.backing_store = WhenMapped ;
  969.  
  970.    XChangeWindowAttributes(Dpl,wd,CWBackingStore,&wattrib);
  971. }
  972.