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 *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 WMView *WMGetTableViewDocumentView(WMTableView *table)
 437 {
 438     return table->tableView;
 439 }
 440
 441
 442 void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 443                              int row)
 444 {
 445     return (*table->delegate->valueForCell)(table->delegate, column, row);
 446 }
 447
 448
 449 void WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 450                                int row, void *data)
 451 {
 452     (*table->delegate->setValueForCell)(table->delegate, column, row, data);
 453 }
 454
 455
 456 WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
 457                               int row)
 458 {
 459     WMRect rect;
 460     int i;
 461
 462     rect.pos.x = 0;
 463     rect.pos.y = row * table->rowHeight;
 464     rect.size.height = table->rowHeight;
 465
 466     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 467         WMTableColumn *col;
 468         col = WMGetFromArray(table->columns, i);
 469
 470         if (col == column) {
 471             rect.size.width = col->width;
 472             break;
 473         }
 474
 475         rect.pos.x += col->width;
 476     }
 477     return rect;
 478 }
 479
 480
 481 void WMSetTableViewDataSource(WMTableView *table, void *source)
 482 {
 483     table->dataSource = source;
 484 }
 485
 486
 487 void *WMGetTableViewDataSource(WMTableView *table)
 488 {
 489     return table->dataSource;
 490 }
 491
 492
 493 void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 494 {
 495     W_SetViewBackgroundColor(table->tableView, color);
 496 }
 497
 498
 499 void WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 500 {
 501     WMReleaseColor(table->gridColor);
 502     table->gridColor = WMRetainColor(color);
 503     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC,
 504                    WMColorPixel(color));
 505 }
 506
 507
 508
 509 void WMSetTableViewRowHeight(WMTableView *table, int height)
 510 {
 511     table->rowHeight = height;
 512
 513     WMRedisplayWidget(table);
 514 }
 515
 516
 517 void WMScrollTableViewRowToVisible(WMTableView *table, int row)
 518 {
 519     WMScroller *scroller;
 520     WMRange range;
 521     WMRect rect;
 522     int newY, tmp;
 523
 524     rect = WMGetScrollViewVisibleRect(table->scrollView);
 525     range = rowsInRect(table, rect);
 526
 527     scroller = WMGetScrollViewVerticalScroller(table->scrollView);
 528
 529     if (row < range.position) {
 530         newY = row * table->rowHeight - rect.size.height / 2;
 531     } else if (row >= range.position + range.count) {
 532         newY = row * table->rowHeight - rect.size.height / 2;
 533     } else {
 534         return;
 535     }
 536     tmp = table->rows*table->rowHeight - rect.size.height;
 537     newY = WMAX(0, WMIN(newY, tmp));
 538     WMScrollViewScrollPoint(table->scrollView, rect.pos.x, newY);
 539 }
 540
 541
 542
 543 static void drawGrid(WMTableView *table, WMRect rect)
 544 {
 545     WMScreen *scr = WMWidgetScreen(table);
 546     Display *dpy = WMScreenDisplay(scr);
 547     int i;
 548     int y1, y2;
 549     int x1, x2;
 550     int xx;
 551     Drawable d = W_VIEW_DRAWABLE(table->tableView);
 552     GC gc = table->gridGC;
 553
 554 #if 0
 555     char dashl[1] = {1};
 556
 557     XSetDashes(dpy, gc, 0, dashl, 1);
 558
 559     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 560     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 561 #endif
 562     y1 = 0;
 563     y2 = W_VIEW_HEIGHT(table->tableView);
 564
 565     xx = 0;
 566     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 567         WMTableColumn *column;
 568
 569         if (xx >= rect.pos.x && xx <= rect.pos.x+rect.size.width) {
 570             XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 571         }
 572         column = WMGetFromArray(table->columns, i);
 573         xx += column->width;
 574     }
 575     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 576
 577
 578     x1 = rect.pos.x;
 579     x2 = WMIN(x1 + rect.size.width, xx);
 580
 581     if (x2 <= x1)
 582         return;
 583 #if 0
 584     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 585 #endif
 586
 587     y1 = rect.pos.y - rect.pos.y%table->rowHeight;
 588     y2 = y1 + rect.size.height + table->rowHeight;
 589
 590     for (i = y1; i <= y2; i += table->rowHeight) {
 591         XDrawLine(dpy, d, gc, x1, i, x2, i);
 592     }
 593 }
 594
 595
 596 static WMRange columnsInRect(WMTableView *table, WMRect rect)
 597 {
 598     WMTableColumn *column;
 599     int width;
 600     int i , j;
 601     int totalColumns = WMGetArrayItemCount(table->columns);
 602     WMRange range;
 603
 604     j = 0;
 605     width = 0;
 606     for (i = 0; i < totalColumns; i++) {
 607         column = WMGetFromArray(table->columns, i);
 608         if (j == 0) {
 609             if (width <= rect.pos.x && width + column->width > rect.pos.x) {
 610                 range.position = i;
 611                 j = 1;
 612             }
 613         } else {
 614             if (width > rect.pos.x + rect.size.width) {
 615                 range.count = i - range.position;
 616                 break;
 617             }
 618         }
 619         width += column->width;
 620     }
 621
 622     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 623
 624     return range;
 625 }
 626
 627
 628 static WMRange rowsInRect(WMTableView *table, WMRect rect)
 629 {
 630     WMRange range;
 631     int rh = table->rowHeight;
 632     int dif;
 633
 634     dif = rect.pos.y % rh;
 635
 636     range.position = WMAX(0, (rect.pos.y - dif) / rh);
 637     range.count = WMAX(1, WMIN((rect.size.height + dif) / rh, table->rows));
 638
 639     return range;
 640 }
 641
 642
 643 static void drawRow(WMTableView *table, int row, WMRect clipRect)
 644 {
 645     int i;
 646     WMRange cols = columnsInRect(table, clipRect);
 647     WMTableColumn *column;
 648
 649     for (i = cols.position; i < cols.position+cols.count; i++) {
 650         column = WMGetFromArray(table->columns, i);
 651
 652         wassertr(column->delegate && column->delegate->drawCell);
 653
 654         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 655             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 656         else
 657             (*column->delegate->drawCell)(column->delegate, column, row);
 658     }
 659 }
 660
 661
 662 static void drawFullRow(WMTableView *table, int row)
 663 {
 664     int i;
 665     WMTableColumn *column;
 666
 667     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 668         column = WMGetFromArray(table->columns, i);
 669
 670         wassertr(column->delegate && column->delegate->drawCell);
 671
 672         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 673             (*column->delegate->drawSelectedCell)(column->delegate, column, row);
 674         else
 675             (*column->delegate->drawCell)(column->delegate, column, row);
 676     }
 677 }
 678
 679
 680 static void setRowSelected(WMTableView *table, unsigned row, Bool flag)
 681 {
 682     int repaint = 0;
 683
 684
 685     if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound) {
 686         if (!flag) {
 687             WMRemoveFromArray(table->selectedRows, (void*)row);
 688             repaint = 1;
 689         }
 690     } else {
 691         if (flag) {
 692             WMAddToArray(table->selectedRows, (void*)row);
 693             repaint = 1;
 694         }
 695     }
 696
 697     if (repaint) {
 698         drawFullRow(table, row);
 699     }
 700 }
 701
 702
 703 static void repaintTable(WMTableView *table, int x, int y,
 704                          int width, int height)
 705 {
 706     WMRect rect;
 707     WMRange rows;
 708     int i;
 709
 710     wassertr(table->delegate && table->delegate->numberOfRows);
 711     i = (*table->delegate->numberOfRows)(table->delegate, table);
 712
 713     if (i != table->rows) {
 714         table->rows = i;
 715         W_ResizeView(table->tableView, table->tableWidth,
 716                      table->rows * table->rowHeight + 1);
 717     }
 718
 719
 720     rect.pos = wmkpoint(x,y);
 721     rect.size = wmksize(width, height);
 722
 723     if (table->drawsGrid) {
 724         drawGrid(table, rect);
 725     }
 726
 727     rows = rowsInRect(table, rect);
 728     for (i = rows.position;
 729          i < WMIN(rows.position+rows.count + 1, table->rows);
 730          i++) {
 731         drawRow(table, i, rect);
 732     }
 733 }
 734
 735
 736 static void stopRowEdit(WMTableView *table, int row)
 737 {
 738     int i;
 739     WMTableColumn *column;
 740
 741     table->editingRow = -1;
 742     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 743         column = WMGetFromArray(table->columns, i);
 744
 745         if (column->delegate && column->delegate->endCellEdit)
 746             (*column->delegate->endCellEdit)(column->delegate, column, row);
 747     }
 748 }
 749
 750
 751
 752 void WMEditTableViewRow(WMTableView *table, int row)
 753 {
 754     int i;
 755     WMTableColumn *column;
 756
 757     if (table->editingRow >= 0) {
 758         stopRowEdit(table, table->editingRow);
 759     }
 760
 761     table->editingRow = row;
 762     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 763         column = WMGetFromArray(table->columns, i);
 764
 765         if (column->delegate && column->delegate->beginCellEdit)
 766             (*column->delegate->beginCellEdit)(column->delegate, column, row);
 767     }
 768 }
 769
 770
 771 void WMSelectTableViewRow(WMTableView *table, int row)
 772 {
 773     if (table->clickedRow >= 0)
 774         setRowSelected(table, table->clickedRow, False);
 775
 776     if (row <= table->rows)
 777         return;
 778
 779     setRowSelected(table, row, True);
 780     table->clickedRow = row;
 781
 782     if (table->action)
 783         (*table->action)(table, table->clientData);
 784     WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
 785                            table, NULL);
 786 }
 787
 788
 789 void WMReloadTableView(WMTableView *table)
 790 {
 791     WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);
 792
 793     repaintTable(table, 0, 0,
 794                  W_VIEW_WIDTH(table->tableView), rect.size.height);
 795
 796     table->clickedRow = -1;
 797 }
 798
 799
 800 void WMNoteTableViewNumberOfRowsChanged(WMTableView *table)
 801 {
 802     WMReloadTableView(table);
 803 }
 804
 805
 806 static void handleTableEvents(XEvent *event, void *data)
 807 {
 808     WMTableView *table = (WMTableView*)data;
 809     int row;
 810
 811     switch (event->type) {
 812      case ButtonPress:
 813         if (event->xbutton.button == Button1) {
 814             row = event->xbutton.y/table->rowHeight;
 815             if (row != table->clickedRow) {
 816                 setRowSelected(table, table->clickedRow, False);
 817                 setRowSelected(table, row, True);
 818                 table->clickedRow = row;
 819                 table->dragging = 1;
 820             }
 821         }
 822         break;
 823
 824      case MotionNotify:
 825         if (table->dragging && event->xmotion.y >= 0) {
 826             row = event->xmotion.y/table->rowHeight;
 827             if (table->clickedRow != row && row >= 0) {
 828                 setRowSelected(table, table->clickedRow, False);
 829                 setRowSelected(table, row, True);
 830                 table->clickedRow = row;
 831             }
 832         }
 833         break;
 834
 835      case ButtonRelease:
 836         if (event->xbutton.button == Button1) {
 837             if (table->action)
 838                 (*table->action)(table, table->clientData);
 839             WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
 840                                    table, NULL);
 841             table->dragging = 0;
 842         }
 843         break;
 844
 845      case Expose:
 846         repaintTable(table, event->xexpose.x, event->xexpose.y,
 847                      event->xexpose.width, event->xexpose.height);
 848         break;
 849     }
 850 }
 851
 852
 853 static void handleEvents(XEvent *event, void *data)
 854 {
 855     WMTableView *table = (WMTableView*)data;
 856     WMScreen *scr = WMWidgetScreen(table);
 857
 858     switch (event->type) {
 859      case Expose:
 860         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
 861                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
 862                      WRSunken);
 863
 864         if (event->xexpose.serial == 0) {
 865             WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);
 866
 867             repaintTable(table, rect.pos.x, rect.pos.y,
 868                          rect.size.width, rect.size.height);
 869         }
 870         break;
 871     }
 872 }
 873
 874
 875 static void handleResize(W_ViewDelegate *self, WMView *view)
 876 {
 877     int width;
 878     int height;
 879     WMTableView *table = view->self;
 880
 881     width = W_VIEW_WIDTH(view) - 2;
 882     height = W_VIEW_HEIGHT(view) - 3;
 883
 884     height -= table->headerHeight; /* table header */
 885
 886     if (table->corner)
 887         WMResizeWidget(table->corner, 20, table->headerHeight);
 888
 889     if (table->scrollView) {
 890         WMMoveWidget(table->scrollView, 1, table->headerHeight + 2);
 891         WMResizeWidget(table->scrollView, width, height);
 892     }
 893     if (table->header)
 894         WMResizeWidget(table->header, width - 21, table->headerHeight);
 895 }
 896
 897
 898 static void rearrangeHeader(WMTableView *table)
 899 {
 900     int width;
 901     int count;
 902     int i;
 903     width = 0;
 904
 905     count = WMGetArrayItemCount(table->columns);
 906     for (i = 0; i < count; i++) {
 907         WMTableColumn *column = WMGetFromArray(table->columns, i);
 908
 909         WMMoveWidget(column->titleW, width, 0);
 910         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
 911
 912         if (i > 0) {
 913             WMView *splitter = WMGetFromArray(table->splitters, i-1);
 914
 915             W_MoveView(splitter, width-1, 0);
 916         }
 917         width += column->width;
 918     }
 919
 920     wassertr(table->delegate && table->delegate->numberOfRows);
 921
 922     table->rows = table->delegate->numberOfRows(table->delegate, table);
 923
 924     W_ResizeView(table->tableView, width+1,
 925                  table->rows * table->rowHeight + 1);
 926
 927     table->tableWidth = width + 1;
 928 }