WINGs/wsplitview.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7
   8
   9
  10 typedef struct W_SplitView {
  11     W_Class widgetClass;
  12     W_View *view;
  13
  14 /*    WMSplitViewResizeSubviewsProc *resizeSubviewsProc;
  15  */
  16     WMSplitViewConstrainProc *constrainProc;
  17
  18     struct {
  19         unsigned int splitViewIsFull:1;        /* already added 2 subviews */
  20     } flags;
  21 } SplitView;
  22
  23
  24 #define DIVIDER_THICKNESS       8
  25
  26
  27
  28 static void destroySplitView(SplitView *sPtr);
  29 static void paintSplitView(SplitView *sPtr);
  30
  31
  32 static void handleEvents(XEvent *event, void *data);
  33 static void handleActionEvents(XEvent *event, void *data);
  34
  35
  36 W_ViewProcedureTable _SplitViewViewProcedures = {
  37     NULL,
  38         NULL,
  39         NULL
  40 };
  41
  42
  43
  44 static int
  45 subviewCount(SplitView *sPtr)
  46 {
  47     int count = 0;
  48     WMView *view;
  49
  50     for (view=sPtr->view->childrenList; view != NULL; view=view->nextSister)
  51         count++;
  52
  53     return count;
  54 }
  55
  56
  57 static void
  58 handleViewResized(void *self, WMNotification *notification)
  59 {
  60     SplitView *sPtr = (SplitView*)self;
  61     int oldHeight;
  62     WMView *view = sPtr->view;
  63     int newWidth = view->size.width;
  64     WMView *upper, *lower;
  65
  66     if (!view->childrenList)
  67         return;
  68
  69     if (view->childrenList->nextSister==NULL) {
  70         if (view->self)
  71             WMResizeWidget(view->childrenList->self, newWidth, view->size.height);
  72         else
  73             W_ResizeView(view->childrenList, newWidth, view->size.height);
  74     } else {
  75         upper = view->childrenList;
  76         lower = upper->nextSister;
  77         oldHeight = upper->size.height+DIVIDER_THICKNESS+lower->size.height;
  78
  79         if (oldHeight > view->size.height
  80             && upper->size.height+DIVIDER_THICKNESS >= view->size.height) {
  81             WMAdjustSplitViewSubviews(sPtr);
  82         } else {
  83             if (upper->self) {
  84                 WMResizeWidget(upper->self, newWidth, upper->size.height);
  85             } else {
  86                 W_ResizeView(upper, newWidth, upper->size.height);
  87             }
  88             if (lower->self) {
  89                 WMResizeWidget(lower->self, newWidth,
  90                                view->size.height-lower->pos.y);
  91             } else {
  92                 W_ResizeView(lower, newWidth, view->size.height-lower->pos.y);
  93             }
  94         }
  95     }
  96 }
  97
  98
  99
 100 WMSplitView*
 101 WMCreateSplitView(WMWidget *parent)
 102 {
 103     SplitView *sPtr;
 104
 105     sPtr = wmalloc(sizeof(SplitView));
 106     memset(sPtr, 0, sizeof(SplitView));
 107
 108     sPtr->widgetClass = WC_SplitView;
 109
 110     sPtr->view = W_CreateView(W_VIEW(parent));
 111     if (!sPtr->view) {
 112         free(sPtr);
 113         return NULL;
 114     }
 115     sPtr->view->self = sPtr;
 116
 117     WMSetViewNotifySizeChanges(sPtr->view, True);
 118
 119     WMCreateEventHandler(sPtr->view, ExposureMask|StructureNotifyMask
 120                          |ClientMessageMask, handleEvents, sPtr);
 121
 122
 123     WMCreateEventHandler(sPtr->view, ButtonPressMask|ButtonReleaseMask
 124                          |EnterWindowMask|LeaveWindowMask,
 125                          handleActionEvents, sPtr);
 126
 127
 128     WMAddNotificationObserver(handleViewResized, sPtr,
 129                               WMViewSizeDidChangeNotification, sPtr->view);
 130
 131     return sPtr;
 132 }
 133
 134
 135 void
 136 WMAddSplitViewSubview(WMSplitView *sPtr, WMView *subview)
 137 {
 138     int wasMapped;
 139
 140     assert(!sPtr->flags.splitViewIsFull);
 141
 142     wasMapped = subview->flags.mapped;
 143     if (wasMapped) {
 144         W_UnmapView(subview);
 145     }
 146
 147     W_ReparentView(subview, sPtr->view);
 148
 149 #if 0
 150     if (sPtr->resizeSubviewsProc && subviewCount(sPtr)>1) {
 151         (*sPtr->resizeSubviewsProc)(sPtr, sPtr->view->size.width,
 152                                     sPtr->view->size.height);
 153         /* check if there is free space for the new subview and
 154          * put the subview in it */
 155     } else {
 156     }
 157 #endif
 158     WMAdjustSplitViewSubviews(sPtr);
 159
 160     if (subviewCount(sPtr)==2)
 161         sPtr->flags.splitViewIsFull = 1;
 162
 163     if (wasMapped) {
 164         W_MapView(subview);
 165     }
 166 }
 167
 168
 169 void
 170 WMSetSplitViewConstrainProc(WMSplitView *sPtr, WMSplitViewConstrainProc *proc)
 171 {
 172     sPtr->constrainProc = proc;
 173 }
 174
 175
 176 void
 177 WMAdjustSplitViewSubviews(WMSplitView *sPtr)
 178 {
 179     int theight = sPtr->view->size.height;
 180     int width = sPtr->view->size.width;
 181     int height;
 182     int y, count;
 183     W_View *view;
 184
 185     count = subviewCount(sPtr);
 186
 187     height = (theight - (count-1)*DIVIDER_THICKNESS)/count;
 188
 189
 190     view = sPtr->view->childrenList;
 191     if (view->self) {
 192         WMMoveWidget(view->self, 0, 0);
 193         WMResizeWidget(view->self, width, height);
 194     } else {
 195         W_MoveView(view, 0, 0);
 196         W_ResizeView(view, width, height);
 197     }
 198
 199     y = height + DIVIDER_THICKNESS;
 200
 201     for (view = view->nextSister; view != NULL; view = view->nextSister) {
 202         if (view->self) {
 203             WMMoveWidget(view->self, 0, y);
 204             WMResizeWidget(view->self, width, height);
 205         } else {
 206             W_MoveView(view, 0, y);
 207             W_ResizeView(view, width, height);
 208         }
 209         y += height + DIVIDER_THICKNESS;
 210     }
 211 }
 212
 213 #if 0
 214 void
 215 WMSetSplitViewResizeSubviewsProc(WMSplitView *sPtr,
 216                                  WMSplitViewResizeSubviewsProc *proc)
 217 {
 218     sPtr->resizeSubviewsProc = proc;
 219 }
 220 #endif
 221
 222
 223 int
 224 WMGetSplitViewDividerThickness(WMSplitView *sPtr)
 225 {
 226     return DIVIDER_THICKNESS;
 227 }
 228
 229
 230 static void
 231 paintSplitView(SplitView *sPtr)
 232 {
 233     W_Screen *scr = sPtr->view->screen;
 234     int y, x;
 235     W_View *ptr;
 236     WMPixmap *dimple = scr->scrollerDimple;
 237
 238     XClearWindow(scr->display, sPtr->view->window);
 239
 240     x = (sPtr->view->size.width - dimple->width)/2;
 241
 242     ptr = sPtr->view->childrenList;
 243
 244     y = ptr->size.height;
 245     XSetClipMask(scr->display, scr->clipGC, dimple->mask);
 246     while (ptr->nextSister) {
 247         y += (DIVIDER_THICKNESS - dimple->width)/2;
 248
 249         XSetClipOrigin(scr->display, scr->clipGC, x, y);
 250         XCopyArea(scr->display, dimple->pixmap, sPtr->view->window,
 251                   scr->clipGC, 0, 0, dimple->width, dimple->height, x, y);
 252
 253         y += ptr->size.height;
 254
 255         ptr = ptr->nextSister;
 256     }
 257 }
 258
 259
 260
 261 static void
 262 handleEvents(XEvent *event, void *data)
 263 {
 264     SplitView *sPtr = (SplitView*)data;
 265
 266     CHECK_CLASS(data, WC_SplitView);
 267
 268
 269     switch (event->type) {
 270      case Expose:
 271         if (event->xexpose.count!=0)
 272             break;
 273         paintSplitView(sPtr);
 274         break;
 275
 276      case DestroyNotify:
 277         destroySplitView(sPtr);
 278         break;
 279     }
 280 }
 281
 282
 283 static void
 284 dragDivider(SplitView *sPtr, int clickY)
 285 {
 286     int divider;
 287     WMView *view, *view1=NULL, *view2=NULL;
 288     int y;
 289     int ofsY;
 290     int done;
 291     int dragging;
 292     int minCoord;
 293     int maxCoord;
 294     XEvent ev;
 295     WMScreen *scr = sPtr->view->screen;
 296
 297     view = sPtr->view->childrenList;
 298     divider = 0;
 299     ofsY = 0;
 300     y = 0;
 301     done = 0;
 302     while (view) {
 303         y += view->size.height+DIVIDER_THICKNESS;
 304         if (clickY < y) {
 305             /* offset from point where use clicked and the top of the
 306              * divider */
 307             ofsY = clickY - y + DIVIDER_THICKNESS;
 308             view1 = view;
 309             view2 = view->nextSister;
 310             /* can't be NULL. It would mean the divider is at the bottom */
 311             assert(view2!=NULL);
 312             done = 1;
 313             break;
 314         }
 315         view = view->nextSister;
 316         divider++;
 317     }
 318     assert(done);
 319
 320     minCoord = view1->pos.y;
 321     maxCoord = view2->pos.y+view2->size.height-DIVIDER_THICKNESS;
 322
 323     if (sPtr->constrainProc)
 324         (*sPtr->constrainProc)(sPtr, divider, &minCoord, &maxCoord);
 325
 326     done = 0;
 327     dragging = 0;
 328     while (!done) {
 329         WMMaskEvent(scr->display, ButtonMotionMask|ButtonReleaseMask
 330                     |ExposureMask, &ev);
 331
 332         switch (ev.type) {
 333          case ButtonRelease:
 334             done = 1;
 335             if (dragging) {
 336                 XFillRectangle(scr->display, sPtr->view->window, scr->ixorGC,
 337                                0, y, sPtr->view->size.width,DIVIDER_THICKNESS);
 338             }
 339             break;
 340
 341          case MotionNotify:
 342             if (dragging) {
 343                 XFillRectangle(scr->display, sPtr->view->window, scr->ixorGC,
 344                                0, y, sPtr->view->size.width,DIVIDER_THICKNESS);
 345             }
 346             if (ev.xmotion.y-ofsY < minCoord)
 347                 y = minCoord;
 348             else if (ev.xmotion.y-ofsY > maxCoord)
 349                 y = maxCoord;
 350             else
 351                 y = ev.xmotion.y-ofsY;
 352             XFillRectangle(scr->display, sPtr->view->window, scr->ixorGC,
 353                            0, y, sPtr->view->size.width, DIVIDER_THICKNESS);
 354             dragging = 1;
 355             break;
 356
 357          default:
 358             WMHandleEvent(&ev);
 359             break;
 360         }
 361     }
 362
 363     if (dragging) {
 364         int theight;
 365
 366         theight = view1->size.height + view2->size.height + DIVIDER_THICKNESS;
 367
 368         WMResizeWidget(view1->self, sPtr->view->size.width, y - view1->pos.y);
 369
 370         WMResizeWidget(view2->self, sPtr->view->size.width,
 371                        theight - view1->size.height - DIVIDER_THICKNESS);
 372         WMMoveWidget(view2->self, 0,
 373                      view1->pos.y+view1->size.height+DIVIDER_THICKNESS);
 374     }
 375 }
 376
 377
 378 static void
 379 handleActionEvents(XEvent *event, void *data)
 380 {
 381
 382     CHECK_CLASS(data, WC_SplitView);
 383
 384
 385     switch (event->type) {
 386      case ButtonPress:
 387         if (event->xbutton.button == Button1)
 388             dragDivider(data, event->xbutton.y);
 389         break;
 390     }
 391 }
 392
 393
 394
 395 static void
 396 destroySplitView(SplitView *sPtr)
 397 {
 398     WMRemoveNotificationObserver(sPtr);
 399
 400     free(sPtr);
 401 }
 402