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
  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 *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 WMSetTableColumnId(WMTableColumn *column, void *id)
  61 {
  62     column->id = id;
  63 }
  64
  65
  66 void *WMGetTableColumnId(WMTableColumn *column)
  67 {
  68     return column->id;
  69 }
  70
  71
  72 void WMSetTableColumnWidth(WMTableColumn *column, unsigned width)
  73 {
  74     if (column->maxWidth == 0)
  75         column->width = WMAX(column->minWidth, width);
  76     else
  77         column->width = WMAX(column->minWidth, WMIN(column->maxWidth, width));
  78
  79     if (column->table) {
  80         rearrangeHeader(column->table);
  81     }
  82 }
  83
  84
  85 void WMSetTableColumnDelegate(WMTableColumn *column,
  86                               WMTableColumnDelegate *delegate)
  87 {
  88     column->delegate = delegate;
  89 }
  90
  91
  92 void WMSetTableColumnConstraints(WMTableColumn *column,
  93                                  unsigned minWidth, unsigned maxWidth)
  94 {
  95     wassertr(maxWidth == 0 || minWidth <= maxWidth);
  96
  97     column->minWidth = minWidth;
  98     column->maxWidth = maxWidth;
  99
 100     if (column->width < column->minWidth)
 101         WMSetTableColumnWidth(column, column->minWidth);
 102     else if (column->width > column->maxWidth && column->maxWidth != 0)
 103         WMSetTableColumnWidth(column, column->maxWidth);
 104 }
 105
 106
 107 void WMSetTableColumnEditable(WMTableColumn *column, Bool flag)
 108 {
 109     column->editable = flag;
 110 }
 111
 112
 113 WMTableView *WMGetTableColumnTableView(WMTableColumn *column)
 114 {
 115     return column->table;
 116 }
 117
 118
 119
 120 struct W_TableView {
 121     W_Class widgetClass;
 122     WMView *view;
 123
 124     WMFrame *header;
 125
 126     WMLabel *corner;
 127
 128     WMScrollView *scrollView;
 129     WMView *tableView;
 130
 131     WMArray *columns;
 132     WMArray *splitters;
 133
 134     WMArray *selectedRows;
 135
 136     int tableWidth;
 137
 138     int rows;
 139
 140     GC gridGC;
 141     WMColor *gridColor;
 142
 143     Cursor splitterCursor;
 144
 145     void *dataSource;
 146
 147     WMTableViewDelegate *delegate;
 148
 149     WMAction *action;
 150     void *clientData;
 151
 152     void *clickedColumn;
 153     int clickedRow;
 154
 155     int editingRow;
 156
 157     unsigned headerHeight;
 158
 159     unsigned rowHeight;
 160
 161     unsigned dragging:1;
 162     unsigned drawsGrid:1;
 163     unsigned canSelectRow:1;
 164     unsigned canSelectMultiRows:1;
 165     unsigned canDeselectRow:1;
 166 };
 167
 168 static W_Class tableClass = 0;
 169
 170
 171 static W_ViewDelegate viewDelegate = {
 172     NULL,
 173         NULL,
 174         handleResize,
 175         NULL,
 176         NULL
 177 };
 178
 179
 180
 181
 182
 183 static void handleEvents(XEvent *event, void *data);
 184 static void handleTableEvents(XEvent *event, void *data);
 185
 186
 187 static void scrollObserver(void *self, WMNotification *notif)
 188 {
 189     WMTableView *table = (WMTableView*)self;
 190     WMRect rect;
 191     int i, x;
 192
 193     rect = WMGetScrollViewVisibleRect(table->scrollView);
 194
 195     x = 0;
 196     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 197         WMTableColumn *column;
 198         WMView *splitter;
 199
 200         column = WMGetFromArray(table->columns, i);
 201
 202         WMMoveWidget(column->titleW, x - rect.pos.x, 0);
 203
 204         x += W_VIEW_WIDTH(WMWidgetView(column->titleW)) + 1;
 205
 206         splitter = WMGetFromArray(table->splitters, i);
 207         W_MoveView(splitter, x - rect.pos.x - 1, 0);
 208     }
 209 }
 210
 211
 212 static void splitterHandler(XEvent *event, void *data)
 213 {
 214     WMTableColumn *column = (WMTableColumn*)data;
 215     WMTableView *table = column->table;
 216     int done = 0;
 217     int cx, ox, offsX;
 218     WMPoint pos;
 219     WMScreen *scr = WMWidgetScreen(table);
 220     GC gc = scr->ixorGC;
 221     Display *dpy = WMScreenDisplay(scr);
 222     int h = WMWidgetHeight(table) - 22;
 223     Window w = WMViewXID(table->view);
 224
 225     pos = WMGetViewPosition(WMWidgetView(column->titleW));
 226
 227     offsX = pos.x + column->width;
 228
 229     ox = cx = offsX;
 230
 231     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 232
 233     while (!done) {
 234         XEvent ev;
 235
 236         WMMaskEvent(dpy, ButtonMotionMask|ButtonReleaseMask, &ev);
 237
 238         switch (ev.type) {
 239          case MotionNotify:
 240             ox = cx;
 241
 242             if (column->width + ev.xmotion.x < column->minWidth)
 243                 cx = pos.x + column->minWidth;
 244             else if (column->maxWidth > 0
 245                 && column->width + ev.xmotion.x > column->maxWidth)
 246                 cx = pos.x + column->maxWidth;
 247             else
 248                 cx = offsX + ev.xmotion.x;
 249
 250             XDrawLine(dpy, w, gc, ox+20, 0, ox+20, h);
 251             XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 252             break;
 253
 254          case ButtonRelease:
 255             column->width = cx - pos.x;
 256             done = 1;
 257             break;
 258         }
 259     }
 260
 261     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 262     rearrangeHeader(table);
 263 }
 264
 265
 266
 267 WMTableView *WMCreateTableView(WMWidget *parent)
 268 {
 269     WMTableView *table = wmalloc(sizeof(WMTableView));
 270     WMScreen *scr = WMWidgetScreen(parent);
 271
 272     memset(table, 0, sizeof(WMTableView));
 273
 274     if (!tableClass) {
 275         tableClass = W_RegisterUserWidget();
 276     }
 277     table->widgetClass = tableClass;
 278
 279     table->view = W_CreateView(W_VIEW(parent));
 280     if (!table->view)
 281         goto error;
 282     table->view->self = table;
 283
 284     table->view->delegate = &viewDelegate;
 285
 286     table->headerHeight = 20;
 287
 288     table->scrollView = WMCreateScrollView(table);
 289     if (!table->scrollView)
 290         goto error;
 291     WMResizeWidget(table->scrollView, 10, 10);
 292     WMSetScrollViewHasVerticalScroller(table->scrollView, True);
 293     WMSetScrollViewHasHorizontalScroller(table->scrollView, True);
 294     {
 295         WMScroller *scroller;
 296         scroller = WMGetScrollViewHorizontalScroller(table->scrollView);
 297         WMAddNotificationObserver(scrollObserver, table,
 298                                   WMScrollerDidScrollNotification,
 299                                   scroller);
 300     }
 301     WMMoveWidget(table->scrollView, 1, 2+table->headerHeight);
 302     WMMapWidget(table->scrollView);
 303
 304     table->header = WMCreateFrame(table);
 305     WMMoveWidget(table->header, 22, 2);
 306     WMMapWidget(table->header);
 307     WMSetFrameRelief(table->header, WRFlat);
 308
 309     table->corner = WMCreateLabel(table);
 310     WMResizeWidget(table->corner, 20, table->headerHeight);
 311     WMMoveWidget(table->corner, 2, 2);
 312     WMMapWidget(table->corner);
 313     WMSetLabelRelief(table->corner, WRRaised);
 314     WMSetWidgetBackgroundColor(table->corner, scr->darkGray);
 315
 316
 317     table->tableView = W_CreateView(W_VIEW(parent));
 318     if (!table->tableView)
 319         goto error;
 320     table->tableView->self = table;
 321     W_ResizeView(table->tableView, 100, 1000);
 322     W_MapView(table->tableView);
 323
 324     table->tableView->flags.dontCompressExpose = 1;
 325
 326     table->gridColor = WMCreateNamedColor(scr, "#cccccc", False);
 327  /*   table->gridColor = WMGrayColor(scr);*/
 328
 329     {
 330         XGCValues gcv;
 331
 332         gcv.foreground = WMColorPixel(table->gridColor);
 333         gcv.dashes = 1;
 334         gcv.line_style = LineOnOffDash;
 335         table->gridGC = XCreateGC(WMScreenDisplay(scr), W_DRAWABLE(scr),
 336                                   GCForeground, &gcv);
 337     }
 338
 339     table->editingRow = -1;
 340     table->clickedRow = -1;
 341
 342     table->drawsGrid = 1;
 343     table->rowHeight = 16;
 344
 345     WMSetScrollViewLineScroll(table->scrollView, table->rowHeight);
 346
 347     table->tableWidth = 1;
 348
 349     table->columns = WMCreateArray(4);
 350     table->splitters = WMCreateArray(4);
 351
 352     table->selectedRows = WMCreateArray(16);
 353
 354     table->splitterCursor = XCreateFontCursor(WMScreenDisplay(scr),
 355                                               XC_sb_h_double_arrow);
 356
 357     table->canSelectRow = 1;
 358
 359     WMCreateEventHandler(table->view, ExposureMask|StructureNotifyMask,
 360                          handleEvents, table);
 361
 362     WMCreateEventHandler(table->tableView, ExposureMask|ButtonPressMask|
 363                          ButtonReleaseMask|ButtonMotionMask,
 364                          handleTableEvents, table);
 365
 366     WMSetScrollViewContentView(table->scrollView, table->tableView);
 367
 368     return table;
 369
 370  error:
 371     if (table->scrollView)
 372         WMDestroyWidget(table->scrollView);
 373     if (table->tableView)
 374         W_DestroyView(table->tableView);
 375     if (table->view)
 376         W_DestroyView(table->view);
 377     wfree(table);
 378     return NULL;
 379 }
 380
 381
 382 void WMAddTableViewColumn(WMTableView *table, WMTableColumn *column)
 383 {
 384     int width;
 385     int i;
 386     WMScreen *scr = WMWidgetScreen(table);
 387     int count;
 388
 389     column->table = table;
 390
 391     WMAddToArray(table->columns, column);
 392
 393     if (!column->titleW) {
 394         column->titleW = WMCreateLabel(table);
 395         WMSetLabelRelief(column->titleW, WRRaised);
 396         WMSetLabelFont(column->titleW, scr->boldFont);
 397         WMSetLabelTextColor(column->titleW, scr->white);
 398         WMSetWidgetBackgroundColor(column->titleW, scr->darkGray);
 399         WMSetLabelText(column->titleW, column->title);
 400         W_ReparentView(WMWidgetView(column->titleW),
 401                        WMWidgetView(table->header), 0, 0);
 402         if (W_VIEW_REALIZED(table->view))
 403             WMRealizeWidget(column->titleW);
 404         WMMapWidget(column->titleW);
 405     }
 406
 407     {
 408         WMView *splitter = W_CreateView(WMWidgetView(table->header));
 409
 410         W_SetViewBackgroundColor(splitter, WMWhiteColor(scr));
 411
 412         if (W_VIEW_REALIZED(table->view))
 413             W_RealizeView(splitter);
 414
 415         W_ResizeView(splitter, 2, table->headerHeight-1);
 416         W_MapView(splitter);
 417
 418         W_SetViewCursor(splitter, table->splitterCursor);
 419         WMCreateEventHandler(splitter, ButtonPressMask|ButtonReleaseMask,
 420                              splitterHandler, column);
 421
 422         WMAddToArray(table->splitters, splitter);
 423     }
 424
 425     rearrangeHeader(table);
 426 }
 427
 428
 429 void WMSetTableViewHeaderHeight(WMTableView *table, unsigned height)
 430 {
 431     table->headerHeight = height;
 432
 433     handleResize(NULL, table->view);
 434 }
 435
 436
 437 void WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate)
 438 {
 439     table->delegate = delegate;
 440 }
 441
 442
 443 void WMSetTableViewAction(WMTableView *table, WMAction *action, void *clientData)
 444 {
 445     table->action = action;
 446
 447     table->clientData = clientData;
 448 }
 449
 450
 451 void *WMGetTableViewClickedColumn(WMTableView *table)
 452 {
 453     return table->clickedColumn;
 454 }
 455
 456
 457 int WMGetTableViewClickedRow(WMTableView *table)
 458 {
 459     return table->clickedRow;
 460 }
 461
 462
 463 WMArray *WMGetTableViewSelectedRows(WMTableView *table)
 464 {
 465     return table->selectedRows;
 466 }
 467
 468
 469 WMView *WMGetTableViewDocumentView(WMTableView *table)
 470 {
 471     return table->tableView;
 472 }
 473
 474
 475 void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 476                              int row)
 477 {
 478     return (*table->delegate->valueForCell)(table->delegate, column, row);
 479 }
 480
 481
 482 void WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 483                                int row, void *data)
 484 {
 485     (*table->delegate->setValueForCell)(table->delegate, column, row, data);
 486 }
 487
 488
 489 WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
 490                               int row)
 491 {
 492     WMRect rect;
 493     int i;
 494
 495     rect.pos.x = 0;
 496     rect.pos.y = row * table->rowHeight;
 497     rect.size.height = table->rowHeight;
 498
 499     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 500         WMTableColumn *col;
 501         col = WMGetFromArray(table->columns, i);
 502
 503         if (col == column) {
 504             rect.size.width = col->width;
 505             break;
 506         }
 507
 508         rect.pos.x += col->width;
 509     }
 510     return rect;
 511 }
 512
 513
 514 void WMSetTableViewDataSource(WMTableView *table, void *source)
 515 {
 516     table->dataSource = source;
 517 }
 518
 519
 520 void *WMGetTableViewDataSource(WMTableView *table)
 521 {
 522     return table->dataSource;
 523 }
 524
 525
 526 void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 527 {
 528     W_SetViewBackgroundColor(table->tableView, color);
 529 }
 530
 531
 532 void WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 533 {
 534     WMReleaseColor(table->gridColor);
 535     table->gridColor = WMRetainColor(color);
 536     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC,
 537                    WMColorPixel(color));
 538 }
 539
 540
 541
 542 void WMSetTableViewRowHeight(WMTableView *table, int height)
 543 {
 544     table->rowHeight = height;
 545
 546     WMRedisplayWidget(table);
 547 }
 548
 549
 550 void WMScrollTableViewRowToVisible(WMTableView *table, int row)
 551 {
 552     WMScroller *scroller;
 553     WMRange range;
 554     WMRect rect;
 555     int newY, tmp;
 556
 557     rect = WMGetScrollViewVisibleRect(table->scrollView);
 558     range = rowsInRect(table, rect);
 559
 560     scroller = WMGetScrollViewVerticalScroller(table->scrollView);
 561
 562     if (row < range.position) {
 563         newY = row * table->rowHeight - rect.size.height / 2;
 564     } else if (row >= range.position + range.count) {
 565         newY = row * table->rowHeight - rect.size.height / 2;
 566     } else {
 567         return;
 568     }
 569     tmp = table->rows*table->rowHeight - rect.size.height;
 570     newY = WMAX(0, WMIN(newY, tmp));
 571     WMScrollViewScrollPoint(table->scrollView, rect.pos.x, newY);
 572 }
 573
 574
 575
 576 static void drawGrid(WMTableView *table, WMRect rect)
 577 {
 578     WMScreen *scr = WMWidgetScreen(table);
 579     Display *dpy = WMScreenDisplay(scr);
 580     int i;
 581     int y1, y2;
 582     int x1, x2;
 583     int xx;
 584     Drawable d = W_VIEW_DRAWABLE(table->tableView);
 585     GC gc = table->gridGC;
 586
 587 #if 0
 588     char dashl[1] = {1};
 589
 590     XSetDashes(dpy, gc, 0, dashl, 1);
 591
 592     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 593     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 594 #endif
 595     y1 = 0;
 596     y2 = W_VIEW_HEIGHT(table->tableView);
 597
 598     xx = 0;
 599     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 600         WMTableColumn *column;
 601
 602         if (xx >= rect.pos.x && xx <= rect.pos.x+rect.size.width) {
 603             XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 604         }
 605         column = WMGetFromArray(table->columns, i);
 606         xx += column->width;
 607     }
 608     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 609
 610
 611     x1 = rect.pos.x;
 612     x2 = WMIN(x1 + rect.size.width, xx);
 613
 614     if (x2 <= x1)
 615         return;
 616 #if 0
 617     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 618 #endif
 619
 620     y1 = rect.pos.y - rect.pos.y%table->rowHeight;
 621     y2 = y1 + rect.size.height + table->rowHeight;
 622
 623     for (i = y1; i <= y2; i += table->rowHeight) {
 624         XDrawLine(dpy, d, gc, x1, i, x2, i);
 625     }
 626 }
 627
 628
 629 static WMRange columnsInRect(WMTableView *table, WMRect rect)
 630 {
 631     WMTableColumn *column;
 632     int width;
 633     int i , j;
 634     int totalColumns = WMGetArrayItemCount(table->columns);
 635     WMRange range;
 636
 637     j = 0;
 638     width = 0;
 639     for (i = 0; i < totalColumns; i++) {
 640         column = WMGetFromArray(table->columns, i);
 641         if (j == 0) {
 642             if (width <= rect.pos.x && width + column->width > rect.pos.x) {
 643                 range.position = i;
 644                 j = 1;
 645             }
 646         } else {
 647             range.count++;
 648             if (width > rect.pos.x + rect.size.width) {
 649                 break;
 650             }
 651         }
 652         width += column->width;
 653     }
 654     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 655     return range;
 656 }
 657
 658
 659 static WMRange rowsInRect(WMTableView *table, WMRect rect)
 660 {
 661     WMRange range;
 662     int rh = table->rowHeight;
 663     int dif;
 664
 665     dif = rect.pos.y % rh;
 666
 667     range.position = WMAX(0, (rect.pos.y - dif) / rh);
 668     range.count = WMAX(1, WMIN((rect.size.height + dif) / rh, table->rows));
 669
 670     return range;
 671 }
 672
 673
 674 static void drawRow(WMTableView *table, int row, WMRect clipRect)
 675 {
 676     int i;
 677     WMRange cols = columnsInRect(table, clipRect);
 678     WMTableColumn *column;
 679
 680     for (i = cols.position; i < cols.position+cols.count; i++) {
 681         column = WMGetFromArray(table->columns, i);
 682
 683         wassertr(column->delegate && column->delegate->drawCell);
 684
 685         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 686             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 687         else
 688             (*column->delegate->drawCell)(column->delegate, column, row);
 689     }
 690 }
 691
 692
 693 static void drawFullRow(WMTableView *table, int row)
 694 {
 695     int i;
 696     WMTableColumn *column;
 697
 698     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 699         column = WMGetFromArray(table->columns, i);
 700
 701         wassertr(column->delegate && column->delegate->drawCell);
 702
 703         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 704             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 705         else
 706             (*column->delegate->drawCell)(column->delegate, column, row);
 707     }
 708 }
 709
 710
 711 static void setRowSelected(WMTableView *table, unsigned row, Bool flag)
 712 {
 713     int repaint = 0;
 714
 715     if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound) {
 716         if (!flag) {
 717             WMRemoveFromArray(table->selectedRows, (void*)row);
 718             repaint = 1;
 719         }
 720     } else {
 721         if (flag) {
 722             WMAddToArray(table->selectedRows, (void*)row);
 723             repaint = 1;
 724         }
 725     }
 726     if (repaint && row < table->rows) {
 727         drawFullRow(table, row);
 728     }
 729 }
 730
 731
 732 static void repaintTable(WMTableView *table, int x, int y,
 733                          int width, int height)
 734 {
 735     WMRect rect;
 736     WMRange rows;
 737     int i;
 738
 739     wassertr(table->delegate && table->delegate->numberOfRows);
 740     i = (*table->delegate->numberOfRows)(table->delegate, table);
 741
 742     if (i != table->rows) {
 743         table->rows = i;
 744         W_ResizeView(table->tableView, table->tableWidth,
 745                      table->rows * table->rowHeight + 1);
 746     }
 747
 748
 749     if (x >= table->tableWidth-1)
 750         return;
 751
 752     rect.pos = wmkpoint(x,y);
 753     rect.size = wmksize(width, height);
 754
 755     if (table->drawsGrid) {
 756         drawGrid(table, rect);
 757     }
 758
 759     rows = rowsInRect(table, rect);
 760     for (i = rows.position;
 761          i < WMIN(rows.position+rows.count + 1, table->rows);
 762          i++) {
 763         drawRow(table, i, rect);
 764     }
 765 }
 766
 767
 768 static void stopRowEdit(WMTableView *table, int row)
 769 {
 770     int i;
 771     WMTableColumn *column;
 772
 773     table->editingRow = -1;
 774     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 775         column = WMGetFromArray(table->columns, i);
 776
 777         if (column->delegate && column->delegate->endCellEdit)
 778             (*column->delegate->endCellEdit)(column->delegate, column, row);
 779     }
 780 }
 781
 782
 783
 784 void WMEditTableViewRow(WMTableView *table, int row)
 785 {
 786     int i;
 787     WMTableColumn *column;
 788
 789     if (table->editingRow >= 0) {
 790         stopRowEdit(table, table->editingRow);
 791     }
 792
 793     table->editingRow = row;
 794
 795     if (row < 0)
 796         return;
 797
 798     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 799         column = WMGetFromArray(table->columns, i);
 800
 801         if (column->delegate && column->delegate->beginCellEdit)
 802             (*column->delegate->beginCellEdit)(column->delegate, column, row);
 803     }
 804 }
 805
 806
 807 void WMSelectTableViewRow(WMTableView *table, int row)
 808 {
 809     if (table->clickedRow >= 0)
 810         setRowSelected(table, table->clickedRow, False);
 811
 812     if (row >= table->rows) {
 813         return;
 814     }
 815
 816     setRowSelected(table, row, True);
 817     table->clickedRow = row;
 818
 819     if (table->action)
 820         (*table->action)(table, table->clientData);
 821     WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
 822                            table, NULL);
 823 }
 824
 825
 826 void WMReloadTableView(WMTableView *table)
 827 {
 828     WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);
 829
 830     if (table->editingRow >= 0)
 831         stopRowEdit(table, table->editingRow);
 832
 833     /* when this is called, nothing in the table can be assumed to be
 834      * like the last time we accessed it (ie, rows might have disappeared) */
 835
 836     WMEmptyArray(table->selectedRows);
 837
 838     if (table->clickedRow >= 0) {
 839         table->clickedRow = -1;
 840
 841         if (table->action)
 842             (*table->action)(table, table->clientData);
 843         WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
 844                                table, NULL);
 845     }
 846
 847     repaintTable(table, 0, 0,
 848                  W_VIEW_WIDTH(table->tableView), rect.size.height);
 849 }
 850
 851
 852 void WMNoteTableViewNumberOfRowsChanged(WMTableView *table)
 853 {
 854     WMReloadTableView(table);
 855 }
 856
 857
 858 static void handleTableEvents(XEvent *event, void *data)
 859 {
 860     WMTableView *table = (WMTableView*)data;
 861     int row;
 862
 863     switch (event->type) {
 864      case ButtonPress:
 865         if (event->xbutton.button == Button1) {
 866             row = event->xbutton.y/table->rowHeight;
 867             if (row != table->clickedRow) {
 868                 setRowSelected(table, table->clickedRow, False);
 869                 setRowSelected(table, row, True);
 870                 table->clickedRow = row;
 871                 table->dragging = 1;
 872             }
 873         }
 874         break;
 875
 876      case MotionNotify:
 877         if (table->dragging && event->xmotion.y >= 0) {
 878             row = event->xmotion.y/table->rowHeight;
 879             if (table->clickedRow != row && row >= 0 && row < table->rows) {
 880                 setRowSelected(table, table->clickedRow, False);
 881                 setRowSelected(table, row, True);
 882                 table->clickedRow = row;
 883             }
 884         }
 885         break;
 886
 887      case ButtonRelease:
 888         if (event->xbutton.button == Button1) {
 889             if (table->action)
 890                 (*table->action)(table, table->clientData);
 891             WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
 892                                    table, NULL);
 893             table->dragging = 0;
 894         }
 895         break;
 896
 897      case Expose:
 898         repaintTable(table, event->xexpose.x, event->xexpose.y,
 899                      event->xexpose.width, event->xexpose.height);
 900         break;
 901     }
 902 }
 903
 904
 905 static void handleEvents(XEvent *event, void *data)
 906 {
 907     WMTableView *table = (WMTableView*)data;
 908     WMScreen *scr = WMWidgetScreen(table);
 909
 910     switch (event->type) {
 911      case Expose:
 912         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
 913                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
 914                      WRSunken);
 915
 916         if (event->xexpose.serial == 0) {
 917             WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);
 918
 919             repaintTable(table, rect.pos.x, rect.pos.y,
 920                          rect.size.width, rect.size.height);
 921         }
 922         break;
 923     }
 924 }
 925
 926
 927 static void handleResize(W_ViewDelegate *self, WMView *view)
 928 {
 929     int width;
 930     int height;
 931     WMTableView *table = view->self;
 932
 933     width = W_VIEW_WIDTH(view) - 2;
 934     height = W_VIEW_HEIGHT(view) - 3;
 935
 936     height -= table->headerHeight; /* table header */
 937
 938     if (table->corner)
 939         WMResizeWidget(table->corner, 20, table->headerHeight);
 940
 941     if (table->scrollView) {
 942         WMMoveWidget(table->scrollView, 1, table->headerHeight + 2);
 943         WMResizeWidget(table->scrollView, width, height);
 944     }
 945     if (table->header)
 946         WMResizeWidget(table->header, width - 21, table->headerHeight);
 947 }
 948
 949
 950 static void rearrangeHeader(WMTableView *table)
 951 {
 952     int width;
 953     int count;
 954     int i;
 955     WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);
 956
 957     width = 0;
 958
 959     count = WMGetArrayItemCount(table->columns);
 960     for (i = 0; i < count; i++) {
 961         WMTableColumn *column = WMGetFromArray(table->columns, i);
 962         WMView *splitter = WMGetFromArray(table->splitters, i);
 963
 964         WMMoveWidget(column->titleW, width, 0);
 965         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
 966
 967         width += column->width;
 968         W_MoveView(splitter, width-1, 0);
 969     }
 970
 971     wassertr(table->delegate && table->delegate->numberOfRows);
 972
 973     table->rows = table->delegate->numberOfRows(table->delegate, table);
 974
 975     W_ResizeView(table->tableView, width+1,
 976                  table->rows * table->rowHeight + 1);
 977
 978     table->tableWidth = width + 1;
 979 }