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