WINGs/wruler.c

   1 /*
   2  *  WINGs WMRuler: nifty ruler widget for WINGs :-)
   3  *
   4  *  Copyright (c) 1999-2000 Nwanua Elumeze
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  19  *  MA 02110-1301, USA.
  20  */
  21
  22 #include "WINGsP.h"
  23 #include "wconfig.h"
  24
  25 #define MIN_DOC_WIDTH 10
  26
  27 typedef struct W_Ruler {
  28         W_Class widgetClass;
  29         W_View *view;
  30         W_View *pview;          /* the parent's view (for drawing the line) */
  31
  32         WMAction *moveAction;   /* what to when while moving */
  33         WMAction *releaseAction;        /* what to do when released */
  34         void *clientData;
  35
  36         WMColor *fg;
  37         GC fgGC, bgGC;
  38         WMFont *font;
  39         WMRulerMargins margins;
  40         int offset;
  41         int motion;             /* the position of the _moving_ marker(s) */
  42         int end;                /* the last tick on the baseline (restrict markers to it) */
  43
  44         Pixmap drawBuffer;
  45
  46         struct {
  47                 unsigned int whichMarker:3;
  48                 /*    0,    1,     2,     3,    4,       5,            6 */
  49                 /* none, left, right, first, body, tabstop, first & body */
  50
  51                 unsigned int buttonPressed:1;
  52                 unsigned int redraw:1;
  53                 unsigned int RESERVED:27;
  54         } flags;
  55 } Ruler;
  56
  57 /* Marker for left margin
  58
  59    |\
  60    | \
  61    |__\
  62    |
  63    |
  64
  65  */
  66 static void drawLeftMarker(Ruler * rPtr)
  67 {
  68         XPoint points[4];
  69         int xpos = (rPtr->flags.whichMarker == 1 ? rPtr->motion : rPtr->margins.left);
  70
  71         XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC, xpos, 8, xpos, 22);
  72         points[0].x = xpos;
  73         points[0].y = 1;
  74         points[1].x = points[0].x + 6;
  75         points[1].y = 8;
  76         points[2].x = points[0].x + 6;
  77         points[2].y = 9;
  78         points[3].x = points[0].x;
  79         points[3].y = 9;
  80         XFillPolygon(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC,
  81                      points, 4, Convex, CoordModeOrigin);
  82 }
  83
  84 /* Marker for right margin
  85
  86   /|
  87  / |
  88 /__|
  89    |
  90    |
  91
  92  */
  93 static void drawRightMarker(Ruler * rPtr)
  94 {
  95         XPoint points[4];
  96         int xpos = (rPtr->flags.whichMarker == 2 ? rPtr->motion : rPtr->margins.right);
  97
  98         XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC, xpos, 8, xpos, 22);
  99         points[0].x = xpos + 1;
 100         points[0].y = 0;
 101         points[1].x = points[0].x - 6;
 102         points[1].y = 7;
 103         points[2].x = points[0].x - 6;
 104         points[2].y = 9;
 105         points[3].x = points[0].x;
 106         points[3].y = 9;
 107         XFillPolygon(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC,
 108                      points, 4, Convex, CoordModeOrigin);
 109 }
 110
 111 /* Marker for first line only
 112    _____
 113    |___|
 114    |
 115
 116  */
 117 static void drawFirstMarker(Ruler * rPtr)
 118 {
 119         int xpos = ((rPtr->flags.whichMarker == 3 || rPtr->flags.whichMarker == 6) ?
 120                     rPtr->motion : rPtr->margins.first);
 121
 122         XFillRectangle(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC, xpos - 5, 10, 11, 5);
 123         XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC, xpos, 12, xpos, 22);
 124 }
 125
 126 /* Marker for rest of body
 127    _____
 128    \   /
 129     \./
 130  */
 131 static void drawBodyMarker(Ruler * rPtr)
 132 {
 133         XPoint points[4];
 134         int xpos = ((rPtr->flags.whichMarker == 4 || rPtr->flags.whichMarker == 6) ?
 135                     rPtr->motion : rPtr->margins.body);
 136
 137         points[0].x = xpos - 5;
 138         points[0].y = 16;
 139         points[1].x = points[0].x + 11;
 140         points[1].y = 16;
 141         points[2].x = points[0].x + 5;
 142         points[2].y = 22;
 143         XFillPolygon(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC,
 144                      points, 3, Convex, CoordModeOrigin);
 145 }
 146
 147 static void createDrawBuffer(Ruler * rPtr)
 148 {
 149         if (!rPtr->view->flags.realized)
 150                 return;
 151
 152         if (rPtr->drawBuffer)
 153                 XFreePixmap(rPtr->view->screen->display, rPtr->drawBuffer);
 154
 155         rPtr->drawBuffer = XCreatePixmap(rPtr->view->screen->display,
 156                                          rPtr->view->window, rPtr->view->size.width, 40,
 157                                          rPtr->view->screen->depth);
 158         XFillRectangle(rPtr->view->screen->display, rPtr->drawBuffer,
 159                        rPtr->bgGC, 0, 0, rPtr->view->size.width, 40);
 160 }
 161
 162 static void drawRulerOnPixmap(Ruler * rPtr)
 163 {
 164         int i, j, w, m;
 165         char c[3];
 166         int marks[9] = { 11, 3, 5, 3, 7, 3, 5, 3 };
 167
 168         if (!rPtr->drawBuffer || !rPtr->view->flags.realized)
 169                 return;
 170
 171         XFillRectangle(rPtr->view->screen->display, rPtr->drawBuffer,
 172                        rPtr->bgGC, 0, 0, rPtr->view->size.width, 40);
 173
 174         WMDrawString(rPtr->view->screen, rPtr->drawBuffer, rPtr->fg,
 175                      rPtr->font, rPtr->margins.left + 2, 26, _("0   inches"), 10);
 176
 177         /* marker ticks */
 178         i = j = m = 0;
 179         w = rPtr->view->size.width - rPtr->margins.left;
 180         while (m < w) {
 181                 XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer,
 182                           rPtr->fgGC, rPtr->margins.left + m, 23, rPtr->margins.left + m, marks[i % 8] + 23);
 183                 if (i != 0 && i % 8 == 0) {
 184                         if (j < 10)
 185                                 snprintf(c, 3, "%d", ++j);
 186                         else
 187                                 snprintf(c, 3, "%2d", ++j);
 188                         WMDrawString(rPtr->view->screen, rPtr->drawBuffer, rPtr->fg,
 189                                      rPtr->font, rPtr->margins.left + 2 + m, 26, c, 2);
 190                 }
 191                 m = (++i) * 10;
 192         }
 193
 194         rPtr->end = rPtr->margins.left + m - 10;
 195         if (rPtr->margins.right > rPtr->end)
 196                 rPtr->margins.right = rPtr->end;
 197         /* base line */
 198         XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer, rPtr->fgGC,
 199                   rPtr->margins.left, 22, rPtr->margins.left + m - 10, 22);
 200
 201         drawLeftMarker(rPtr);
 202         drawRightMarker(rPtr);
 203         drawFirstMarker(rPtr);
 204         drawBodyMarker(rPtr);
 205
 206         rPtr->flags.redraw = False;
 207 }
 208
 209 static void paintRuler(Ruler * rPtr)
 210 {
 211         if (!rPtr->drawBuffer || !rPtr->view->flags.realized)
 212                 return;
 213
 214         if (rPtr->flags.redraw)
 215                 drawRulerOnPixmap(rPtr);
 216         XCopyArea(rPtr->view->screen->display, rPtr->drawBuffer,
 217                   rPtr->view->window, rPtr->bgGC, 0, 0, rPtr->view->size.width, 40, 0, 0);
 218 }
 219
 220 static Bool verifyMarkerMove(Ruler * rPtr, int x)
 221 {
 222         if (rPtr->flags.whichMarker < 1 || rPtr->flags.whichMarker > 6)
 223                 return False;
 224
 225         switch (rPtr->flags.whichMarker) {
 226         case 1:
 227                 if (x > rPtr->margins.right - 10 || x < rPtr->offset ||
 228                     rPtr->margins.body + x > rPtr->margins.right - MIN_DOC_WIDTH ||
 229                     rPtr->margins.first + x > rPtr->margins.right - MIN_DOC_WIDTH)
 230                         return False;
 231                 break;
 232
 233         case 2:
 234                 if (x < rPtr->margins.first + MIN_DOC_WIDTH || x < rPtr->margins.body + MIN_DOC_WIDTH || x < rPtr->margins.left + MIN_DOC_WIDTH || x > rPtr->end)       /*rPtr->view->size.width) */
 235                         return False;
 236                 break;
 237
 238         case 3:
 239                 if (x >= rPtr->margins.right - MIN_DOC_WIDTH || x < rPtr->margins.left)
 240                         return False;
 241                 break;
 242
 243         case 4:
 244                 if (x >= rPtr->margins.right - MIN_DOC_WIDTH || x < rPtr->margins.left)
 245                         return False;
 246                 break;
 247
 248         case 6:
 249                 if (x >= rPtr->margins.right - MIN_DOC_WIDTH || x < rPtr->margins.left)
 250                         return False;
 251                 break;
 252
 253         default:
 254                 return False;
 255         }
 256
 257         rPtr->motion = x;
 258         return True;
 259 }
 260
 261 static int whichMarker(Ruler * rPtr, int x, int y)
 262 {
 263         if (x < rPtr->offset || y > 22)
 264                 return 0;
 265
 266         if (rPtr->margins.left - x >= -6 && y <= 9 && (rPtr->margins.left - x <= 0) && y >= 4) {
 267                 rPtr->motion = rPtr->margins.left;
 268                 return 1;
 269         }
 270         if (rPtr->margins.right - x >= -1 && y <= 11 && rPtr->margins.right - x <= 5 && y >= 4) {
 271                 rPtr->motion = rPtr->margins.right;
 272                 return 2;
 273         }
 274 #if 0
 275         /* both first and body? */
 276         if (rPtr->margins.first - x <= 4 && rPtr->margins.first - x >= -5
 277             && rPtr->margins.body - x <= 4 && rPtr->margins.body - x >= -5 && y >= 15 && y <= 17) {
 278                 rPtr->motion = rPtr->margins.first;
 279                 return 6;
 280         }
 281 #endif
 282
 283         if (rPtr->margins.first - x <= 4 && y <= 15 && rPtr->margins.first - x >= -5 && y >= 10) {
 284                 rPtr->motion = rPtr->margins.first;
 285                 return 3;
 286         }
 287         if (rPtr->margins.body - x <= 4 && y <= 21 && rPtr->margins.body - x >= -5 && y >= 17) {
 288                 rPtr->motion = rPtr->margins.body;
 289                 return 4;
 290         }
 291         /* do tabs (5) */
 292
 293         return 0;
 294 }
 295
 296 static void rulerDidResize(W_ViewDelegate * self, WMView * view)
 297 {
 298         Ruler *rPtr = (Ruler *) view->self;
 299
 300         /* Parameter not used, but tell the compiler that it is ok */
 301         (void) self;
 302
 303         createDrawBuffer(rPtr);
 304         rPtr->flags.redraw = True;
 305         paintRuler(rPtr);
 306
 307 }
 308
 309 static void handleEvents(XEvent * event, void *data)
 310 {
 311         Ruler *rPtr = (Ruler *) data;
 312
 313         switch (event->type) {
 314         case Expose:
 315                 rulerDidResize(rPtr->view->delegate, rPtr->view);
 316                 break;
 317
 318         case MotionNotify:
 319                 if (rPtr->flags.buttonPressed && (event->xmotion.state & Button1Mask)) {
 320                         if (verifyMarkerMove(rPtr, event->xmotion.x)) {
 321                                 GC gc = WMColorGC(WMDarkGrayColor(rPtr->view->screen));
 322
 323                                 if (rPtr->moveAction)
 324                                         (rPtr->moveAction) (rPtr, rPtr->clientData);
 325                                 rPtr->flags.redraw = True;
 326                                 paintRuler(rPtr);
 327                                 XSetLineAttributes(rPtr->view->screen->display, gc, 1,
 328                                                    LineSolid, CapNotLast, JoinMiter);
 329                                 XDrawLine(rPtr->pview->screen->display,
 330                                           rPtr->pview->window,
 331                                           gc, rPtr->motion + 1, 40,
 332                                           rPtr->motion + 1, rPtr->pview->size.height - 5);
 333                         }
 334                 }
 335                 break;
 336
 337         case ButtonPress:
 338                 if (event->xbutton.button != Button1)
 339                         return;
 340                 rPtr->flags.buttonPressed = True;
 341                 rPtr->flags.whichMarker = whichMarker(rPtr, event->xmotion.x, event->xmotion.y);
 342                 break;
 343
 344         case ButtonRelease:
 345                 if (event->xbutton.button != Button1)
 346                         return;
 347                 rPtr->flags.buttonPressed = False;
 348                 switch (rPtr->flags.whichMarker) {
 349                 case 1:{
 350                                 int change = rPtr->margins.left - rPtr->motion;
 351
 352                                 rPtr->margins.first -= change;
 353                                 rPtr->margins.body -= change;
 354                                 rPtr->margins.left = rPtr->motion;
 355                                 rPtr->flags.redraw = True;
 356                                 paintRuler(rPtr);
 357                                 break;
 358                         }
 359                 case 2:
 360                         rPtr->margins.right = rPtr->motion;
 361                         break;
 362                 case 3:
 363                         rPtr->margins.first = rPtr->motion;
 364                         break;
 365                 case 4:
 366                         rPtr->margins.body = rPtr->motion;
 367                         break;
 368                 case 6:
 369                         rPtr->margins.first = rPtr->margins.body = rPtr->motion;
 370                         break;
 371                 }
 372                 if (rPtr->releaseAction)
 373                         (rPtr->releaseAction) (rPtr, rPtr->clientData);
 374                 break;
 375         }
 376 }
 377
 378 W_ViewDelegate _RulerViewDelegate = {
 379         NULL,
 380         NULL,
 381         rulerDidResize,
 382         NULL,
 383         NULL
 384 };
 385
 386 WMRuler *WMCreateRuler(WMWidget * parent)
 387 {
 388         Ruler *rPtr = wmalloc(sizeof(Ruler));
 389         unsigned int w = WMWidgetWidth(parent);
 390
 391         rPtr->widgetClass = WC_Ruler;
 392
 393         rPtr->view = W_CreateView(W_VIEW(parent));
 394
 395         if (!rPtr->view) {
 396                 wfree(rPtr);
 397                 return NULL;
 398         }
 399
 400         rPtr->view->self = rPtr;
 401
 402         rPtr->drawBuffer = (Pixmap) NULL;
 403
 404         W_ResizeView(rPtr->view, w, 40);
 405
 406         WMCreateEventHandler(rPtr->view, ExposureMask | StructureNotifyMask
 407                              | EnterWindowMask | LeaveWindowMask | FocusChangeMask
 408                              | ButtonReleaseMask | ButtonPressMask | KeyReleaseMask
 409                              | KeyPressMask | Button1MotionMask, handleEvents, rPtr);
 410
 411         rPtr->view->delegate = &_RulerViewDelegate;
 412
 413         rPtr->fg = WMBlackColor(rPtr->view->screen);
 414         rPtr->fgGC = WMColorGC(rPtr->fg);
 415         rPtr->bgGC = WMColorGC(WMGrayColor(rPtr->view->screen));
 416         rPtr->font = WMSystemFontOfSize(rPtr->view->screen, 8);
 417
 418         rPtr->offset = 22;
 419         rPtr->margins.left = 22;
 420         rPtr->margins.body = 22;
 421         rPtr->margins.first = 42;
 422         rPtr->margins.right = (w < 502 ? w : 502);
 423         rPtr->margins.tabs = NULL;
 424
 425         rPtr->flags.whichMarker = 0;    /* none */
 426         rPtr->flags.buttonPressed = False;
 427         rPtr->flags.redraw = True;
 428
 429         rPtr->moveAction = NULL;
 430         rPtr->releaseAction = NULL;
 431
 432         rPtr->pview = W_VIEW(parent);
 433
 434         return rPtr;
 435 }
 436
 437 void WMSetRulerMargins(WMRuler * rPtr, WMRulerMargins margins)
 438 {
 439         if (!rPtr)
 440                 return;
 441         rPtr->margins.left = margins.left + rPtr->offset;
 442         rPtr->margins.right = margins.right + rPtr->offset;
 443         rPtr->margins.first = margins.first + rPtr->offset;
 444         rPtr->margins.body = margins.body + rPtr->offset;
 445         rPtr->margins.tabs = margins.tabs;      /*for loop */
 446         rPtr->flags.redraw = True;
 447         paintRuler(rPtr);
 448
 449 }
 450
 451 WMRulerMargins *WMGetRulerMargins(WMRuler * rPtr)
 452 {
 453         WMRulerMargins *margins = wmalloc(sizeof(WMRulerMargins));
 454
 455         if (!rPtr) {
 456                 margins->first = margins->body = margins->left = 0;
 457                 margins->right = 100;
 458                 return margins;
 459         }
 460
 461         margins->left = rPtr->margins.left - rPtr->offset;
 462         margins->right = rPtr->margins.right - rPtr->offset;
 463         margins->first = rPtr->margins.first - rPtr->offset;
 464         margins->body = rPtr->margins.body - rPtr->offset;
 465         /*for */
 466         margins->tabs = rPtr->margins.tabs;
 467
 468         return margins;
 469 }
 470
 471 Bool WMIsMarginEqualToMargin(WMRulerMargins * aMargin, WMRulerMargins * anotherMargin)
 472 {
 473         if (aMargin == anotherMargin)
 474                 return True;
 475         else if (!aMargin || !anotherMargin)
 476                 return False;
 477         if (aMargin->left != anotherMargin->left)
 478                 return False;
 479         if (aMargin->first != anotherMargin->first)
 480                 return False;
 481         if (aMargin->body != anotherMargin->body)
 482                 return False;
 483         if (aMargin->right != anotherMargin->right)
 484                 return False;
 485
 486         return True;
 487 }
 488
 489 void WMSetRulerOffset(WMRuler * rPtr, int pixels)
 490 {
 491         if (!rPtr || pixels < 0 || pixels + MIN_DOC_WIDTH >= rPtr->view->size.width)
 492                 return;
 493         rPtr->offset = pixels;
 494         /*rulerDidResize(rPtr, rPtr->view); */
 495 }
 496
 497 int WMGetRulerOffset(WMRuler * rPtr)
 498 {
 499         if (!rPtr)
 500                 return 0;       /* what value should return if no ruler? -1 or 0? */
 501         return rPtr->offset;
 502 }
 503
 504 void WMSetRulerReleaseAction(WMRuler * rPtr, WMAction * action, void *clientData)
 505 {
 506         if (!rPtr)
 507                 return;
 508
 509         rPtr->releaseAction = action;
 510         rPtr->clientData = clientData;
 511 }
 512
 513 void WMSetRulerMoveAction(WMRuler * rPtr, WMAction * action, void *clientData)
 514 {
 515         if (!rPtr)
 516                 return;
 517
 518         rPtr->moveAction = action;
 519         rPtr->clientData = clientData;
 520 }
 521
 522 /* _which_ one was released */
 523 int WMGetReleasedRulerMargin(WMRuler * rPtr)
 524 {
 525         if (!rPtr)
 526                 return 0;
 527         return rPtr->flags.whichMarker;
 528 }
 529
 530 /* _which_ one is being grabbed */
 531 int WMGetGrabbedRulerMargin(WMRuler * rPtr)
 532 {
 533         if (!rPtr)
 534                 return 0;
 535         return rPtr->flags.whichMarker;
 536 }