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