src/ssd_ui.c

   1 /*
   2  * Grace - GRaphing, Advanced Computation and Exploration of data
   3  *
   4  * Home page: http://plasma-gate.weizmann.ac.il/Grace/
   5  *
   6  * Copyright (c) 1996-2005 Grace Development Team
   7  *
   8  * Maintained by Evgeny Stambulchik
   9  *
  10  *
  11  *                           All Rights Reserved
  12  *
  13  *    This program is free software; you can redistribute it and/or modify
  14  *    it under the terms of the GNU General Public License as published by
  15  *    the Free Software Foundation; either version 2 of the License, or
  16  *    (at your option) any later version.
  17  *
  18  *    This program is distributed in the hope that it will be useful,
  19  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *    GNU General Public License for more details.
  22  *
  23  *    You should have received a copy of the GNU General Public License
  24  *    along with this program; if not, write to the Free Software
  25  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28 /* SSData UI */
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "events.h"
  34 #include "utils.h"
  35 #include "explorer.h"
  36 #include "xprotos.h"
  37 #include "globals.h"
  38
  39 /* default cell value precision */
  40 #define CELL_PREC 8
  41
  42 /* default cell value format */
  43 #define CELL_FORMAT FORMAT_GENERAL
  44
  45 /* default cell width */
  46 #define CELL_WIDTH 12
  47
  48 /* string cell width */
  49 #define STRING_CELL_WIDTH 128
  50
  51 /* minimum size of the spreadsheet matrix */
  52 #define EXTRA_SS_ROWS      20
  53 #define EXTRA_SS_COLS       3
  54
  55 #define VISIBLE_SS_ROWS  18
  56 #define VISIBLE_SS_COLS   3
  57
  58 static int do_hotlinkfile_proc(FSBStructure *fsb, char *filename, void *data)
  59 {
  60     SSDataUI *ui = (SSDataUI *) data;
  61
  62     xv_setstr(ui->hotfile, filename);
  63
  64     return TRUE;
  65 }
  66
  67 /*
  68  * create file selection pop up to choose the file for hotlink
  69  */
  70 static void create_hotfiles_popup(Widget but, void *data)
  71 {
  72     static FSBStructure *fsb = NULL;
  73
  74     set_wait_cursor();
  75
  76     if (fsb == NULL) {
  77         fsb = CreateFileSelectionBox(app_shell, "Hotlinked file");
  78         AddFileSelectionBoxCB(fsb, do_hotlinkfile_proc, data);
  79         ManageChild(fsb->FSB);
  80     }
  81
  82     RaiseWindow(fsb->dialog);
  83
  84     unset_wait_cursor();
  85 }
  86
  87 /*
  88  * We use a stack of static buffers to work around asynchronous
  89  * refresh/redraw events
  90  */
  91 #define STACKLEN    (VISIBLE_SS_ROWS*VISIBLE_SS_COLS)
  92
  93 static char *get_cell_content(SSDataUI *ui, int row, int column, int *format)
  94 {
  95     static char buf[STACKLEN][32];
  96     static int stackp = 0;
  97
  98     int nrows = ssd_get_nrows(ui->q);
  99     ss_column *col = ssd_get_col(ui->q, column);
 100     char *s;
 101
 102     if (col && row >= 0 && row < nrows) {
 103         unsigned int prec;
 104         *format = col->format;
 105         switch (col->format) {
 106         case FFORMAT_STRING:
 107             s = ((char **) col->data)[row];
 108             break;
 109         default:
 110             prec = project_get_prec(get_parent_project(ui->q));
 111             sprintf(buf[stackp], "%.*g", prec, ((double *) col->data)[row]);
 112             s = buf[stackp];
 113             stackp++;
 114             stackp %= STACKLEN;
 115
 116             /* get rid of spaces */
 117             while (s && *s == ' ') {
 118                 s++;
 119             }
 120
 121             break;
 122         }
 123     } else {
 124         s = "";
 125     }
 126
 127     return s;
 128 }
 129
 130 static int drawcellCB(TableEvent *event)
 131 {
 132     SSDataUI *ui = (SSDataUI *) event->anydata;
 133     int format;
 134
 135     event->value_type = TABLE_CELL_STRING;
 136     event->value = get_cell_content(ui, event->row, event->col, &format);
 137
 138     return TRUE;
 139 }
 140
 141 static int enterCB(TableEvent *event)
 142 {
 143     SSDataUI *ui = (SSDataUI *) event->anydata;
 144
 145     int ncols = ssd_get_ncols(ui->q);
 146
 147     if (event->col >= 0 && event->col <= ncols) {
 148         TableDeselectAllCells(ui->mw);
 149         return TRUE;
 150     } else {
 151         return FALSE;
 152     }
 153 }
 154
 155 static int leaveCB(TableEvent *event)
 156 {
 157     SSDataUI *ui = (SSDataUI *) event->anydata;
 158
 159     int nrows = ssd_get_nrows(ui->q);
 160     int ncols = ssd_get_ncols(ui->q);
 161     int format;
 162     double value;
 163
 164     int changed = FALSE;
 165
 166     GraceApp *gapp = gapp_from_quark(ui->q);
 167
 168     if (event->row < 0 || event->col < 0 || event->col > ncols) {
 169         return TRUE;
 170     }
 171
 172     if (event->row >= nrows && !string_is_empty(event->value)) {
 173         if (ssd_set_nrows(ui->q, event->row + 1) == RETURN_SUCCESS) {
 174             changed = TRUE;
 175         }
 176     }
 177
 178     if (event->col == ncols && !string_is_empty(event->value)) {
 179         if (parse_date_or_number(get_parent_project(ui->q),
 180             event->value, FALSE, get_date_hint(gapp), &value) == RETURN_SUCCESS) {
 181             format = FFORMAT_NUMBER;
 182         } else {
 183             format = FFORMAT_STRING;
 184         }
 185         if (ssd_add_col(ui->q, format)) {
 186             ncols++;
 187             changed = TRUE;
 188         }
 189     }
 190
 191     if (event->col < ncols) {
 192         char *old_value = get_cell_content(ui, event->row, event->col, &format);
 193         if (!strings_are_equal(old_value, event->value)) {
 194             switch (format) {
 195             case FFORMAT_STRING:
 196                 if (ssd_set_string(ui->q, event->row, event->col, event->value) ==
 197                     RETURN_SUCCESS) {
 198                     quark_dirtystate_set(ui->q, TRUE);
 199                     changed = TRUE;
 200                 }
 201                 break;
 202             default:
 203                 if (graal_eval_expr(grace_get_graal(gapp->grace),
 204                     event->value, &value, gproject_get_top(gapp->gp)) == RETURN_SUCCESS) {
 205
 206                     unsigned int prec;
 207                     char buf[32];
 208                     double val;
 209
 210                     prec = project_get_prec(get_parent_project(ui->q));
 211                     sprintf(buf, "%.*g", prec, value);
 212
 213                     if (parse_date_or_number(get_parent_project(ui->q),
 214                         buf, FALSE, get_date_hint(gapp), &val) == RETURN_SUCCESS) {
 215
 216                         if (ssd_set_value(ui->q, event->row, event->col, val) == RETURN_SUCCESS) {
 217                             quark_dirtystate_set(ui->q, TRUE);
 218                             changed = TRUE;
 219                         }
 220                     }
 221                 } else {
 222                     errmsg("Can't parse input value");
 223                     return FALSE;
 224                 }
 225                 break;
 226             }
 227         }
 228     }
 229
 230     if (changed) {
 231         snapshot_and_update(gapp->gp, FALSE);
 232     }
 233
 234     return TRUE;
 235 }
 236
 237 static int labelCB(TableEvent *event)
 238 {
 239     SSDataUI *ui = (SSDataUI *) event->anydata;
 240     static int last_row, last_column;
 241     int i;
 242
 243     if (!event || event->type != MOUSE_PRESS) {
 244         return TRUE;
 245     }
 246
 247     if (event->button == LEFT_BUTTON) {
 248         TableCommitEdit(ui->mw, TRUE);
 249
 250         if (event->row_label) {
 251             if (event->modifiers & CONTROL_MODIFIER) {
 252                 if (TableIsRowSelected(ui->mw, event->row)) {
 253                     TableDeselectRow(ui->mw, event->row);
 254                 } else {
 255                     TableSelectRow(ui->mw, event->row);
 256                 }
 257                 last_row = event->row;
 258             } else
 259             if ((event->modifiers & SHIFT_MODIFIER) && last_row >= 0) {
 260                 for (i = MIN2(last_row, event->row); i <= MAX2(last_row, event->row); i++) {
 261                     TableSelectRow(ui->mw, i);
 262                 }
 263             } else {
 264                 TableDeselectAllCells(ui->mw);
 265                 TableSelectRow(ui->mw, event->row);
 266                 last_row = event->row;
 267             }
 268
 269             last_column = -1;
 270         } else {
 271             if (event->modifiers & CONTROL_MODIFIER) {
 272                 if (TableIsColSelected(ui->mw, event->col)) {
 273                     TableDeselectCol(ui->mw, event->col);
 274                 } else {
 275                     TableSelectCol(ui->mw, event->col);
 276                 }
 277                 last_column = event->col;
 278             } else
 279             if ((event->modifiers & SHIFT_MODIFIER) && last_column >= 0) {
 280                 for (i = MIN2(last_column, event->col); i <= MAX2(last_column, event->col); i++) {
 281                     TableSelectCol(ui->mw, i);
 282                 }
 283             } else {
 284                 TableDeselectAllCells(ui->mw);
 285                 TableSelectCol(ui->mw, event->col);
 286                 last_column = event->col;
 287             }
 288
 289             last_row = -1;
 290         }
 291     }
 292
 293     if (event->button == RIGHT_BUTTON) {
 294         ss_column *col;
 295         if (!event->row_label) {
 296             ui->cb_column = event->col;
 297         }
 298
 299         col = ssd_get_col(ui->q, ui->cb_column);
 300         SetSensitive(ui->delete_btn, col != NULL);
 301         SetSensitive(ui->index_btn, col != NULL && ui->cb_column != 0 &&
 302             (col->format == FFORMAT_NUMBER || col->format == FFORMAT_DATE));
 303         SetSensitive(ui->unindex_btn, ui->cb_column == 0 && col != NULL &&
 304             ssd_is_indexed(ui->q));
 305
 306         ShowMenu(ui->popup, event->udata);
 307     }
 308
 309     return TRUE;
 310 }
 311
 312 static void col_delete_cb(Widget but, void *udata)
 313 {
 314     SSDataUI *ui = (SSDataUI *) udata;
 315     if (ssd_delete_col(ui->q, ui->cb_column) == RETURN_SUCCESS) {
 316         snapshot_and_update(gapp->gp, TRUE);
 317     }
 318 }
 319
 320 static void index_cb(Widget but, void *udata)
 321 {
 322     SSDataUI *ui = (SSDataUI *) udata;
 323     if (ssd_set_index(ui->q, ui->cb_column) == RETURN_SUCCESS) {
 324         snapshot_and_update(gapp->gp, TRUE);
 325     }
 326 }
 327
 328 static void unindex_cb(Widget but, void *udata)
 329 {
 330     SSDataUI *ui = (SSDataUI *) udata;
 331     if (ssd_set_indexed(ui->q, FALSE) == RETURN_SUCCESS) {
 332         snapshot_and_update(gapp->gp, TRUE);
 333     }
 334 }
 335
 336 static void col_cb(ListStructure *sel, int n, int *values, void *data)
 337 {
 338     SSDataUI *ui = (SSDataUI *) data;
 339     Quark *ssd = (Quark *) sel->anydata;
 340
 341     if (ssd && n == 1) {
 342         int col = values[0];
 343         SetSensitive(ui->col_label->text, TRUE);
 344         SetTextString(ui->col_label, ssd_get_col_label(ssd, col));
 345     } else {
 346         SetSensitive(ui->col_label->text, FALSE);
 347     }
 348 }
 349
 350 SSDataUI *create_ssd_ui(ExplorerUI *eui)
 351 {
 352     SSDataUI *ui;
 353
 354     Widget tab, fr, rc, rc1, wbut;
 355
 356     ui = xmalloc(sizeof(SSDataUI));
 357     if (!ui) {
 358         return NULL;
 359     }
 360     memset(ui, 0, sizeof(SSDataUI));
 361
 362     /* ------------ Tabs -------------- */
 363
 364     tab = CreateTab(eui->scrolled_window);
 365     AddHelpCB(tab, "doc/UsersGuide.html#ssd-properties");
 366
 367     ui->top = tab;
 368
 369     /* ------------ Main tab -------------- */
 370     ui->main_tp = CreateTabPage(tab, "Data");
 371
 372     ui->mw = CreateTable("SSD", ui->main_tp,
 373                          EXTRA_SS_ROWS, EXTRA_SS_COLS,
 374                          VISIBLE_SS_ROWS, VISIBLE_SS_COLS);
 375     TableSSDInit(ui->mw);
 376     TableSetDefaultColWidth(ui->mw, CELL_WIDTH);
 377     TableSetDefaultColLabelAlignment(ui->mw, ALIGN_CENTER);
 378
 379     AddTableDrawCellCB(ui->mw, drawcellCB, ui);
 380     AddTableLeaveCellCB(ui->mw, leaveCB, ui);
 381     AddTableEnterCellCB(ui->mw, enterCB, ui);
 382     AddTableLabelActivateCB(ui->mw, labelCB, ui);
 383
 384     ui->popup = CreatePopupMenu(ui->mw);
 385     ui->delete_btn  = CreateMenuButton(ui->popup, "Delete column", '\0', col_delete_cb, ui);
 386     ui->index_btn   = CreateMenuButton(ui->popup, "Set as index", '\0', index_cb, ui);
 387     ui->unindex_btn = CreateMenuButton(ui->popup, "Unset index", '\0', unindex_cb, ui);
 388
 389
 390     /* ------------ Column props -------------- */
 391     ui->column_tp = CreateTabPage(tab, "Columns");
 392     ui->col_sel = CreateColChoice(ui->column_tp, "Column:", LIST_TYPE_SINGLE);
 393     AddListChoiceCB(ui->col_sel, col_cb, ui);
 394
 395     ui->col_label = CreateCSText(ui->column_tp, "Label:");
 396     SetSensitive(ui->col_label->text, FALSE);
 397     AddTextInputCB(ui->col_label, text_explorer_cb, eui);
 398
 399
 400     /* ------------ Hotlink tab -------------- */
 401     ui->hotlink_tp = CreateTabPage(tab, "Hotlink");
 402
 403     fr = CreateFrame(ui->hotlink_tp, "Hotlink");
 404     rc = CreateVContainer(fr);
 405     rc1 = CreateHContainer(rc);
 406     ui->hotlink = CreateToggleButton(rc1, "Enabled");
 407     ui->hotsrc  = CreateOptionChoiceVA(rc1, "Source type:",
 408         "Disk", SOURCE_DISK,
 409         "Pipe", SOURCE_PIPE,
 410         NULL);
 411     rc1 = CreateHContainer(rc);
 412     ui->hotfile = CreateTextItem(rc1, 20, "File name:");
 413     wbut = CreateButton(rc1, "Browse...");
 414     AddButtonCB(wbut, create_hotfiles_popup, ui);
 415
 416     return ui;
 417 }
 418
 419 void update_ssd_ui(SSDataUI *ui, Quark *q)
 420 {
 421     if (ui && q) {
 422         int i, nc, nr, new_nc, new_nr, ncols, nrows, nfixed_cols;
 423         int delta_nc, delta_nr;
 424         int *maxlengths;
 425         char **rowlabels, **collabels;
 426
 427         if (ui->q != q) {
 428             TableDeselectAllCells(ui->mw);
 429         }
 430
 431         ui->q = q;
 432
 433         ncols = ssd_get_ncols(q);
 434         nrows = ssd_get_nrows(q);
 435
 436         new_nc = ncols + EXTRA_SS_COLS;
 437         new_nr = nrows + EXTRA_SS_ROWS;
 438
 439         if (ssd_is_indexed(q)) {
 440             nfixed_cols = 1;
 441         } else {
 442             nfixed_cols = 0;
 443         }
 444
 445         nr = TableGetNrows(ui->mw);
 446         nc = TableGetNcols(ui->mw);
 447
 448         delta_nr = new_nr - nr;
 449         delta_nc = new_nc - nc;
 450
 451         if (delta_nr > 0) {
 452             TableAddRows(ui->mw, delta_nr);
 453         } else if (delta_nr < 0) {
 454             TableDeleteRows(ui->mw, -delta_nr);
 455         }
 456
 457         rowlabels = xmalloc(new_nr*sizeof(char *));
 458         for (i = 0; i < new_nr; i++) {
 459             char buf[32];
 460             sprintf(buf, "%d", i + 1);
 461             rowlabels[i] = copy_string(NULL, buf);
 462         }
 463         TableSetRowLabels(ui->mw, rowlabels);
 464         for (i = 0; i < new_nr; i++) {
 465             xfree(rowlabels[i]);
 466         }
 467         xfree(rowlabels);
 468
 469         maxlengths = xmalloc(new_nc*SIZEOF_INT);
 470         collabels = xmalloc(new_nc*sizeof(char *));
 471
 472         for (i = 0; i < new_nc; i++) {
 473             ss_column *col = ssd_get_col(q, i);
 474             if (col && col->format == FFORMAT_STRING) {
 475                 maxlengths[i] = STRING_CELL_WIDTH;
 476             } else {
 477                 maxlengths[i] = 2*CELL_WIDTH;
 478             }
 479             if (col && !string_is_empty(col->label)) {
 480                 collabels[i] = copy_string(NULL, col->label);
 481             } else {
 482                 unsigned int coli;
 483                 char buf[32];
 484
 485                 coli = i;
 486                 sprintf(buf, "%c", coli%26 + 'A');
 487                 while ((coli /= 26)) {
 488                     memmove(&buf[1], buf, strlen(buf) + 1);
 489                     buf[0] = coli%26 + 'A' - 1;
 490                 }
 491
 492                 collabels[i] = copy_string(NULL, buf);
 493             }
 494         }
 495
 496         if (delta_nc > 0) {
 497             TableAddCols(ui->mw, delta_nc);
 498         } else if (delta_nc < 0) {
 499             TableDeleteCols(ui->mw, -delta_nc);
 500         }
 501
 502         TableSetColMaxlengths(ui->mw, maxlengths);
 503         TableSetColLabels(ui->mw, collabels);
 504         TableSetFixedCols(ui->mw, nfixed_cols);
 505         TableUpdateVisibleRowsCols(ui->mw);
 506
 507         xfree(maxlengths);
 508         for (i = 0; i < new_nc; i++) {
 509             xfree(collabels[i]);
 510         }
 511         xfree(collabels);
 512
 513         UpdateColChoice(ui->col_sel, q);
 514     }
 515 }
 516
 517 int set_ssd_data(SSDataUI *ui, Quark *q, void *caller)
 518 {
 519     int retval = RETURN_SUCCESS;
 520
 521     if (ui && q) {
 522         if (!caller) {
 523             /* commit the last entered cell changes */
 524             TableCommitEdit(ui->mw, FALSE);
 525         }
 526
 527         if (!caller || caller == ui->col_label) {
 528             int col;
 529             if (GetSingleListChoice(ui->col_sel, &col) == RETURN_SUCCESS) {
 530                 char *s = GetTextString(ui->col_label);
 531                 ssd_set_col_label(q, col, s);
 532                 xfree(s);
 533
 534                 /* FIXME: this is an overkill */
 535                 update_ssd_ui(ui, q);
 536             }
 537         }
 538     }
 539
 540     return retval;
 541 }