WINGs/Extras/wtableview.c

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