WINGs/Extras/wtableview.c

   1
   2
   3 #include <WINGsP.h>
   4 #include <X11/cursorfont.h>
   5
   6 #include "wtableview.h"
   7
   8
   9 const char *WMTableViewRowWasSelectedNotification = "WMTableViewRowWasSelectedNotification";
  10 const char *WMTableViewRowWasUnselectedNotification = "WMTableViewRowWasUnselectedNotification";
  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
  31 static void handleResize(W_ViewDelegate *self, WMView *view);
  32
  33
  34 WMTableColumn *WMCreateTableColumn(char *title)
  35 {
  36     WMTableColumn *col = wmalloc(sizeof(WMTableColumn));
  37
  38     col->table = NULL;
  39     col->titleW = NULL;
  40     col->width = 50;
  41     col->minWidth = 5;
  42     col->maxWidth = 0;
  43
  44     col->id = NULL;
  45
  46     col->title = wstrdup(title);
  47
  48     col->delegate = NULL;
  49
  50     col->resizable = 1;
  51     col->editable = 0;
  52
  53     return col;
  54 }
  55
  56
  57 void WMSetTableColumnId(WMTableColumn *column, void *id)
  58 {
  59     column->id = id;
  60 }
  61
  62
  63 void *WMGetTableColumnId(WMTableColumn *column)
  64 {
  65     return column->id;
  66 }
  67
  68
  69 void WMSetTableColumnWidth(WMTableColumn *column, unsigned width)
  70 {
  71     if (column->maxWidth == 0)
  72         column->width = WMAX(column->minWidth, width);
  73     else
  74         column->width = WMAX(column->minWidth, WMIN(column->maxWidth, width));
  75
  76     if (column->table) {
  77         handleResize(NULL, W_VIEW(column->table));
  78     }
  79 }
  80
  81
  82 void WMSetTableColumnDelegate(WMTableColumn *column,
  83                               WMTableColumnDelegate *delegate)
  84 {
  85     column->delegate = delegate;
  86 }
  87
  88
  89 void WMSetTableColumnConstraints(WMTableColumn *column,
  90                                  unsigned minWidth, unsigned maxWidth)
  91 {
  92     wassertr(minWidth <= maxWidth);
  93
  94     column->minWidth = minWidth;
  95     column->maxWidth = maxWidth;
  96
  97     if (column->width < column->minWidth)
  98         WMSetTableColumnWidth(column, column->minWidth);
  99     else if (column->width > column->maxWidth || column->maxWidth == 0)
 100         WMSetTableColumnWidth(column, column->maxWidth);
 101 }
 102
 103
 104 void WMSetTableColumnEditable(WMTableColumn *column, Bool flag)
 105 {
 106     column->editable = flag;
 107 }
 108
 109
 110 WMTableView *WMGetTableColumnTableView(WMTableColumn *column)
 111 {
 112     return column->table;
 113 }
 114
 115
 116
 117 struct W_TableView {
 118     W_Class widgetClass;
 119     WMView *view;
 120
 121     WMFrame *header;
 122
 123     WMLabel *corner;
 124
 125     WMScrollView *scrollView;
 126     WMView *tableView;
 127
 128     WMArray *columns;
 129     WMArray *splitters;
 130
 131     WMArray *selectedRows;
 132
 133     int tableWidth;
 134
 135     int rows;
 136
 137     GC gridGC;
 138     WMColor *gridColor;
 139
 140     Cursor splitterCursor;
 141
 142     void *dataSource;
 143
 144     WMTableViewDelegate *delegate;
 145
 146     int editingRow;
 147
 148     unsigned headerHeight;
 149
 150     unsigned rowHeight;
 151
 152     unsigned drawsGrid:1;
 153     unsigned canSelectRow:1;
 154     unsigned canSelectMultiRows:1;
 155     unsigned canDeselectRow:1;
 156 };
 157
 158 static W_Class tableClass = 0;
 159
 160
 161 static W_ViewDelegate viewDelegate = {
 162     NULL,
 163         NULL,
 164         handleResize,
 165         NULL,
 166         NULL
 167 };
 168
 169
 170
 171
 172
 173 static void handleEvents(XEvent *event, void *data);
 174 static void handleTableEvents(XEvent *event, void *data);
 175
 176
 177 static void scrollObserver(void *self, WMNotification *notif)
 178 {
 179     WMTableView *table = (WMTableView*)self;
 180     WMRect rect;
 181     int i, x;
 182
 183     rect = WMGetScrollViewVisibleRect(table->scrollView);
 184
 185     x = 0;
 186     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 187         WMTableColumn *column;
 188
 189         column = WMGetFromArray(table->columns, i);
 190
 191         WMMoveWidget(column->titleW, x + rect.pos.x, 0);
 192
 193         if (i > 0) {
 194             WMView *splitter;
 195
 196             splitter = WMGetFromArray(table->splitters, i-1);
 197             W_MoveView(splitter, x + rect.pos.x - 1, 0);
 198         }
 199
 200         x += W_VIEW_WIDTH(WMWidgetView(column->titleW)) + 1;
 201     }
 202 }
 203
 204
 205 static void splitterHandler(XEvent *event, void *data)
 206 {
 207     WMTableView *table = (WMTableView*)data;
 208     int done = 0;
 209
 210     while (!done) {
 211         XEvent ev;
 212
 213         WMMaskEvent(event->xany.display, ButtonMotionMask|ButtonReleaseMask,
 214                     &ev);
 215
 216         switch (event->type) {
 217          case MotionNotify:
 218             printf("%i\n", event->xmotion.x);
 219             break;
 220
 221          case ButtonRelease:
 222             done = 1;
 223             break;
 224         }
 225     }
 226 }
 227
 228
 229
 230 WMTableView *WMCreateTableView(WMWidget *parent)
 231 {
 232     WMTableView *table = wmalloc(sizeof(WMTableView));
 233     WMScreen *scr = WMWidgetScreen(parent);
 234
 235     memset(table, 0, sizeof(WMTableView));
 236
 237     if (!tableClass) {
 238         tableClass = W_RegisterUserWidget();
 239     }
 240     table->widgetClass = tableClass;
 241
 242     table->view = W_CreateView(W_VIEW(parent));
 243     if (!table->view)
 244         goto error;
 245     table->view->self = table;
 246
 247     table->view->delegate = &viewDelegate;
 248
 249     table->headerHeight = 20;
 250
 251     table->scrollView = WMCreateScrollView(table);
 252     if (!table->scrollView)
 253         goto error;
 254     WMResizeWidget(table->scrollView, 10, 10);
 255     WMSetScrollViewHasVerticalScroller(table->scrollView, True);
 256     WMSetScrollViewHasHorizontalScroller(table->scrollView, True);
 257     {
 258         WMScroller *scroller;
 259         scroller = WMGetScrollViewHorizontalScroller(table->scrollView);
 260         WMAddNotificationObserver(scrollObserver, table,
 261                                   WMScrollerDidScrollNotification,
 262                                   scroller);
 263     }
 264     WMMoveWidget(table->scrollView, 1, 2+table->headerHeight);
 265     WMMapWidget(table->scrollView);
 266
 267     table->header = WMCreateFrame(table);
 268     WMMoveWidget(table->header, 22, 2);
 269     WMMapWidget(table->header);
 270     WMSetFrameRelief(table->header, WRFlat);
 271     table->corner = WMCreateLabel(table);
 272     WMResizeWidget(table->corner, 20, table->headerHeight);
 273     WMMoveWidget(table->corner, 2, 2);
 274     WMMapWidget(table->corner);
 275     WMSetLabelRelief(table->corner, WRRaised);
 276     WMSetWidgetBackgroundColor(table->corner, scr->darkGray);
 277
 278
 279     table->tableView = W_CreateView(W_VIEW(parent));
 280     if (!table->tableView)
 281         goto error;
 282     table->tableView->self = table;
 283     W_ResizeView(table->tableView, 100, 1000);
 284     W_MapView(table->tableView);
 285
 286     WMSetScrollViewContentView(table->scrollView, table->tableView);
 287
 288     table->tableView->flags.dontCompressExpose = 1;
 289
 290     table->gridColor = WMDarkGrayColor(scr);
 291
 292     {
 293         XGCValues gcv;
 294
 295         gcv.foreground = WMColorPixel(table->gridColor);
 296         gcv.dashes = 1;
 297         gcv.line_style = LineOnOffDash;
 298         table->gridGC = XCreateGC(WMScreenDisplay(scr), W_DRAWABLE(scr),
 299                                   GCForeground, &gcv);
 300     }
 301
 302     table->editingRow = -1;
 303
 304     table->drawsGrid = 1;
 305     table->rowHeight = 16;
 306
 307     table->tableWidth = 1;
 308
 309     table->columns = WMCreateArray(4);
 310     table->splitters = WMCreateArray(4);
 311
 312     table->selectedRows = WMCreateArray(16);
 313
 314     table->splitterCursor = XCreateFontCursor(WMScreenDisplay(scr),
 315                                               XC_sb_h_double_arrow);
 316
 317     table->canSelectRow = 1;
 318
 319     WMCreateEventHandler(table->view, ExposureMask|StructureNotifyMask,
 320                          handleEvents, table);
 321
 322     WMCreateEventHandler(table->tableView, ExposureMask|ButtonPressMask,
 323                          handleTableEvents, table);
 324
 325     return table;
 326
 327  error:
 328     if (table->scrollView)
 329         WMDestroyWidget(table->scrollView);
 330     if (table->tableView)
 331         W_DestroyView(table->tableView);
 332     if (table->view)
 333         W_DestroyView(table->view);
 334     wfree(table);
 335     return NULL;
 336 }
 337
 338
 339 void WMAddTableViewColumn(WMTableView *table, WMTableColumn *column)
 340 {
 341     int width;
 342     int i;
 343     WMScreen *scr = WMWidgetScreen(table);
 344     int count;
 345
 346     column->table = table;
 347
 348     WMAddToArray(table->columns, column);
 349
 350     if (!column->titleW) {
 351         column->titleW = WMCreateLabel(table);
 352         WMSetLabelRelief(column->titleW, WRRaised);
 353         WMSetLabelFont(column->titleW, scr->boldFont);
 354         WMSetLabelTextColor(column->titleW, scr->white);
 355         WMSetWidgetBackgroundColor(column->titleW, scr->darkGray);
 356         WMSetLabelText(column->titleW, column->title);
 357         W_ReparentView(WMWidgetView(column->titleW),
 358                        WMWidgetView(table->header), 0, 0);
 359         if (W_VIEW_REALIZED(table->view))
 360             WMRealizeWidget(column->titleW);
 361         WMMapWidget(column->titleW);
 362     }
 363
 364     if (WMGetArrayItemCount(table->columns) > 1) {
 365         WMView *splitter = W_CreateView(WMWidgetView(table->header));
 366
 367         W_SetViewBackgroundColor(splitter, WMWhiteColor(scr));
 368
 369         if (W_VIEW_REALIZED(table->view))
 370             W_RealizeView(splitter);
 371
 372         W_ResizeView(splitter, 2, table->headerHeight-1);
 373         W_MapView(splitter);
 374
 375         W_SetViewCursor(splitter, table->splitterCursor);
 376         WMCreateEventHandler(splitter, ButtonPressMask,
 377                              splitterHandler, table);
 378
 379         WMAddToArray(table->splitters, splitter);
 380     }
 381
 382     count = WMGetArrayItemCount(table->columns);
 383     for (i = 0, width = 0; i < count; i++) {
 384         WMTableColumn *column = WMGetFromArray(table->columns, i);
 385
 386         WMMoveWidget(column->titleW, width, 0);
 387         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
 388
 389         if (i > 0) {
 390             WMView *splitter = WMGetFromArray(table->splitters, i-1);
 391
 392             W_MoveView(splitter, width-1, 0);
 393         }
 394         width += column->width;
 395     }
 396
 397     wassertr(table->delegate && table->delegate->numberOfRows);
 398
 399     table->rows = table->delegate->numberOfRows(table->delegate, table);
 400
 401     W_ResizeView(table->tableView, width+1,
 402                  table->rows * table->rowHeight + 1);
 403
 404     table->tableWidth = width + 1;
 405 }
 406
 407
 408 void WMSetTableViewHeaderHeight(WMTableView *table, unsigned height)
 409 {
 410     table->headerHeight = height;
 411
 412     handleResize(NULL, table->view);
 413 }
 414
 415
 416 void WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate)
 417 {
 418     table->delegate = delegate;
 419 }
 420
 421
 422 WMView *WMGetTableViewDocumentView(WMTableView *table)
 423 {
 424     return table->tableView;
 425 }
 426
 427
 428 void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 429                              int row)
 430 {
 431     return (*table->delegate->valueForCell)(table->delegate, column, row);
 432 }
 433
 434
 435 void WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 436                                int row, void *data)
 437 {
 438     (*table->delegate->setValueForCell)(table->delegate, column, row, data);
 439 }
 440
 441
 442 WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
 443                               int row)
 444 {
 445     WMRect rect;
 446     int i;
 447
 448     rect.pos.x = 0;
 449     rect.pos.y = row * table->rowHeight;
 450     rect.size.height = table->rowHeight;
 451
 452     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 453         WMTableColumn *col;
 454         col = WMGetFromArray(table->columns, i);
 455
 456         if (col == column) {
 457             rect.size.width = col->width;
 458             break;
 459         }
 460
 461         rect.pos.x += col->width;
 462     }
 463     return rect;
 464 }
 465
 466
 467 void WMSetTableViewDataSource(WMTableView *table, void *source)
 468 {
 469     table->dataSource = source;
 470 }
 471
 472
 473 void *WMGetTableViewDataSource(WMTableView *table)
 474 {
 475     return table->dataSource;
 476 }
 477
 478
 479 void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 480 {
 481     W_SetViewBackgroundColor(table->tableView, color);
 482 }
 483
 484
 485 void WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 486 {
 487     WMReleaseColor(table->gridColor);
 488     table->gridColor = WMRetainColor(color);
 489     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC, WMColorPixel(color));
 490 }
 491
 492
 493
 494 static void drawGrid(WMTableView *table, WMRect rect)
 495 {
 496     WMScreen *scr = WMWidgetScreen(table);
 497     Display *dpy = WMScreenDisplay(scr);
 498     int i;
 499     int y1, y2;
 500     int x1, x2;
 501     int xx;
 502     Drawable d = W_VIEW_DRAWABLE(table->tableView);
 503     GC gc = table->gridGC;
 504
 505 #if 0
 506     char dashl[1] = {1};
 507
 508     XSetDashes(dpy, gc, 0, dashl, 1);
 509
 510     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 511     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 512 #endif
 513     y1 = 0;
 514     y2 = W_VIEW_HEIGHT(table->tableView);
 515
 516     xx = 0;
 517     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 518         WMTableColumn *column;
 519
 520         if (xx >= rect.pos.x && xx <= rect.pos.x+rect.size.width) {
 521             XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 522         }
 523         column = WMGetFromArray(table->columns, i);
 524         xx += column->width;
 525     }
 526     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 527
 528
 529     x1 = rect.pos.x;
 530     x2 = WMIN(x1 + rect.size.width, xx);
 531
 532     if (x2 <= x1)
 533         return;
 534 #if 0
 535     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 536 #endif
 537
 538     y1 = rect.pos.y - rect.pos.y%table->rowHeight;
 539     y2 = y1 + rect.size.height + table->rowHeight;
 540
 541     for (i = y1; i <= y2; i += table->rowHeight) {
 542         XDrawLine(dpy, d, gc, x1, i, x2, i);
 543     }
 544 }
 545
 546
 547 static WMRange columnsInRect(WMTableView *table, WMRect rect)
 548 {
 549     WMTableColumn *column;
 550     int width;
 551     int i , j;
 552     int totalColumns = WMGetArrayItemCount(table->columns);
 553     WMRange range;
 554
 555     j = 0;
 556     width = 0;
 557     for (i = 0; i < totalColumns; i++) {
 558         column = WMGetFromArray(table->columns, i);
 559         if (j == 0) {
 560             if (width <= rect.pos.x && width + column->width > rect.pos.x) {
 561                 range.position = i;
 562                 j = 1;
 563             }
 564         } else {
 565             if (width > rect.pos.x + rect.size.width) {
 566                 range.count = i - range.position;
 567                 break;
 568             }
 569         }
 570         width += column->width;
 571     }
 572
 573     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 574
 575     return range;
 576 }
 577
 578
 579 static WMRange rowsInRect(WMTableView *table, WMRect rect)
 580 {
 581     WMRange range;
 582     int rh = table->rowHeight;
 583
 584     range.position = WMAX(0, rect.pos.y / rh - 1);
 585     range.count = WMAX(1, WMIN(rect.size.height / rh + 3, table->rows));
 586
 587     return range;
 588 }
 589
 590
 591 static void drawRow(WMTableView *table, int row, WMRect clipRect)
 592 {
 593     int i;
 594     WMRange cols = columnsInRect(table, clipRect);
 595     WMTableColumn *column;
 596
 597     for (i = cols.position; i < cols.position+cols.count; i++) {
 598         column = WMGetFromArray(table->columns, i);
 599
 600         wassertr(column->delegate && column->delegate->drawCell);
 601
 602         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 603             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 604         else
 605             (*column->delegate->drawCell)(column->delegate, column, row);
 606     }
 607 }
 608
 609
 610 static void drawFullRow(WMTableView *table, int row)
 611 {
 612     int i;
 613     WMTableColumn *column;
 614
 615     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 616         column = WMGetFromArray(table->columns, i);
 617
 618         wassertr(column->delegate && column->delegate->drawCell);
 619
 620         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 621             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 622         else
 623             (*column->delegate->drawCell)(column->delegate, column, row);
 624     }
 625 }
 626
 627
 628 static void setRowSelected(WMTableView *table, unsigned row, Bool flag)
 629 {
 630     int repaint = 0;
 631
 632
 633     if (WMGetArrayItemCount(table->selectedRows) > 0
 634         && !table->canSelectMultiRows) {
 635         int r = (int)WMGetFromArray(table->selectedRows, 0);
 636
 637         WMDeleteFromArray(table->selectedRows, 0);
 638
 639         drawFullRow(table, r);
 640
 641         WMPostNotificationName(WMTableViewRowWasUnselectedNotification,
 642                                table, (void*)r);
 643     }
 644
 645     if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound) {
 646         if (!flag) {
 647             WMRemoveFromArray(table->selectedRows, (void*)row);
 648             WMPostNotificationName(WMTableViewRowWasUnselectedNotification,
 649                                    table, (void*)row);
 650             repaint = 1;
 651         }
 652     } else {
 653         if (flag) {
 654             WMAddToArray(table->selectedRows, (void*)row);
 655             WMPostNotificationName(WMTableViewRowWasSelectedNotification,
 656                                    table, (void*)row);
 657             repaint = 1;
 658         }
 659     }
 660
 661     if (repaint) {
 662         drawFullRow(table, row);
 663     }
 664 }
 665
 666
 667 static void repaintTable(WMTableView *table, int x, int y,
 668                          int width, int height)
 669 {
 670     WMRect rect;
 671     WMRange rows;
 672     int i;
 673
 674     wassertr(table->delegate && table->delegate->numberOfRows);
 675     i = (*table->delegate->numberOfRows)(table->delegate, table);
 676
 677     if (i != table->rows) {
 678         table->rows = i;
 679         W_ResizeView(table->tableView, table->tableWidth,
 680                      table->rows * table->rowHeight + 1);
 681     }
 682
 683
 684     rect.pos = wmkpoint(x,y);
 685     rect.size = wmksize(width, height);
 686
 687     if (table->drawsGrid) {
 688         drawGrid(table, rect);
 689     }
 690
 691     rows = rowsInRect(table, rect);
 692     for (i = rows.position;
 693          i < WMIN(rows.position+rows.count, table->rows);
 694          i++) {
 695         drawRow(table, i, rect);
 696     }
 697 }
 698
 699
 700 static void stopRowEdit(WMTableView *table, int row)
 701 {
 702     int i;
 703     WMTableColumn *column;
 704
 705     table->editingRow = -1;
 706     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 707         column = WMGetFromArray(table->columns, i);
 708
 709         wassertr(column->delegate && column->delegate->endCellEdit);
 710
 711         (*column->delegate->endCellEdit)(column->delegate, column, row);
 712     }
 713 }
 714
 715
 716
 717 void WMEditTableViewRow(WMTableView *table, int row)
 718 {
 719     int i;
 720     WMTableColumn *column;
 721
 722     if (table->editingRow >= 0) {
 723         stopRowEdit(table, table->editingRow);
 724     }
 725
 726     table->editingRow = row;
 727     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 728         column = WMGetFromArray(table->columns, i);
 729
 730         wassertr(column->delegate && column->delegate->beginCellEdit);
 731
 732         (*column->delegate->beginCellEdit)(column->delegate, column, row);
 733     }
 734 }
 735
 736
 737 static void handleTableEvents(XEvent *event, void *data)
 738 {
 739     WMTableView *table = (WMTableView*)data;
 740
 741     switch (event->type) {
 742      case ButtonPress:
 743         setRowSelected(table, event->xbutton.y/table->rowHeight, True);
 744         break;
 745
 746      case Expose:
 747         repaintTable(table, event->xexpose.x, event->xexpose.y,
 748                      event->xexpose.width, event->xexpose.height);
 749         break;
 750     }
 751 }
 752
 753
 754 static void handleEvents(XEvent *event, void *data)
 755 {
 756     WMTableView *table = (WMTableView*)data;
 757     WMScreen *scr = WMWidgetScreen(table);
 758
 759     switch (event->type) {
 760      case Expose:
 761         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
 762                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
 763                      WRSunken);
 764         break;
 765     }
 766 }
 767
 768
 769 static void handleResize(W_ViewDelegate *self, WMView *view)
 770 {
 771     int width;
 772     int height;
 773     WMTableView *table = view->self;
 774
 775     width = W_VIEW_WIDTH(view) - 2;
 776     height = W_VIEW_HEIGHT(view) - 3;
 777
 778     height -= table->headerHeight; /* table header */
 779
 780     if (table->corner)
 781         WMResizeWidget(table->corner, 20, table->headerHeight);
 782
 783     if (table->scrollView) {
 784         WMMoveWidget(table->scrollView, 1, table->headerHeight + 2);
 785         WMResizeWidget(table->scrollView, width, height);
 786     }
 787     if (table->header)
 788         WMResizeWidget(table->header, width - 21, table->headerHeight);
 789 }
 790
 791