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