modules/FvwmScroll/GrabWindow.c

   1 /* -*-c-*- */
   2 /* This module, and the entire GoodStuff program, and the concept for
   3  * interfacing this module to the Window Manager, are all original work
   4  * by Robert Nation
   5  *
   6  * Copyright 1993, Robert Nation. No guarantees or warantees or anything
   7  * are provided or implied in any way whatsoever. Use this program at your
   8  * own risk. Permission to use this program for any purpose is given,
   9  * as long as the copyright is kept intact. */
  10
  11 /* This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #if 0
  27 #define MAX_ICON_NAME_LEN 255
  28 #endif
  29
  30 #include "config.h"
  31
  32 #ifdef HAVE_SYS_BSDTYPES_H
  33 #include <sys/bsdtypes.h> /* Saul */
  34 #endif
  35
  36 #include <stdio.h>
  37 #include <signal.h>
  38 #include <sys/wait.h>
  39 #include "libs/ftime.h"
  40
  41 #if HAVE_SYS_SELECT_H
  42 #include <sys/select.h>
  43 #endif
  44 #include <ctype.h>
  45 #include <X11/Xlib.h>
  46 #include <X11/Xatom.h>
  47
  48 #include "libs/Module.h"
  49 #include "libs/fvwmlib.h"
  50 #include "libs/Colorset.h"
  51 #include "libs/PictureBase.h"
  52 #include "libs/FScreen.h"
  53 #include "libs/Graphics.h"
  54 #include "libs/Parse.h"
  55 #include "libs/Strings.h"
  56
  57 #include "FvwmScroll.h"
  58
  59 static int Width = 300, Height = 300;
  60 static int target_width, target_height;
  61 static int target_x_offset = 0, target_y_offset = 0;
  62 static int exposed;
  63 int Reduction_H = 2;
  64 int Reduction_V = 2;
  65 int Percent_H = -1;
  66 int Percent_V =-1;
  67
  68 #define BAR_WIDTH 21
  69 #define SCROLL_BAR_WIDTH 9
  70
  71 #define PAD_WIDTH2 3
  72 #define PAD_WIDTH3 5
  73
  74 static Window main_win,holder_win;
  75 static Pixel hilite_pix,shadow_pix;
  76 extern int colorset;
  77 extern char *BackColor;
  78
  79 #define MW_EVENTS   (ExposureMask | StructureNotifyMask| ButtonReleaseMask |\
  80                      ButtonPressMask | ButtonMotionMask | FocusChangeMask)
  81
  82 Atom wm_del_win;
  83 Atom _XA_WM_PROTOCOLS;
  84 Atom _XA_WM_COLORMAP_WINDOWS;
  85
  86 /*
  87  *
  88  * Sizes and creates the window
  89  *
  90  */
  91 XSizeHints mysizehints;
  92 void CreateWindow(int x,int y, int w, int h)
  93 {
  94   XGCValues gcv;
  95   unsigned long gcm;
  96   XSetWindowAttributes attributes;
  97   int wx;
  98   int wy;
  99
 100   wm_del_win = XInternAtom(dpy,"WM_DELETE_WINDOW",False);
 101   _XA_WM_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False);
 102
 103   mysizehints.flags = PWinGravity| PResizeInc | PBaseSize | PMaxSize | PMinSize
 104     | USSize | USPosition;
 105   /* subtract one for the right/bottom border */
 106   mysizehints.width_inc = 1;
 107   mysizehints.height_inc = 1;
 108   mysizehints.base_height = BAR_WIDTH + PAD_WIDTH3;
 109   mysizehints.base_width = BAR_WIDTH + PAD_WIDTH3;
 110
 111   if ( Percent_V > -1 )
 112   {
 113     Width = (ScreenWidth * Percent_V)/100;
 114     if ( Width > (w + BAR_WIDTH + PAD_WIDTH3) || Percent_V == 0 )
 115       Width = w + BAR_WIDTH + PAD_WIDTH3;
 116   }
 117   else
 118   {
 119     Width = w/Reduction_V + BAR_WIDTH + PAD_WIDTH3;
 120   }
 121
 122   if ( Percent_H > -1 )
 123   {
 124     Height = (ScreenHeight * Percent_H)/100;
 125     if ( Height > h || Percent_H == 0 )
 126       Height = h + BAR_WIDTH + PAD_WIDTH3;
 127   }
 128   else
 129   {
 130     Height = h/Reduction_H + BAR_WIDTH + PAD_WIDTH3;
 131   }
 132
 133   target_width = w;
 134   target_height = h;
 135   mysizehints.width = Width;
 136   mysizehints.height = Height;
 137   wx = x;
 138   wy = y;
 139   mysizehints.max_width = w + BAR_WIDTH + PAD_WIDTH3;
 140   mysizehints.max_height = h + BAR_WIDTH + PAD_WIDTH3;
 141
 142   mysizehints.win_gravity = NorthWestGravity;
 143
 144   attributes.backing_store = NotUseful;
 145   attributes.background_pixel = (colorset < 0) ? GetColor(BackColor)
 146     : Colorset[colorset].bg;
 147   attributes.border_pixel = 0;
 148   attributes.colormap = Pcmap;
 149   main_win = XCreateWindow(dpy, Root, wx, wy,
 150                            mysizehints.width, mysizehints.height, 0, Pdepth,
 151                            InputOutput, Pvisual, CWBackingStore | CWBackPixel
 152                            | CWBorderPixel | CWColormap, &attributes);
 153
 154   hilite_pix = (colorset < 0) ? GetHilite(attributes.background_pixel)
 155     : Colorset[colorset].hilite;
 156   shadow_pix = (colorset < 0) ? GetShadow(attributes.background_pixel)
 157     : Colorset[colorset].shadow;
 158
 159   XSetWMProtocols(dpy,main_win,&wm_del_win,1);
 160
 161   /* hack to prevent mapping on wrong screen with StartsOnScreen */
 162   FScreenMangleScreenIntoUSPosHints(FSCREEN_XYPOS, &mysizehints);
 163   XSetWMNormalHints(dpy,main_win,&mysizehints);
 164   XSelectInput(dpy,main_win,MW_EVENTS);
 165   change_window_name(module->name);
 166
 167   holder_win = XCreateWindow(dpy, main_win, PAD_WIDTH3, PAD_WIDTH3,
 168                              mysizehints.width - BAR_WIDTH - PAD_WIDTH3,
 169                              mysizehints.height - BAR_WIDTH - PAD_WIDTH3,
 170                              0, Pdepth, InputOutput, Pvisual, CWBackingStore
 171                              | CWBackPixel | CWBorderPixel | CWColormap,
 172                              &attributes);
 173   XMapWindow(dpy,holder_win);
 174
 175
 176   gcm = GCForeground;
 177   gcv.foreground = hilite_pix;
 178   hiliteGC = fvwmlib_XCreateGC(dpy, holder_win, gcm, &gcv);
 179   gcv.foreground = shadow_pix;
 180   shadowGC = fvwmlib_XCreateGC(dpy, holder_win, gcm, &gcv);
 181
 182   if (colorset >= 0)
 183     SetWindowBackground(dpy, main_win, mysizehints.width, mysizehints.height,
 184                         &Colorset[(colorset)], Pdepth, shadowGC,
 185                         True);
 186
 187   _XA_WM_COLORMAP_WINDOWS = XInternAtom (dpy, "WM_COLORMAP_WINDOWS", False);
 188 }
 189
 190 /*
 191   LoopOnEvents - Process all the X events we get
 192 */
 193
 194 #define RIGHT 7
 195 #define LEFT 6
 196 #define BOTTOM 5
 197 #define TOP 4
 198 #define QUIT 3
 199 #define VERTICAL 2
 200 #define HORIZONTAL 1
 201 #define NONE 0
 202 int motion = NONE;
 203
 204 void LoopOnEvents(Window target)
 205 {
 206         Window root;
 207         int x, y;
 208         XEvent Event;
 209         XEvent ev;
 210         unsigned int tw, th, depth, border_width;
 211         char *temp;
 212         char *prop = NULL;
 213         Atom actual = None;
 214         int actual_format;
 215         unsigned long nitems, bytesafter;
 216
 217         while (FPending(dpy)) {
 218                 FNextEvent(dpy,&Event);
 219                 switch(Event.type)
 220                 {
 221                 case Expose:
 222                         while (FCheckTypedWindowEvent(
 223                                 dpy, main_win, Expose, &Event));
 224                         exposed = 1;
 225                         RedrawWindow(target);
 226                         break;
 227
 228                 case ConfigureNotify:
 229                         while (FCheckTypedWindowEvent(
 230                                 dpy, main_win, ConfigureNotify, &ev))
 231                         {
 232                                 if (!ev.xconfigure.send_event)
 233                                         continue;
 234                                 Event.xconfigure.send_event = True;
 235                         }
 236                         if (!XGetGeometry(
 237                                 dpy, main_win, &root ,&x, &y, &tw, &th,
 238                                 &border_width, &depth))
 239                         {
 240                                 return;
 241                         }
 242                         if ((tw != Width) || (th != Height))
 243                         {
 244                                 if (colorset >= 0)
 245                                         SetWindowBackground(
 246                                                 dpy, main_win, tw, th,
 247                                                 &Colorset[(colorset)], Pdepth,
 248                                                 shadowGC, True);
 249                                 XResizeWindow(
 250                                         dpy, holder_win,
 251                                         tw - BAR_WIDTH - PAD_WIDTH3,
 252                                         th - BAR_WIDTH - PAD_WIDTH3);
 253                                 Width = tw;
 254                                 Height = th;
 255                                 if (target_y_offset > target_height - Height +
 256                                     BAR_WIDTH)
 257                                         target_y_offset =
 258                                                 target_height - Height +
 259                                                 BAR_WIDTH;
 260                                 if (target_y_offset < 0)
 261                                         target_y_offset = 0;
 262                                 if (target_x_offset > target_width - Width +
 263                                     BAR_WIDTH)
 264                                         target_x_offset =
 265                                                 target_width - Width + BAR_WIDTH;
 266                                 if (target_x_offset < 0)
 267                                         target_x_offset = 0;
 268
 269                                 XMoveWindow(
 270                                         dpy, target, -target_x_offset,
 271                                         -target_y_offset);
 272                         }
 273                         else if (Event.xconfigure.send_event &&
 274                                  CSET_IS_TRANSPARENT(colorset))
 275                         {
 276                                 SetWindowBackground(
 277                                         dpy, main_win, tw, th,
 278                                         &Colorset[(colorset)], Pdepth,
 279                                         shadowGC, True);
 280                         }
 281                         break;
 282
 283                 case ButtonPress:
 284                         if((Event.xbutton.y > Height-BAR_WIDTH) &&
 285                            (Event.xbutton.x < SCROLL_BAR_WIDTH+PAD_WIDTH3))
 286                         {
 287                                 motion = LEFT;
 288                                 exposed = 2;
 289                                 RedrawWindow(target);
 290                         }
 291                         else if((Event.xbutton.y > Height - BAR_WIDTH) &&
 292                                 (Event.xbutton.x > Width - BAR_WIDTH -
 293                                  SCROLL_BAR_WIDTH-2) &&
 294                                 (Event.xbutton.x < Width-BAR_WIDTH))
 295                         {
 296                                 motion = RIGHT;
 297                                 exposed = 2;
 298                                 RedrawWindow(target);
 299                         }
 300                         else if((Event.xbutton.y < SCROLL_BAR_WIDTH+PAD_WIDTH3)
 301                                 && (Event.xbutton.x > Width-BAR_WIDTH))
 302                         {
 303                                 motion = TOP;
 304                                 exposed = 2;
 305                                 RedrawWindow(target);
 306                         }
 307                         else if((Event.xbutton.y > Height - BAR_WIDTH -
 308                                  SCROLL_BAR_WIDTH-2) &&
 309                                 (Event.xbutton.y < Height-BAR_WIDTH)&&
 310                                 (Event.xbutton.x > Width-BAR_WIDTH))
 311                         {
 312                                 motion = BOTTOM;
 313                                 exposed = 2;
 314                                 RedrawWindow(target);
 315                         }
 316                         else if((Event.xbutton.x > Width - BAR_WIDTH)&&
 317                                 (Event.xbutton.y < Height- BAR_WIDTH))
 318                         {
 319                                 motion = VERTICAL;
 320                                 target_y_offset=
 321                                         (Event.xbutton.y - PAD_WIDTH3-
 322                                          SCROLL_BAR_WIDTH)* target_height/
 323                                         (Height-BAR_WIDTH-PAD_WIDTH3 -
 324                                          2*SCROLL_BAR_WIDTH);
 325                                 if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 >
 326                                    target_height)
 327                                         target_y_offset =
 328                                                 target_height - Height+BAR_WIDTH
 329                                                 +PAD_WIDTH3;
 330                                 if(target_y_offset < 0)
 331                                         target_y_offset = 0;
 332                                 XMoveWindow(
 333                                         dpy,target,-target_x_offset,
 334                                         -target_y_offset);
 335                                 RedrawWindow(target);
 336                         }
 337                         else if((Event.xbutton.y > Height- BAR_WIDTH ) &&
 338                                 (Event.xbutton.x < Width- BAR_WIDTH))
 339                         {
 340                                 motion=HORIZONTAL;
 341                                 target_x_offset=
 342                                         (Event.xbutton.x -PAD_WIDTH3-
 343                                          SCROLL_BAR_WIDTH)* target_width/
 344                                         (Width-BAR_WIDTH-PAD_WIDTH3-
 345                                          2*SCROLL_BAR_WIDTH);
 346                                 if(target_x_offset < 0)
 347                                         target_x_offset = 0;
 348
 349                                 if(target_x_offset + Width -BAR_WIDTH-PAD_WIDTH3>
 350                                    target_width)
 351                                         target_x_offset =
 352                                                 target_width - Width + BAR_WIDTH+
 353                                                 PAD_WIDTH3;
 354                                 XMoveWindow(
 355                                         dpy,target,-target_x_offset,
 356                                         -target_y_offset);
 357                                 RedrawWindow(target);
 358                         }
 359                         else if((Event.xbutton.y > Height- BAR_WIDTH ) &&
 360                                 (Event.xbutton.x > Width- BAR_WIDTH))
 361                         {
 362                                 exposed = 2;
 363                                 motion=QUIT;
 364                         }
 365                         RedrawWindow(target);
 366                         break;
 367
 368                 case ButtonRelease:
 369                         if((Event.xbutton.y > Height- BAR_WIDTH ) &&
 370                            (Event.xbutton.x > Width- BAR_WIDTH)&&
 371                            (motion==QUIT))
 372                         {
 373                                 XUnmapWindow(dpy,main_win);
 374                                 XReparentWindow(dpy,target,Root,x,y);
 375                                 XSync(dpy,0);
 376                                 exit(0);
 377                         }
 378                         if((motion == LEFT)&&
 379                            (Event.xbutton.y > Height-BAR_WIDTH) &&
 380                            (Event.xbutton.x < SCROLL_BAR_WIDTH+PAD_WIDTH3))
 381                         {
 382                                 target_x_offset -= (Width-BAR_WIDTH-PAD_WIDTH2);
 383                                 if(target_x_offset < 0)
 384                                         target_x_offset = 0;
 385                                 XMoveWindow(
 386                                         dpy,target,-target_x_offset,
 387                                         -target_y_offset);
 388                                 motion = NONE;
 389                                 exposed = 2;
 390                         }
 391                         else if((motion == RIGHT)&&
 392                                 (Event.xbutton.y > Height-BAR_WIDTH) &&
 393                                 (Event.xbutton.x >
 394                                  Width-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
 395                                 (Event.xbutton.x < Width-BAR_WIDTH))
 396                         {
 397                                 target_x_offset += (Width-BAR_WIDTH-PAD_WIDTH2);
 398                                 if(target_x_offset+Width-BAR_WIDTH -PAD_WIDTH3 >
 399                                    target_width)
 400                                         target_x_offset =
 401                                                 target_width - Width+BAR_WIDTH+
 402                                                 PAD_WIDTH3;
 403                                 XMoveWindow(
 404                                         dpy,target,-target_x_offset,
 405                                         -target_y_offset);
 406                                 motion = NONE;
 407                                 exposed = 2;
 408                         }
 409                         else if((motion == TOP)&&
 410                                 (Event.xbutton.y<SCROLL_BAR_WIDTH+PAD_WIDTH3)&&
 411                                 (Event.xbutton.x > Width-BAR_WIDTH))
 412                         {
 413                                 target_y_offset -= (Height-BAR_WIDTH-PAD_WIDTH2);
 414                                 if(target_y_offset < 0)
 415                                         target_y_offset = 0;
 416                                 XMoveWindow(
 417                                         dpy,target,-target_x_offset,
 418                                         -target_y_offset);
 419                                 motion = NONE;
 420                                 exposed = 2;
 421                         }
 422                         else if((motion == BOTTOM)&&
 423                                 (Event.xbutton.y >
 424                                  Height-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
 425                                 (Event.xbutton.y < Height-BAR_WIDTH)&&
 426                                 (Event.xbutton.x > Width-BAR_WIDTH))
 427                         {
 428                                 target_y_offset += (Height-BAR_WIDTH-PAD_WIDTH2);
 429                                 if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 >
 430                                    target_height)
 431                                         target_y_offset = target_height -
 432                                                 Height+BAR_WIDTH+PAD_WIDTH3;
 433                                 XMoveWindow(
 434                                         dpy,target,-target_x_offset,
 435                                         -target_y_offset);
 436                                 motion = NONE;
 437                                 exposed = 2;
 438                         }
 439                         if(motion == VERTICAL)
 440                         {
 441                                 target_y_offset =
 442                                         (Event.xbutton.y-PAD_WIDTH3-
 443                                          SCROLL_BAR_WIDTH)*target_height /
 444                                         (Height-BAR_WIDTH-PAD_WIDTH3 -
 445                                          2*SCROLL_BAR_WIDTH);
 446                                 if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 >
 447                                    target_height)
 448                                         target_y_offset = target_height - Height+
 449                                                 BAR_WIDTH+PAD_WIDTH3;
 450                                 if(target_y_offset < 0)
 451                                         target_y_offset = 0;
 452                                 XMoveWindow(
 453                                         dpy,target,-target_x_offset,
 454                                         -target_y_offset);
 455                         }
 456                         if(motion == HORIZONTAL)
 457                         {
 458                                 target_x_offset=
 459                                         (Event.xbutton.x -PAD_WIDTH3-
 460                                          SCROLL_BAR_WIDTH) * target_width /
 461                                         (Width-BAR_WIDTH-PAD_WIDTH3-
 462                                          2*SCROLL_BAR_WIDTH);
 463                                 if(target_x_offset < 0)
 464                                         target_x_offset = 0;
 465
 466                                 if(target_x_offset + Width-BAR_WIDTH-PAD_WIDTH3>
 467                                    target_width)
 468                                         target_x_offset =
 469                                                 target_width - Width +
 470                                                 BAR_WIDTH+PAD_WIDTH3;
 471                                 XMoveWindow(
 472                                         dpy,target,-target_x_offset,
 473                                         -target_y_offset);
 474                         }
 475                         RedrawWindow(target);
 476                         motion = NONE;
 477                         break;
 478
 479                 case MotionNotify:
 480                         if((motion == LEFT)&&
 481                            ((Event.xmotion.y < Height-BAR_WIDTH) ||
 482                             (Event.xmotion.x > SCROLL_BAR_WIDTH+PAD_WIDTH3)))
 483                         {
 484                                 motion = NONE;
 485                                 exposed = 2;
 486                         }
 487                         else if((motion == RIGHT)&&
 488                                 ((Event.xmotion.y < Height-BAR_WIDTH) ||
 489                                  (Event.xmotion.x <
 490                                   Width-BAR_WIDTH-SCROLL_BAR_WIDTH-2) ||
 491                                  (Event.xmotion.x > Width-BAR_WIDTH)))
 492                         {
 493                                 motion = NONE;
 494                                 exposed = 2;
 495                         }
 496                         else if((motion == TOP)&&
 497                                 ((Event.xmotion.y>SCROLL_BAR_WIDTH+PAD_WIDTH3)||
 498                                  (Event.xmotion.x < Width-BAR_WIDTH)))
 499                         {
 500                                 motion = NONE;
 501                                 exposed = 2;
 502                         }
 503                         else if((motion == BOTTOM)&&
 504                                 ((Event.xmotion.y <
 505                                   Height-BAR_WIDTH-SCROLL_BAR_WIDTH-2) ||
 506                                  (Event.xmotion.y > Height-BAR_WIDTH)||
 507                                  (Event.xmotion.x < Width-BAR_WIDTH)))
 508                         {
 509                                 motion = NONE;
 510                                 exposed = 2;
 511                         }
 512                         if(motion == VERTICAL)
 513                         {
 514                                 target_y_offset=
 515                                         (Event.xmotion.y-PAD_WIDTH3-
 516                                          SCROLL_BAR_WIDTH)*target_height/
 517                                         (Height-BAR_WIDTH-PAD_WIDTH3-
 518                                          2*SCROLL_BAR_WIDTH);
 519                                 if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 >
 520                                    target_height)
 521                                         target_y_offset =
 522                                                 target_height - Height+BAR_WIDTH+
 523                                                 PAD_WIDTH3;
 524                                 if(target_y_offset < 0)
 525                                         target_y_offset = 0;
 526                                 XMoveWindow(
 527                                         dpy,target,-target_x_offset,
 528                                         -target_y_offset);
 529                         }
 530                         if(motion == HORIZONTAL)
 531                         {
 532                                 target_x_offset =
 533                                         (Event.xmotion.x -PAD_WIDTH3-
 534                                          SCROLL_BAR_WIDTH)* target_width/
 535                                         (Width-BAR_WIDTH-PAD_WIDTH3-
 536                                          2*SCROLL_BAR_WIDTH);
 537                                 if(target_x_offset < 0)
 538                                         target_x_offset = 0;
 539
 540                                 if(target_x_offset + Width-BAR_WIDTH-PAD_WIDTH3>
 541                                    target_width)
 542                                         target_x_offset =
 543                                                 target_width - Width + BAR_WIDTH+
 544                                                 PAD_WIDTH3;
 545                                 XMoveWindow(
 546                                         dpy,target,-target_x_offset,
 547                                         -target_y_offset);
 548                         }
 549                         if((motion == QUIT)&&
 550                            ((Event.xbutton.y < Height- BAR_WIDTH )||
 551                             (Event.xbutton.x < Width- BAR_WIDTH)))
 552                         {
 553                                 motion = NONE;
 554                                 exposed = 2;
 555                         }
 556                         RedrawWindow(target);
 557                         break;
 558                 case ClientMessage:
 559                         if ((Event.xclient.format==32) &&
 560                             (Event.xclient.data.l[0]==wm_del_win))
 561                         {
 562                                 DeadPipe(1);
 563                         }
 564                         break;
 565                 case PropertyNotify:
 566                         if(Event.xproperty.atom == XA_WM_NAME)
 567                         {
 568                                 if(XFetchName(dpy, target, &temp)==0)
 569                                         temp = NULL;
 570                                 change_window_name(temp);
 571                         }
 572                         else if (Event.xproperty.atom == XA_WM_ICON_NAME)
 573                         {
 574                                 if (XGetWindowProperty (
 575                                         dpy,
 576                                         target, Event.xproperty.atom, 0L,
 577                                         (long)MAX_ICON_NAME_LEN, False, XA_STRING,
 578                                         &actual,&actual_format, &nitems,
 579                                         &bytesafter, (unsigned char **) &prop)
 580                                     == Success && (prop != NULL))
 581                                         change_icon_name(prop);
 582                         }
 583                         else if(Event.xproperty.atom == XA_WM_HINTS)
 584                         {
 585                                 XWMHints *wmhints;
 586
 587                                 wmhints = XGetWMHints(dpy,target);
 588                                 XSetWMHints(dpy,main_win, wmhints);
 589                                 XFree(wmhints);
 590                         }
 591                         else if(Event.xproperty.atom == XA_WM_NORMAL_HINTS)
 592                         {
 593                                 /* don't do Normal Hints. They alter the size of
 594                                  * the window */
 595                         }
 596                         else if (Event.xproperty.atom == _XA_WM_COLORMAP_WINDOWS)
 597                         {
 598                                 /* ignore colormap stuff. The FvwmScroll window
 599                                  * may have a different visual to the client and
 600                                  so cannot pass this on */
 601                         }
 602                         break;
 603
 604                 case DestroyNotify:
 605                         DeadPipe(1);
 606                         break;
 607
 608                 case UnmapNotify:
 609                         break;
 610
 611                 case MapNotify:
 612                         XMapWindow(dpy,main_win);
 613                         break;
 614                 case FocusIn:
 615                         XSetInputFocus(dpy,target,RevertToParent,CurrentTime);
 616                         break;
 617                 case ColormapNotify:
 618                         /* FvwmScroll may not have the same visual as the
 619                          * captured window and so cannot share its colormap
 620                          {
 621                          XWindowAttributes xwa;
 622                          if(XGetWindowAttributes(dpy,target, &xwa) != 0)
 623                          {
 624                          XSetWindowColormap(dpy,main_win,xwa.colormap);
 625                          }
 626                          }
 627                         */
 628                         break;
 629                 default:
 630                         break;
 631                 }
 632         }
 633 }
 634
 635 /*
 636   ProcessMessage - Process the message coming from Fvwm
 637 */
 638 void ProcessMessage(unsigned long type,unsigned long *body)
 639 {
 640         char *tline, *token;
 641
 642         switch(type)
 643         {
 644         case M_CONFIG_INFO:
 645                 tline = (char*)&body[3];
 646                 tline = GetNextToken(tline, &token);
 647                 if (StrEquals(token, "Colorset"))
 648                 {
 649                         /* track all colorset changes and update display
 650                          * if necessary */
 651                         if (LoadColorset(tline) == colorset)
 652                         {
 653                                 XSetForeground(
 654                                         dpy, hiliteGC,Colorset[colorset].hilite);
 655                                 XSetForeground(
 656                                         dpy, shadowGC, Colorset[colorset].shadow);
 657                                 SetWindowBackground(
 658                                         dpy, main_win, Width, Height,
 659                                         &Colorset[colorset], Pdepth, shadowGC,
 660                                         True);
 661                         }
 662                 }
 663                 free(token);
 664                 break;
 665         case MX_PROPERTY_CHANGE:
 666                 if (body[0] == MX_PROPERTY_CHANGE_BACKGROUND && body[2] == 0 &&
 667                     CSET_IS_TRANSPARENT_PR(colorset))
 668                 {
 669                         SetWindowBackground(
 670                                 dpy, main_win, Width, Height,
 671                                 &Colorset[colorset],
 672                                 Pdepth, shadowGC, True);
 673                 }
 674                 break;
 675         }
 676 }
 677
 678 /*
 679   Loop -  Read and redraw until we die, blocking when can't read
 680 */
 681 void Loop(Window target)
 682 {
 683         while(1)
 684         {
 685                 FvwmPacket* packet;
 686                 fd_set fdset;
 687
 688                 FD_ZERO(&fdset);
 689                 FD_SET(fd[1], &fdset);
 690                 FD_SET(x_fd, &fdset);
 691
 692                 LoopOnEvents(target);
 693
 694                 select(fd_width, SELECT_FD_SET_CAST &fdset, NULL, NULL, NULL );
 695
 696                 /* parse any config lines (colorsets) */
 697                 if (FD_ISSET(fd[1], &fdset))
 698                 {
 699                         packet = ReadFvwmPacket(fd[1]);
 700                         if (!packet)
 701                         {
 702                                 /* fvwm has gone away or done KillModule */
 703                                 XUnmapWindow(dpy,main_win);
 704                                 XReparentWindow(dpy,target,Root,0,0);
 705                                 XSync(dpy,0);
 706                                 exit(0);
 707                         }
 708                         else
 709                         {
 710                                 ProcessMessage(packet->type, packet->body);
 711                         }
 712                 }
 713         }
 714         return;
 715 }
 716
 717
 718
 719
 720 /*
 721  *
 722  * Draw the window
 723  *
 724  */
 725 void RedrawWindow(Window target)
 726 {
 727   static int xv= 0,yv= 0,hv=0,wv=0;
 728   static int xh=0,yh=0,hh=0,wh=0;
 729   int x,y,w,h;
 730   XEvent dummy;
 731
 732   while (FCheckTypedWindowEvent(dpy, main_win, Expose, &dummy))
 733     exposed |= 1;
 734
 735   XSetWindowBorderWidth(dpy,target,0);
 736
 737   RelieveRectangle(dpy, main_win, PAD_WIDTH3 - 2, PAD_WIDTH3 - 2,
 738                    Width-BAR_WIDTH - PAD_WIDTH3 + 3,
 739                    Height-BAR_WIDTH - PAD_WIDTH3 + 3,
 740                    shadowGC, hiliteGC, 2);
 741
 742   y = (Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
 743     target_y_offset/target_height
 744     + PAD_WIDTH2 + 2 + SCROLL_BAR_WIDTH;
 745   x = Width-SCROLL_BAR_WIDTH- PAD_WIDTH2-2;
 746   w = SCROLL_BAR_WIDTH;
 747   h = (Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
 748     (Height-BAR_WIDTH-PAD_WIDTH3)/
 749     target_height;
 750   if((y!=yv)||(x != xv)||(w != wv)||(h != hv)||(exposed & 1))
 751   {
 752     yv = y;
 753     xv = x;
 754     wv = w;
 755     hv = h;
 756     XClearArea(dpy,main_win,x,PAD_WIDTH3+SCROLL_BAR_WIDTH,
 757                w,Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH,False);
 758
 759     RelieveRectangle(dpy, main_win, x, y, w - 1, h - 1,
 760                      hiliteGC, shadowGC, 2);
 761   }
 762   if(exposed & 1)
 763     RelieveRectangle(dpy, main_win, x - 2, PAD_WIDTH2, w + 3,
 764                      Height - BAR_WIDTH - PAD_WIDTH2 + 1,
 765                      shadowGC, hiliteGC, 2);
 766   if(exposed)
 767   {
 768     if(motion == TOP)
 769       RedrawTopButton(shadowGC,hiliteGC,x,PAD_WIDTH3);
 770     else
 771       RedrawTopButton(hiliteGC,shadowGC,x,PAD_WIDTH3);
 772     if(motion == BOTTOM)
 773       RedrawBottomButton(shadowGC,hiliteGC,x,
 774                          Height-BAR_WIDTH-SCROLL_BAR_WIDTH);
 775     else
 776       RedrawBottomButton(hiliteGC,shadowGC,x,
 777                          Height-BAR_WIDTH-SCROLL_BAR_WIDTH);
 778   }
 779
 780   x = (Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*target_x_offset/
 781     target_width+PAD_WIDTH2+2 + SCROLL_BAR_WIDTH;
 782   y = Height-SCROLL_BAR_WIDTH-PAD_WIDTH2-2;
 783   w = (Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
 784     (Width-BAR_WIDTH-PAD_WIDTH3)/target_width;
 785   h = SCROLL_BAR_WIDTH;
 786   if((y!=yh)||(x != xh)||(w != wh)||(h != hh)||(exposed & 1))
 787   {
 788     yh = y;
 789     xh = x;
 790     wh = w;
 791     hh = h;
 792     XClearArea(dpy,main_win,PAD_WIDTH3+SCROLL_BAR_WIDTH,y,
 793                Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH,h,False);
 794     RelieveRectangle(dpy, main_win, x, y, w - 1, h - 1,
 795                      hiliteGC, shadowGC, 2);
 796   }
 797   if(exposed& 1)
 798   {
 799     RelieveRectangle(dpy, main_win, PAD_WIDTH2, y - 2,
 800                      Width - BAR_WIDTH - PAD_WIDTH2 + 1, h + 2,
 801                      shadowGC, hiliteGC, 2);
 802   }
 803   if(exposed)
 804   {
 805     if(motion == LEFT)
 806       RedrawLeftButton(shadowGC,hiliteGC,PAD_WIDTH3,y);
 807     else
 808       RedrawLeftButton(hiliteGC,shadowGC,PAD_WIDTH3,y);
 809     if(motion ==RIGHT)
 810       RedrawRightButton(shadowGC,hiliteGC,
 811                         Width-BAR_WIDTH-SCROLL_BAR_WIDTH,y);
 812     else
 813       RedrawRightButton(hiliteGC,shadowGC,
 814                         Width-BAR_WIDTH-SCROLL_BAR_WIDTH,y);
 815   }
 816
 817   if(exposed)
 818   {
 819     XClearArea(dpy,main_win,Width-BAR_WIDTH+2,
 820                Height-BAR_WIDTH+2,BAR_WIDTH-3,BAR_WIDTH-3,False);
 821     if(motion == QUIT)
 822       RelieveRectangle(dpy, main_win, Width - SCROLL_BAR_WIDTH - PAD_WIDTH2 - 4,
 823                        Height - SCROLL_BAR_WIDTH - PAD_WIDTH2 - 4,
 824                        SCROLL_BAR_WIDTH + 3, SCROLL_BAR_WIDTH + 3,
 825                        shadowGC, hiliteGC, 2);
 826     else
 827       RelieveRectangle(dpy, main_win, Width - SCROLL_BAR_WIDTH - PAD_WIDTH2 - 4,
 828                        Height - SCROLL_BAR_WIDTH - PAD_WIDTH2 - 4,
 829                        SCROLL_BAR_WIDTH + 3,SCROLL_BAR_WIDTH + 3,
 830                        hiliteGC, shadowGC, 2);
 831   }
 832   exposed = 0;
 833 }
 834
 835
 836 /*
 837  *  Change the window name displayed in the title bar.
 838  */
 839 void change_window_name(char *str)
 840 {
 841   XTextProperty name;
 842
 843   if(str == NULL)
 844     return;
 845
 846   if (XStringListToTextProperty(&str,1,&name) == 0)
 847   {
 848     fprintf(stderr,"%s: cannot allocate window name\n",module->name);
 849     return;
 850   }
 851   XSetWMName(dpy,main_win,&name);
 852   XFree(name.value);
 853 }
 854
 855
 856 /*
 857  *  Change the window name displayed in the icon.
 858  */
 859 void change_icon_name(char *str)
 860 {
 861   XTextProperty name;
 862
 863   if(str == NULL)
 864     return;
 865   if (XStringListToTextProperty(&str,1,&name) == 0)
 866   {
 867     fprintf(stderr,"%s: cannot allocate window name\n",module->name);
 868     return;
 869   }
 870   XSetWMIconName(dpy,main_win,&name);
 871   XFree(name.value);
 872 }
 873
 874
 875 void GrabWindow(Window target)
 876 {
 877   char *temp;
 878   Window Junk,root;
 879   unsigned int tw,th,border_width,depth;
 880   int x,y;
 881   char *prop = NULL;
 882   Atom actual = None;
 883   int actual_format;
 884   unsigned long nitems, bytesafter;
 885
 886   XUnmapWindow(dpy,target);
 887   XSync(dpy,0);
 888   if (!XGetGeometry(dpy,target,&root,&x,&y,
 889                     (unsigned int *)&tw,(unsigned int *)&th,
 890                     (unsigned int *)&border_width,
 891                     (unsigned int *)&depth))
 892   {
 893     fprintf(stderr,"%s: cannot get window geometry\n", module->name);
 894     exit(0);
 895   }
 896   XSync(dpy,0);
 897
 898   XTranslateCoordinates(dpy, target, Root, 0, 0, &x,&y, &Junk);
 899
 900   CreateWindow(x,y,tw,th);
 901   XSetWindowBorderWidth(dpy,target,0);
 902   XReparentWindow(dpy,target, holder_win,0,0);
 903   XMapWindow(dpy,target);
 904   XSelectInput(dpy,target, PropertyChangeMask|StructureNotifyMask);
 905   if(XFetchName(dpy, target, &temp)==0)
 906     temp = NULL;
 907   if (XGetWindowProperty (dpy,
 908                           target, XA_WM_ICON_NAME, 0L,
 909                           (long)MAX_ICON_NAME_LEN, False, XA_STRING,
 910                           &actual,&actual_format, &nitems,
 911                           &bytesafter, (unsigned char **) &prop)
 912       == Success && (prop != NULL))
 913   {
 914     change_icon_name(prop);
 915     XFree(prop);
 916   }
 917   change_window_name(temp);
 918   {
 919     XWMHints *wmhints;
 920
 921     wmhints = XGetWMHints(dpy,target);
 922     if(wmhints != NULL)
 923     {
 924       XSetWMHints(dpy,main_win, wmhints);
 925       XFree(wmhints);
 926     }
 927   }
 928   /* FvwmScroll may not share the same visual as the target window
 929    * and so cannot share its colormap  {
 930    XWindowAttributes xwa;
 931    if(XGetWindowAttributes(dpy,target, &xwa) != 0)
 932    {
 933    XSetWindowColormap(dpy,main_win,xwa.colormap);
 934    }
 935    }
 936   */
 937   XMapWindow(dpy,main_win);
 938   RedrawWindow(target);
 939   XFree(temp);
 940 }
 941
 942
 943
 944
 945
 946 void RedrawLeftButton(GC rgc, GC sgc,int x1,int y1)
 947 {
 948   XSegment seg[4];
 949   int i=0;
 950
 951   seg[i].x1 = x1+1;                     seg[i].y1   = y1+SCROLL_BAR_WIDTH/2;
 952   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+1;
 953
 954   seg[i].x1 = x1;                       seg[i].y1   = y1+SCROLL_BAR_WIDTH/2;
 955   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1;
 956   XDrawSegments(dpy, main_win, rgc, seg, i);
 957
 958   i = 0;
 959   seg[i].x1 = x1+1;                     seg[i].y1   =y1+ SCROLL_BAR_WIDTH/2;
 960   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 =y1+ SCROLL_BAR_WIDTH - 2;
 961
 962   seg[i].x1 = x1;                       seg[i].y1   = y1+SCROLL_BAR_WIDTH/2;
 963   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
 964
 965   seg[i].x1 = x1+SCROLL_BAR_WIDTH - 2;  seg[i].y1   = y1+1;
 966   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
 967
 968   seg[i].x1 = x1+SCROLL_BAR_WIDTH - 1;  seg[i].y1   = y1;
 969   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
 970   XDrawSegments(dpy,main_win, sgc, seg, i);
 971 }
 972
 973 void RedrawRightButton(GC rgc, GC sgc,int x1,int y1)
 974 {
 975   XSegment seg[4];
 976   int i=0;
 977
 978   seg[i].x1 = x1+1;             seg[i].y1   = y1+1;
 979   seg[i].x2 = x1+1;             seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
 980
 981   seg[i].x1 = x1;               seg[i].y1 = y1;
 982   seg[i].x2 = x1;               seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
 983
 984   seg[i].x1 = x1+1;             seg[i].y1 = y1+1;
 985   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH/2;
 986
 987   seg[i].x1 = x1;               seg[i].y1 = y1;
 988   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH/2;
 989
 990   XDrawSegments(dpy, main_win, rgc, seg, i);
 991
 992   i = 0;
 993   seg[i].x1 = x1;               seg[i].y1 = y1+SCROLL_BAR_WIDTH - 2;
 994   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH/2;
 995
 996   seg[i].x1 = x1;                       seg[i].y1 = y1+SCROLL_BAR_WIDTH - 1;
 997   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH/2;
 998   XDrawSegments(dpy,main_win, sgc, seg, i);
 999 }
1000
1001 void RedrawTopButton(GC rgc, GC sgc,int x1,int y1)
1002 {
1003   XSegment seg[4];
1004   int i=0;
1005
1006   seg[i].x1 = x1+SCROLL_BAR_WIDTH/2;    seg[i].y1 = y1+1;
1007   seg[i].x2 = x1+1;             seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
1008
1009   seg[i].x1 = x1+SCROLL_BAR_WIDTH/2;    seg[i].y1 = y1;
1010   seg[i].x2 = x1+0;             seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
1011   XDrawSegments(dpy, main_win, rgc, seg, i);
1012
1013   i = 0;
1014   seg[i].x1 = x1+SCROLL_BAR_WIDTH/2;    seg[i].y1 = y1+1;
1015   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
1016
1017   seg[i].x1 = x1+SCROLL_BAR_WIDTH/2;    seg[i].y1 = y1;
1018   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
1019
1020   seg[i].x1 = x1+1;             seg[i].y1 = y1+SCROLL_BAR_WIDTH - 2;
1021   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
1022
1023   seg[i].x1 = x1+0;             seg[i].y1 = y1+SCROLL_BAR_WIDTH - 1;
1024   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
1025   XDrawSegments(dpy,main_win, sgc, seg, i);
1026 }
1027
1028 void RedrawBottomButton(GC rgc, GC sgc,int x1, int y1)
1029 {
1030   XSegment seg[4];
1031   int i=0;
1032
1033   seg[i].x1 = x1+1;             seg[i].y1 = y1+1;
1034   seg[i].x2 = x1+SCROLL_BAR_WIDTH/2;    seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
1035
1036   seg[i].x1 = x1;               seg[i].y1 = y1+0;
1037   seg[i].x2 = x1+SCROLL_BAR_WIDTH/2;    seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
1038
1039   seg[i].x1 = x1+1;             seg[i].y1 = y1+1;
1040   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 2;  seg[i++].y2 = y1+1;
1041
1042   seg[i].x1 = x1;               seg[i].y1 = y1+0;
1043   seg[i].x2 = x1+SCROLL_BAR_WIDTH - 1;  seg[i++].y2 = y1+0;
1044   XDrawSegments(dpy,main_win, rgc, seg, i);
1045
1046   i = 0;
1047   seg[i].x1 = x1+SCROLL_BAR_WIDTH - 2;  seg[i].y1 = y1+1;
1048   seg[i].x2 = x1+SCROLL_BAR_WIDTH/2;    seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 2;
1049
1050   seg[i].x1 = x1+SCROLL_BAR_WIDTH - 1;  seg[i].y1 = y1+0;
1051   seg[i].x2 = x1+SCROLL_BAR_WIDTH/2;    seg[i++].y2 = y1+SCROLL_BAR_WIDTH - 1;
1052   XDrawSegments(dpy, main_win, sgc, seg, i);
1053 }