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==0) ? 0 : 1);
 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     WMScroller *hscroll;
 129     WMScroller *vscroll;
 130     WMView *tableView;
 131
 132     WMPixmap *viewBuffer;
 133
 134     WMArray *columns;
 135     WMArray *splitters;
 136
 137     WMArray *selectedRows;
 138
 139     int tableWidth;
 140
 141     int rows;
 142
 143     WMColor *backColor;
 144
 145     GC gridGC;
 146     WMColor *gridColor;
 147
 148     Cursor splitterCursor;
 149
 150     void *dataSource;
 151
 152     WMTableViewDelegate *delegate;
 153
 154     WMAction *action;
 155     void *clientData;
 156
 157     void *clickedColumn;
 158     int clickedRow;
 159
 160     int editingRow;
 161
 162     unsigned headerHeight;
 163
 164     unsigned rowHeight;
 165
 166     unsigned dragging:1;
 167     unsigned drawsGrid:1;
 168     unsigned canSelectRow:1;
 169     unsigned canSelectMultiRows:1;
 170     unsigned canDeselectRow:1;
 171 };
 172
 173 static W_Class tableClass = 0;
 174
 175
 176 static W_ViewDelegate viewDelegate = {
 177     NULL,
 178         NULL,
 179         handleResize,
 180         NULL,
 181         NULL
 182 };
 183
 184
 185
 186
 187
 188 static void handleEvents(XEvent *event, void *data);
 189 static void handleTableEvents(XEvent *event, void *data);
 190 static void repaintTable(WMTableView *table);
 191
 192 static WMSize getTotalSize(WMTableView *table)
 193 {
 194     WMSize size;
 195     int i;
 196
 197     /* get width from columns */
 198     size.width = 0;
 199     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 200         WMTableColumn *column;
 201
 202         column = WMGetFromArray(table->columns, i);
 203
 204         size.width += column->width;
 205     }
 206
 207     /* get height from rows */
 208     size.height = table->rows * table->rowHeight;
 209
 210     return size;
 211 }
 212
 213
 214 static WMRect getVisibleRect(WMTableView *table)
 215 {
 216     WMSize size = getTotalSize(table);
 217     WMRect rect;
 218
 219     rect.size.height = size.height * WMGetScrollerKnobProportion(table->vscroll);
 220     rect.size.width = size.width * WMGetScrollerKnobProportion(table->hscroll);
 221
 222     rect.pos.x = (size.width - rect.size.width) * WMGetScrollerValue(table->hscroll);
 223     rect.pos.y = (size.height - rect.size.height) * WMGetScrollerValue(table->vscroll);
 224
 225     return rect;
 226 }
 227
 228
 229 static void scrollToPoint(WMTableView *table, int x, int y)
 230 {
 231     WMSize size = getTotalSize(table);
 232     int i;
 233     float value, prop;
 234
 235     if (size.width > W_VIEW_WIDTH(table->tableView)) {
 236         prop = (float)W_VIEW_WIDTH(table->tableView) / (float)size.width;
 237         value = (float)x / (float)(size.width - W_VIEW_WIDTH(table->tableView));
 238     } else {
 239         prop = 1.0;
 240         value = 0.0;
 241     }
 242     WMSetScrollerParameters(table->hscroll, value, prop);
 243
 244
 245     if (size.height > W_VIEW_HEIGHT(table->tableView)) {
 246         prop = (float)W_VIEW_HEIGHT(table->tableView) / (float)size.height;
 247         value = (float)y / (float)(size.height - W_VIEW_HEIGHT(table->tableView));
 248     } else {
 249         prop = 1.0;
 250         value = 0.0;
 251     }
 252
 253     WMSetScrollerParameters(table->vscroll, value, prop);
 254
 255
 256
 257     if (table->editingRow >= 0) {
 258         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 259             WMTableColumn *column;
 260
 261             column = WMGetFromArray(table->columns, i);
 262
 263             if (column->delegate && column->delegate->beginCellEdit)
 264                 (*column->delegate->beginCellEdit)(column->delegate, column,
 265                                                    table->editingRow);
 266         }
 267     }
 268
 269     repaintTable(table);
 270 }
 271
 272
 273 static void adjustScrollers(WMTableView *table)
 274 {
 275     WMSize size = getTotalSize(table);
 276     WMSize vsize = WMGetViewSize(table->tableView);
 277     float prop, value;
 278     float oprop, ovalue;
 279
 280     if (size.width <= vsize.width) {
 281         value = 0.0;
 282         prop = 1.0;
 283     } else {
 284         oprop = WMGetScrollerKnobProportion(table->hscroll);
 285         if (oprop == 0.0)
 286             oprop = 1.0;
 287         ovalue = WMGetScrollerValue(table->hscroll);
 288
 289         prop = (float)vsize.width/(float)size.width;
 290         value = prop*ovalue / oprop;
 291     }
 292     WMSetScrollerParameters(table->hscroll, value, prop);
 293
 294     if (size.height <= vsize.height) {
 295         value = 0.0;
 296         prop = 1.0;
 297     } else {
 298         oprop = WMGetScrollerKnobProportion(table->vscroll);
 299         oprop = WMGetScrollerKnobProportion(table->hscroll);
 300         if (oprop == 0.0)
 301             oprop = 1.0;
 302         ovalue = WMGetScrollerValue(table->vscroll);
 303
 304         prop = (float)vsize.height/(float)size.height;
 305         value = prop*ovalue / oprop;
 306     }
 307     WMSetScrollerParameters(table->vscroll, value, prop);
 308 }
 309
 310
 311 static void doScroll(WMWidget *self, void *data)
 312 {
 313     WMTableView *table = (WMTableView*)data;
 314     float value;
 315     float vpsize;
 316     float size;
 317     WMSize ts = getTotalSize(table);
 318
 319     value = WMGetScrollerValue(self);
 320
 321     if (table->hscroll == (WMScroller *)self) {
 322         vpsize = W_VIEW_WIDTH(table->tableView);
 323         size = ts.width;
 324     } else {
 325         vpsize = W_VIEW_HEIGHT(table->tableView);
 326         size = ts.height;
 327     }
 328
 329     switch (WMGetScrollerHitPart(self)) {
 330      case WSDecrementWheel:
 331      case WSDecrementLine:
 332         value -= (float)table->rowHeight / size;
 333         if (value < 0)
 334             value = 0.0;
 335         WMSetScrollerParameters(self, value,
 336                                 WMGetScrollerKnobProportion(self));
 337         repaintTable(table);
 338         break;
 339
 340      case WSIncrementWheel:
 341      case WSIncrementLine:
 342         value += (float)table->rowHeight / size;
 343         if (value > 1.0)
 344             value = 1.0;
 345         WMSetScrollerParameters(self, value,
 346                                 WMGetScrollerKnobProportion(self));
 347         repaintTable(table);
 348         break;
 349
 350      case WSKnob:
 351         repaintTable(table);
 352         break;
 353
 354      case WSDecrementPage:
 355         value -= vpsize / size;
 356         if (value < 0.0)
 357             value = 0.0;
 358         WMSetScrollerParameters(self, value,
 359                                 WMGetScrollerKnobProportion(self));
 360         repaintTable(table);
 361         break;
 362
 363      case WSIncrementPage:
 364         value += vpsize / size;
 365         if (value > 1.0)
 366             value = 1.0;
 367         WMSetScrollerParameters(self, value,
 368                                 WMGetScrollerKnobProportion(self));
 369         repaintTable(table);
 370         break;
 371
 372
 373      case WSNoPart:
 374      case WSKnobSlot:
 375         break;
 376     }
 377
 378     if (table->editingRow >= 0) {
 379         int i;
 380         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 381             WMTableColumn *column;
 382
 383             column = WMGetFromArray(table->columns, i);
 384
 385             if (column->delegate && column->delegate->beginCellEdit)
 386                 (*column->delegate->beginCellEdit)(column->delegate, column,
 387                                                    table->editingRow);
 388         }
 389     }
 390
 391
 392     if (table->hscroll == self) {
 393         int x = 0;
 394         int i;
 395         WMRect rect = getVisibleRect(table);
 396
 397         for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 398             WMTableColumn *column;
 399             WMView *splitter;
 400
 401             column = WMGetFromArray(table->columns, i);
 402
 403             WMMoveWidget(column->titleW, x - rect.pos.x, 0);
 404
 405             x += W_VIEW_WIDTH(WMWidgetView(column->titleW)) + 1;
 406
 407             splitter = WMGetFromArray(table->splitters, i);
 408             W_MoveView(splitter, x - rect.pos.x - 1, 0);
 409         }
 410     }
 411 }
 412
 413
 414 static void
 415 splitterHandler(XEvent *event, void *data)
 416 {
 417     WMTableColumn *column = (WMTableColumn*)data;
 418     WMTableView *table = column->table;
 419     int done = 0;
 420     int cx, ox, offsX;
 421     WMPoint pos;
 422     WMScreen *scr = WMWidgetScreen(table);
 423     GC gc = scr->ixorGC;
 424     Display *dpy = WMScreenDisplay(scr);
 425     int h = WMWidgetHeight(table) - 22;
 426     Window w = WMViewXID(table->view);
 427
 428     pos = WMGetViewPosition(WMWidgetView(column->titleW));
 429
 430     offsX = pos.x + column->width;
 431
 432     ox = cx = offsX;
 433
 434     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 435
 436     while (!done) {
 437         XEvent ev;
 438
 439         WMMaskEvent(dpy, ButtonMotionMask|ButtonReleaseMask, &ev);
 440
 441         switch (ev.type) {
 442          case MotionNotify:
 443             ox = cx;
 444
 445             if (column->width + ev.xmotion.x < column->minWidth)
 446                 cx = pos.x + column->minWidth;
 447             else if (column->maxWidth > 0
 448                 && column->width + ev.xmotion.x > column->maxWidth)
 449                 cx = pos.x + column->maxWidth;
 450             else
 451                 cx = offsX + ev.xmotion.x;
 452
 453             XDrawLine(dpy, w, gc, ox+20, 0, ox+20, h);
 454             XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 455             break;
 456
 457          case ButtonRelease:
 458             column->width = cx - pos.x;
 459             done = 1;
 460             break;
 461         }
 462     }
 463
 464     XDrawLine(dpy, w, gc, cx+20, 0, cx+20, h);
 465     rearrangeHeader(table);
 466     repaintTable(table);
 467 }
 468
 469
 470 static void realizeTable(void *data, WMNotification *notif)
 471 {
 472     repaintTable(data);
 473 }
 474
 475
 476 WMTableView *WMCreateTableView(WMWidget *parent)
 477 {
 478     WMTableView *table = wmalloc(sizeof(WMTableView));
 479     WMScreen *scr = WMWidgetScreen(parent);
 480
 481     memset(table, 0, sizeof(WMTableView));
 482
 483     if (!tableClass) {
 484         tableClass = W_RegisterUserWidget();
 485     }
 486     table->widgetClass = tableClass;
 487
 488     table->view = W_CreateView(W_VIEW(parent));
 489     if (!table->view)
 490         goto error;
 491     table->view->self = table;
 492
 493     table->view->delegate = &viewDelegate;
 494
 495     table->headerHeight = 20;
 496
 497     table->hscroll = WMCreateScroller(table);
 498     WMSetScrollerAction(table->hscroll, doScroll, table);
 499     WMMoveWidget(table->hscroll, 1, 2+table->headerHeight);
 500     WMMapWidget(table->hscroll);
 501
 502     table->vscroll = WMCreateScroller(table);
 503     WMSetScrollerArrowsPosition(table->vscroll, WSAMaxEnd);
 504     WMSetScrollerAction(table->vscroll, doScroll, table);
 505     WMMoveWidget(table->vscroll, 1, 2+table->headerHeight);
 506     WMMapWidget(table->vscroll);
 507
 508
 509     table->header = WMCreateFrame(table);
 510     WMMoveWidget(table->header, 22, 2);
 511     WMMapWidget(table->header);
 512     WMSetFrameRelief(table->header, WRFlat);
 513
 514     table->corner = WMCreateLabel(table);
 515     WMResizeWidget(table->corner, 20, table->headerHeight);
 516     WMMoveWidget(table->corner, 2, 2);
 517     WMMapWidget(table->corner);
 518     WMSetLabelRelief(table->corner, WRRaised);
 519     WMSetWidgetBackgroundColor(table->corner, scr->darkGray);
 520
 521
 522     table->tableView = W_CreateView(table->view);
 523     if (!table->tableView)
 524         goto error;
 525     table->tableView->self = table;
 526     W_MapView(table->tableView);
 527
 528     WMAddNotificationObserver(realizeTable, table, WMViewRealizedNotification,
 529                               table->tableView);
 530
 531     table->tableView->flags.dontCompressExpose = 1;
 532
 533     table->gridColor = WMCreateNamedColor(scr, "#cccccc", False);
 534  /*   table->gridColor = WMGrayColor(scr);*/
 535
 536     {
 537         XGCValues gcv;
 538
 539         table->backColor = WMWhiteColor(scr);
 540
 541         gcv.foreground = WMColorPixel(table->gridColor);
 542         gcv.dashes = 1;
 543         gcv.line_style = LineOnOffDash;
 544         table->gridGC = XCreateGC(WMScreenDisplay(scr), W_DRAWABLE(scr),
 545                                   GCForeground, &gcv);
 546     }
 547
 548     table->editingRow = -1;
 549     table->clickedRow = -1;
 550
 551     table->drawsGrid = 1;
 552     table->rowHeight = 16;
 553
 554     table->tableWidth = 1;
 555
 556     table->columns = WMCreateArray(4);
 557     table->splitters = WMCreateArray(4);
 558
 559     table->selectedRows = WMCreateArray(16);
 560
 561     table->splitterCursor = XCreateFontCursor(WMScreenDisplay(scr),
 562                                               XC_sb_h_double_arrow);
 563
 564     table->canSelectRow = 1;
 565
 566     WMCreateEventHandler(table->view, ExposureMask|StructureNotifyMask,
 567                          handleEvents, table);
 568
 569     WMCreateEventHandler(table->tableView, ExposureMask|ButtonPressMask|
 570                          ButtonReleaseMask|ButtonMotionMask,
 571                          handleTableEvents, table);
 572
 573     WMResizeWidget(table, 50, 50);
 574
 575     return table;
 576
 577  error:
 578     if (table->tableView)
 579         W_DestroyView(table->tableView);
 580     if (table->view)
 581         W_DestroyView(table->view);
 582     wfree(table);
 583     return NULL;
 584 }
 585
 586
 587 void WMAddTableViewColumn(WMTableView *table, WMTableColumn *column)
 588 {
 589     WMScreen *scr = WMWidgetScreen(table);
 590
 591     column->table = table;
 592
 593     WMAddToArray(table->columns, column);
 594
 595     if (!column->titleW) {
 596         column->titleW = WMCreateLabel(table);
 597         WMSetLabelRelief(column->titleW, WRRaised);
 598         WMSetLabelFont(column->titleW, scr->boldFont);
 599         WMSetLabelTextColor(column->titleW, scr->white);
 600         WMSetWidgetBackgroundColor(column->titleW, scr->darkGray);
 601         WMSetLabelText(column->titleW, column->title);
 602         W_ReparentView(WMWidgetView(column->titleW),
 603                        WMWidgetView(table->header), 0, 0);
 604         if (W_VIEW_REALIZED(table->view))
 605             WMRealizeWidget(column->titleW);
 606         WMMapWidget(column->titleW);
 607     }
 608
 609     {
 610         WMView *splitter = W_CreateView(WMWidgetView(table->header));
 611
 612         W_SetViewBackgroundColor(splitter, WMWhiteColor(scr));
 613
 614         if (W_VIEW_REALIZED(table->view))
 615             W_RealizeView(splitter);
 616
 617         W_ResizeView(splitter, 2, table->headerHeight);
 618         W_MapView(splitter);
 619
 620         W_SetViewCursor(splitter, table->splitterCursor);
 621         WMCreateEventHandler(splitter, ButtonPressMask|ButtonReleaseMask,
 622                              splitterHandler, column);
 623
 624         WMAddToArray(table->splitters, splitter);
 625     }
 626
 627     rearrangeHeader(table);
 628 }
 629
 630
 631 void WMSetTableViewHeaderHeight(WMTableView *table, unsigned height)
 632 {
 633     table->headerHeight = height;
 634
 635     handleResize(NULL, table->view);
 636 }
 637
 638
 639 void WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate)
 640 {
 641     table->delegate = delegate;
 642 }
 643
 644
 645 void WMSetTableViewAction(WMTableView *table, WMAction *action, void *clientData)
 646 {
 647     table->action = action;
 648
 649     table->clientData = clientData;
 650 }
 651
 652
 653 void *WMGetTableViewClickedColumn(WMTableView *table)
 654 {
 655     return table->clickedColumn;
 656 }
 657
 658
 659 int WMGetTableViewClickedRow(WMTableView *table)
 660 {
 661     return table->clickedRow;
 662 }
 663
 664
 665 WMArray *WMGetTableViewSelectedRows(WMTableView *table)
 666 {
 667     return table->selectedRows;
 668 }
 669
 670
 671 WMView *WMGetTableViewDocumentView(WMTableView *table)
 672 {
 673     return table->tableView;
 674 }
 675
 676
 677 void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 678                              int row)
 679 {
 680     return (*table->delegate->valueForCell)(table->delegate, column, row);
 681 }
 682
 683
 684 void WMSetTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 685                                int row, void *data)
 686 {
 687     (*table->delegate->setValueForCell)(table->delegate, column, row, data);
 688 }
 689
 690
 691 WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
 692                               int row)
 693 {
 694     WMRect rect;
 695     int i;
 696
 697     rect.pos.x = 0;
 698     rect.pos.y = row * table->rowHeight;
 699     rect.size.height = table->rowHeight;
 700
 701     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 702         WMTableColumn *col;
 703         col = WMGetFromArray(table->columns, i);
 704
 705         if (col == column) {
 706             rect.size.width = col->width;
 707             break;
 708         }
 709
 710         rect.pos.x += col->width;
 711     }
 712
 713     {
 714         WMRect r = getVisibleRect(table);
 715
 716         rect.pos.y -= r.pos.y;
 717         rect.pos.x -= r.pos.x;
 718     }
 719
 720     return rect;
 721 }
 722
 723
 724 void WMSetTableViewDataSource(WMTableView *table, void *source)
 725 {
 726     table->dataSource = source;
 727 }
 728
 729
 730 void *WMGetTableViewDataSource(WMTableView *table)
 731 {
 732     return table->dataSource;
 733 }
 734
 735
 736 void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 737 {
 738     W_SetViewBackgroundColor(table->tableView, color);
 739
 740     if (table->backColor)
 741         WMReleaseColor(table->backColor);
 742
 743     table->backColor = WMRetainColor(color);
 744
 745     repaintTable(table);
 746 }
 747
 748
 749 void WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 750 {
 751     WMReleaseColor(table->gridColor);
 752     table->gridColor = WMRetainColor(color);
 753     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC,
 754                    WMColorPixel(color));
 755     repaintTable(table);
 756 }
 757
 758
 759
 760 void WMSetTableViewRowHeight(WMTableView *table, int height)
 761 {
 762     table->rowHeight = height;
 763
 764     repaintTable(table);
 765 }
 766
 767
 768 void WMScrollTableViewRowToVisible(WMTableView *table, int row)
 769 {
 770     WMScroller *scroller;
 771     WMRange range;
 772     WMRect rect;
 773     int newY, tmp;
 774
 775     rect = getVisibleRect(table);
 776     range = rowsInRect(table, rect);
 777
 778     scroller = table->vscroll;
 779
 780     if (row < range.position) {
 781         newY = row * table->rowHeight - rect.size.height / 2;
 782     } else if (row >= range.position + range.count) {
 783         newY = row * table->rowHeight - rect.size.height / 2;
 784     } else {
 785         return;
 786     }
 787     tmp = table->rows*table->rowHeight - rect.size.height;
 788     newY = WMAX(0, WMIN(newY, tmp));
 789
 790     scrollToPoint(table, rect.pos.x, newY);
 791 }
 792
 793
 794
 795 static void drawGrid(WMTableView *table, WMRect rect)
 796 {
 797     WMScreen *scr = WMWidgetScreen(table);
 798     Display *dpy = WMScreenDisplay(scr);
 799     int i;
 800     int y1, y2;
 801     int x1, x2;
 802     int xx;
 803     Drawable d = WMGetPixmapXID(table->viewBuffer);
 804     GC gc = table->gridGC;
 805
 806 #if 0
 807     char dashl[1] = {1};
 808
 809     XSetDashes(dpy, gc, 0, dashl, 1);
 810
 811     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 812     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 813 #endif
 814     y1 = 0;
 815     y2 = W_VIEW_HEIGHT(table->tableView);
 816
 817     xx = -rect.pos.x;
 818     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 819         WMTableColumn *column;
 820
 821         XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 822
 823         column = WMGetFromArray(table->columns, i);
 824         xx += column->width;
 825     }
 826     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 827
 828     x1 = 0;
 829     x2 = rect.size.width;
 830
 831     if (x2 <= x1)
 832         return;
 833 #if 0
 834     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 835 #endif
 836
 837     y1 = -rect.pos.y%table->rowHeight;
 838     y2 = y1 + rect.size.height + table->rowHeight;
 839
 840     for (i = y1; i <= y2; i += table->rowHeight) {
 841         XDrawLine(dpy, d, gc, x1, i, x2, i);
 842     }
 843 }
 844
 845
 846 static WMRange columnsInRect(WMTableView *table, WMRect rect)
 847 {
 848     WMTableColumn *column;
 849     int width;
 850     int i , j;
 851     int totalColumns = WMGetArrayItemCount(table->columns);
 852     WMRange range;
 853
 854     j = 0;
 855     width = 0;
 856     for (i = 0; i < totalColumns; i++) {
 857         column = WMGetFromArray(table->columns, i);
 858         if (j == 0) {
 859             if (width <= rect.pos.x && width + column->width > rect.pos.x) {
 860                 range.position = i;
 861                 j = 1;
 862             }
 863         } else {
 864             range.count++;
 865             if (width > rect.pos.x + rect.size.width) {
 866                 break;
 867             }
 868         }
 869         width += column->width;
 870     }
 871     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 872     return range;
 873 }
 874
 875
 876 static WMRange rowsInRect(WMTableView *table, WMRect rect)
 877 {
 878     WMRange range;
 879     int rh = table->rowHeight;
 880     int dif;
 881
 882     dif = rect.pos.y % rh;
 883
 884     range.position = WMAX(0, (rect.pos.y - dif) / rh);
 885     range.count = WMAX(1, WMIN((rect.size.height + dif) / rh, table->rows));
 886
 887     return range;
 888 }
 889
 890
 891 static void drawRow(WMTableView *table, int row, WMRect clipRect)
 892 {
 893     int i;
 894     WMRange cols = columnsInRect(table, clipRect);
 895     WMTableColumn *column;
 896     Drawable d = WMGetPixmapXID(table->viewBuffer);
 897
 898     for (i = cols.position; i < cols.position+cols.count; i++) {
 899         column = WMGetFromArray(table->columns, i);
 900
 901         if (!column->delegate || !column->delegate->drawCell)
 902             continue;
 903
 904         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 905             (*column->delegate->drawSelectedCell)(column->delegate, column, row, d);
 906         else
 907             (*column->delegate->drawCell)(column->delegate, column, row, d);
 908     }
 909 }
 910
 911
 912 #if 0
 913 static void drawFullRow(WMTableView *table, int row)
 914 {
 915     int i;
 916     WMTableColumn *column;
 917     Drawable d = WMGetPixmapXID(table->viewBuffer);
 918
 919     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 920         column = WMGetFromArray(table->columns, i);
 921
 922         if (!column->delegate || !column->delegate->drawCell)
 923             continue;
 924
 925         if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound)
 926             (*column->delegate->drawSelectedCell)(column->delegate, column, row, d);
 927         else
 928             (*column->delegate->drawCell)(column->delegate, column, row, d);
 929     }
 930 }
 931 #endif
 932
 933
 934 static void setRowSelected(WMTableView *table, unsigned row, Bool flag)
 935 {
 936     int repaint = 0;
 937
 938     if (WMFindInArray(table->selectedRows, NULL, (void*)row) != WANotFound) {
 939         if (!flag) {
 940             WMRemoveFromArray(table->selectedRows, (void*)row);
 941             repaint = 1;
 942         }
 943     } else {
 944         if (flag) {
 945             WMAddToArray(table->selectedRows, (void*)row);
 946             repaint = 1;
 947         }
 948     }
 949     if (repaint && row < table->rows) {
 950         /*drawFullRow(table, row);*/
 951         repaintTable(table);
 952     }
 953 }
 954
 955
 956 static void repaintTable(WMTableView *table)
 957 {
 958     WMRect rect;
 959     WMRange rows;
 960     WMScreen *scr = WMWidgetScreen(table);
 961     int i;
 962
 963     if (!table->delegate || !W_VIEW_REALIZED(table->view))
 964         return;
 965
 966     wassertr(table->delegate->numberOfRows);
 967
 968     if (!table->viewBuffer) {
 969         table->viewBuffer = WMCreatePixmap(scr,
 970                                            W_VIEW_WIDTH(table->tableView),
 971                                            W_VIEW_HEIGHT(table->tableView),
 972                                            WMScreenDepth(scr), 0);
 973     }
 974
 975     XFillRectangle(scr->display,
 976                    WMGetPixmapXID(table->viewBuffer),
 977                    WMColorGC(table->backColor), 0, 0,
 978                    W_VIEW_WIDTH(table->tableView),
 979                    W_VIEW_HEIGHT(table->tableView));
 980
 981     rect = getVisibleRect(table);
 982
 983     if (table->drawsGrid) {
 984         drawGrid(table, rect);
 985     }
 986
 987     rows = rowsInRect(table, rect);
 988     for (i = rows.position;
 989          i < WMIN(rows.position+rows.count + 1, table->rows);
 990          i++) {
 991         drawRow(table, i, rect);
 992     }
 993
 994     XSetWindowBackgroundPixmap(scr->display, table->tableView->window,
 995                                WMGetPixmapXID(table->viewBuffer));
 996     XClearWindow(scr->display, table->tableView->window);
 997 }
 998
 999
1000 static void stopRowEdit(WMTableView *table, int row)
1001 {
1002     int i;
1003     WMTableColumn *column;
1004
1005     table->editingRow = -1;
1006     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
1007         column = WMGetFromArray(table->columns, i);
1008
1009         if (column->delegate && column->delegate->endCellEdit)
1010             (*column->delegate->endCellEdit)(column->delegate, column, row);
1011     }
1012 }
1013
1014
1015
1016 void WMEditTableViewRow(WMTableView *table, int row)
1017 {
1018     int i;
1019     WMTableColumn *column;
1020
1021     if (table->editingRow >= 0) {
1022         stopRowEdit(table, table->editingRow);
1023     }
1024
1025     table->editingRow = row;
1026
1027     if (row < 0)
1028         return;
1029
1030     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
1031         column = WMGetFromArray(table->columns, i);
1032
1033         if (column->delegate && column->delegate->beginCellEdit)
1034             (*column->delegate->beginCellEdit)(column->delegate, column, row);
1035     }
1036 }
1037
1038
1039 void WMSelectTableViewRow(WMTableView *table, int row)
1040 {
1041     if (table->clickedRow >= 0)
1042         setRowSelected(table, table->clickedRow, False);
1043
1044     if (row >= table->rows) {
1045         return;
1046     }
1047
1048     setRowSelected(table, row, True);
1049     table->clickedRow = row;
1050
1051     if (table->action)
1052         (*table->action)(table, table->clientData);
1053     WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1054                            table, NULL);
1055 }
1056
1057
1058 void WMReloadTableView(WMTableView *table)
1059 {
1060     if (table->editingRow >= 0)
1061         stopRowEdit(table, table->editingRow);
1062
1063     /* when this is called, nothing in the table can be assumed to be
1064      * like the last time we accessed it (ie, rows might have disappeared) */
1065
1066     WMEmptyArray(table->selectedRows);
1067
1068     if (table->clickedRow >= 0) {
1069         table->clickedRow = -1;
1070
1071         if (table->action)
1072             (*table->action)(table, table->clientData);
1073         WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1074                                table, NULL);
1075     }
1076
1077     if (table->delegate && table->delegate->numberOfRows) {
1078         int rows;
1079
1080         rows = (*table->delegate->numberOfRows)(table->delegate, table);
1081
1082         if (rows != table->rows) {
1083             table->rows = rows;
1084             handleResize(table->view->delegate, table->view);
1085         } else {
1086             repaintTable(table);
1087         }
1088     }
1089 }
1090
1091
1092 void WMNoteTableViewNumberOfRowsChanged(WMTableView *table)
1093 {
1094     WMReloadTableView(table);
1095 }
1096
1097
1098 static void handleTableEvents(XEvent *event, void *data)
1099 {
1100     WMTableView *table = (WMTableView*)data;
1101     int row;
1102
1103     switch (event->type) {
1104      case ButtonPress:
1105         if (event->xbutton.button == Button1) {
1106             WMRect rect = getVisibleRect(table);
1107
1108             row = (event->xbutton.y + rect.pos.y)/table->rowHeight;
1109             if (row != table->clickedRow) {
1110                 setRowSelected(table, table->clickedRow, False);
1111                 setRowSelected(table, row, True);
1112                 table->clickedRow = row;
1113                 table->dragging = 1;
1114             } else {
1115                 table->dragging = 1;
1116             }
1117         }
1118         break;
1119
1120      case MotionNotify:
1121         if (table->dragging && event->xmotion.y >= 0) {
1122             WMRect rect = getVisibleRect(table);
1123
1124             row = (event->xmotion.y + rect.pos.y)/table->rowHeight;
1125             if (table->clickedRow != row && row >= 0 && row < table->rows) {
1126                 setRowSelected(table, table->clickedRow, False);
1127                 setRowSelected(table, row, True);
1128                 table->clickedRow = row;
1129             }
1130         }
1131         break;
1132
1133      case ButtonRelease:
1134         if (event->xbutton.button == Button1) {
1135             if (table->action)
1136                 (*table->action)(table, table->clientData);
1137             WMPostNotificationName(WMTableViewSelectionDidChangeNotification,
1138                                    table, NULL);
1139             table->dragging = 0;
1140         }
1141         break;
1142     }
1143 }
1144
1145
1146 static void handleEvents(XEvent *event, void *data)
1147 {
1148     WMTableView *table = (WMTableView*)data;
1149     WMScreen *scr = WMWidgetScreen(table);
1150
1151     switch (event->type) {
1152      case Expose:
1153         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
1154                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
1155                      WRSunken);
1156         break;
1157     }
1158 }
1159
1160
1161 static void handleResize(W_ViewDelegate *self, WMView *view)
1162 {
1163     int width;
1164     int height;
1165     WMTableView *table = view->self;
1166     WMSize size = getTotalSize(table);
1167     int vw, vh;
1168
1169     width = W_VIEW_WIDTH(view) - 2;
1170     height = W_VIEW_HEIGHT(view) - 3;
1171
1172     height -= table->headerHeight; /* table header */
1173
1174     if (table->corner)
1175         WMResizeWidget(table->corner, 20, table->headerHeight);
1176
1177     WMMoveWidget(table->vscroll, 1, table->headerHeight + 1);
1178     WMResizeWidget(table->vscroll, 20, height + 1);
1179
1180     WMMoveWidget(table->hscroll, 20, W_VIEW_HEIGHT(view) - 20 - 1);
1181     WMResizeWidget(table->hscroll, width-20+1, 20);
1182
1183     if (table->header)
1184         WMResizeWidget(table->header, width - 21, table->headerHeight);
1185
1186     if (table->viewBuffer) {
1187         WMReleasePixmap(table->viewBuffer);
1188         table->viewBuffer = NULL;
1189     }
1190
1191     width -= 20;
1192     height -= 20;
1193
1194     vw = WMIN(size.width, width);
1195     vh = WMIN(size.height, height);
1196
1197     W_MoveView(table->tableView, 21, 1+table->headerHeight+1);
1198     W_ResizeView(table->tableView, WMAX(vw, 1), WMAX(vh, 1)+1);
1199
1200     adjustScrollers(table);
1201
1202     repaintTable(table);
1203 }
1204
1205
1206 static void rearrangeHeader(WMTableView *table)
1207 {
1208     int width;
1209     int count;
1210     int i;
1211     /*WMRect rect = WMGetScrollViewVisibleRect(table->scrollView);*/
1212
1213     width = 0;
1214
1215     count = WMGetArrayItemCount(table->columns);
1216     for (i = 0; i < count; i++) {
1217         WMTableColumn *column = WMGetFromArray(table->columns, i);
1218         WMView *splitter = WMGetFromArray(table->splitters, i);
1219
1220         WMMoveWidget(column->titleW, width, 0);
1221         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
1222
1223         width += column->width;
1224         W_MoveView(splitter, width-1, 0);
1225     }
1226
1227     wassertr(table->delegate && table->delegate->numberOfRows);
1228
1229     table->rows = table->delegate->numberOfRows(table->delegate, table);
1230
1231     table->tableWidth = width + 1;
1232
1233     handleResize(table->view->delegate, table->view);
1234 }