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