home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Enlightenment / enl_BETA-0.13.src.tar.gz / enl_BETA-0.13.src.tar / enl-0.13 / windowops.c < prev    next >
C/C++ Source or Header  |  1997-11-16  |  25KB  |  1,019 lines
  1. #include "enlightenment.h"
  2.  
  3. /* This file is for all of the code pertaining to windowops
  4.  * file created 08/04/97 by mandrake
  5.  */
  6.  
  7. int ParamToInt(char *params) {
  8.  
  9.     int i;
  10.     char s[5];
  11.  
  12.     for(i=0;i<ACTION_NONE;i++) {
  13.         sprintf(s,"%d",i);
  14.         if(!strcmp(s,params)) return i;
  15.     }
  16.     return 0;
  17.  
  18. }
  19.  
  20. void DoWindowButton(EWin *ewin, Window win, int btn, int mod, int wbtn) {
  21.    /* int i,j; */
  22.    
  23.    /* if it wasnt a left, middle or right mouse button... ignore it */
  24.    if ((btn<1)||(btn>3)) return;
  25.    /* if the subwindow clicked is a decoration subwindow.. ignore the click */
  26.    if (cfg.subwin_type[wbtn]==0) return;
  27.    if (cfg.subwin_action[wbtn][btn-1][mod].id!=ACTION_DRAG) {
  28.        /* flag the button as clicked ... */
  29.        ewin->subwin_state[wbtn]=CLICKED;
  30.        /* redraw the button */
  31.        DrawButton(ewin,wbtn);
  32.    }
  33.    /* set the event mode windowbutton pressed to this one */
  34.    evmd.wbtn=wbtn;
  35.    if(cfg.subwin_action[wbtn][btn-1][mod].id<ACTION_CONFIGURE)
  36.    switch(cfg.subwin_action[wbtn][btn-1][mod].id)
  37.        {
  38.     case ACTION_MOVE:
  39.         Do_RaiseWin(ewin);
  40.         Do_MoveWin(ewin, win);
  41.         return;
  42.     case ACTION_RESIZE:
  43.         Do_RaiseWin(ewin);
  44.         Do_ResizeWin(ewin, win);
  45.         return;
  46.     case ACTION_ICONIFY:
  47.         Do_IconifyWin(ewin);    
  48.         break;
  49.     case ACTION_KILL:
  50.         Do_KillWin(ewin,0);
  51.         break;
  52.     case ACTION_RAISE:
  53.         Do_RaiseWin(ewin);
  54.         break;
  55.     case ACTION_LOWER:
  56.         Do_LowerWin(ewin);
  57.         break;
  58.     case ACTION_RAISE_LOWER:
  59.         Do_RaiseLowerWin(ewin);
  60.         break;
  61.     case ACTION_MAX_HEIGHT:
  62.         Do_RaiseWin(ewin);
  63.         Do_MaxHeightWin(ewin);
  64.         break;
  65.     case ACTION_MAX_WIDTH:
  66.         Do_RaiseWin(ewin);
  67.         Do_MaxWidthWin(ewin);
  68.         break;
  69.     case ACTION_MAX_SIZE:
  70.         Do_RaiseWin(ewin);
  71.         Do_MaxSizeWin(ewin);
  72.         break;
  73.     default: break;
  74.        }
  75.  else
  76.  switch(cfg.subwin_action[wbtn][btn-1][mod].id)
  77.        {
  78.     case ACTION_CONFIGURE:
  79.         Do_Configure();
  80.         break;
  81.     case ACTION_MENU:
  82.         Do_MenuWin(ewin);
  83.         break;
  84.     case ACTION_EXEC:
  85.         Do_Exec(cfg.subwin_action[wbtn][btn-1][mod].params);
  86.         break;
  87.     case ACTION_KILL_NASTY:
  88.         Do_KillWin(ewin,1);
  89.         break;
  90.     case ACTION_STICKY:
  91.         ewin->desk = (ewin->desk<0) ? desk.current : -1;
  92.         break;
  93.     case ACTION_DRAG:
  94.         StartIconDrag(ewin);
  95.         break;
  96.     case ACTION_WINDOWOP:
  97.         PerformWindowOp(ParamToInt(cfg.subwin_action[wbtn][btn-1][mod].params));
  98.         break;
  99.     case ACTION_SKIP:
  100.         ewin->skip=!ewin->skip;
  101.         break;
  102.     case ACTION_SNAPSHOT:
  103.         ModifyEwinState(ewin);
  104.         break;
  105.     case ACTION_UNSNAPSHOT:
  106.         DeleteEwinState(ewin);
  107.         break;
  108.     case ACTION_SHADE:
  109.         Do_RaiseWin(ewin);
  110.         DoShade(ewin);
  111.         break;
  112.     default:
  113.         break;
  114.     }
  115.    evmd.ewin=ewin;
  116.    evmd.wbtn=wbtn;
  117.    evmd.mode=MODE_NORMAL;
  118.    return;
  119. }
  120.  
  121. void Do_MoveWin(EWin *ewin, Window win) {
  122.  
  123.     /* XEvent ev;
  124.     int x,y;
  125.     int sx,sy,d;
  126.     Window w1,w2; */
  127.    
  128.     if(evmd.mode!=MODE_NORMAL)
  129.         return;
  130.     evmd.ewin=ewin;
  131.     ewin->snapshotok=0;
  132.     if(timer_mode==0 && ifb.nodo==0) {
  133.         ifb.nodo=1;
  134.     } else if(ifb.moveresize > 0) {
  135.         if (cfg.move_mode==2) {
  136.             evmd.mode=MODE_MOVE;
  137.             ifb.nodo=1;
  138.             Draw_Cursor(ewin, ewin->frame_x, ewin->frame_y, '+', 1);
  139.             XGrabPointer(disp, win, True, ButtonMotionMask|PointerMotionMask|ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
  140.             return;
  141.         } else {
  142.             ifb.nodo=1;
  143.             MoveLoop(ewin, win);
  144.             ifb.nodo=0;
  145.         }
  146.     }
  147. }
  148.  
  149. void Do_ResizeWin(EWin *ewin, Window win) {
  150.  
  151.     /* XEvent ev;
  152.     int x,y;
  153.     int sx,sy,d;
  154.     Window w1,w2; */
  155.     int wx,wy;
  156.     int mode;
  157.     int x1,y1,x2,y2;
  158.    
  159. /*   XQueryPointer(disp,root,&w1,&w2,&sx,&sy,&x,&y,&d);*/
  160. /*   evmd.px=sx;*/
  161. /*   evmd.py=sy;*/
  162.     if(evmd.mode!=MODE_NORMAL) return;
  163.     x1=ewin->frame_x;
  164.     y1=ewin->frame_y;
  165.     x2=ewin->client_width;
  166.     y2=ewin->client_height;
  167.     wx=evmd.px-x1;
  168.     wy=evmd.py-y1;
  169.     if ((wx<ewin->frame_width/2)&&(wy<ewin->frame_height/2)) mode=0;
  170.     if((wx>=ewin->frame_width/2)&&(wy<ewin->frame_height/2)) mode=1;
  171.     if ((wx<ewin->frame_width/2)&&(wy>=ewin->frame_height/2)) mode=2;
  172.     if ((wx>=ewin->frame_width/2)&&(wy>=ewin->frame_height/2)) mode=3;
  173.     evmd.x1=x1;
  174.     evmd.x2=x2;
  175.     evmd.y1=y1;
  176.     evmd.y2=y2;
  177.     evmd.resize_mode=mode;
  178.     evmd.ewin=ewin;
  179.     ewin->snapshotok=0;
  180.     if(timer_mode==0 && ifb.nodo==0) {
  181.         ifb.nodo=1;
  182.     } else if(ifb.moveresize) {
  183.         if (cfg.resize_mode==2) {
  184.             evmd.mode=MODE_RESIZE;
  185.             ifb.nodo=1;
  186.             Draw_Cursor(ewin, (ewin->client_width-ewin->base_width)/ewin->sizeinc_x, (ewin->client_height-ewin->base_height)/ewin->sizeinc_y, 'x', 1);
  187.             XGrabPointer(disp, win, True, ButtonMotionMask|PointerMotionMask|ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
  188.             return;
  189.         } else {
  190.             ifb.nodo=1;
  191.             ResizeLoop(ewin, win);
  192.             ifb.nodo=0;
  193.         }
  194.     }
  195. }
  196.  
  197. void Do_IconifyWin(EWin *ewin)
  198. {
  199.    struct itimerval tv1,tv2;
  200.    struct sigaction sa;
  201.    
  202.    /* concurrency issues! wait for previous iconify requests to */
  203.    /* be completeed by checking every 10th of a second to see if they */
  204.    /* finished yet */
  205.    if ((timer_mode < TIMER_ICONIFY)&&(timer_mode!=TIMER_INFOBOX)) {
  206.       for (getitimer(ITIMER_REAL, &tv1);
  207.        tv1.it_value.tv_sec != 0 || tv1.it_value.tv_usec != 0
  208.        || tv1.it_interval.tv_sec != 0
  209.        || tv1.it_interval.tv_usec != 0;
  210.        getitimer(ITIMER_REAL, &tv1));
  211.    }
  212. /*   while (newicon.ewin) usleep(100000);
  213.  *  if ((timer_mode < TIMER_ICONIFY)&&(timer_mode!=TIMER_INFOBOX)) {
  214.  *     for (getitimer(ITIMER_REAL, &tv1); 
  215.  *       tv1.it_value.tv_sec != 0 || tv1.it_value.tv_usec != 0;
  216.  *       getitimer(ITIMER_REAL, &tv1)) usleep(100000);
  217.  *  }
  218.  */
  219.    timer_mode = TIMER_ICONIFY;
  220.    tv1.it_value.tv_sec=(unsigned long)(icfg.snapshot_time*1000 / 1000000);
  221.    tv1.it_value.tv_usec=(long)(icfg.snapshot_time*1000 % 1000000);
  222.    tv2.it_value.tv_sec=(unsigned long)(icfg.snapshot_time*1000 / 1000000);
  223.    tv2.it_value.tv_usec=(long)(icfg.snapshot_time*1000 % 1000000);
  224.    tv1.it_interval.tv_sec=0;
  225.    tv1.it_interval.tv_usec=0;
  226.    tv2.it_interval.tv_sec=0;
  227.    tv2.it_interval.tv_usec=0;
  228.    newicon.ewin=ewin;
  229.    newicon.win=ewin->client_win;
  230.    XRaiseWindow(disp,ewin->frame_win);
  231.    setitimer(ITIMER_REAL,&tv1,&tv2);
  232.    sa.sa_handler = Finish_Iconify;
  233.    sa.sa_flags = 0;
  234.    sigemptyset (&sa.sa_mask);
  235.    sigaction(SIGALRM, &sa, (struct sigaction *)0);
  236. }
  237.  
  238. void Do_KillWin(EWin *ewin, int nasty_kill)
  239. {
  240.    XClientMessageEvent xev;
  241.    Atom atm[2];
  242.    /* Window dummyw; */
  243.    int dummy;
  244.    int wmdel;
  245.    int num;
  246.    Atom *prot;
  247.    Atom dummya;
  248.    int i;
  249.    unsigned long dummyl,numl;
  250.    
  251.    prot=NULL;
  252.    wmdel=0;
  253.    if (!(ewin->state&ICONIFIED))
  254.      {
  255.     newicon.kill=nasty_kill+1;
  256.     Do_IconifyWin(ewin);
  257.     return;
  258.      }
  259.    atm[0]=XInternAtom(disp,"WM_DELETE_WINDOW",False);
  260.    atm[1]=XInternAtom(disp,"WM_PROTOCOLS",False);
  261.    /* work out if client wants to have the wm ask it to quit */
  262.    if (!XGetWMProtocols (disp,ewin->client_win,&prot, &num))
  263.      {
  264.     /* have to work it out the hard way.. nasty client */
  265.     XGetWindowProperty(disp,ewin->client_win, atm[1],0,10,False,atm[1],
  266.                &dummya,&dummy,&numl,&dummyl,
  267.                (unsigned char **)&prot);
  268.     num=(int)numl;
  269.      }
  270.    /* check if it has a "delet me" flag set */
  271.    if (prot)
  272.      {
  273.     for (i=0;i<num;i++)
  274.       {
  275.          if (prot[i]==atm[0]) wmdel=1;
  276.       }
  277.      }
  278.    if (prot) XFree(prot);
  279.    if (wmdel)
  280.      {
  281.     /* delete */
  282.     xev.type=ClientMessage;
  283.     xev.window=ewin->client_win;
  284.     xev.message_type=atm[1];
  285.     xev.format=32;
  286.     xev.data.l[0]=atm[0];
  287.     xev.data.l[1]=CurrentTime;
  288.     XSendEvent(disp,ewin->client_win,False,0,(XEvent *)&xev);
  289.      }
  290.    else
  291.      {
  292.     /* kill */
  293.     XKillClient(disp,(XID)ewin->client_win);
  294.      }
  295.    if (nasty_kill)
  296.      {
  297.     /* kill */
  298.     XKillClient(disp,(XID)ewin->client_win);
  299.      }
  300.    XSync(disp,False);
  301. }
  302.  
  303. void Do_RaiseWin(EWin *ewin)
  304. {
  305.    Window *wl;
  306.    int nc,nb;
  307.    int i,j;
  308.    struct blist *bptr;
  309.    struct list *ptr;
  310.    
  311.    if(ewin->state&ICONIFIED) DeIconify(ewin);
  312.    if((ewin->desk>=0) && (ewin->desk != desk.current)) ChangeToDesk(ewin->desk);
  313.    if (ewin->top) return;
  314.    ToFront(ewin);
  315.    j=0;
  316.    nc=global_l->num;
  317.    nb=0;
  318.    bptr=bl.first;
  319.    while (bptr)
  320.      {
  321.     nb++;
  322.     bptr=bptr->next;
  323.      }
  324.    wl=malloc(sizeof(Window)*(nc+nb+3+(MAX_DESKS*2)));
  325.    bptr=bl.first;
  326.    while (bptr)
  327.      {
  328.     if (bptr->bwin->above) wl[j++]=bptr->bwin->win;
  329.     bptr=bptr->next;
  330.      }
  331.    if (icfg.level)
  332.      {
  333.     wl[j++]=icfg.left_win;
  334.     wl[j++]=icfg.right_win;
  335.     wl[j++]=icfg.bg_win;
  336.      }
  337.    for (i=0;i<MAX_DESKS;i++)
  338.      {
  339.     if (desk.di[i].above)
  340.       {
  341.          if (desk.di[i].win) wl[j++]=desk.di[i].win;
  342.          if (desk.di[i].root_win) wl[j++]=desk.di[i].root_win;
  343.       }
  344.      }
  345.    ptr=global_l->first;
  346.    while (ptr)
  347.      {
  348.     wl[j++]=ptr->win->frame_win;
  349.     ptr=ptr->next;
  350.      }
  351.    bptr=bl.first;
  352.    while (bptr)
  353.      {
  354.     if (!bptr->bwin->above) wl[j++]=bptr->bwin->win;
  355.     bptr=bptr->next;
  356.      }
  357.    if (!icfg.level)
  358.      {
  359.     wl[j++]=icfg.left_win;
  360.     wl[j++]=icfg.right_win;
  361.     wl[j++]=icfg.bg_win;
  362.      }
  363.    for (i=0;i<MAX_DESKS;i++)
  364.      {
  365.     if (!desk.di[i].above)
  366.       {
  367.          if (desk.di[i].win) wl[j++]=desk.di[i].win;
  368.          if (desk.di[i].root_win) wl[j++]=desk.di[i].root_win;
  369.       }
  370.      }
  371.    XRestackWindows(disp,wl,j);
  372.    free(wl);
  373. }
  374.  
  375. void Do_LowerWin(EWin *ewin)
  376. {
  377.    Window *wl;
  378.    int nc,nb;
  379.    int i,j;
  380.    struct blist *bptr;
  381.    struct list *ptr;
  382.    
  383.    ToBack(ewin);
  384.    j=0;
  385.    nc=global_l->num;
  386.    nb=0;
  387.    bptr=bl.first;
  388.    while (bptr)
  389.      {
  390.     nb++;
  391.     bptr=bptr->next;
  392.      }
  393.    wl=malloc(sizeof(Window)*(nc+nb+3+(MAX_DESKS*2)));
  394.    bptr=bl.first;
  395.    while (bptr)
  396.      {
  397.     if (bptr->bwin->above) wl[j++]=bptr->bwin->win;
  398.     bptr=bptr->next;
  399.      }
  400.    if (icfg.level)
  401.      {
  402.     wl[j++]=icfg.left_win;
  403.     wl[j++]=icfg.right_win;
  404.     wl[j++]=icfg.bg_win;
  405.      }
  406.    for (i=0;i<MAX_DESKS;i++)
  407.      {
  408.     if (!desk.di[i].above)
  409.       {
  410.          if (desk.di[i].win) wl[j++]=desk.di[i].win;
  411.          if (desk.di[i].root_win) wl[j++]=desk.di[i].root_win;
  412.       }
  413.      }
  414.    ptr=global_l->first;
  415.    while (ptr)
  416.      {
  417.     wl[j++]=ptr->win->frame_win;
  418.     ptr=ptr->next;
  419.      }
  420.    bptr=bl.first;
  421.    while (bptr)
  422.      {
  423.     if (!bptr->bwin->above) wl[j++]=bptr->bwin->win;
  424.     bptr=bptr->next;
  425.      }
  426.    if (!icfg.level)
  427.      {
  428.     wl[j++]=icfg.left_win;
  429.     wl[j++]=icfg.right_win;
  430.     wl[j++]=icfg.bg_win;
  431.      }
  432.    for (i=0;i<MAX_DESKS;i++)
  433.      {
  434.     if (!desk.di[i].above)
  435.       {
  436.          if (desk.di[i].win) wl[j++]=desk.di[i].win;
  437.          if (desk.di[i].root_win) wl[j++]=desk.di[i].root_win;
  438.       }
  439.      }
  440.    XRestackWindows(disp,wl,j);
  441.    free(wl);
  442. }
  443.  
  444. void Do_RaiseLowerWin(EWin *ewin)
  445. {
  446.    if (ewin->top) Do_LowerWin(ewin);
  447.    else Do_RaiseWin(ewin);
  448. }
  449. void DoShade(EWin *ewin)
  450. {
  451.  int h;
  452.  if(ewin->lastop==OP_SHADE)
  453.      {
  454.       h = ewin->prev_client_height;
  455.      ewin->prev_client_height = ewin->client_height;
  456.     }
  457.  else
  458.     {
  459.      ewin->prev_client_height=ewin->client_height;
  460.      h = 0;
  461.     }
  462.  ModifyEWin(ewin,ewin->frame_x,ewin->frame_y,ewin->client_width,h);
  463.  ewin->lastop=OP_SHADE;
  464. }
  465. void Do_MaxHeightWin(EWin *ewin)
  466. {
  467.    int h;
  468.    int y;
  469.    
  470.    if (ewin->lastop==OP_MAXHEIGHT)
  471.      {
  472.     h=ewin->prev_client_height;
  473.     y=ewin->prev_frame_y;
  474.     ewin->prev_client_height=ewin->client_height;
  475.     ewin->prev_client_width=ewin->client_width;
  476.     ewin->prev_frame_x=ewin->frame_x;
  477.     ewin->prev_frame_y=ewin->frame_y;
  478.      }
  479.    else
  480.      {
  481.     ewin->prev_client_height=ewin->client_height;
  482.     ewin->prev_client_width=ewin->client_width;
  483.     ewin->prev_frame_x=ewin->frame_x;
  484.     ewin->prev_frame_y=ewin->frame_y;
  485.     h=DisplayHeight(disp,screen);
  486.     h-=ewin->border_t;
  487.     h-=ewin->border_b;
  488.     while (((h-ewin->base_height)%ewin->sizeinc_y)>0) h--;
  489.     while (((h-ewin->base_height)%ewin->sizeinc_y)<0) h++;
  490.     y=0;
  491.      }
  492.    ModifyEWin(ewin,ewin->frame_x,y,ewin->client_width,h);
  493.    ewin->lastop=OP_MAXHEIGHT;
  494. }
  495.  
  496. void Do_MaxWidthWin(EWin *ewin)
  497. {
  498.    int w;
  499.    int x;
  500.    
  501.    if (ewin->lastop==OP_MAXWIDTH)
  502.      {
  503.     w=ewin->prev_client_width;
  504.     x=ewin->prev_frame_x;
  505.     ewin->prev_client_height=ewin->client_height;
  506.     ewin->prev_client_width=ewin->client_width;
  507.     ewin->prev_frame_x=ewin->frame_x;
  508.     ewin->prev_frame_y=ewin->frame_y;
  509.      }
  510.    else
  511.      {
  512.     ewin->prev_client_height=ewin->client_height;
  513.     ewin->prev_client_width=ewin->client_width;
  514.     ewin->prev_frame_x=ewin->frame_x;
  515.     ewin->prev_frame_y=ewin->frame_y;
  516.     w=DisplayWidth(disp,screen);
  517.     w-=ewin->border_l;
  518.     w-=ewin->border_r;
  519.     while (((w-ewin->base_width)%ewin->sizeinc_x)>0) w--;
  520.     while (((w-ewin->base_width)%ewin->sizeinc_x)<0) w++;
  521.     x=0;
  522.      }
  523.    ModifyEWin(ewin,x,ewin->frame_y,w,ewin->client_height);
  524.    ewin->lastop=OP_MAXWIDTH;
  525. }
  526.  
  527. void Do_MaxSizeWin(EWin *ewin)
  528. {
  529.    int h;
  530.    int y;
  531.    int w;
  532.    int x;
  533.    
  534.    if (ewin->lastop==OP_MAXSIZE)
  535.      {
  536.     h=ewin->prev_client_height;
  537.     y=ewin->prev_frame_y;
  538.     w=ewin->prev_client_width;
  539.     x=ewin->prev_frame_x;
  540.     ewin->prev_client_height=ewin->client_height;
  541.     ewin->prev_client_width=ewin->client_width;
  542.     ewin->prev_frame_x=ewin->frame_x;
  543.     ewin->prev_frame_y=ewin->frame_y;
  544.      }
  545.    else
  546.      {
  547.     ewin->prev_client_height=ewin->client_height;
  548.     ewin->prev_client_width=ewin->client_width;
  549.     ewin->prev_frame_x=ewin->frame_x;
  550.     ewin->prev_frame_y=ewin->frame_y;
  551.     h=DisplayHeight(disp,screen);
  552.     h-=ewin->border_t;
  553.     h-=ewin->border_b;
  554.     while (((h-ewin->base_height)%ewin->sizeinc_y)>0) h--;
  555.     while (((h-ewin->base_height)%ewin->sizeinc_y)<0) h++;
  556.     y=0;
  557.     w=DisplayWidth(disp,screen);
  558.     w-=ewin->border_l;
  559.     w-=ewin->border_r;
  560.     while (((w-ewin->base_width)%ewin->sizeinc_x)>0) w--;
  561.     while (((w-ewin->base_width)%ewin->sizeinc_x)<0) w++;
  562.     x=0;
  563.      }
  564.    ModifyEWin(ewin,x,y,w,h);
  565.    ewin->lastop=OP_MAXSIZE;
  566. }
  567.  
  568. void Do_Configure()
  569. {
  570. }
  571.  
  572. void Do_MenuWin(EWin *ewin)
  573. {
  574. }
  575.  
  576. void CycleToNextWindow()
  577. {
  578.    struct list *l;
  579.    EWin *ewin1;
  580.    EWin *ewin2;
  581.    int i,x,y;
  582.    XWindowAttributes xatt;
  583.   
  584.    do {   
  585.        l=global_l->first;
  586.        if (!l) return;
  587.        if (!l->next) return;
  588.        ewin1=l->win;
  589.        ewin2=l->next->win;
  590.        ToBack(ewin1);
  591.       } while(ewin2->skip); 
  592.  
  593.  
  594.    for (i=0;i<cfg.num_subwins;i++)
  595.      {
  596.     if (cfg.subwin_type[i]==2)
  597.       {
  598.          XGetWindowAttributes(disp,ewin2->subwins[i],&xatt);
  599.          x=ewin2->frame_x+xatt.x+(xatt.width/2);
  600.          y=ewin2->frame_y+xatt.y+(xatt.height/2);
  601.          i=64;
  602.       }
  603.      }
  604.    XWarpPointer(disp,None,root,0,0,1,1,x,y);
  605.    FocWin(ewin2->client_win,1);
  606.    Do_RaiseWin(ewin2);
  607. }
  608.  
  609. void CycleToPreviousWindow()
  610. {
  611.    struct list *l;
  612.    EWin *ewin2, *ewin1, *ewin3;
  613.    int i,x,y;
  614.    XWindowAttributes xatt;
  615.    
  616.    l=global_l->first;
  617.    if (!l) return;
  618.    if (!l->next) return;
  619.    ewin1=global_l->last->win;
  620.    ewin3=global_l->first->win; 
  621.    ewin2=global_l->last->win;
  622.    while((!ewin3->skip)&&(ewin3!=ewin1))
  623.      {
  624.        l=l->next;
  625.        if (!l) return;
  626.        if (!l->next) return;   
  627.        ewin3=l->next->win;
  628.        if((!ewin3->skip)&&(ewin3!=ewin1)) ewin2=ewin3;
  629.      }
  630.  
  631.  
  632.    for (i=0;i<cfg.num_subwins;i++)
  633.      {
  634.     if (cfg.subwin_type[i]==2)
  635.       {
  636.          XGetWindowAttributes(disp,ewin2->subwins[i],&xatt);
  637.          x=ewin2->frame_x+xatt.x+(xatt.width/2);
  638.          y=ewin2->frame_y+xatt.y+(xatt.height/2);
  639.          i=64;
  640.       }
  641.      }
  642.    XWarpPointer(disp,None,root,0,0,1,1,x,y);
  643.    FocWin(ewin2->client_win,1);
  644.    Do_RaiseWin(ewin2);
  645. }
  646.  
  647. void ResizeLoop(EWin *ewin, Window win)
  648. {
  649.    GC gc;
  650.    XGCValues gcv;
  651.    XEvent xev;     
  652.    int first;
  653.    int sx,sy;
  654.    Window w1,w2;
  655.    int xx,yy; /* x,y */
  656.    unsigned int d;
  657.    int wx,wy;
  658.    /* Window dummyw;
  659.    int dummy; */
  660.    int col;
  661.    
  662.    if (depth>8) col=WhitePixel(disp,screen);
  663.    else col=1;
  664.    first=0;
  665.    XGrabServer(disp);
  666.    XGrabPointer(disp, win, True, ButtonMotionMask|PointerMotionMask|ButtonReleaseMask|ButtonPressMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
  667.    gc=XCreateGC(disp,root,0,&gcv);
  668.    XSetSubwindowMode(disp,gc,IncludeInferiors);
  669.    XSetForeground(disp,gc,col);
  670.    XSetFunction(disp,gc,GXxor);
  671.  
  672.    Draw_Cursor(ewin,(evmd.ewin->client_width-evmd.ewin->base_width)/evmd.ewin->sizeinc_x,(evmd.ewin->client_height-evmd.ewin->base_height)/evmd.ewin->sizeinc_y, 'x', 1);
  673.    while (1) {
  674.     XMaskEvent(disp,ButtonMotionMask|PointerMotionMask|ButtonReleaseMask,&xev);
  675.         XQueryPointer(disp,root,&w1,&w2,&sx,&sy,&xx,&yy,&d);
  676.     if (xev.type==ButtonRelease) {
  677.          if (first) {
  678.           XPutBackEvent(disp,&xev);
  679.           switch(cfg.resize_mode) {
  680.             case 0:
  681.                        XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  682.                       evmd.x2+ewin->border_l+ewin->border_r,
  683.                       evmd.y2+ewin->border_t+ewin->border_b);
  684.                        XDrawRectangle(disp,root,gc,
  685.                       evmd.x1+ewin->border_l,
  686.                       evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  687.                 break;
  688.              case 1:
  689.                        XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  690.                       evmd.x2+ewin->border_l+ewin->border_r,
  691.                       evmd.y2+ewin->border_t+ewin->border_b);
  692.                        XFillRectangle(disp,root,gc,
  693.                       evmd.x1+ewin->border_l,
  694.                       evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  695.                 break;
  696.           }
  697.           break;
  698.          } else {
  699.           XPutBackEvent(disp,&xev);
  700.           break;
  701.          }
  702.     }
  703.     if (first) {
  704.          if (cfg.resize_mode==0) {
  705.           XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  706.                  evmd.x2+ewin->border_l+ewin->border_r,
  707.                  evmd.y2+ewin->border_t+ewin->border_b);
  708.           XDrawRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  709.                  evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  710.          } else if (cfg.resize_mode==1) {
  711.           XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  712.                  evmd.x2+ewin->border_l+ewin->border_r,
  713.                  evmd.y2+ewin->border_t+ewin->border_b);
  714.           XFillRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  715.                  evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  716.          }
  717.     }
  718.     wx=sx-evmd.px;
  719.     while ((wx%evmd.ewin->sizeinc_x)>0) wx--;
  720.     while ((wx%evmd.ewin->sizeinc_x)<0) wx++;
  721.     wy=sy-evmd.py;
  722.     while ((wy%evmd.ewin->sizeinc_y)>0) wy--;
  723.     while ((wy%evmd.ewin->sizeinc_y)<0) wy++;
  724.     if ((wx!=0)||(wy!=0)) {
  725.         switch(evmd.resize_mode) {
  726.             case 0:
  727.                   if ((wx>0)&&(evmd.x2<wx)) wx=0;
  728.                   if ((wy>0)&&(evmd.y2<wy)) wy=0;
  729.                   evmd.x1+=wx;evmd.y1+=wy;
  730.                   evmd.x2-=wx;evmd.y2-=wy;
  731.                 break;
  732.             case 1:
  733.                   if ((wx<0)&&(evmd.x2<-wx)) wx=0;
  734.                   if ((wy>0)&&(evmd.y2<wy)) wy=0;
  735.                   evmd.y1+=wy;
  736.                   evmd.x2+=wx;evmd.y2-=wy;
  737.                 break;
  738.             case 2:
  739.                   if ((wx>0)&&(evmd.x2<wx)) wx=0;
  740.                   if ((wy<0)&&(evmd.y2<-wy)) wy=0;
  741.                   evmd.x1+=wx;
  742.                   evmd.x2-=wx;evmd.y2+=wy;
  743.                 break;
  744.             case 3:
  745.                   if ((wx<0)&&(evmd.x2<-wx)) wx=0;
  746.                   if ((wy<0)&&(evmd.y2<-wy)) wy=0;
  747.                   evmd.x2+=wx;evmd.y2+=wy;
  748.                 break;
  749.          }
  750.          if (evmd.x2>evmd.ewin->max_width) evmd.x2=evmd.ewin->max_width;
  751.          if (evmd.x2<evmd.ewin->min_width) evmd.x2=evmd.ewin->min_width;
  752.          if (evmd.y2>evmd.ewin->max_height) evmd.y2=evmd.ewin->max_height;
  753.          if (evmd.y2<evmd.ewin->min_height) evmd.y2=evmd.ewin->min_height;
  754.     }
  755.     switch(cfg.resize_mode) {
  756.         case 0:
  757.                  XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  758.                 evmd.x2+ewin->border_l+ewin->border_r,
  759.                 evmd.y2+ewin->border_t+ewin->border_b);
  760.                  XDrawRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  761.                 evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  762.             break;
  763.         case 1:
  764.                  XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  765.                 evmd.x2+ewin->border_l+ewin->border_r,
  766.                 evmd.y2+ewin->border_t+ewin->border_b);
  767.                  XFillRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  768.                 evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  769.             break;
  770.     }
  771.     first=1;
  772.     Draw_Cursor(ewin,(evmd.x2-evmd.ewin->base_width)/evmd.ewin->sizeinc_x,(evmd.y2-evmd.ewin->base_height)/evmd.ewin->sizeinc_y, 'x', 0);
  773.     XSync(disp,False);
  774.     evmd.px+=wx;
  775.     evmd.py+=wy;
  776.    }
  777.    XFreeGC(disp,gc);
  778.    XUngrabServer(disp);
  779.    Draw_Cursor(ewin, evmd.x1,evmd.y1, '+', 2);
  780.    XUngrabPointer(disp, CurrentTime);
  781.    ModifyEWin(evmd.ewin,evmd.x1,evmd.y1,evmd.x2,evmd.y2);
  782.    XSync(disp,False);
  783. /*   while (XCheckTypedEvent(disp,MotionNotify,&xev));*/
  784. }
  785.  
  786. void MoveLoop(EWin *ewin, Window win)
  787. {
  788.    GC gc;
  789.    XGCValues gcv;
  790.    XEvent xev;     
  791.    int first;
  792.    int sx,sy;
  793.    Window w1,w2;
  794.    int xx,yy; /* x,y */
  795.    unsigned int d;
  796.    /* int wx,wy;
  797.    Window dummyw;
  798.    int dummy; */
  799.    int col;
  800.    
  801.    if (depth>8) col=WhitePixel(disp,screen);
  802.    else col=1;
  803.    first=0;
  804.    XGrabServer(disp);
  805.    XGrabPointer(disp, win, True, ButtonMotionMask|PointerMotionMask|ButtonReleaseMask|ButtonPressMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
  806.    Draw_Cursor(ewin, ewin->frame_x, ewin->frame_y, '+', 1);
  807.    gc=XCreateGC(disp,root,0,&gcv);
  808.    XSetSubwindowMode(disp,gc,IncludeInferiors);
  809.    XSetForeground(disp,gc,col);
  810.    XSetFunction(disp,gc,GXxor);
  811.    evmd.x1=ewin->frame_x;
  812.    evmd.y1=ewin->frame_y;
  813.    evmd.x2=ewin->client_width;
  814.    evmd.y2=ewin->client_height;
  815.    while (1)
  816.      {
  817.     XMaskEvent(disp,ButtonMotionMask|PointerMotionMask|ButtonReleaseMask,&xev);
  818.         XQueryPointer(disp,root,&w1,&w2,&sx,&sy,&xx,&yy,&d);
  819.     if (xev.type==ButtonRelease)
  820.       {
  821.          if (first)
  822.            {
  823.           XPutBackEvent(disp,&xev);
  824.           if (cfg.move_mode==0)
  825.             {
  826.                XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  827.                       evmd.x2+ewin->border_l+ewin->border_r,
  828.                       evmd.y2+ewin->border_t+ewin->border_b);
  829.                XDrawRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  830.                       evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  831.             }
  832.           else if (cfg.move_mode==1) 
  833.             {
  834.                XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  835.                       evmd.x2+ewin->border_l+ewin->border_r,
  836.                       evmd.y2+ewin->border_t+ewin->border_b);
  837.                XFillRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  838.                       evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  839.             }
  840.           break;
  841.            }
  842.          else
  843.            {
  844.           XPutBackEvent(disp,&xev);
  845.           break;
  846.            }
  847.       }
  848.     if (first)
  849.       {
  850.          if (cfg.move_mode==0)
  851.            {
  852.           XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  853.                  evmd.x2+ewin->border_l+ewin->border_r,
  854.                  evmd.y2+ewin->border_t+ewin->border_b);
  855.           XDrawRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  856.                  evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  857.            }
  858.          else if (cfg.move_mode==1) 
  859.            {
  860.           XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  861.                  evmd.x2+ewin->border_l+ewin->border_r,
  862.                  evmd.y2+ewin->border_t+ewin->border_b);
  863.           XFillRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  864.                  evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  865.            }
  866.       }
  867.         evmd.x1+=sx-evmd.px;
  868.     evmd.y1+=sy-evmd.py;
  869.     if (cfg.move_mode==0)
  870.       {
  871.          XDrawRectangle(disp,root,gc,evmd.x1,evmd.y1,
  872.                 evmd.x2+ewin->border_l+ewin->border_r,
  873.                 evmd.y2+ewin->border_t+ewin->border_b);
  874.          XDrawRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  875.                 evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  876.       }
  877.     else if (cfg.move_mode==1) 
  878.       {
  879.          XFillRectangle(disp,root,gc,evmd.x1,evmd.y1,
  880.                 evmd.x2+ewin->border_l+ewin->border_r,
  881.                 evmd.y2+ewin->border_t+ewin->border_b);
  882.          XFillRectangle(disp,root,gc,evmd.x1+ewin->border_l,
  883.                 evmd.y1+ewin->border_t,evmd.x2,evmd.y2);
  884.       }
  885.     first=1;
  886.     Draw_Cursor(ewin, evmd.x1,evmd.y1, '+', 0);
  887.     XSync(disp,False);
  888.         evmd.px=sx;
  889.     evmd.py=sy;
  890.      }
  891.    XFreeGC(disp,gc);
  892.    XUngrabServer(disp);
  893.    Draw_Cursor(ewin, evmd.x1,evmd.y1, '+', 2);
  894.    XUngrabPointer(disp, CurrentTime);
  895.    ModifyEWin(evmd.ewin,evmd.x1,evmd.y1,evmd.x2,evmd.y2);
  896.    XSync(disp,False);
  897. /*   while (XCheckTypedEvent(disp,MotionNotify,&xev));*/
  898. }
  899.  
  900. void PerformWindowOp (int OpToPerform) {
  901.  
  902. /* created 08/04/97 mandrake */
  903. /* This code is SUPPOSED to behave in roughly the following:
  904.  * If you're in pointerfocus, automatically performs the selected windowop.
  905.  * (if you're already over a window)
  906.  * otherwise it will allow you to move the mouse pointer to another window,
  907.  * click that window, and then have the specified windowop performed.
  908.  * It should, also, change the cursor to a predefined select cursor
  909.  * (via pointer hotswapping code)
  910.  */
  911.  
  912.     EWin *ewin;
  913.     Window wwin;
  914.     
  915. /* first we're going to let the user select a window (this will
  916.  * grab the server, temporarily, too
  917.  */
  918.     int dummy;
  919.     unsigned int dummyui;
  920.     int finished=0;
  921.     Window dwin,tmp_win;
  922.     XEvent xev;
  923.     char NeedToQuery=1;
  924.  
  925.  
  926.     if(!OpToPerform) return;
  927.     /* XGrabServer(disp); */
  928.  
  929.     /* I'm not totally sure if this part in here will mess up if you're
  930.      * calling it from a root menu... 
  931.      */
  932.     XQueryPointer(disp,root,&dwin,&wwin,&dummy,&dummy,&dummy,&dummy,&dummyui);
  933.     ewin=ListGetWinID(global_l,wwin);
  934.     if(ewin) {
  935.         finished=1;
  936.         NeedToQuery=0;
  937.     }
  938.  
  939.     if(NeedToQuery)
  940.         Do_ChangeMouseCursor("windowselect");
  941.  
  942.     while (finished==0) {
  943.         XNextEvent(disp,&xev);
  944.         tmp_win=xev.xbutton.subwindow;
  945.         if(xev.type == ButtonPress) finished=1;
  946.     }
  947.  
  948.     if(NeedToQuery) {
  949.         XQueryPointer(disp,root,&dwin,&wwin,&dummy,&dummy,&dummy,&dummy,&dummyui);
  950.         if(!(ewin=ListGetWinID(global_l,wwin)))
  951.             return;
  952.     }
  953.     /* Do_ChangeMouseCursor("default"); */
  954.     /* XUngrabServer(disp); */
  955.         if(OpToPerform < ACTION_MAX_WIDTH)
  956.     switch(OpToPerform) {
  957.         case ACTION_MOVE:
  958.             Do_RaiseWin(ewin);
  959.             Do_MoveWin(ewin,wwin);
  960.             Do_ChangeMouseCursor("default");
  961.             return;
  962.         case ACTION_RESIZE:
  963.             Do_RaiseWin(ewin);
  964.             Do_ResizeWin(ewin,wwin);
  965.             Do_ChangeMouseCursor("default");
  966.             return;
  967.         case ACTION_ICONIFY:
  968.             Do_IconifyWin(ewin);
  969.             return;
  970.         case ACTION_KILL:
  971.             Do_KillWin(ewin,0);
  972.             return;
  973.         case ACTION_RAISE:
  974.             Do_RaiseWin(ewin);
  975.             return;
  976.         case ACTION_LOWER:
  977.             Do_LowerWin(ewin);
  978.             return;
  979.         case ACTION_RAISE_LOWER:
  980.             Do_RaiseLowerWin(ewin);
  981.             return;
  982.         case ACTION_MAX_HEIGHT:
  983.             Do_RaiseWin(ewin);
  984.             Do_MaxHeightWin(ewin);
  985.             return;
  986.            }
  987.           else
  988.               switch(OpToPerform)
  989.            {         
  990.         case ACTION_MAX_WIDTH:
  991.             Do_RaiseWin(ewin);
  992.             Do_MaxWidthWin(ewin);
  993.             return;
  994.         case ACTION_MAX_SIZE:
  995.             Do_RaiseWin(ewin);
  996.             Do_MaxSizeWin(ewin);
  997.             return;
  998.         case ACTION_KILL_NASTY:
  999.             Do_KillWin(ewin,1);
  1000.             return;
  1001.         case ACTION_STICKY:
  1002.             ewin->desk = (ewin->desk<0) ? desk.current : -1;
  1003.             return;
  1004.         case ACTION_DRAG:
  1005.             StartIconDrag(ewin);
  1006.             return;
  1007.         case ACTION_SKIP:
  1008.             ewin->skip=ewin->skip?0:1;
  1009.             return;
  1010.         case ACTION_SHADE:
  1011.             Do_RaiseWin(ewin);
  1012.             DoShade(ewin);
  1013.             break;
  1014.         default:
  1015.             break;
  1016.     }
  1017.  
  1018. }
  1019.