2019-07-22 20:32:33 +00:00
|
|
|
# data file for the Fltk User Interface Designer (fluid)
|
|
|
|
version 1.0300
|
|
|
|
header_name {.h}
|
|
|
|
code_name {.cxx}
|
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
decl {\#include <FL/Fl_Table.H>} {public global}
|
|
|
|
decl {\#include <FL/Fl_Select_Browser.H>} {public global}
|
|
|
|
decl {\#include <FL/Fl_Sys_Menu_Bar.H>} {public global}
|
|
|
|
|
|
|
|
decl {\#include "display.h"} {public global}
|
|
|
|
|
|
|
|
decl {\#include <unistd.h>} {private global}
|
|
|
|
decl {\#include <stdint.h>} {private global}
|
|
|
|
decl {\#include <limits.h>} {private global}
|
|
|
|
decl {\#include <fcntl.h>} {private global}
|
|
|
|
|
2019-08-03 16:42:32 +00:00
|
|
|
decl {\#define SKIPDEFCOLS(c) while (c == DefaultCN[FOREGROUND] || c == DefaultCN[BACKGROUND]) ++c}
|
2019-08-03 03:21:58 +00:00
|
|
|
{private global}
|
2019-08-03 00:31:48 +00:00
|
|
|
decl {\#define shadow _shadow} {private global}
|
|
|
|
decl {\#define transparent _transparent} {private global}
|
|
|
|
decl {\#define MenuChoice _MenuChoice} {private global}
|
|
|
|
decl {\#define Cell _Cell} {private global}
|
|
|
|
|
|
|
|
decl {\#include <FL/fl_message.H>} {private local}
|
|
|
|
decl {\#include <FL/fl_draw.H>} {private global}
|
|
|
|
decl {\#include <FL/Fl_Native_File_Chooser.H>} {private global}
|
|
|
|
decl {\#include <FL/Fl_File_Icon.H>} {private global}
|
|
|
|
decl {\#include <FL/filename.H>} {private global}
|
|
|
|
|
|
|
|
decl {\#undef shadow} {private global}
|
|
|
|
decl {\#undef transparent} {private global}
|
|
|
|
decl {\#undef MenuChoice} {private global}
|
|
|
|
decl {\#undef Cell} {private global}
|
|
|
|
|
|
|
|
decl {\#include "tpt_choose.h"} {private global}
|
2019-08-03 03:21:58 +00:00
|
|
|
decl {\#include "default.h"} {private global}
|
2019-08-03 00:31:48 +00:00
|
|
|
decl {\#include "misc.h"} {private global}
|
|
|
|
|
2019-08-03 03:21:58 +00:00
|
|
|
decl {Fl_Color tpt_selection_version(Fl_Color base);} {private global}
|
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
class TeapotTable {open : {public Fl_Table}}
|
|
|
|
{
|
|
|
|
decl {Sheet *cursheet;} {protected local}
|
|
|
|
decl {bool cut, updating;} {protected local}
|
|
|
|
decl {static const TableContext ACTION = (TableContext)(1<<8);}
|
|
|
|
{public local}
|
|
|
|
decl {static const TableContext REFRESH = (TableContext)(1<<9);}
|
|
|
|
{public local}
|
|
|
|
|
|
|
|
Function
|
|
|
|
{TeapotTable(int x, int y, int w, int h, const char *l=0) :
|
|
|
|
Fl_Table(x, y, w, h, l), cut(false), updating(false)} {open} {code
|
|
|
|
{
|
|
|
|
end();
|
|
|
|
col_resize_min(10);
|
|
|
|
col_resize(true);
|
|
|
|
col_header(header);
|
|
|
|
row_resize(false);
|
|
|
|
row_header(header);
|
|
|
|
set_visible_focus();
|
|
|
|
table_box(FL_THIN_UP_FRAME);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function {~TeapotTable()} {} {code {} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{sheet(Sheet *s)} {open return_type void} {code
|
|
|
|
{
|
|
|
|
cursheet = s;
|
|
|
|
s->display = (void *)this;
|
|
|
|
clear();
|
|
|
|
update_table();
|
|
|
|
do_callback(CONTEXT_NONE, 0, 0);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function {sheet()} {return_type {Sheet *}} {code {return cursheet;} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{draw_cell(TableContext context, int R, int C, int xx, int yy,
|
|
|
|
int W, int H)} {open return_type void} {code
|
|
|
|
{
|
|
|
|
char s[1024];
|
|
|
|
if (debug_level > 2)
|
|
|
|
printf("DRAW: %i @%i,%i - (%i,%i) %ix%i\\n",
|
|
|
|
context, C, R, xx, yy, W, H);
|
|
|
|
switch (context) {
|
|
|
|
case CONTEXT_ENDPAGE:
|
|
|
|
W = xx-x()-2; H = yy-y()-2;
|
|
|
|
xx = x()+2; yy = y()+2;
|
|
|
|
fl_font(FL_HELVETICA | FL_BOLD, 14);
|
|
|
|
fl_push_clip(xx, yy, W, H);
|
|
|
|
fl_draw_box(FL_DIAMOND_UP_BOX, xx, yy, W, H, col_header_color());
|
|
|
|
fl_color(FL_INACTIVE_COLOR);
|
|
|
|
sprintf(s, "%d", cursheet->cur[Z]);
|
|
|
|
fl_draw(s, xx, yy, W, H, FL_ALIGN_CENTER);
|
|
|
|
fl_pop_clip();
|
2019-07-27 04:14:26 +00:00
|
|
|
break;
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
case CONTEXT_STARTPAGE:
|
|
|
|
adjust_outside();
|
|
|
|
if (Fl::event_button1()) update_sheet();
|
|
|
|
break;
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 03:21:58 +00:00
|
|
|
case CONTEXT_COL_HEADER: {
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_font(FL_HELVETICA | FL_BOLD, 14);
|
|
|
|
fl_push_clip(xx, yy, W, H);
|
2019-08-03 03:21:58 +00:00
|
|
|
Fl_Color hd_clr = col_header_color();
|
|
|
|
if (C == cursheet->cur[X]) hd_clr = tpt_selection_version(hd_clr);
|
|
|
|
fl_draw_box(FL_THIN_UP_BOX, xx, yy, W, H, hd_clr);
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_color(FL_FOREGROUND_COLOR);
|
|
|
|
sprintf(s, "%d", C);
|
|
|
|
fl_draw(s, xx, yy, W, H, FL_ALIGN_CENTER);
|
|
|
|
fl_pop_clip();
|
|
|
|
return;
|
2019-08-03 03:21:58 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
|
2019-08-03 03:21:58 +00:00
|
|
|
case CONTEXT_ROW_HEADER: {
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_font(FL_HELVETICA | FL_BOLD, 14);
|
|
|
|
fl_push_clip(xx, yy, W, H);
|
2019-08-03 03:21:58 +00:00
|
|
|
Fl_Color hd_clr = row_header_color();
|
|
|
|
if (R == cursheet->cur[Y]) hd_clr = tpt_selection_version(hd_clr);
|
|
|
|
fl_draw_box(FL_THIN_UP_BOX, xx, yy, W, H, hd_clr);
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_color(FL_FOREGROUND_COLOR);
|
|
|
|
sprintf(s, "%d", R);
|
|
|
|
fl_draw(s, xx, yy, W, H, FL_ALIGN_CENTER);
|
|
|
|
fl_pop_clip();
|
|
|
|
return;
|
2019-08-03 03:21:58 +00:00
|
|
|
}
|
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
case CONTEXT_CELL: {
|
|
|
|
while (SHADOWEDC(cursheet, C, R, cursheet->cur[Z]))
|
|
|
|
xx -= W = col_width(--C);
|
|
|
|
int x = C+1;
|
|
|
|
while (SHADOWEDC(cursheet, x, R, cursheet->cur[Z]))
|
|
|
|
W += col_width(x), x++;
|
|
|
|
|
|
|
|
fl_push_clip(xx, yy, W, H);
|
|
|
|
bool selected = false;
|
|
|
|
MarkState ms = getmarkstate(cursheet);
|
|
|
|
Location test;
|
|
|
|
test[X] = C; test[Y] = R; test[Z] = cursheet->cur[Z];
|
|
|
|
if (ms != UNMARKED)
|
|
|
|
selected = loc_in_box(test, cursheet->mark1, cursheet->mark2);
|
2019-08-03 03:21:58 +00:00
|
|
|
bool iscurrent = (C == cursheet->cur[X] && R == cursheet->cur[Y]);
|
|
|
|
Cell *cell = safe_cell_at(cursheet, test);
|
|
|
|
Fl_Color cellbg =
|
2019-08-03 16:42:32 +00:00
|
|
|
((Fl_Color *)(cursheet->palette))[getcolor(cell, BACKGROUND)];
|
2019-08-03 03:21:58 +00:00
|
|
|
if (selected) cellbg = tpt_selection_version(cellbg);
|
|
|
|
if (!LOC_WITHIN(cursheet,test))
|
|
|
|
cellbg = fl_color_average(cellbg, FL_BLACK, 0.97);
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_draw_box(iscurrent ? FL_BORDER_BOX : FL_THIN_DOWN_BOX,
|
2019-08-03 03:21:58 +00:00
|
|
|
xx, yy, W, H, cellbg);
|
2019-08-03 00:31:48 +00:00
|
|
|
if (Fl::focus() == this && iscurrent)
|
|
|
|
draw_focus(FL_BORDER_BOX, xx, yy, W, H);
|
|
|
|
fl_pop_clip();
|
|
|
|
|
|
|
|
fl_push_clip(xx+3, yy+3, W-6, H-6);
|
2019-08-03 03:21:58 +00:00
|
|
|
Fl_Color cellfg =
|
2019-08-03 16:42:32 +00:00
|
|
|
((Fl_Color *)(cursheet->palette))[getcolor(cell, FOREGROUND)];
|
2019-08-03 03:21:58 +00:00
|
|
|
fl_color(cellfg);
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_font(FL_HELVETICA | (isbold(cell) ? FL_BOLD : 0), 14);
|
|
|
|
|
|
|
|
printvalue(s, sizeof(s), 0, 0, getscientific(cell),
|
|
|
|
getprecision(cell), cursheet, test);
|
|
|
|
|
|
|
|
int ww = 0, hh = 0;
|
|
|
|
fl_measure(s, ww, hh, 0);
|
|
|
|
if (ww > W-6) for (int i = 0; s[i]; i++) s[i] = '\#';
|
|
|
|
|
Streamline internals of teapot
The primary change is to add a “funcall” token, so that an entire expression
can be encapsulated as a single token. This change is used to allow a cell to
include simply a selection of appropriate semantic tokens. I.e., the content
and iterative content are now each a single token like the value and the
result value. Token vectors are used only as intermediate results in scanning
and parsing.
Not this means the cells are now in effect storing parse trees, so
computation should be slightly faster and future extensions (like #56) should
be facilitated.
This commit also takes the opportunity while internals are being altered to
add another token to a cell for future use for computed attributes, cf #22,
and to change the internal numerical values from double and ints to long
doubles and long longs. However, the change attempts to encapsulate that
choice so it would be easy to change back or change to another representation.
Note that these changes break savexdr(), as the internal binary format of
a cell is now different. Rather than reimplement it, it is deprecated as
the world does not need another binary spreadsheet format. Hence, the
ascii format for teapot spreadsheets becomes the primary file format.
Loading of old xdr files is still supported for backward compatibility.
Closes #59.
Also along the way, various other slight fixes and enhancements crept in,
a partial but probably not exhaustive list of which follows:
Fixes #31.
Further revisions and improvements to documentation.
Make the approximate comparison of floating point values scale more
accurately with the size of the doubles being compared.
Further extensions of absolute and relative cell addressing.
Addition of (circle constant) tau function/constant.
Modified string conversion to simply use internal printing routines, and
to take "scientific" and "decimal" keywords.
Allowed n() function to take a list of values, or just a single location
defaulting to the current location.
Added floor, ceil, trunc, and round functions, and allowed them to be
keywords controlling the int() integer conversion function as well.
Allowed substr() to drop its last argument to go to the end of the string.
Provided an enum of built-in functions to preserve legacy function
identifiers, allowing the large table inside func.c to be reorganized
in a clearer fashion.
Added additional annotation of properties of the built-in functions,
including precedence.
All operators are now also accessible as built-in functions.
Made precedence of unary - lower than ^ to match python.
Avoided inadvertently using FLTK @symbol abbreviations for formulas with
"@" in them.
2019-08-23 19:12:06 +00:00
|
|
|
Adjust adj = getadjust(cell);
|
2019-08-03 00:31:48 +00:00
|
|
|
fl_draw(s, xx+3, yy+3, W-6, H-6,
|
|
|
|
adj == RIGHT ? FL_ALIGN_RIGHT :
|
Streamline internals of teapot
The primary change is to add a “funcall” token, so that an entire expression
can be encapsulated as a single token. This change is used to allow a cell to
include simply a selection of appropriate semantic tokens. I.e., the content
and iterative content are now each a single token like the value and the
result value. Token vectors are used only as intermediate results in scanning
and parsing.
Not this means the cells are now in effect storing parse trees, so
computation should be slightly faster and future extensions (like #56) should
be facilitated.
This commit also takes the opportunity while internals are being altered to
add another token to a cell for future use for computed attributes, cf #22,
and to change the internal numerical values from double and ints to long
doubles and long longs. However, the change attempts to encapsulate that
choice so it would be easy to change back or change to another representation.
Note that these changes break savexdr(), as the internal binary format of
a cell is now different. Rather than reimplement it, it is deprecated as
the world does not need another binary spreadsheet format. Hence, the
ascii format for teapot spreadsheets becomes the primary file format.
Loading of old xdr files is still supported for backward compatibility.
Closes #59.
Also along the way, various other slight fixes and enhancements crept in,
a partial but probably not exhaustive list of which follows:
Fixes #31.
Further revisions and improvements to documentation.
Make the approximate comparison of floating point values scale more
accurately with the size of the doubles being compared.
Further extensions of absolute and relative cell addressing.
Addition of (circle constant) tau function/constant.
Modified string conversion to simply use internal printing routines, and
to take "scientific" and "decimal" keywords.
Allowed n() function to take a list of values, or just a single location
defaulting to the current location.
Added floor, ceil, trunc, and round functions, and allowed them to be
keywords controlling the int() integer conversion function as well.
Allowed substr() to drop its last argument to go to the end of the string.
Provided an enum of built-in functions to preserve legacy function
identifiers, allowing the large table inside func.c to be reorganized
in a clearer fashion.
Added additional annotation of properties of the built-in functions,
including precedence.
All operators are now also accessible as built-in functions.
Made precedence of unary - lower than ^ to match python.
Avoided inadvertently using FLTK @symbol abbreviations for formulas with
"@" in them.
2019-08-23 19:12:06 +00:00
|
|
|
adj == LEFT ? FL_ALIGN_LEFT : FL_ALIGN_CENTER,
|
|
|
|
NULL, 0);
|
2019-08-03 00:31:48 +00:00
|
|
|
if (underlined(cell)) fl_xyline(xx, yy+H-7, xx+W);
|
|
|
|
fl_pop_clip();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} {selected} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{update_table()} {open return_type void} {code
|
|
|
|
{
|
|
|
|
if (updating) return;
|
|
|
|
updating = true;
|
|
|
|
if (debug_level > 2)
|
|
|
|
printf("update_table: %ix%i@%i,%i; %i[%i], %i[%i]\\n",
|
|
|
|
cursheet->dimx, cursheet->dimy,
|
|
|
|
cursheet->cur[X], cursheet->cur[Y],
|
|
|
|
cursheet->offx, cursheet->maxx,
|
|
|
|
cursheet->offy, cursheet->maxy);
|
|
|
|
|
|
|
|
if (cursheet->dimx > cols()) cols(cursheet->dimx);
|
|
|
|
if (cursheet->dimy > rows()) rows(cursheet->dimy);
|
|
|
|
adjust_outside();
|
|
|
|
|
|
|
|
for (int x = 0; x < cursheet->dimx; x++) {
|
|
|
|
int w = columnwidth(cursheet, x, cursheet->cur[Z])*10;
|
|
|
|
if (col_width(x) != w) col_width(x, w);
|
|
|
|
}
|
|
|
|
col_position(cursheet->offx);
|
|
|
|
row_position(cursheet->offy);
|
|
|
|
set_selection(cursheet->cur[Y], cursheet->cur[X],
|
|
|
|
cursheet->cur[Y], cursheet->cur[X]);
|
|
|
|
move_cursor(0,0);
|
|
|
|
updating = false;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{update_sheet()} {return_type void} {code
|
|
|
|
{
|
|
|
|
int x1, x2, y1, y2;
|
|
|
|
|
|
|
|
if (updating) return;
|
|
|
|
updating = true;
|
|
|
|
|
|
|
|
get_selection(y1, x1, y2, x2);
|
|
|
|
if (x1 != x2 || y1 != y2) {
|
|
|
|
cursheet->mark1[X] = x1;
|
|
|
|
cursheet->mark1[Y] = y1;
|
|
|
|
cursheet->mark2[X] = x2;
|
|
|
|
cursheet->mark2[Y] = y2;
|
|
|
|
cursheet->mark1[Z] = cursheet->mark2[Z] = cursheet->cur[Z];
|
|
|
|
cursheet->marking = MARKED;
|
|
|
|
}
|
|
|
|
moveto(cursheet, current_col, current_row, -1);
|
|
|
|
visible_cells(cursheet->offy, cursheet->maxy,
|
|
|
|
cursheet->offx, cursheet->maxx);
|
|
|
|
cursheet->maxx -= cursheet->offx;
|
|
|
|
cursheet->maxy -= cursheet->offy;
|
|
|
|
|
|
|
|
if (is_interactive_resize()) {
|
|
|
|
for (int C = 0; C < cursheet->dimx; C++) {
|
|
|
|
int w = (col_width(C) + 5)/10;
|
|
|
|
if (w != columnwidth(cursheet, C, cursheet->cur[Z]))
|
|
|
|
setwidth(cursheet, C, cursheet->cur[Z], w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
updating = false;
|
|
|
|
if (debug_level > 2)
|
|
|
|
printf("upd_sheet: %ix%i@%i,%i; %i[%i], %i[%i] (%i,%i)-(%i,%i)\\n",
|
|
|
|
cols(), rows(), cursheet->cur[X], cursheet->cur[Y],
|
|
|
|
cursheet->offx, cursheet->maxx,
|
|
|
|
cursheet->offy, cursheet->maxy, x1, y1, x2, y2);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{handle(int event)} {open return_type int} {code
|
|
|
|
{
|
|
|
|
if (event == FL_KEYDOWN) {
|
|
|
|
int ctrl = Fl::event_ctrl();
|
|
|
|
int alt = Fl::event_alt();
|
|
|
|
int shift = Fl::event_shift();
|
|
|
|
Key k = (Key)Fl::event_key();
|
|
|
|
|
|
|
|
switch ((unsigned int)k) {
|
|
|
|
case FL_Escape: k = K_INVALID; break;
|
|
|
|
case FL_BackSpace: k = K_BACKSPACE; break;
|
|
|
|
case FL_F+1: k = ctrl?K_ABOUT:K_HELP; break;
|
|
|
|
case FL_F+8: k = ctrl?K_RECALC:K_CLOCK; break;
|
|
|
|
case FL_F+9: k = ctrl?K_RECALC:K_CLOCK; break;
|
|
|
|
case FL_F+10: k = (Key)'/'; break;
|
|
|
|
case FL_Tab: if (shift) { k = K_CLOCK; break; }
|
|
|
|
case FL_Enter:
|
|
|
|
case FL_KP_Enter: k = alt?K_MENTER:K_ENTER; break;
|
|
|
|
case 'c':
|
|
|
|
if (ctrl) {
|
|
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
|
|
cut = false;
|
|
|
|
k = K_NONE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'v':
|
|
|
|
if (ctrl) {
|
|
|
|
do_mark(cursheet, MARKED);
|
|
|
|
k = cut ? BLOCK_MOVE : BLOCK_COPY;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'x':
|
|
|
|
if (ctrl) {
|
|
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
|
|
cut = true;
|
|
|
|
k = K_NONE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'r': if (ctrl) k = K_RECALC; break;
|
|
|
|
case 'd':
|
|
|
|
if (ctrl && shift && debug_level > 0) k = K_DUMPCELL;
|
|
|
|
break;
|
|
|
|
case FL_Insert:
|
|
|
|
if (ctrl) {
|
|
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
|
|
cut = false;
|
|
|
|
}
|
|
|
|
k = !shift ? K_NONE : cut ? BLOCK_MOVE : BLOCK_COPY;
|
|
|
|
break;
|
|
|
|
case FL_Delete:
|
|
|
|
if (shift) {
|
|
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
|
|
cut = true;
|
|
|
|
}
|
|
|
|
k = shift ? K_NONE : BLOCK_CLEAR;
|
|
|
|
break;
|
|
|
|
case FL_Home: k = ctrl ? K_FIRSTL : shift ? K_FSHEET: K_HOME; break;
|
|
|
|
case FL_End: k = ctrl ? K_LASTL : shift ? K_LSHEET : K_END; break;
|
|
|
|
case FL_Up:
|
|
|
|
if (shift) do_mark(cursheet, MARKING);
|
|
|
|
k = ctrl ? K_PPAGE : K_UP;
|
|
|
|
break;
|
|
|
|
case FL_Down:
|
|
|
|
if (shift) do_mark(cursheet, MARKING);
|
|
|
|
k = ctrl ? K_NPAGE : K_DOWN;
|
|
|
|
break;
|
|
|
|
case FL_Right:
|
|
|
|
if (shift) do_mark(cursheet, MARKING);
|
|
|
|
k = ctrl ? K_FPAGE : K_RIGHT;
|
|
|
|
break;
|
|
|
|
case FL_Left:
|
|
|
|
if (shift) do_mark(cursheet, MARKING);
|
|
|
|
k = ctrl ? K_BPAGE : K_LEFT; break;
|
|
|
|
case FL_Page_Down:
|
|
|
|
k = shift ? K_NSHEET : ctrl ? K_LASTL : K_NPAGE;
|
|
|
|
break;
|
|
|
|
case FL_Page_Up:
|
|
|
|
k = shift ? K_PSHEET : ctrl ? K_FIRSTL : K_PPAGE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (k > 0 && (ctrl || alt)) return 0;
|
|
|
|
|
|
|
|
// Quick and dirty upper-case fix, fails for international chars on keyboards...
|
|
|
|
if (shift && !alt && !ctrl && k >= 'a' && k <= 'z')
|
|
|
|
k = (Key)(k - 'a' + 'A');
|
|
|
|
|
|
|
|
do_sheetcmd(cursheet, k, cursheet->moveonly);
|
|
|
|
do_callback(ACTION, 0, 0);
|
|
|
|
redraw();
|
|
|
|
} else if (event == FL_FOCUS) {
|
|
|
|
do_callback(REFRESH, 0, 0);
|
|
|
|
return 1;
|
|
|
|
} else if (event == FL_PUSH) {
|
|
|
|
int ex = Fl::event_x() - x(), ey = Fl::event_y() - y();
|
|
|
|
if (ex >= row_header_width() || ey >= col_header_height()) {
|
2019-07-22 20:32:33 +00:00
|
|
|
int rc = Fl_Table::handle(event);
|
|
|
|
do_callback(ACTION, 0, 0);
|
|
|
|
return rc;
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
if (ex < row_header_width()/2) relmoveto(cursheet, 0, 0, -1);
|
|
|
|
else relmoveto(cursheet, 0, 0, 1);
|
|
|
|
return 1;
|
|
|
|
} else if (event != FL_KEYUP) {
|
|
|
|
return Fl_Table::handle(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{adjust_outside()} {open protected return_type void} {code
|
|
|
|
{
|
|
|
|
int x1, x2, y1, y2;
|
|
|
|
|
|
|
|
if (!cols() || !rows()) { cols(1); rows(1); }
|
|
|
|
|
|
|
|
visible_cells(y1, y2, x1, x2);
|
|
|
|
if (debug_level > 2)
|
|
|
|
printf("adj: (%i,%i)-(%i,%i) %ix%i\\n", x1, y1, x2, y2,
|
|
|
|
cols(), rows());
|
|
|
|
if (x2+2 < cols() && cols() > cursheet->dimx)
|
|
|
|
cols(x2+2 < cursheet->dimx?cursheet->dimx:x2+2);
|
|
|
|
else if (x2+1 == cols()) {
|
|
|
|
int xpos = col_scroll_position(cols());
|
|
|
|
int w = col_width(cols()-1);
|
|
|
|
x2 += (tow + hscrollbar->value() - xpos) / w + 2;
|
|
|
|
//printf(" : t: %i, w: %i, p: %i, r: %i\\n", tow, w, xpos, x2+1);
|
|
|
|
cols(x2+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (y2+2 < rows() && rows() > cursheet->dimy)
|
|
|
|
rows(y2+2 < cursheet->dimy?cursheet->dimy:y2+2);
|
|
|
|
else if (y2+1 == rows()) {
|
|
|
|
int ypos = row_scroll_position(rows());
|
|
|
|
int h = row_height(rows()-1);
|
|
|
|
y2 += (toh + vscrollbar->value() - ypos) / h + 2;
|
|
|
|
rows(y2+1);
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
} {} }
|
|
|
|
|
|
|
|
}
|
|
|
|
# End of class TeapotTable
|
|
|
|
|
|
|
|
class MainWindow {open}
|
|
|
|
{
|
|
|
|
decl {static MainWindow *current;} {protected local}
|
|
|
|
decl {int edit_rc;} {private local}
|
|
|
|
|
|
|
|
Function
|
|
|
|
{MainWindow(Sheet *sheet)} {open}
|
|
|
|
{
|
|
|
|
Fl_Window window {
|
|
|
|
label teapot
|
|
|
|
callback {
|
|
|
|
if (Fl::event_key(FL_Escape)) table->take_focus();
|
|
|
|
else if (do_sheetcmd(table->sheet(), K_QUIT, 0) &&
|
|
|
|
doanyway(table->sheet(),
|
|
|
|
_("Sheet modified, leave anyway?"))) {
|
|
|
|
line_label->deactivate();
|
|
|
|
window->hide();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
open protected
|
|
|
|
xywh {866 342 800 600} type Double when 0 hide resizable
|
|
|
|
}
|
|
|
|
{
|
|
|
|
Fl_Menu_Bar menu {
|
|
|
|
callback {
|
|
|
|
Sheet *sheet = table->sheet();
|
|
|
|
Key action = (Key)(intptr_t)o->mvalue()->user_data();
|
|
|
|
|
|
|
|
if (do_sheetcmd(sheet, action, sheet->moveonly) &&
|
|
|
|
doanyway(sheet, _("Sheet modified, leave anyway?")))
|
|
|
|
{
|
|
|
|
window->hide();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
table->update_table();
|
|
|
|
table->redraw();
|
|
|
|
}
|
|
|
|
open xywh {0 0 800 25} class Fl_Sys_Menu_Bar
|
|
|
|
}
|
|
|
|
{
|
|
|
|
Submenu {} {label {&File} xywh {25 25 67 24} } {
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Open...}
|
|
|
|
user_data K_LOADMENU
|
|
|
|
xywh {5 5 30 20} shortcut 0x4006f
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Save}
|
|
|
|
user_data K_SAVE
|
|
|
|
xywh {0 0 30 20} shortcut 0x40073
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {Save &As...}
|
|
|
|
user_data K_NAME
|
|
|
|
xywh {0 0 30 20} shortcut 0x50053 divider
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Quit}
|
|
|
|
user_data K_QUIT
|
|
|
|
xywh {0 0 30 20} shortcut 0x40071
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
Submenu {} {label {&Block} xywh {25 25 67 24} } {
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Insert}
|
|
|
|
user_data BLOCK_INSERT
|
|
|
|
xywh {0 0 30 20} shortcut 0x90069
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
MenuItem {} {
|
|
|
|
label {&Delete}
|
|
|
|
user_data BLOCK_DELETE
|
|
|
|
xywh {0 0 30 20} shortcut 0x90064 divider
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
MenuItem {} {
|
|
|
|
label {&Move}
|
|
|
|
user_data BLOCK_MOVE
|
|
|
|
xywh {0 0 30 20} shortcut 0x9006d
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
MenuItem {} {
|
|
|
|
label {&Copy}
|
|
|
|
user_data BLOCK_COPY
|
|
|
|
xywh {0 0 36 21} shortcut 0x90063 divider
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
MenuItem {} {
|
|
|
|
label {&Fill}
|
|
|
|
user_data BLOCK_FILL
|
|
|
|
xywh {0 0 36 21} shortcut 0x90066
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
MenuItem {} {
|
|
|
|
label {FillWith}
|
|
|
|
user_data FILL_BLOCK
|
|
|
|
xywh {0 0 36 30}
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {C&lear}
|
|
|
|
user_data BLOCK_CLEAR
|
|
|
|
xywh {0 0 36 21} shortcut 0x9006c divider
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Sort}
|
|
|
|
user_data BLOCK_SORT
|
|
|
|
xywh {0 0 36 21} shortcut 0x90073
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {Mi&rror}
|
|
|
|
user_data BLOCK_MIRROR
|
|
|
|
xywh {0 0 36 21} shortcut 0x90072
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Submenu {} {label {&View} xywh {0 0 70 21}} {
|
|
|
|
MenuItem {} {
|
|
|
|
label {Column &Width...}
|
|
|
|
user_data K_COLWIDTH
|
|
|
|
xywh {0 0 36 21} shortcut 0x80077
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Goto}
|
|
|
|
user_data K_GOTO
|
|
|
|
xywh {0 0 36 21} shortcut 0x40067
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Submenu {} {label {F&ormat} open xywh {5 5 70 21}} {
|
|
|
|
MenuItem {} {
|
|
|
|
label {L&abel...}
|
|
|
|
user_data ADJUST_LABEL
|
|
|
|
xywh {0 0 36 21} shortcut 0x80061 divider
|
|
|
|
}
|
|
|
|
MenuItem bold {
|
|
|
|
label {&Bold}
|
|
|
|
user_data ADJUST_BOLD
|
|
|
|
protected xywh {0 0 34 21} shortcut 0x80062
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem underline {
|
|
|
|
label {&Underline}
|
|
|
|
user_data ADJUST_UNDERLINE
|
|
|
|
protected xywh {0 0 34 21} shortcut 0x80075 divider
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem left {
|
|
|
|
label {&Left}
|
|
|
|
user_data ADJUST_LEFT
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x8006c
|
|
|
|
code0 {o->flags |= FL_MENU_RADIO;}
|
|
|
|
}
|
|
|
|
MenuItem right {
|
|
|
|
label {&Right}
|
|
|
|
user_data ADJUST_RIGHT
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80072
|
|
|
|
code0 {o->flags |= FL_MENU_RADIO;}
|
|
|
|
}
|
|
|
|
MenuItem center {
|
|
|
|
label {&Center}
|
|
|
|
user_data ADJUST_CENTER
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80063 divider
|
|
|
|
code0 {o->flags |= FL_MENU_RADIO;}
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Precision...}
|
|
|
|
user_data ADJUST_PRECISION
|
|
|
|
xywh {0 0 36 21} shortcut 0x80070 divider
|
|
|
|
}
|
|
|
|
MenuItem sci {
|
|
|
|
label {&Scientific}
|
|
|
|
user_data ADJUST_SCIENTIFIC
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80073
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem shadow {
|
|
|
|
label {Shadow&ed}
|
|
|
|
user_data ADJUST_SHADOW
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80065
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem transparent {
|
|
|
|
label {&Transparent}
|
|
|
|
user_data ADJUST_TRANSPARENT
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80074 divider
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem lock {
|
|
|
|
label {Lo&ck}
|
|
|
|
user_data ADJUST_LOCK
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80063
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
MenuItem ignore {
|
|
|
|
label {&Ignore}
|
|
|
|
user_data ADJUST_IGNORE
|
|
|
|
protected xywh {0 0 36 21} shortcut 0x80069
|
|
|
|
code0 {o->flags |= FL_MENU_TOGGLE;}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Submenu {} {label {&Help} open xywh {25 25 67 24}} {
|
|
|
|
MenuItem {} {
|
|
|
|
label {&Manual}
|
|
|
|
user_data K_HELP
|
|
|
|
xywh {0 0 30 20} shortcut 0xffbe
|
|
|
|
}
|
|
|
|
MenuItem {} {
|
|
|
|
label {&About}
|
|
|
|
user_data K_ABOUT
|
|
|
|
xywh {0 0 30 20}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Fl_Group line_label {
|
|
|
|
label { Input:} open
|
|
|
|
protected xywh {0 25 800 25} box ROUND_UP_BOX align 20 deactivate
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
{
|
|
|
|
Fl_Input line_input {
|
|
|
|
callback {
|
|
|
|
bool enterkey = Fl::event_key(FL_Enter) ||
|
|
|
|
Fl::event_key(FL_KP_Enter);
|
|
|
|
if (Fl::focus() &&
|
|
|
|
(Fl::focus() != table || enterkey ||
|
|
|
|
Fl::event_key(FL_Escape))) {
|
|
|
|
if (enterkey) edit_rc = 0;
|
|
|
|
line_label->deactivate();
|
|
|
|
}
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
protected xywh {75 27 723 21} box ROUND_DOWN_BOX
|
|
|
|
labeltype NO_LABEL align 20 when 6 deactivate
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Fl_Box table {
|
|
|
|
callback {
|
|
|
|
Sheet *sheet = table->sheet();
|
|
|
|
table->update_sheet();
|
|
|
|
|
|
|
|
const char *label = getlabel(curcell(sheet));
|
|
|
|
char moveonly=sheet->moveonly ? *_("V") : *_("E");
|
|
|
|
|
|
|
|
char buf[1024];
|
|
|
|
if (*label == 0)
|
|
|
|
snprintf(buf, sizeof(buf), "%c @@(%d,%d,%d)=", moveonly,
|
|
|
|
sheet->cur[X], sheet->cur[Y], sheet->cur[Z]);
|
|
|
|
else snprintf(buf, sizeof(buf), "%c @@(%s)=", moveonly, label);
|
|
|
|
|
|
|
|
if (moveonly &&
|
|
|
|
table->callback_context() == TeapotTable::ACTION)
|
|
|
|
{
|
|
|
|
char valbuf[1024] = "";
|
|
|
|
if (Fl::event_key() == 'p' || Fl::event_button1())
|
|
|
|
sprintf(valbuf, "(%i,%i,%i)",
|
|
|
|
sheet->cur[X], sheet->cur[Y], sheet->cur[Z]);
|
|
|
|
else if (Fl::event_key() == 'v')
|
|
|
|
printvalue(valbuf, sizeof(valbuf), 0, 1,
|
|
|
|
getscientific(curcell(sheet)),
|
|
|
|
-1, sheet, sheet->cur);
|
|
|
|
else if (Fl::event_key(FL_Tab)) line_input->take_focus();
|
|
|
|
if (valbuf[0]) {
|
|
|
|
line_input->insert(valbuf);
|
|
|
|
line_input->take_focus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
char *err;
|
|
|
|
char val[1024];
|
|
|
|
if ((err = geterror(sheet, sheet->cur))) {
|
|
|
|
strncpy(val,err,sizeof(val));
|
|
|
|
free(err);
|
|
|
|
val[sizeof(val)-1] = 0;
|
|
|
|
} else {
|
Streamline internals of teapot
The primary change is to add a “funcall” token, so that an entire expression
can be encapsulated as a single token. This change is used to allow a cell to
include simply a selection of appropriate semantic tokens. I.e., the content
and iterative content are now each a single token like the value and the
result value. Token vectors are used only as intermediate results in scanning
and parsing.
Not this means the cells are now in effect storing parse trees, so
computation should be slightly faster and future extensions (like #56) should
be facilitated.
This commit also takes the opportunity while internals are being altered to
add another token to a cell for future use for computed attributes, cf #22,
and to change the internal numerical values from double and ints to long
doubles and long longs. However, the change attempts to encapsulate that
choice so it would be easy to change back or change to another representation.
Note that these changes break savexdr(), as the internal binary format of
a cell is now different. Rather than reimplement it, it is deprecated as
the world does not need another binary spreadsheet format. Hence, the
ascii format for teapot spreadsheets becomes the primary file format.
Loading of old xdr files is still supported for backward compatibility.
Closes #59.
Also along the way, various other slight fixes and enhancements crept in,
a partial but probably not exhaustive list of which follows:
Fixes #31.
Further revisions and improvements to documentation.
Make the approximate comparison of floating point values scale more
accurately with the size of the doubles being compared.
Further extensions of absolute and relative cell addressing.
Addition of (circle constant) tau function/constant.
Modified string conversion to simply use internal printing routines, and
to take "scientific" and "decimal" keywords.
Allowed n() function to take a list of values, or just a single location
defaulting to the current location.
Added floor, ceil, trunc, and round functions, and allowed them to be
keywords controlling the int() integer conversion function as well.
Allowed substr() to drop its last argument to go to the end of the string.
Provided an enum of built-in functions to preserve legacy function
identifiers, allowing the large table inside func.c to be reorganized
in a clearer fashion.
Added additional annotation of properties of the built-in functions,
including precedence.
All operators are now also accessible as built-in functions.
Made precedence of unary - lower than ^ to match python.
Avoided inadvertently using FLTK @symbol abbreviations for formulas with
"@" in them.
2019-08-23 19:12:06 +00:00
|
|
|
Token t = gettok(curcell(sheet), BASE_CONT);
|
|
|
|
printtok(val, sizeof(val), 0, 1, getscientific(curcell(sheet)),
|
|
|
|
-1, true, &t);
|
|
|
|
t = gettok(curcell(sheet), ITER_CONT);
|
|
|
|
if (t.type != EMPTY) {
|
2019-08-03 00:31:48 +00:00
|
|
|
snprintf(val+strlen(val),sizeof(val)-strlen(val),
|
|
|
|
" -> ");
|
Streamline internals of teapot
The primary change is to add a “funcall” token, so that an entire expression
can be encapsulated as a single token. This change is used to allow a cell to
include simply a selection of appropriate semantic tokens. I.e., the content
and iterative content are now each a single token like the value and the
result value. Token vectors are used only as intermediate results in scanning
and parsing.
Not this means the cells are now in effect storing parse trees, so
computation should be slightly faster and future extensions (like #56) should
be facilitated.
This commit also takes the opportunity while internals are being altered to
add another token to a cell for future use for computed attributes, cf #22,
and to change the internal numerical values from double and ints to long
doubles and long longs. However, the change attempts to encapsulate that
choice so it would be easy to change back or change to another representation.
Note that these changes break savexdr(), as the internal binary format of
a cell is now different. Rather than reimplement it, it is deprecated as
the world does not need another binary spreadsheet format. Hence, the
ascii format for teapot spreadsheets becomes the primary file format.
Loading of old xdr files is still supported for backward compatibility.
Closes #59.
Also along the way, various other slight fixes and enhancements crept in,
a partial but probably not exhaustive list of which follows:
Fixes #31.
Further revisions and improvements to documentation.
Make the approximate comparison of floating point values scale more
accurately with the size of the doubles being compared.
Further extensions of absolute and relative cell addressing.
Addition of (circle constant) tau function/constant.
Modified string conversion to simply use internal printing routines, and
to take "scientific" and "decimal" keywords.
Allowed n() function to take a list of values, or just a single location
defaulting to the current location.
Added floor, ceil, trunc, and round functions, and allowed them to be
keywords controlling the int() integer conversion function as well.
Allowed substr() to drop its last argument to go to the end of the string.
Provided an enum of built-in functions to preserve legacy function
identifiers, allowing the large table inside func.c to be reorganized
in a clearer fashion.
Added additional annotation of properties of the built-in functions,
including precedence.
All operators are now also accessible as built-in functions.
Made precedence of unary - lower than ^ to match python.
Avoided inadvertently using FLTK @symbol abbreviations for formulas with
"@" in them.
2019-08-23 19:12:06 +00:00
|
|
|
printtok(val+strlen(val), sizeof(val)-strlen(val), 0, 1,
|
|
|
|
getscientific(curcell(sheet)), -1, true, &t);
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
line_edit(sheet, val, 0, buf, 0, 0);
|
|
|
|
Cell *cell = curcell(sheet);
|
|
|
|
int adj = getadjust(cell);
|
|
|
|
if (adj == LEFT) left->setonly();
|
|
|
|
else if (adj == RIGHT) right->setonly();
|
|
|
|
else if (adj == CENTER) center->setonly();
|
|
|
|
if (SHADOWEDC(sheet,
|
|
|
|
sheet->cur[X]+1, sheet->cur[Y], sheet->cur[Z]))
|
|
|
|
shadow->set();
|
|
|
|
else shadow->clear();
|
|
|
|
if (::transparent(cell)) transparent->set();
|
|
|
|
else transparent->clear();
|
|
|
|
if (locked(cell)) lock->set();
|
|
|
|
else lock->clear();
|
|
|
|
if (ignored(cell)) ignore->set();
|
|
|
|
else ignore->clear();
|
|
|
|
if (isbold(cell)) bold->set();
|
|
|
|
else bold->clear();
|
|
|
|
if (underlined(cell)) underline->set();
|
|
|
|
else underline->clear();
|
|
|
|
if (getscientific(cell)) sci->set();
|
|
|
|
else sci->clear();}
|
|
|
|
protected xywh {0 50 800 525} box DOWN_FRAME
|
|
|
|
labeltype NO_LABEL resizable
|
2019-07-22 20:32:33 +00:00
|
|
|
code0 {table->sheet(sheet);}
|
|
|
|
class TeapotTable
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
Fl_Box status {
|
2019-07-22 20:32:33 +00:00
|
|
|
label {teapot ready.}
|
|
|
|
protected xywh {0 575 800 25} box GTK_ROUND_DOWN_BOX align 20
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
} code {
|
|
|
|
current = this;
|
|
|
|
} {}
|
|
|
|
}
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
Function
|
|
|
|
{line_edit(Sheet *sheet, char *buf, size_t size, const char *prompt,
|
|
|
|
size_t *x, size_t *offx)} {open return_type int} {code
|
|
|
|
{
|
|
|
|
if (line_label->active()) {
|
|
|
|
if (x) line_msg(NULL, "Action not possible at this time.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
line_label->copy_label(prompt);
|
|
|
|
|
|
|
|
int ww = 0, hh = 0;
|
|
|
|
line_label->measure_label(ww, hh);
|
|
|
|
line_input->resize(line_label->x()+ww+5, line_input->y(),
|
|
|
|
line_label->w()-ww-7, line_input->h());
|
|
|
|
line_input->value(buf);
|
|
|
|
|
|
|
|
if (!x) return 0;
|
|
|
|
|
|
|
|
line_input->maximum_size(size);
|
|
|
|
line_input->position(*x, *x);
|
|
|
|
line_label->activate();
|
|
|
|
line_input->activate();
|
|
|
|
table->sheet()->moveonly = 1;
|
|
|
|
line_input->take_focus();
|
|
|
|
|
|
|
|
edit_rc = -1;
|
|
|
|
while (line_label->active()) Fl::wait();
|
|
|
|
|
|
|
|
memcpy(buf, line_input->value(), size);
|
|
|
|
line_input->deactivate();
|
|
|
|
table->sheet()->moveonly = 0;
|
|
|
|
table->take_focus();
|
|
|
|
return edit_rc;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_msg(const char *prompt, const char *msg)} {return_type void} {code
|
|
|
|
{
|
|
|
|
char label[1024];
|
|
|
|
snprintf(label, sizeof(label), "%s%s%s",
|
|
|
|
prompt ? prompt : "", prompt ? " " : "", msg);
|
|
|
|
status->copy_label(label);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
decl {friend void line_msg(const char*, const char*);} {private local}
|
|
|
|
}
|
|
|
|
# End of class MainWindow
|
|
|
|
|
2019-08-03 03:21:58 +00:00
|
|
|
Function
|
|
|
|
{tpt_selection_version(Fl_Color base)} {open return_type {Fl_Color}} {code
|
|
|
|
{
|
|
|
|
return fl_color_average(base, FL_SELECTION_COLOR, 0.85);
|
|
|
|
} {} }
|
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
Function
|
|
|
|
{line_file(const char *file, const char *pattern, const char *title,
|
|
|
|
int create)} {open C return_type {const char *}} {code
|
|
|
|
{
|
|
|
|
static char buf[PATH_MAX];
|
|
|
|
Fl_Native_File_Chooser chooser;
|
|
|
|
|
|
|
|
chooser.title(title);
|
|
|
|
chooser.type(create ? Fl_Native_File_Chooser::BROWSE_SAVE_FILE :
|
|
|
|
Fl_Native_File_Chooser::BROWSE_FILE);
|
|
|
|
chooser.filter(pattern);
|
|
|
|
chooser.options((create ? Fl_Native_File_Chooser::NEW_FOLDER : 0) |
|
|
|
|
Fl_Native_File_Chooser::SAVEAS_CONFIRM);
|
|
|
|
|
|
|
|
if (file) {
|
2019-07-22 20:32:33 +00:00
|
|
|
fl_filename_absolute(buf, sizeof(buf), file);
|
|
|
|
char *p = (char *)fl_filename_name(buf);
|
|
|
|
*p = 0;
|
|
|
|
chooser.directory(buf);
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
if (chooser.show()) return NULL;
|
|
|
|
|
|
|
|
strncpy(buf, chooser.filename(), sizeof(buf));
|
|
|
|
buf[sizeof(buf)-1] = 0;
|
|
|
|
return buf;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_edit(Sheet *sheet, char *buf, size_t size, const char *prompt,
|
|
|
|
size_t *x, size_t *offx)} {C return_type int} {code
|
|
|
|
{
|
|
|
|
if (sheet)
|
|
|
|
return ((MainWindow*)
|
|
|
|
((TeapotTable*)sheet->display)->parent()->user_data()) ->
|
|
|
|
line_edit(sheet, buf, size, prompt, x, offx);
|
|
|
|
|
|
|
|
const char *val = fl_input("%s", buf, prompt);
|
|
|
|
if (val) {
|
2019-07-22 20:32:33 +00:00
|
|
|
strncpy(buf, val, size);
|
|
|
|
buf[size-1] = 0;
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
return !val;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_ok(const char *prompt, int curx)} {C return_type int} {code
|
|
|
|
{
|
|
|
|
return tpt_choose(prompt, "&No", "&Yes", NULL, curx);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_binary(const char *prompt, const char* op1, const char* op2, int curx)}
|
|
|
|
{C return_type int} {code
|
|
|
|
{
|
|
|
|
char *top[2];
|
|
|
|
top[0] = strdup(op1+1); top[1] = strdup(op2+1);
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
|
char* foundparen = strchr(top[i], ')');
|
|
|
|
if (foundparen) {
|
|
|
|
*foundparen = *(foundparen-1);
|
|
|
|
*(foundparen-1) = '&';
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
int retval = tpt_choose(prompt, "&Cancel", top[0], top[1], curx+1) - 1;
|
|
|
|
free(top[0]);
|
|
|
|
free(top[1]);
|
|
|
|
return retval;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_msg(const char *prompt, const char *msg)} {C return_type void} {code
|
|
|
|
{
|
|
|
|
MainWindow::current->line_msg(prompt, msg);
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function {keypressed()} {open C return_type int} {code
|
|
|
|
{
|
|
|
|
while (Fl::wait(.01)) if (Fl::event_key(FL_Escape)) return 1;
|
|
|
|
return 0;
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{line_menu(const char *prompt, const MenuChoice *choice, int curx)}
|
|
|
|
{C return_type int}
|
|
|
|
{
|
|
|
|
Fl_Window line_menu_menu {
|
|
|
|
label {Please Choose} open
|
|
|
|
xywh {706 58 250 245} type Double hide resizable modal
|
|
|
|
}
|
|
|
|
{
|
|
|
|
Fl_Group {} {
|
|
|
|
label {Please Choose:} open
|
|
|
|
xywh {0 0 250 200} box ENGRAVED_BOX align 21
|
|
|
|
}
|
|
|
|
{
|
|
|
|
Fl_Browser line_menu_browser {
|
|
|
|
callback {line_menu_menu->hide();}
|
|
|
|
xywh {5 25 240 170}
|
|
|
|
class Fl_Select_Browser
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
|
|
|
Fl_Button {} {
|
|
|
|
label Cancel
|
|
|
|
callback {line_menu_menu->hide();}
|
|
|
|
xywh {5 205 240 35}
|
|
|
|
}
|
|
|
|
} code
|
|
|
|
{
|
|
|
|
line_menu_browser->clear();
|
|
|
|
while (choice->str) {
|
2019-07-22 20:32:33 +00:00
|
|
|
line_menu_browser->add(choice->str+1);
|
|
|
|
choice++;
|
2019-08-03 00:31:48 +00:00
|
|
|
}
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
line_menu_menu->show();
|
|
|
|
while (line_menu_menu->shown()) Fl::wait();
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
return line_menu_browser->value()-1;
|
|
|
|
} {} }
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
Function
|
|
|
|
{redraw_sheet(Sheet *sheet)} {C return_type void} {code
|
|
|
|
{
|
|
|
|
TeapotTable *t = (TeapotTable*)sheet->display;
|
|
|
|
t->update_table();
|
|
|
|
t->redraw();} {}
|
2019-07-22 20:32:33 +00:00
|
|
|
}
|
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
Function
|
|
|
|
{redraw_cell(Sheet *sheet, const Location /* at */)} {C return_type void}
|
|
|
|
{ code
|
|
|
|
{
|
|
|
|
redraw_sheet(sheet);
|
|
|
|
} {} }
|
2019-07-22 20:32:33 +00:00
|
|
|
|
2019-08-03 00:31:48 +00:00
|
|
|
Function
|
|
|
|
{display_init(Sheet *sheet, int always_redraw)}
|
|
|
|
{open C return_type void} {code
|
|
|
|
{
|
|
|
|
Fl::get_system_colors();
|
2019-07-22 20:32:33 +00:00
|
|
|
\#ifdef ENABLE_HELP
|
2019-08-03 00:31:48 +00:00
|
|
|
Fl_File_Icon::load_system_icons();
|
2019-07-22 20:32:33 +00:00
|
|
|
\#endif
|
2019-08-03 00:31:48 +00:00
|
|
|
Fl::scheme("gtk+");
|
|
|
|
int ch = sheet->changed;
|
|
|
|
resize(sheet, 1, 1, 1);
|
|
|
|
sheet->changed = ch;
|
|
|
|
new MainWindow(sheet);
|
2019-08-03 03:21:58 +00:00
|
|
|
/* allocate and initialize the palette */
|
|
|
|
Fl_Color* palt = new Fl_Color[sheet->max_colors];
|
|
|
|
sheet->palette = (void *) palt;
|
2019-08-03 16:42:32 +00:00
|
|
|
palt[DefaultCN[FOREGROUND]] = FL_FOREGROUND_COLOR;
|
|
|
|
palt[DefaultCN[BACKGROUND]] = FL_BACKGROUND2_COLOR;
|
2019-08-03 03:21:58 +00:00
|
|
|
ColorNum c = 0; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_BACKGROUND_COLOR; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_INACTIVE_COLOR; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_SELECTION_COLOR; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_GRAY0; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK3; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK2; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK1; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_LIGHT1; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_LIGHT2; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_LIGHT3; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_BLACK; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_RED; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_GREEN; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_YELLOW; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_BLUE; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_MAGENTA; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_CYAN; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_RED; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_GREEN; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_YELLOW; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_BLUE; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_MAGENTA; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_DARK_CYAN; SKIPDEFCOLS(c);
|
|
|
|
palt[c++] = FL_WHITE; SKIPDEFCOLS(c);
|
|
|
|
while (c < sheet->max_colors) { palt[c++] = FL_WHITE; SKIPDEFCOLS(c); }
|
2019-08-03 00:31:48 +00:00
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{display_end(Sheet* sheet)} {C return_type void} {code
|
|
|
|
{
|
2019-08-03 03:21:58 +00:00
|
|
|
ColorNum* palt = (ColorNum *)sheet->palette;
|
|
|
|
delete [] palt;
|
2019-08-03 00:31:48 +00:00
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function
|
|
|
|
{display_main(Sheet *cursheet)} {C return_type void} {code
|
|
|
|
{
|
|
|
|
((TeapotTable *)cursheet->display)->parent()->show();
|
|
|
|
Fl::run();
|
|
|
|
} {} }
|
|
|
|
|
|
|
|
Function {show_menu(Sheet *sheet)} {C return_type Key} {code
|
|
|
|
{
|
|
|
|
return K_NONE;
|
|
|
|
} {}}
|
|
|
|
|
|
|
|
decl {MainWindow *MainWindow::current;} {private global}
|
|
|
|
|
|
|
|
declblock {\#ifdef ENABLE_HELP} {after {\#endif}} {
|
|
|
|
decl {\#include <FL/Fl_Help_Dialog.H>} {private global}
|
|
|
|
|
|
|
|
Function
|
|
|
|
{show_text(const char *text)} {open C return_type void} {code
|
|
|
|
{
|
|
|
|
Fl_Help_Dialog *d = new Fl_Help_Dialog();
|
|
|
|
if (strchr(text, '<')) d->value(text);
|
|
|
|
else d->load(text);
|
|
|
|
d->resize(d->x(), d->y(), d->w()*3/2, d->h()*3/2);
|
|
|
|
d->show();
|
|
|
|
} {} }
|
|
|
|
}
|
|
|
|
|
|
|
|
declblock {\#ifndef ENABLE_HELP} {after {\#endif}} {
|
|
|
|
Function
|
|
|
|
{show_text(const char *text)} {open C return_type void} {code
|
|
|
|
{
|
|
|
|
char *txt = striphtml(text);
|
|
|
|
fl_message("%s", txt);
|
|
|
|
free(txt);
|
|
|
|
} {} }
|
|
|
|
}
|
|
|
|
|
|
|
|
Function
|
|
|
|
{find_helpfile(char *buf, int size, const char *argv0)}
|
|
|
|
{open C return_type void} {code
|
|
|
|
{
|
|
|
|
fl_filename_absolute(buf, size, argv0);
|
|
|
|
char *p = (char *)fl_filename_name(buf);
|
|
|
|
strncpy(p, "../share/doc/teapot/html/index.html", buf+size-p);
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
// Check if help exists in default installed location, fallback value is valid for build directory
|
|
|
|
int test = open(buf, O_RDONLY);
|
|
|
|
if (test < 0) strncpy(p, "html/index.html", buf+size-p);
|
|
|
|
else close(test);
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
// Try the configure-time determined value
|
|
|
|
test = open(buf, O_RDONLY);
|
|
|
|
if (test < 0) strncpy(buf, HELPFILE, size);
|
|
|
|
else close(test);
|
|
|
|
buf[size-1] = 0;
|
|
|
|
|
|
|
|
// Fall back to a sane value for unixoid systems
|
|
|
|
test = open(buf, O_RDONLY);
|
|
|
|
if (test < 0) strncpy(buf, "/usr/share/doc/teapot/html/index.html", size);
|
|
|
|
else close(test);
|
|
|
|
buf[size-1] = 0;
|
|
|
|
} {} }
|