1019 lines
30 KiB
Plaintext
1019 lines
30 KiB
Plaintext
# data file for the Fltk User Interface Designer (fluid)
|
|
version 1.0300
|
|
header_name {.h}
|
|
code_name {.cxx}
|
|
|
|
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}
|
|
|
|
decl {\#define SKIPDEFCOLS(c) while (c == DefaultCN[FOREGROUND] || c == DefaultCN[BACKGROUND]) ++c}
|
|
{private global}
|
|
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}
|
|
decl {\#include "default.h"} {private global}
|
|
decl {\#include "misc.h"} {private global}
|
|
|
|
decl {Fl_Color tpt_selection_version(Fl_Color base);} {private global}
|
|
|
|
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();
|
|
break;
|
|
|
|
case CONTEXT_STARTPAGE:
|
|
adjust_outside();
|
|
if (Fl::event_button1()) update_sheet();
|
|
break;
|
|
|
|
case CONTEXT_COL_HEADER: {
|
|
fl_font(FL_HELVETICA | FL_BOLD, 14);
|
|
fl_push_clip(xx, yy, W, H);
|
|
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);
|
|
fl_color(FL_FOREGROUND_COLOR);
|
|
sprintf(s, "%d", C);
|
|
fl_draw(s, xx, yy, W, H, FL_ALIGN_CENTER);
|
|
fl_pop_clip();
|
|
return;
|
|
}
|
|
|
|
case CONTEXT_ROW_HEADER: {
|
|
fl_font(FL_HELVETICA | FL_BOLD, 14);
|
|
fl_push_clip(xx, yy, W, H);
|
|
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);
|
|
fl_color(FL_FOREGROUND_COLOR);
|
|
sprintf(s, "%d", R);
|
|
fl_draw(s, xx, yy, W, H, FL_ALIGN_CENTER);
|
|
fl_pop_clip();
|
|
return;
|
|
}
|
|
|
|
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);
|
|
bool iscurrent = (C == cursheet->cur[X] && R == cursheet->cur[Y]);
|
|
Cell *cell = safe_cell_at(cursheet, test);
|
|
Fl_Color cellbg =
|
|
((Fl_Color *)(cursheet->palette))[getcolor(cell, BACKGROUND)];
|
|
if (selected) cellbg = tpt_selection_version(cellbg);
|
|
if (!LOC_WITHIN(cursheet,test))
|
|
cellbg = fl_color_average(cellbg, FL_BLACK, 0.97);
|
|
fl_draw_box(iscurrent ? FL_BORDER_BOX : FL_THIN_DOWN_BOX,
|
|
xx, yy, W, H, cellbg);
|
|
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);
|
|
Fl_Color cellfg =
|
|
((Fl_Color *)(cursheet->palette))[getcolor(cell, FOREGROUND)];
|
|
fl_color(cellfg);
|
|
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] = '\#';
|
|
|
|
int adj = getadjust(cell);
|
|
fl_draw(s, xx+3, yy+3, W-6, H-6,
|
|
adj == RIGHT ? FL_ALIGN_RIGHT :
|
|
adj == LEFT ? FL_ALIGN_LEFT : FL_ALIGN_CENTER);
|
|
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()) {
|
|
int rc = Fl_Table::handle(event);
|
|
do_callback(ACTION, 0, 0);
|
|
return rc;
|
|
}
|
|
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);
|
|
}
|
|
} {} }
|
|
|
|
}
|
|
# 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
|
|
}
|
|
}
|
|
Submenu {} {label {&Block} xywh {25 25 67 24} } {
|
|
MenuItem {} {
|
|
label {&Insert}
|
|
user_data BLOCK_INSERT
|
|
xywh {0 0 30 20} shortcut 0x90069
|
|
}
|
|
MenuItem {} {
|
|
label {&Delete}
|
|
user_data BLOCK_DELETE
|
|
xywh {0 0 30 20} shortcut 0x90064 divider
|
|
}
|
|
MenuItem {} {
|
|
label {&Move}
|
|
user_data BLOCK_MOVE
|
|
xywh {0 0 30 20} shortcut 0x9006d
|
|
}
|
|
MenuItem {} {
|
|
label {&Copy}
|
|
user_data BLOCK_COPY
|
|
xywh {0 0 36 21} shortcut 0x90063 divider
|
|
}
|
|
MenuItem {} {
|
|
label {&Fill}
|
|
user_data BLOCK_FILL
|
|
xywh {0 0 36 21} shortcut 0x90066
|
|
}
|
|
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
|
|
}
|
|
{
|
|
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();
|
|
}
|
|
}
|
|
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 {
|
|
print(val, sizeof(val), 0, 1, getscientific(curcell(sheet)),
|
|
-1, getcont(curcell(sheet), BASE));
|
|
Token **iter = getcont(curcell(sheet), ITERATIVE);
|
|
if (iter != EMPTY_TVEC) {
|
|
snprintf(val+strlen(val),sizeof(val)-strlen(val),
|
|
" -> ");
|
|
print(val+strlen(val), sizeof(val)-strlen(val), 0, 1,
|
|
getscientific(curcell(sheet)), -1, iter);
|
|
}
|
|
}
|
|
|
|
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
|
|
code0 {table->sheet(sheet);}
|
|
class TeapotTable
|
|
}
|
|
Fl_Box status {
|
|
label {teapot ready.}
|
|
protected xywh {0 575 800 25} box GTK_ROUND_DOWN_BOX align 20
|
|
}
|
|
} code {
|
|
current = this;
|
|
} {}
|
|
}
|
|
|
|
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
|
|
|
|
Function
|
|
{tpt_selection_version(Fl_Color base)} {open return_type {Fl_Color}} {code
|
|
{
|
|
return fl_color_average(base, FL_SELECTION_COLOR, 0.85);
|
|
} {} }
|
|
|
|
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) {
|
|
fl_filename_absolute(buf, sizeof(buf), file);
|
|
char *p = (char *)fl_filename_name(buf);
|
|
*p = 0;
|
|
chooser.directory(buf);
|
|
}
|
|
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) {
|
|
strncpy(buf, val, size);
|
|
buf[size-1] = 0;
|
|
}
|
|
|
|
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) = '&';
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
Fl_Button {} {
|
|
label Cancel
|
|
callback {line_menu_menu->hide();}
|
|
xywh {5 205 240 35}
|
|
}
|
|
} code
|
|
{
|
|
line_menu_browser->clear();
|
|
while (choice->str) {
|
|
line_menu_browser->add(choice->str+1);
|
|
choice++;
|
|
}
|
|
|
|
line_menu_menu->show();
|
|
while (line_menu_menu->shown()) Fl::wait();
|
|
|
|
return line_menu_browser->value()-1;
|
|
} {} }
|
|
|
|
Function
|
|
{redraw_sheet(Sheet *sheet)} {C return_type void} {code
|
|
{
|
|
TeapotTable *t = (TeapotTable*)sheet->display;
|
|
t->update_table();
|
|
t->redraw();} {}
|
|
}
|
|
|
|
Function
|
|
{redraw_cell(Sheet *sheet, const Location /* at */)} {C return_type void}
|
|
{ code
|
|
{
|
|
redraw_sheet(sheet);
|
|
} {} }
|
|
|
|
Function
|
|
{display_init(Sheet *sheet, int always_redraw)}
|
|
{open C return_type void} {code
|
|
{
|
|
Fl::get_system_colors();
|
|
\#ifdef ENABLE_HELP
|
|
Fl_File_Icon::load_system_icons();
|
|
\#endif
|
|
Fl::scheme("gtk+");
|
|
int ch = sheet->changed;
|
|
resize(sheet, 1, 1, 1);
|
|
sheet->changed = ch;
|
|
new MainWindow(sheet);
|
|
/* allocate and initialize the palette */
|
|
Fl_Color* palt = new Fl_Color[sheet->max_colors];
|
|
sheet->palette = (void *) palt;
|
|
palt[DefaultCN[FOREGROUND]] = FL_FOREGROUND_COLOR;
|
|
palt[DefaultCN[BACKGROUND]] = FL_BACKGROUND2_COLOR;
|
|
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); }
|
|
} {} }
|
|
|
|
Function
|
|
{display_end(Sheet* sheet)} {C return_type void} {code
|
|
{
|
|
ColorNum* palt = (ColorNum *)sheet->palette;
|
|
delete [] palt;
|
|
} {} }
|
|
|
|
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;
|
|
} {} }
|