WINGs/Extras/wtableview.c

   1
   2
   3 #include <WINGsP.h>
   4 #include <X11/cursorfont.h>
   5
   6 #include "wtableview.h"
   7
   8 struct W_TableColumn {
   9     WMTableView *table;
  10     WMWidget *titleW;
  11     char *title;
  12     int width;
  13     int minWidth;
  14     int maxWidth;
  15
  16     void *id;
  17
  18     WMTableColumnDelegate *delegate;
  19
  20     unsigned resizable:1;
  21     unsigned editable:1;
  22 };
  23
  24
  25
  26 static void handleResize(W_ViewDelegate *self, WMView *view);
  27
  28
  29 WMTableColumn *WMCreateTableColumn(char *title)
  30 {
  31     WMTableColumn *col = wmalloc(sizeof(WMTableColumn));
  32
  33     col->table = NULL;
  34     col->titleW = NULL;
  35     col->width = 50;
  36     col->minWidth = 5;
  37     col->maxWidth = 0;
  38
  39     col->id = NULL;
  40
  41     col->title = wstrdup(title);
  42
  43     col->delegate = NULL;
  44
  45     col->resizable = 1;
  46     col->editable = 0;
  47
  48     return col;
  49 }
  50
  51
  52 void WMSetTableColumnId(WMTableColumn *column, void *id)
  53 {
  54     column->id = id;
  55 }
  56
  57
  58 void *WMGetTableColumnId(WMTableColumn *column)
  59 {
  60     return column->id;
  61 }
  62
  63
  64 void WMSetTableColumnWidth(WMTableColumn *column, unsigned width)
  65 {
  66     if (column->maxWidth == 0)
  67         column->width = WMAX(column->minWidth, width);
  68     else
  69         column->width = WMAX(column->minWidth, WMIN(column->maxWidth, width));
  70
  71     if (column->table) {
  72         handleResize(NULL, W_VIEW(column->table));
  73     }
  74 }
  75
  76
  77 void WMSetTableColumnDelegate(WMTableColumn *column,
  78                               WMTableColumnDelegate *delegate)
  79 {
  80     column->delegate = delegate;
  81 }
  82
  83
  84 void WMSetTableColumnConstraints(WMTableColumn *column,
  85                                  unsigned minWidth, unsigned maxWidth)
  86 {
  87     wassertr(minWidth <= maxWidth);
  88
  89     column->minWidth = minWidth;
  90     column->maxWidth = maxWidth;
  91
  92     if (column->width < column->minWidth)
  93         WMSetTableColumnWidth(column, column->minWidth);
  94     else if (column->width > column->maxWidth || column->maxWidth == 0)
  95         WMSetTableColumnWidth(column, column->maxWidth);
  96 }
  97
  98
  99 void WMSetTableColumnEditable(WMTableColumn *column, Bool flag)
 100 {
 101     column->editable = flag;
 102 }
 103
 104
 105 WMTableView *WMGetTableColumnTableView(WMTableColumn *column)
 106 {
 107     return column->table;
 108 }
 109
 110
 111
 112 struct W_TableView {
 113     W_Class widgetClass;
 114     WMView *view;
 115
 116     WMFrame *header;
 117
 118     WMLabel *corner;
 119
 120     WMScrollView *scrollView;
 121     WMView *tableView;
 122
 123     WMArray *columns;
 124     WMArray *splitters;
 125
 126     int tableWidth;
 127
 128     int rows;
 129
 130     GC gridGC;
 131     WMColor *gridColor;
 132
 133     Cursor splitterCursor;
 134
 135     void *dataSource;
 136
 137     WMTableViewDelegate *delegate;
 138
 139     unsigned headerHeight;
 140
 141     unsigned rowHeight;
 142
 143     unsigned drawsGrid:1;
 144 };
 145
 146 static W_Class tableClass = 0;
 147
 148
 149 static W_ViewDelegate viewDelegate = {
 150     NULL,
 151         NULL,
 152         handleResize,
 153         NULL,
 154         NULL
 155 };
 156
 157
 158
 159
 160
 161 static void handleEvents(XEvent *event, void *data);
 162 static void handleTableEvents(XEvent *event, void *data);
 163
 164
 165 static void scrollObserver(void *self, WMNotification *notif)
 166 {
 167     WMTableView *table = (WMTableView*)self;
 168     WMRect rect;
 169     int i, x;
 170
 171     rect = WMGetScrollViewVisibleRect(table->scrollView);
 172
 173     x = 0;
 174     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 175         WMTableColumn *column;
 176
 177         column = WMGetFromArray(table->columns, i);
 178
 179         WMMoveWidget(column->titleW, x + rect.pos.x, 0);
 180
 181         if (i > 0) {
 182             WMView *splitter;
 183
 184             splitter = WMGetFromArray(table->splitters, i-1);
 185             W_MoveView(splitter, x + rect.pos.x - 1, 0);
 186         }
 187
 188         x += W_VIEW_WIDTH(WMWidgetView(column->titleW)) + 1;
 189     }
 190 }
 191
 192
 193 static void splitterHandler(XEvent *event, void *data)
 194 {
 195     WMTableView *table = (WMTableView*)data;
 196
 197
 198 }
 199
 200
 201
 202 WMTableView *WMCreateTableView(WMWidget *parent)
 203 {
 204     WMTableView *table = wmalloc(sizeof(WMTableView));
 205     WMScreen *scr = WMWidgetScreen(parent);
 206
 207     memset(table, 0, sizeof(WMTableView));
 208
 209     if (!tableClass) {
 210         tableClass = W_RegisterUserWidget();
 211     }
 212     table->widgetClass = tableClass;
 213
 214     table->view = W_CreateView(W_VIEW(parent));
 215     if (!table->view)
 216         goto error;
 217     table->view->self = table;
 218
 219     table->view->delegate = &viewDelegate;
 220
 221     table->headerHeight = 20;
 222
 223     table->scrollView = WMCreateScrollView(table);
 224     if (!table->scrollView)
 225         goto error;
 226     WMResizeWidget(table->scrollView, 10, 10);
 227     WMSetScrollViewHasVerticalScroller(table->scrollView, True);
 228     WMSetScrollViewHasHorizontalScroller(table->scrollView, True);
 229     {
 230         WMScroller *scroller;
 231         scroller = WMGetScrollViewHorizontalScroller(table->scrollView);
 232         WMAddNotificationObserver(scrollObserver, table,
 233                                   WMScrollerDidScrollNotification,
 234                                   scroller);
 235     }
 236     WMMoveWidget(table->scrollView, 1, 2+table->headerHeight);
 237     WMMapWidget(table->scrollView);
 238
 239     table->header = WMCreateFrame(table);
 240     WMMoveWidget(table->header, 22, 2);
 241     WMMapWidget(table->header);
 242     WMSetFrameRelief(table->header, WRFlat);
 243     table->corner = WMCreateLabel(table);
 244     WMResizeWidget(table->corner, 20, table->headerHeight);
 245     WMMoveWidget(table->corner, 2, 2);
 246     WMMapWidget(table->corner);
 247     WMSetLabelRelief(table->corner, WRRaised);
 248     WMSetWidgetBackgroundColor(table->corner, scr->darkGray);
 249
 250
 251     table->tableView = W_CreateView(W_VIEW(parent));
 252     if (!table->tableView)
 253         goto error;
 254     W_ResizeView(table->tableView, 100, 1000);
 255     W_MapView(table->tableView);
 256
 257     WMSetScrollViewContentView(table->scrollView, table->tableView);
 258
 259     table->tableView->flags.dontCompressExpose = 1;
 260
 261     table->gridColor = WMDarkGrayColor(scr);
 262
 263     {
 264         XGCValues gcv;
 265
 266         gcv.foreground = WMColorPixel(table->gridColor);
 267         gcv.dashes = 1;
 268         gcv.line_style = LineOnOffDash;
 269         table->gridGC = XCreateGC(WMScreenDisplay(scr), W_DRAWABLE(scr),
 270                                   GCForeground, &gcv);
 271     }
 272
 273     table->drawsGrid = 1;
 274     table->rowHeight = 16;
 275
 276     table->tableWidth = 1;
 277
 278     table->columns = WMCreateArray(4);
 279     table->splitters = WMCreateArray(4);
 280
 281     table->splitterCursor = XCreateFontCursor(WMScreenDisplay(scr),
 282                                               XC_sb_h_double_arrow);
 283
 284     WMCreateEventHandler(table->view, ExposureMask|StructureNotifyMask,
 285                          handleEvents, table);
 286
 287     WMCreateEventHandler(table->tableView, ExposureMask,
 288                          handleTableEvents, table);
 289
 290     return table;
 291
 292  error:
 293     if (table->scrollView)
 294         WMDestroyWidget(table->scrollView);
 295     if (table->tableView)
 296         W_DestroyView(table->tableView);
 297     if (table->view)
 298         W_DestroyView(table->view);
 299     wfree(table);
 300     return NULL;
 301 }
 302
 303
 304 void WMAddTableViewColumn(WMTableView *table, WMTableColumn *column)
 305 {
 306     int width;
 307     int i;
 308     WMScreen *scr = WMWidgetScreen(table);
 309     int count;
 310
 311     column->table = table;
 312
 313     WMAddToArray(table->columns, column);
 314
 315     if (!column->titleW) {
 316         column->titleW = WMCreateLabel(table);
 317         WMSetLabelRelief(column->titleW, WRRaised);
 318         WMSetLabelFont(column->titleW, scr->boldFont);
 319         WMSetLabelTextColor(column->titleW, scr->white);
 320         WMSetWidgetBackgroundColor(column->titleW, scr->darkGray);
 321         WMSetLabelText(column->titleW, column->title);
 322         W_ReparentView(WMWidgetView(column->titleW),
 323                        WMWidgetView(table->header), 0, 0);
 324         if (W_VIEW_REALIZED(table->view))
 325             WMRealizeWidget(column->titleW);
 326         WMMapWidget(column->titleW);
 327     }
 328
 329     if (WMGetArrayItemCount(table->columns) > 1) {
 330         WMView *splitter = W_CreateView(WMWidgetView(table->header));
 331
 332         W_SetViewBackgroundColor(splitter, WMWhiteColor(scr));
 333
 334         if (W_VIEW_REALIZED(table->view))
 335             W_RealizeView(splitter);
 336
 337         W_ResizeView(splitter, 2, table->headerHeight-1);
 338         W_MapView(splitter);
 339
 340         W_SetViewCursor(splitter, table->splitterCursor);
 341         WMCreateEventHandler(splitter, ButtonPressMask|ButtonReleaseMask
 342                              |PointerMotionMask, splitterHandler, table);
 343
 344         WMAddToArray(table->splitters, splitter);
 345     }
 346
 347     count = WMGetArrayItemCount(table->columns);
 348     for (i = 0, width = 0; i < count; i++) {
 349         WMTableColumn *column = WMGetFromArray(table->columns, i);
 350
 351         WMMoveWidget(column->titleW, width, 0);
 352         WMResizeWidget(column->titleW, column->width-1, table->headerHeight);
 353
 354         if (i > 0) {
 355             WMView *splitter = WMGetFromArray(table->splitters, i-1);
 356
 357             W_MoveView(splitter, width-1, 0);
 358         }
 359         width += column->width;
 360     }
 361
 362     wassertr(table->delegate && table->delegate->numberOfRows);
 363
 364     table->rows = table->delegate->numberOfRows(table->delegate, table);
 365
 366     W_ResizeView(table->tableView, width+1,
 367                  table->rows * table->rowHeight + 1);
 368
 369     table->tableWidth = width + 1;
 370 }
 371
 372
 373 void WMSetTableViewHeaderHeight(WMTableView *table, unsigned height)
 374 {
 375     table->headerHeight = height;
 376
 377     handleResize(NULL, table->view);
 378 }
 379
 380
 381 void WMSetTableViewDelegate(WMTableView *table, WMTableViewDelegate *delegate)
 382 {
 383     table->delegate = delegate;
 384 }
 385
 386
 387 WMView *WMGetTableViewDocumentView(WMTableView *table)
 388 {
 389     return table->tableView;
 390 }
 391
 392
 393 void *WMTableViewDataForCell(WMTableView *table, WMTableColumn *column,
 394                              int row)
 395 {
 396     return (*table->delegate->valueForCell)(table->delegate, column, row);
 397 }
 398
 399
 400 WMRect WMTableViewRectForCell(WMTableView *table, WMTableColumn *column,
 401                               int row)
 402 {
 403     WMRect rect;
 404     int i;
 405
 406     rect.pos.x = 0;
 407     rect.pos.y = row * table->rowHeight;
 408     rect.size.height = table->rowHeight;
 409
 410     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 411         WMTableColumn *col;
 412         col = WMGetFromArray(table->columns, i);
 413
 414         if (col == column) {
 415             rect.size.width = col->width;
 416             break;
 417         }
 418
 419         rect.pos.x += col->width;
 420     }
 421     return rect;
 422 }
 423
 424
 425 void WMSetTableViewDataSource(WMTableView *table, void *source)
 426 {
 427     table->dataSource = source;
 428 }
 429
 430
 431 void *WMGetTableViewDataSource(WMTableView *table)
 432 {
 433     return table->dataSource;
 434 }
 435
 436
 437 void WMSetTableViewBackgroundColor(WMTableView *table, WMColor *color)
 438 {
 439     W_SetViewBackgroundColor(table->tableView, color);
 440 }
 441
 442
 443 void WMSetTableViewGridColor(WMTableView *table, WMColor *color)
 444 {
 445     WMReleaseColor(table->gridColor);
 446     table->gridColor = WMRetainColor(color);
 447     XSetForeground(WMScreenDisplay(WMWidgetScreen(table)), table->gridGC, WMColorPixel(color));
 448 }
 449
 450
 451 static void drawGrid(WMTableView *table, WMRect rect)
 452 {
 453     WMScreen *scr = WMWidgetScreen(table);
 454     Display *dpy = WMScreenDisplay(scr);
 455     int i;
 456     int y1, y2;
 457     int x1, x2;
 458     int xx;
 459     Drawable d = W_VIEW_DRAWABLE(table->tableView);
 460     GC gc = table->gridGC;
 461
 462 #if 0
 463     char dashl[1] = {1};
 464
 465     XSetDashes(dpy, gc, 0, dashl, 1);
 466
 467     y1 = (rect.pos.y/table->rowHeight - 1)*table->rowHeight;
 468     y2 = y1 + (rect.size.height/table->rowHeight+2)*table->rowHeight;
 469 #endif
 470     y1 = 0;
 471     y2 = W_VIEW_HEIGHT(table->tableView);
 472
 473     xx = 0;
 474     for (i = 0; i < WMGetArrayItemCount(table->columns); i++) {
 475         WMTableColumn *column;
 476
 477         if (xx >= rect.pos.x && xx <= rect.pos.x+rect.size.width) {
 478             XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 479         }
 480         column = WMGetFromArray(table->columns, i);
 481         xx += column->width;
 482     }
 483     XDrawLine(dpy, d, gc, xx, y1, xx, y2);
 484
 485
 486     x1 = rect.pos.x;
 487     x2 = WMIN(x1 + rect.size.width, xx);
 488
 489     if (x2 <= x1)
 490         return;
 491 #if 0
 492     XSetDashes(dpy, gc, (rect.pos.x&1), dashl, 1);
 493 #endif
 494
 495     y1 = rect.pos.y - rect.pos.y%table->rowHeight;
 496     y2 = y1 + rect.size.height + table->rowHeight;
 497
 498     for (i = y1; i <= y2; i += table->rowHeight) {
 499         XDrawLine(dpy, d, gc, x1, i, x2, i);
 500     }
 501 }
 502
 503
 504 static WMRange columnsInRect(WMTableView *table, WMRect rect)
 505 {
 506     WMTableColumn *column;
 507     int width;
 508     int i , j;
 509     int totalColumns = WMGetArrayItemCount(table->columns);
 510     WMRange range;
 511
 512     j = 0;
 513     width = 0;
 514     for (i = 0; i < totalColumns; i++) {
 515         column = WMGetFromArray(table->columns, i);
 516         if (j == 0) {
 517             if (width <= rect.pos.x && width + column->width > rect.pos.x) {
 518                 range.position = i;
 519                 j = 1;
 520             }
 521         } else {
 522             if (width > rect.pos.x + rect.size.width) {
 523                 range.count = i - range.position;
 524                 break;
 525             }
 526         }
 527         width += column->width;
 528     }
 529
 530     range.count = WMAX(1, WMIN(range.count, totalColumns - range.position));
 531
 532     return range;
 533 }
 534
 535
 536 static WMRange rowsInRect(WMTableView *table, WMRect rect)
 537 {
 538     WMRange range;
 539     int rh = table->rowHeight;
 540
 541     range.position = WMAX(0, rect.pos.y / rh - 1);
 542     range.count = WMAX(1, WMIN(rect.size.height / rh + 3, table->rows));
 543
 544     return range;
 545 }
 546
 547
 548 static void drawRow(WMTableView *table, int row, WMRect clipRect)
 549 {
 550     int i;
 551     WMRange cols = columnsInRect(table, clipRect);
 552     WMTableColumn *column;
 553
 554     for (i = cols.position; i < cols.position+cols.count; i++) {
 555         column = WMGetFromArray(table->columns, i);
 556
 557         wassertr(column->delegate && column->delegate->drawCell);
 558
 559         (*column->delegate->drawCell)(column->delegate, column, row);
 560     }
 561 }
 562
 563
 564 static void repaintTable(WMTableView *table, int x, int y,
 565                          int width, int height)
 566 {
 567     WMRect rect;
 568     WMRange rows;
 569     int i;
 570
 571     wassertr(table->delegate && table->delegate->numberOfRows);
 572     i = (*table->delegate->numberOfRows)(table->delegate, table);
 573
 574     if (i != table->rows) {
 575         table->rows = i;
 576         W_ResizeView(table->tableView, table->tableWidth,
 577                      table->rows * table->rowHeight + 1);
 578     }
 579
 580
 581     rect.pos = wmkpoint(x,y);
 582     rect.size = wmksize(width, height);
 583
 584     if (table->drawsGrid) {
 585         drawGrid(table, rect);
 586     }
 587
 588     rows = rowsInRect(table, rect);
 589     for (i = rows.position;
 590          i < WMIN(rows.position+rows.count, table->rows);
 591          i++) {
 592         drawRow(table, i, rect);
 593     }
 594 }
 595
 596
 597 static void handleTableEvents(XEvent *event, void *data)
 598 {
 599     WMTableView *table = (WMTableView*)data;
 600
 601     switch (event->type) {
 602      case Expose:
 603         repaintTable(table, event->xexpose.x, event->xexpose.y,
 604                      event->xexpose.width, event->xexpose.height);
 605         break;
 606     }
 607 }
 608
 609
 610 static void handleEvents(XEvent *event, void *data)
 611 {
 612     WMTableView *table = (WMTableView*)data;
 613     WMScreen *scr = WMWidgetScreen(table);
 614
 615     switch (event->type) {
 616      case Expose:
 617         W_DrawRelief(scr, W_VIEW_DRAWABLE(table->view), 0, 0,
 618                      W_VIEW_WIDTH(table->view), W_VIEW_HEIGHT(table->view),
 619                      WRSunken);
 620         break;
 621     }
 622 }
 623
 624
 625 static void handleResize(W_ViewDelegate *self, WMView *view)
 626 {
 627     int width;
 628     int height;
 629     WMTableView *table = view->self;
 630
 631     width = W_VIEW_WIDTH(view) - 2;
 632     height = W_VIEW_HEIGHT(view) - 3;
 633
 634     height -= table->headerHeight; /* table header */
 635
 636     if (table->corner)
 637         WMResizeWidget(table->corner, 20, table->headerHeight);
 638
 639     if (table->scrollView) {
 640         WMMoveWidget(table->scrollView, 1, table->headerHeight + 2);
 641         WMResizeWidget(table->scrollView, width, height);
 642     }
 643     if (table->header)
 644         WMResizeWidget(table->header, width - 21, table->headerHeight);
 645 }
 646
 647