WINGs/Extras/wtableview.c

   1
   2
   3 #include <WINGs/WINGsP.h>
   4 #include <X11/cursorfont.h>
   5 #include <stdint.h>
   6
   7 #include "wtableview.h"
   8
   9
  10 const char *WMTableViewSelectionDidChangeNotification = "WMTableViewSelectionDidChangeNotification";
  11
  12
  13 struct W_TableColumn {
  14     WMTableView *table;
  15     WMWidget *titleW;
  16     char *title;
  17     int width;
  18     int minWidth;
  19     int maxWidth;
  20
  21     void *id;
  22
  23     WMTableColumnDelegate *delegate;
  24
  25     unsigned resizable:1;
  26     unsigned editable:1;
  27 };
  28
  29
  30 static void handleResize(W_ViewDelegate *self, WMView *view);
  31
  32 static void rearrangeHeader(WMTableView *table);
  33
  34 static WMRange rowsInRect(WMTableView *table, WMRect rect);
  35
  36
  37 WMTableColumn*
  38 WMCreateTableColumn(char *title)
  39 {
  40     WMTableColumn *col = wmalloc(sizeof(WMTableColumn));
  41
  42     col->table = NULL;
  43     col->titleW = NULL;
  44     col->width = 50;
  45     col->minWidth = 5;
  46     col->maxWidth = 0;
  47
  48     col->id = NULL;
  49
  50     col->title = wstrdup(title);
  51
  52     col->delegate = NULL;
  53
  54     col->resizable = 1;
  55     col->editable = 0;
  56
  57     return col;
  58 }
  59
  60
  61 void
  62 WMSetTableColumnId(WMTableColumn *column, void *id)
  63 {
  64     column->id = id;
  65 }
  66
  67
  68 void*
  69 WMGetTableColumnId(WMTableColumn *column)
  70 {
  71     return column->id;
  72 }
  73
  74
  75 void
  76 WMSetTableColumnWidth(WMTableColumn *column, unsigned width)
  77 {
  78     if (column->maxWidth == 0)
  79         column->width = WMAX(column->minWidth, width);
  80     else
  81         column->width = WMAX(column->minWidth, WMIN(column->maxWidth, width));
  82
  83     if (column->table) {
  84         rearrangeHeader(column->table);
  85     }
  86 }
  87
  88
  89 void
  90 WMSetTableColumnDelegate(WMTableColumn *column, WMTableColumnDelegate *delegate)
  91 {
  92     column->delegate = delegate;
  93 }
  94
  95
  96 void
  97 WMSetTableColumnConstraints(WMTableColumn *column, unsigned minWidth,
  98                             unsigned maxWidth)
  99 {
 100     wassertr(maxWidth == 0 || minWidth <= maxWidth);
 101
 102     column->minWidth = minWidth;
 103     column->maxWidth = maxWidth;
 104
 105     if (column->width < column->minWidth)
 106         WMSetTableColumnWidth(column, column->minWidth);
 107     else if (column->width > column->maxWidth && column->maxWidth != 0)
 108         WMSetTableColumnWidth(column, column->maxWidth);
 109 }
 110
 111
 112 void
 113 WMSetTableColumnEditable(WMTableColumn *column, Bool flag)
 114 {
 115     column->editable = ((flag==0) ? 0 : 1);
 116 }
 117
 118
 119 WMTableView*
 120 WMGetTableColumnTableView(WMTableColumn *column)
 121 {
 122     return column->table;
 123 }
 124
 125
 126
 127 struct W_TableView {
 128     W_Class widgetClass;
 129     WMView *view;
 130
 131     WMFrame *header;
 132
 133     WMLabel *corner;
 134
 135     WMScroller *hscroll;
 136     WMScroller *vscroll;
 137     WMView *tableView;
 138
 139     WMPixmap *viewBuffer;
 140
 141     WMArray *columns;
 142     WMArray *splitters;
 143
 144     WMArray *selectedRows;
 145
 146     int tableWidth;
 147
 148     int rows;
 149
 150     WMColor *backColor;
 151
 152     GC gridGC;
 153     WMColor *gridColor;
 154
 155     Cursor splitterCursor;
 156
 157     void *dataSource;
 158
 159     WMTableViewDelegate *delegate;
 160
 161     WMAction *action;
 162     void *clientData;
 163
 164     void *clickedColumn;
 165     int clickedRow;
 166
 167     int editingRow;
 168
 169     unsigned headerHeight;
 170
 171     unsigned rowHeight;
 172
 173     unsigned dragging:1;
 174     unsigned drawsGrid:1;
 175     unsigned canSelectRow:1;
 176     unsigned canSelectMultiRows:1;
 177     unsigned canDeselectRow:1;
 178
 179     unsigned int hasVScroller:1;
 180     unsigned int hasHScroller:1;
 181 };
 182
 183 static W_Class tableClass = 0;
 184
 185
 186 static W_ViewDelegate viewDelegate = {
 187     NULL,
 188     NULL,
 189     handleResize,
 190     NULL,
 191     NULL
 192 };
 193
 194
 195
 196 static void reorganizeInterior(WMTableView *table);
 197
 198
 199 static void handleEvents(XEvent *event, void *data);
 200 static void handleTableEvents(XEvent *event, void *data);
 201 static void repaintTable(WMTableView *table);
 202
 203 static WMSize
 204 getTotalSize(WMTableView *table)
 205 {
 206     WMSize size;
 207     int i;
 208
 209     /* get width from columns */
 210     size.width = 0;
 211     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 212         WMTableColumn *column;
 213
 214         column = WMGetFromArray(table->columns, i);
 215
 216         size.width += column->width;
 217     }
 218
 219     /* get height from rows */
 220     size.height = table->rows * table->rowHeight;
 221
 222     return size;
 223 }
 224
 225
 226 static WMRect
 227 getVisibleRect(WMTableView *table)
 228 {
 229     WMSize size = getTotalSize(table);
 230     WMRect rect;
 231
 232     if (table->vscroll) {
 233         rect.size.height = size.height * WMGetScrollerKnobProportion(table->vscroll);
 234         rect.pos.y = (size.height - rect.size.height) * WMGetScrollerValue(table->vscroll);
 235     } else {
 236         rect.size.height = size.height;
 237         rect.pos.y = 0;
 238     }
 239
 240     if (table->hscroll) {
 241         rect.size.width = size.width * WMGetScrollerKnobProportion(table->hscroll);
 242         rect.pos.x = (size.width - rect.size.width) * WMGetScrollerValue(table->hscroll);
 243     } else {
 244         rect.size.width = size.width;
 245         rect.pos.x = 0;
 246     }
 247
 248     return rect;
 249 }
 250
 251
 252 static void
 253 scrollToPoint(WMTableView *table, int x, int y)
 254 {
 255     WMSize size = getTotalSize(table);
 256     int i;
 257     float value, prop;
 258
 259     if (table->hscroll) {
 260         if (size.width > W_VIEW_WIDTH(table->tableView)) {
 261             prop = (float)W_VIEW_WIDTH(table->tableView) / (float)size.width;
 262             value = (float)x / (float)(size.width - W_VIEW_WIDTH(table->tableView));
 263         } else {
 264             prop = 1.0;
 265             value = 0.0;
 266         }
 267         WMSetScrollerParameters(table->hscroll, value, prop);
 268     }
 269
 270     if (table->vscroll) {
 271         if (size.height > W_VIEW_HEIGHT(table->tableView)) {
 272             prop = (float)W_VIEW_HEIGHT(table->tableView) / (float)size.height;
 273             value = (float)y / (float)(size.height - W_VIEW_HEIGHT(table->tableView));
 274         } else {
 275             prop = 1.0;
 276             value = 0.0;
 277         }
 278
 279         WMSetScrollerParameters(table->vscroll, value, prop);
 280     }
 281
 282
 283     if (table->editingRow >= 0) {
 284         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 285             WMTableColumn *column;
 286
 287             column = WMGetFromArray(table->columns, i);
 288
 289             if (column->delegate && column->delegate->beginCellEdit)
 290                 (*column->delegate->beginCellEdit)(column->delegate, column,
 291                                                    table->editingRow);
 292         }
 293     }
 294
 295     repaintTable(table);
 296 }
 297
 298
 299 static void
 300 adjustScrollers(WMTableView *table)
 301 {
 302     WMSize size = getTotalSize(table);
 303     WMSize vsize = WMGetViewSize(table->tableView);
 304     float prop, value;
 305     float oprop, ovalue;
 306
 307     if (table->hscroll) {
 308         if (size.width <= vsize.width) {
 309             value = 0.0;
 310             prop = 1.0;
 311         } else {
 312             oprop = WMGetScrollerKnobProportion(table->hscroll);
 313             if (oprop == 0.0)
 314                 oprop = 1.0;
 315             ovalue = WMGetScrollerValue(table->hscroll);
 316
 317             prop = (float)vsize.width/(float)size.width;
 318             value = prop*ovalue / oprop;
 319         }
 320         WMSetScrollerParameters(table->hscroll, value, prop);
 321     }
 322
 323     if (table->vscroll) {
 324         if (size.height <= vsize.height) {
 325             value = 0.0;
 326             prop = 1.0;
 327         } else {
 328             oprop = WMGetScrollerKnobProportion(table->vscroll);
 329             if (oprop == 0.0)
 330                 oprop = 1.0;
 331             ovalue = WMGetScrollerValue(table->vscroll);
 332
 333             prop = (float)vsize.height/(float)size.height;
 334             value = prop*ovalue / oprop;
 335         }
 336         WMSetScrollerParameters(table->vscroll, value, prop);
 337     }
 338 }
 339
 340
 341 static void
 342 doScroll(WMWidget *self, void *data)
 343 {
 344     WMTableView *table = (WMTableView*)data;
 345     float value;
 346     float vpsize;
 347     float size;
 348     WMSize ts = getTotalSize(table);
 349
 350     value = WMGetScrollerValue(self);
 351
 352     if (table->hscroll == (WMScroller *)self) {
 353         vpsize = W_VIEW_WIDTH(table->tableView);
 354         size = ts.width;
 355     } else {
 356         vpsize = W_VIEW_HEIGHT(table->tableView);
 357         size = ts.height;
 358     }
 359
 360     switch (WMGetScrollerHitPart(self)) {
 361     case WSDecrementWheel:
 362     case WSDecrementLine:
 363         value -= (float)table->rowHeight / size;
 364         if (value < 0)
 365             value = 0.0;
 366         WMSetScrollerParameters(self, value,
 367                                 WMGetScrollerKnobProportion(self));
 368         repaintTable(table);
 369         break;
 370
 371     case WSIncrementWheel:
 372     case WSIncrementLine:
 373         value += (float)table->rowHeight / size;
 374         if (value > 1.0)
 375             value = 1.0;
 376         WMSetScrollerParameters(self, value,
 377                                 WMGetScrollerKnobProportion(self));
 378         repaintTable(table);
 379         break;
 380
 381     case WSKnob:
 382         repaintTable(table);
 383         break;
 384
 385     case WSDecrementPage:
 386         value -= vpsize / size;
 387         if (value < 0.0)
 388             value = 0.0;
 389         WMSetScrollerParameters(self, value,
 390                                 WMGetScrollerKnobProportion(self));
 391         repaintTable(table);
 392         break;
 393
 394     case WSIncrementPage:
 395         value += vpsize / size;
 396         if (value > 1.0)
 397             value = 1.0;
 398         WMSetScrollerParameters(self, value,
 399                                 WMGetScrollerKnobProportion(self));
 400         repaintTable(table);
 401         break;
 402
 403
 404     case WSNoPart:
 405     case WSKnobSlot:
 406         break;
 407     }
 408
 409     if (table->editingRow >= 0) {
 410         int i;
 411         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 412             WMTableColumn *column;
 413
 414             column = WMGetFromArray(table->columns, i);
 415
 416             if (column->delegate && column->delegate->beginCellEdit)
 417                 (*column->delegate->beginCellEdit)(column->delegate, column,
 418                                                    table->editingRow);
 419         }
 420     }
 421
 422
 423     if (table->hscroll == self) {
 424         int x = 0;
 425         int i;
 426         WMRect rect = getVisibleRect(table);
 427
 428         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 429             WMTableColumn *column;
 430             WMView *splitter;
 431
 432             column = WMGetFromArray(table->columns, i);
 433
 434             WMMoveWidget(column->titleW, x - rect.pos.x, 0);
 435
 436             x += W_VIEW_WIDTH(WMWidgetView(column->titleW)) + 1;
 437
 438             splitter = WMGetFromArray(table->splitters, i);
 439             W_MoveView(splitter, x - rect.pos.x - 1, 0);
 440         }
 441     }
 442 }
 443
 444
 445 static void
 446 splitterHandler(XEvent *event, void *data)
 447 {
 448     WMTableColumn *column = (WMTableColumn*)data;
 449     WMTableView *table = column->table;
 450     int done = 0;
 451     int cx, ox, offsX;
 452     WMPoint pos;
 453     WMScreen *scr = WMWidgetScreen(table);
 454     GC gc = scr->ixorGC;
 455     Display *dpy = WMScreenDisplay(scr);
 456     int h = WMWidgetHeight(table) - 22;
 457     Window w = WMViewXID(table->view);
 458
 459     pos = WMGetViewPosition(WMWidgetView(column->titleW));
 460
 461     offsX = pos.x + column->width;
 462
 463     ox = cx = offsX;
 464
 465     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 466
 467     while (!done) {
 468         XEvent ev;
 469
 470         WMMaskEvent(dpy, ButtonMotionMask|ButtonReleaseMask, &ev);
 471
 472         switch (ev.type) {
 473         case MotionNotify:
 474             ox = cx;
 475
 476             if (column->width + ev.xmotion.x < column->minWidth)
 477                 cx = pos.x + column->minWidth;
 478             else if (column->maxWidth > 0
 479                      && column->width + ev.xmotion.x > column->maxWidth)
 480                 cx = pos.x + column->maxWidth;
 481             else
 482                 cx = offsX + ev.xmotion.x;
 483
 484             XDrawLine(dpy, w, gc, ox+20, 0, ox+20, h);
 485             XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 486             break;
 487
 488         case ButtonRelease:
 489             column->width = cx - pos.x;
 490             done = 1;
 491             break;
 492         }
 493     }
 494
 495     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 496     rearrangeHeader(table);
 497     repaintTable(table);
 498 }
 499
 500
 501 static void
 502 realizeTable(void *data, WMNotification *notif)
 503 {
 504     repaintTable(data);
 505 }
 506
 507
 508 WMTableView*
 509 WMCreateTableView(WMWidget *parent)
 510 {
 511     WMTableView *table = wmalloc(sizeof(WMTableView));
 512     WMScreen *scr = WMWidgetScreen(parent);
 513
 514     memset(table, 0, sizeof(WMTableView));
 515
 516     if (!tableClass) {
 517         tableClass = W_RegisterUserWidget();
 518     }
 519     table->widgetClass = tableClass;
 520
 521     table->view = W_CreateView(W_VIEW(parent));
 522     if (!table->view)
 523         goto error;
 524     table->view->self = table;
 525
 526     table->view->delegate = &viewDelegate;
 527
 528     table->headerHeight = 20;
 529
 530     table->hscroll = WMCreateScroller(table);
 531     WMSetScrollerAction(table->hscroll, doScroll, table);
 532     WMMoveWidget(table->hscroll, 1, 2+table->headerHeight);
 533     WMMapWidget(table->hscroll);
 534
 535     table->hasHScroller = 1;
 536
 537     table->vscroll = WMCreateScroller(table);
 538     WMSetScrollerArrowsPosition(table->vscroll, WSAMaxEnd);
 539     WMSetScrollerAction(table->vscroll, doScroll, table);
 540     WMMoveWidget(table->vscroll, 1, 2+table->headerHeight);
 541     WMMapWidget(table->vscroll);
 542
 543     table->hasVScroller = 1;
 544
 545     table->header = WMCreateFrame(table);
 546     WMMoveWidget(table->header, 22, 2);
 547     WMMapWidget(table->header);
 548     WMSetFrameRelief(table->header, WRFlat);
 549
 550     table->corner = WMCreateLabel(table);
 551     WMResizeWidget(table->corner, 20, table->headerHeight);
 552     WMMoveWidget(table->corner, 2, 2);
 553     WMMapWidget(table->corner);
 554     WMSetLabelRelief(table->corner, WRRaised);
 555     WMSetWidgetBackgroundColor(table->corner, scr->darkGray);
 556
 557
 558     table->tableView = W_CreateView(table->view);
 559     if (!table->tableView)
 560         goto error;
 561     table->tableView->self = table;
 562     W_MapView(table->tableView);
 563
 564     WMAddNotificationObserver(realizeTable, table, WMViewRealizedNotification,
 565                               table->tableView);
 566
 567     table->tableView->flags.dontCompressExpose = 1;
 568
 569     table->gridColor = WMCreateNamedColor(scr, "#cccccc", False);
 570     /*   table->gridColor = WMGrayColor(scr);*/
 571
 572     {
 573         XGCValues gcv;
 574
 575         table->backColor = WMWhiteColor(scr);
 576
 577         gcv.foreground = WMColorPixel(table->gridColor);
 578         gcv.dashes = 1;
 579         gcv.line_style = LineOnOffDash;
 580         table->gridGC = XCreateGC(WMScreenDisplay(scr), W_DRAWABLE(scr),
 581                                   GCForeground, &gcv);
 582     }
 583
 584     table->editingRow = -1;
 585     table->clickedRow = -1;
 586
 587     table->drawsGrid = 1;
 588     table->rowHeight = 16;
 589
 590     table->tableWidth = 1;
 591
 592     table->columns = WMCreateArray(4);
 593     table->splitters = WMCreateArray(4);
 594
 595     table->selectedRows = WMCreateArray(16);
 596
 597     table->splitterCursor = XCreateFontCursor(WMScreenDisplay(scr),
 598                                               XC_sb_h_double_arrow);
 599
 600     table->canSelectRow = 1;
 601
 602     WMCreateEventHandler(table->view, ExposureMask|StructureNotifyMask,
 603                          handleEvents, table);
 604
 605     WMCreateEventHandler(table->tableView, ExposureMask|ButtonPressMask|
 606                          ButtonReleaseMask|ButtonMotionMask,
 607                          handleTableEvents, table);
 608
 609     WMResizeWidget(table, 50, 50);
 610
 611     return table;
 612
 613     error:
 614         if (table->tableView)
 615             W_DestroyView(table->tableView);
 616         if (table->view)
 617             W_DestroyView(table->view);
 618         wfree(table);
 619         return NULL;
 620 }
 621
 622
 623 void
 624 WMAddTableViewColumn(WMTableView *table, WMTableColumn *column)
 625 {
 626     WMScreen *scr = WMWidgetScreen(table);
 627
 628     column->table = table;
 629
 630     WMAddToArray(table->columns, column);
 631
 632     if (!column->titleW) {
 633         column->titleW = WMCreateLabel(table);
 634         WMSetLabelRelief(column->titleW, WRRaised);
 635         WMSetLabelFont(column->titleW, scr->boldFont);
 636         WMSetLabelTextColor(column->titleW, scr->white);
 637         WMSetWidgetBackgroundColor(column->titleW, scr->darkGray);
 638         WMSetLabelText(column->titleW, column->title);
 639         W_ReparentView(WMWidgetView(column->titleW),
 640                        WMWidgetView(table->header), 0, 0);
 641         if (W_VIEW_REALIZED(table->view))
 642             WMRealizeWidget(column->titleW);
 643         WMMapWidget(column->titleW);
 644     }
 645
 646     {
 647         WMView *splitter = W_CreateView(WMWidgetView(table->header));
 648
 649         W_SetViewBackgroundColor(splitter, WMWhiteColor(scr));
 650
 651         if (W_VIEW_REALIZED(table->view))
 652             W_RealizeView(splitter);
 653
 654         W_ResizeView(splitter, 2, table->headerHeight);
 655         W_MapView(splitter);
 656
 657         W_SetViewCursor(splitter, table->splitterCursor);
 658         WMCreateEventHandler(splitter, ButtonPressMask|ButtonReleaseMask,
 659                              splitterHandler, column);
 660
 661         WMAddToArray(table->splitters, splitter);
 662     }
 663
 664     rearrangeHeader(table);
 665 }
 666
 667
 668 void
 669 WMSetTableViewHeaderHeight(WMTableView *table, unsigned height)
 670 {
 671     table->headerHeight = height;
 672
 673     handleResize(NULL, table->view);
 674 }
 675
 676
 677 void
 678 WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate)
 679 {
 680     table->delegate = delegate;
 681 }
 682
 683
 684 void
 685 WMSetTableViewAction(WMTableView *table, WMAction *action, void *clientData)
 686 {
 687     table->action = action;
 688
 689     table->clientData = clientData;
 690 }
 691
 692
 693 void*
 694 WMGetTableViewClickedColumn(WMTableView *table)
 695 {
 696     return table->clickedColumn;
 697 }
 698
 699
 700 int
 701 WMGetTableViewClickedRow(WMTableView *table)
 702 {
 703     return table->clickedRow;
 704 }
 705
 706
 707 WMArray*
 708 WMGetTableViewSelectedRows(WMTableView *table)
 709 {
 710     return table->selectedRows;
 711 }
 712
 713
 714 WMView*
 715 WMGetTableViewDocumentView(WMTableView *table)
 716 {
 717     return table->tableView;
 718 }
 719
 720
 721 void*
 722 WMTableViewDataForCell(WMTableView *table, WMTableColumn *column, int row)
 723 {
 724     return (*table->delegate->valueForCell)(table->delegate, column, row);
 725 }
 726
 727
 728 void
 729 WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column, int row,
 730                           void *data)
 731 {
 732     (*table->delegate->setValueForCell)(table->delegate, column, row, data);
 733 }
 734
 735
 736 WMRect
 737 WMTableViewRectForCell(WMTableView *table, WMTableColumn *column, int row)
 738 {
 739     WMRect rect;
 740     int i;
 741
 742     rect.pos.x = 0;
 743     rect.pos.y = row * table->rowHeight;
 744     rect.size.height = table->rowHeight;
 745
 746     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 747         WMTableColumn *col;
 748         col = WMGetFromArray(table->columns, i);
 749
 750         if (col == column) {
 751             rect.size.width = col->width;
 752             break;
 753         }
 754
 755         rect.pos.x += col->width;
 756     }
 757
 758     {
 759         WMRect r = getVisibleRect(table);
 760
 761         rect.pos.y -= r.pos.y;
 762         rect.pos.x -= r.pos.x;
 763     }
 764
 765     return rect;
 766 }
 767
 768
 769 void
 770 WMSetTableViewDataSource(WMTableView *table, void *source)
 771 {
 772     table->dataSource = source;
 773 }
 774
 775
 776 void*
 777 WMGetTableViewDataSource(WMTableView *table)
 778 {
 779     return table->dataSource;
 780 }
 781
 782
 783
 784 void
 785 WMSetTableViewHasHorizontalScroller(WMTableView *tPtr, Bool flag)
 786 {
 787     if (flag) {
 788         if (tPtr->hasHScroller)
 789             return;
 790         tPtr->hasHScroller = 1;
 791
 792         tPtr->hscroll = WMCreateScroller(tPtr);
 793         WMSetScrollerAction(tPtr->hscroll, doScroll, tPtr);
 794         WMSetScrollerArrowsPosition(tPtr->hscroll, WSAMaxEnd);
 795         /* make it a horiz. scroller */
 796         WMResizeWidget(tPtr->hscroll, 1, 2);
 797
 798         if (W_VIEW_REALIZED(tPtr->view)) {
 799             WMRealizeWidget(tPtr->hscroll);
 800         }
 801
 802         reorganizeInterior(tPtr);
 803
 804         WMMapWidget(tPtr->hscroll);
 805     } else {
 806         if (!tPtr->hasHScroller)
 807             return;
 808         tPtr->hasHScroller = 0;
 809
 810         WMUnmapWidget(tPtr->hscroll);
 811         WMDestroyWidget(tPtr->hscroll);
 812         tPtr->hscroll = NULL;
 813
 814         reorganizeInterior(tPtr);
 815     }
 816 }
 817
 818 #if 0
 819 /* not supported by now */
 820 void
 821 WMSetTableViewHasVerticalScroller(WMTableView *tPtr, Bool flag)
 822 {
 823     if (flag) {
 824         if (tPtr->hasVScroller)
 825             return;
 826         tPtr->hasVScroller = 1;
 827
 828         tPtr->vscroll = WMCreateScroller(tPtr);
 829         WMSetScrollerAction(tPtr->vscroll, doScroll, tPtr);
 830         WMSetScrollerArrowsPosition(tPtr->vscroll, WSAMaxEnd);
 831         /* make it a vert. scroller */
 832         WMResizeWidget(tPtr->vscroll, 1, 2);
 833
 834         if (W_VIEW_REALIZED(tPtr->view)) {
 835             WMRealizeWidget(tPtr->vscroll);
 836         }
 837
 838         reorganizeInterior(tPtr);
 839
 840         WMMapWidget(tPtr->vscroll);
 841     } else {
 842         if (!tPtr->hasVScroller)
 843             return;
 844         tPtr->hasVScroller = 0;
 845
 846         WMUnmapWidget(tPtr->vscroll);
 847         WMDestroyWidget(tPtr->vscroll);
 848         tPtr->vscroll = NULL;
 849
 850         reorganizeInterior(tPtr);
 851     }
 852 }
 853 #endif
 854
 855 void
 856 WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 857 {
 858     W_SetViewBackgroundColor(table->tableView, color);
 859
 860     if (table->backColor)
 861         WMReleaseColor(table->backColor);
 862
 863     table->backColor = WMRetainColor(color);
 864
 865     repaintTable(table);
 866 }
 867
 868
 869 void
 870 WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 871 {
 872     WMReleaseColor(table->gridColor);
 873     table->gridColor = WMRetainColor(color);
 874     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC,
 875                    WMColorPixel(color));
 876     repaintTable(table);
 877 }
 878
 879
 880
 881 void
 882 WMSetTableViewRowHeight(WMTableView *table, int height)
 883 {
 884     table->rowHeight = height;
 885
 886     repaintTable(table);
 887 }
 888
 889
 890 void
 891 WMScrollTableViewRowToVisible(WMTableView *table, int row)
 892 {
 893     WMScroller *scroller;
 894     WMRange range;
 895     WMRect rect;
 896     int newY, tmp;
 897
 898     rect = getVisibleRect(table);
 899     range = rowsInRect(table, rect);
 900
 901     scroller = table->vscroll;
 902
 903     if (row < range.position) {
 904         newY = row * table->rowHeight - rect.size.height / 2;
 905     } else if (row >= range.position + range.count) {
 906         newY = row * table->rowHeight - rect.size.height / 2;
 907     } else {
 908         return;
 909     }
 910     tmp = table->rows*table->rowHeight - rect.size.height;
 911     newY = WMAX(0, WMIN(newY, tmp));
 912
 913     scrollToPoint(table, rect.pos.x, newY);
 914 }
 915
 916
 917
 918 static void
 919 drawGrid(WMTableView *table, WMRect rect)
 920 {
 921     WMScreen *scr = WMWidgetScreen(table);
 922     Display *dpy = WMScreenDisplay(scr);
 923     int i;
 924     int y1, y2;
 925     int x1, x2;
 926     int xx;
 927     Drawable d = WMGetPixmapXID(table->viewBuffer);
 928     GC gc = table->gridGC;
 929
 930 #if 0
 931     char dashl[1] = {1};
 932
 933     XSetDashes(dpy, gc, 0, dashl, 1);
 934
 935     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 936     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 937 #endif
 938     y1 = 0;
 939     y2 = W_VIEW_HEIGHT(table->tableView);
 940
 941     xx = -rect.pos.x;
 942     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 943         WMTableColumn *column;
 944
 945         XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 946
 947         column = WMGetFromArray(table->columns, i);
 948         xx += column->width;
 949     }
 950     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 951
 952     x1 = 0;
 953     x2 = rect.size.width;
 954
 955     if (x2 <= x1)
 956         return;
 957 #if 0
 958     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 959 #endif
 960
 961     y1 = -rect.pos.y%table->rowHeight;
 962     y2 = y1 + rect.size.height + table->rowHeight;
 963
 964     for (i = y1; i <= y2; i += table->rowHeight) {
 965         XDrawLine(dpy, d, gc, x1, i, x2, i);
 966     }
 967 }
 968
 969
 970 static WMRange
 971 columnsInRect(WMTableView *table, WMRect rect)
 972 {
 973     WMTableColumn *column;
 974     int pos;
 975     int i, found;
 976     int totalColumns = WMGetArrayItemCount(table->columns);
 977     WMRange range;
 978
 979     pos = 0;
 980     found = 0;
 981     for (i = 0; i < totalColumns; i++) {
 982         column = WMGetFromArray(table->columns, i);
 983         if (!found) {
 984             if (rect.pos.x >= pos && rect.pos.x < pos + column->width) {
 985                 range.position = i;
 986                 range.count = 1;
 987                 found = 1;
 988             }
 989         } else {
 990             if (pos > rect.pos.x + rect.size.width) {
 991                 break;
 992             }
 993             range.count++;
 994         }
 995         pos += column->width;
 996     }
 997     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 998     return range;
 999 }
1000
1001
1002 static WMRange
1003 rowsInRect(WMTableView *table, WMRect rect)
1004 {
1005     WMRange range;
1006     int rh = table->rowHeight;
1007     int dif;
1008
1009     dif = rect.pos.y % rh;
1010
1011     range.position = WMAX(0, (rect.pos.y - dif) / rh);
1012     range.count = WMAX(1, WMIN((rect.size.height + dif) / rh, table->rows));
1013
1014     return range;
1015 }
1016
1017
1018 static void
1019 drawRow(WMTableView *table, int row, WMRect clipRect)
1020 {
1021     int i;
1022     WMRange cols = columnsInRect(table, clipRect);
1023     WMTableColumn *column;
1024     Drawable d = WMGetPixmapXID(table->viewBuffer);
1025
1026     for (i = cols.position; i < cols.position+cols.count; i++) {
1027         column = WMGetFromArray(table->columns, i);
1028
1029         if (!column->delegate || !column->delegate->drawCell)
1030             continue;
1031
1032         if (WMFindInArray(table->selectedRows, NULL, (void*)(uintptr_t)row) != WANotFound)
1033             (*column->delegate->drawSelectedCell)(column->delegate, column, row, d);
1034         else
1035             (*column->delegate->drawCell)(column->delegate, column, row, d);
1036     }
1037 }
1038
1039
1040 #if 0
1041 static void
1042 drawFullRow(WMTableView *table, int row)
1043 {
1044     int i;
1045     WMTableColumn *column;
1046     Drawable d = WMGetPixmapXID(table->viewBuffer);
1047
1048     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
1049         column = WMGetFromArray(table->columns, i);
1050
1051         if (!column->delegate || !column->delegate->drawCell)
1052             continue;
1053
1054         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
1055             (*column->delegate->drawSelectedCell)(column->delegate, column, row, d);
1056         else
1057             (*column->delegate->drawCell)(column->delegate, column, row, d);
1058     }
1059 }
1060 #endif
1061
1062
1063 static void
1064 setRowSelected(WMTableView *table, unsigned row, Bool flag)
1065 {
1066     int repaint = 0;
1067
1068     if (WMFindInArray(table->selectedRows, NULL, (void*)(uintptr_t)row) != WANotFound) {
1069         if (!flag) {
1070             WMRemoveFromArray(table->selectedRows, (void*)(uintptr_t)row);
1071             repaint = 1;
1072         }
1073     } else {
1074         if (flag) {
1075             WMAddToArray(table->selectedRows, (void*)(uintptr_t)row);
1076             repaint = 1;
1077         }
1078     }
1079     if (repaint && row < table->rows) {
1080         /*drawFullRow(table, row);*/
1081         repaintTable(table);
1082     }
1083 }
1084
1085
1086 static void
1087 repaintTable(WMTableView *table)
1088 {
1089     WMRect rect;
1090     WMRange rows;
1091     WMScreen *scr = WMWidgetScreen(table);
1092     int i;
1093
1094     if (!table->delegate || !W_VIEW_REALIZED(table->view))
1095         return;
1096
1097     wassertr(table->delegate->numberOfRows);
1098
1099     if (!table->viewBuffer) {
1100         table->viewBuffer = WMCreatePixmap(scr,
1101                                            W_VIEW_WIDTH(table->tableView),
1102                                            W_VIEW_HEIGHT(table->tableView),
1103                                            WMScreenDepth(scr), 0);
1104     }
1105
1106     XFillRectangle(scr->display,
1107                    WMGetPixmapXID(table->viewBuffer),
1108                    WMColorGC(table->backColor), 0, 0,
1109                    W_VIEW_WIDTH(table->tableView),
1110                    W_VIEW_HEIGHT(table->tableView));
1111
1112     rect = getVisibleRect(table);
1113
1114     if (table->drawsGrid) {
1115         drawGrid(table, rect);
1116     }
1117
1118     rows = rowsInRect(table, rect);
1119     for (i = rows.position;
1120          i < WMIN(rows.position+rows.count + 1, table->rows);
1121          i++) {
1122         drawRow(table, i, rect);
1123     }
1124
1125     XSetWindowBackgroundPixmap(scr->display, table->tableView->window,
1126                                WMGetPixmapXID(table->viewBuffer));
1127     XClearWindow(scr->display, table->tableView->window);
1128 }
1129
1130
1131 static void
1132 stopRowEdit(WMTableView *table, int row)
1133 {
1134     int i;
1135     WMTableColumn *column;
1136
1137     table->editingRow = -1;
1138     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
1139         column = WMGetFromArray(table->columns, i);
1140
1141         if (column->delegate && column->delegate->endCellEdit)
1142             (*column->delegate->endCellEdit)(column->delegate, column, row);
1143     }
1144 }
1145
1146
1147
1148 void
1149 WMEditTableViewRow(WMTableView *table, int row)
1150 {
1151     int i;
1152     WMTableColumn *column;
1153
1154     if (table->editingRow >= 0) {
1155         stopRowEdit(table, table->editingRow);
1156     }
1157
1158     table->editingRow = row;
1159
1160     if (row < 0)
1161         return;
1162
1163     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
1164         column = WMGetFromArray(table->columns, i);
1165
1166         if (column->delegate && column->delegate->beginCellEdit)
1167             (*column->delegate->beginCellEdit)(column->delegate, column, row);
1168     }
1169 }
1170
1171
1172 void
1173 WMSelectTableViewRow(WMTableView *table, int row)
1174 {
1175     if (table->clickedRow >= 0)
1176         setRowSelected(table, table->clickedRow, False);
1177
1178     if (row >= table->rows) {
1179         return;
1180     }
1181
1182     setRowSelected(table, row, True);
1183     table->clickedRow = row;
1184
1185     if (table->action)
1186         (*table->action)(table, table->clientData);
1187     WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1188                            table, NULL);
1189 }
1190
1191
1192 void
1193 WMReloadTableView(WMTableView *table)
1194 {
1195     if (table->editingRow >= 0)
1196         stopRowEdit(table, table->editingRow);
1197
1198     /* when this is called, nothing in the table can be assumed to be
1199      * like the last time we accessed it (ie, rows might have disappeared) */
1200
1201     WMEmptyArray(table->selectedRows);
1202
1203     if (table->clickedRow >= 0) {
1204         if (table->action)
1205             (*table->action)(table, table->clientData);
1206         WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1207                                table, NULL);
1208         table->clickedRow = -1;
1209     }
1210
1211     if (table->delegate && table->delegate->numberOfRows) {
1212         int rows;
1213
1214         rows = (*table->delegate->numberOfRows)(table->delegate, table);
1215
1216         if (rows != table->rows) {
1217             table->rows = rows;
1218             handleResize(table->view->delegate, table->view);
1219         } else {
1220             repaintTable(table);
1221         }
1222     }
1223 }
1224
1225
1226 void
1227 WMNoteTableViewNumberOfRowsChanged(WMTableView *table)
1228 {
1229     WMReloadTableView(table);
1230 }
1231
1232
1233 static void
1234 handleTableEvents(XEvent *event, void *data)
1235 {
1236     WMTableView *table = (WMTableView*)data;
1237     int row;
1238
1239     switch (event->type) {
1240     case ButtonPress:
1241         if (event->xbutton.button == Button1) {
1242             WMRect rect = getVisibleRect(table);
1243
1244             row = (event->xbutton.y + rect.pos.y)/table->rowHeight;
1245             if (row != table->clickedRow) {
1246                 setRowSelected(table, table->clickedRow, False);
1247                 setRowSelected(table, row, True);
1248                 table->clickedRow = row;
1249                 table->dragging = 1;
1250             } else {
1251                 table->dragging = 1;
1252             }
1253         }
1254         break;
1255
1256     case MotionNotify:
1257         if (table->dragging && event->xmotion.y >= 0) {
1258             WMRect rect = getVisibleRect(table);
1259
1260             row = (event->xmotion.y + rect.pos.y)/table->rowHeight;
1261             if (table->clickedRow != row && row >= 0 && row < table->rows) {
1262                 setRowSelected(table, table->clickedRow, False);
1263                 setRowSelected(table, row, True);
1264                 table->clickedRow = row;
1265             }
1266         }
1267         break;
1268
1269     case ButtonRelease:
1270         if (event->xbutton.button == Button1) {
1271             if (table->action)
1272                 (*table->action)(table, table->clientData);
1273             WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1274                                    table, NULL);
1275             table->dragging = 0;
1276         }
1277         break;
1278     }
1279 }
1280
1281
1282 static void
1283 handleEvents(XEvent *event, void *data)
1284 {
1285     WMTableView *table = (WMTableView*)data;
1286     WMScreen *scr = WMWidgetScreen(table);
1287
1288     switch (event->type) {
1289     case Expose:
1290         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
1291                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
1292                      WRSunken);
1293         break;
1294     }
1295 }
1296
1297
1298 static void
1299 handleResize(W_ViewDelegate *self, WMView *view)
1300 {
1301     reorganizeInterior(view->self);
1302 }
1303
1304
1305 static void
1306 reorganizeInterior(WMTableView *table)
1307 {
1308     int width;
1309     int height;
1310     WMSize size = getTotalSize(table);
1311     WMView *view = table->view;
1312     int vw, vh;
1313     int hsThickness, vsThickness;
1314
1315     if (table->vscroll)
1316         vsThickness = WMWidgetWidth(table->vscroll);
1317     if (table->hscroll)
1318         hsThickness = WMWidgetHeight(table->hscroll);
1319
1320     width = W_VIEW_WIDTH(view) - 2;
1321     height = W_VIEW_HEIGHT(view) - 3;
1322
1323     height -= table->headerHeight; /* table header */
1324
1325     if (table->corner)
1326         WMResizeWidget(table->corner, 20, table->headerHeight);
1327
1328     WMMoveWidget(table->vscroll, 1, table->headerHeight + 1);
1329     WMResizeWidget(table->vscroll, 20, height + 1);
1330
1331     if (table->hscroll) {
1332         WMMoveWidget(table->hscroll, vsThickness, W_VIEW_HEIGHT(view) - hsThickness - 1);
1333         WMResizeWidget(table->hscroll, width-(vsThickness+1), hsThickness);
1334     }
1335
1336     if (table->header)
1337         WMResizeWidget(table->header, width-(vsThickness+1), table->headerHeight);
1338
1339     if (table->viewBuffer) {
1340         WMReleasePixmap(table->viewBuffer);
1341         table->viewBuffer = NULL;
1342     }
1343
1344     width -= vsThickness;
1345     height -= hsThickness;
1346
1347
1348     vw = WMIN(size.width, width);
1349     vh = WMIN(size.height, height);
1350
1351     W_MoveView(table->tableView, vsThickness+1, 1+table->headerHeight+1);
1352     W_ResizeView(table->tableView, WMAX(vw, 1), WMAX(vh, 1)+1);
1353
1354     adjustScrollers(table);
1355
1356     repaintTable(table);
1357 }
1358
1359
1360 static void
1361 rearrangeHeader(WMTableView *table)
1362 {
1363     int width;
1364     int count;
1365     int i;
1366     /*WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);*/
1367
1368     width = 0;
1369
1370     count = WMGetArrayItemCount(table->columns);
1371     for (i = 0; i < count; i++) {
1372         WMTableColumn *column = WMGetFromArray(table->columns, i);
1373         WMView *splitter = WMGetFromArray(table->splitters, i);
1374
1375         WMMoveWidget(column->titleW, width, 0);
1376         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
1377
1378         width += column->width;
1379         W_MoveView(splitter, width-1, 0);
1380     }
1381
1382     wassertr(table->delegate && table->delegate->numberOfRows);
1383
1384     table->rows = table->delegate->numberOfRows(table->delegate, table);
1385
1386     table->tableWidth = width + 1;
1387
1388     handleResize(table->view->delegate, table->view);
1389 }
1390