872 lines
23 KiB
Plaintext
872 lines
23 KiB
Plaintext
# data file for the Fltk User Interface Designer (fluid)
|
|
version 1.0300
|
|
header_name {.h}
|
|
code_name {.cxx}
|
|
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 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 {\#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 {\#undef shadow} {private global
|
|
}
|
|
|
|
decl {\#undef transparent} {private global
|
|
}
|
|
|
|
decl {\#undef MenuChoice} {private global
|
|
}
|
|
|
|
decl {\#undef Cell} {private global
|
|
}
|
|
|
|
decl {\#include "misc.h"} {private global
|
|
}
|
|
|
|
decl {\#include "display.h"} {public 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];
|
|
//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_draw_box(FL_THIN_UP_BOX, xx, yy, W, H, col_header_color());
|
|
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_draw_box(FL_THIN_UP_BOX, xx, yy, W, H, row_header_color());
|
|
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];
|
|
fl_draw_box(iscurrent ? FL_BORDER_BOX : FL_THIN_DOWN_BOX, xx, yy, W, H,
|
|
selected ? FL_SELECTION_COLOR : FL_BACKGROUND2_COLOR);
|
|
if (Fl::focus() == this && iscurrent)
|
|
draw_focus(FL_BORDER_BOX, xx, yy, W, H);
|
|
fl_pop_clip();
|
|
|
|
Cell *cell = safe_cell_at(cursheet, test);
|
|
|
|
fl_push_clip(xx+3, yy+3, W-6, H-6);
|
|
fl_color(FL_FOREGROUND_COLOR);
|
|
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;
|
|
//printf("update_table: %ix%i@%i,%i; %i[%i], %i[%i]\\n", cursheet->dimx, cursheet->dimy, cursheet->curx, cursheet->cury, 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;
|
|
//printf("update_sheet: %ix%i@%i,%i; %i[%i], %i[%i] (%i,%i)-(%i,%i)\\n", cols(), rows(), cursheet->curx, cursheet->cury, 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);
|
|
//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);
|
|
}} {}
|
|
}
|
|
}
|
|
|
|
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 {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
|
|
}
|
|
}
|
|
|
|
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 {int rc = !!fl_choice("%s", "&No", NULL, "&Yes", prompt);
|
|
if (Fl::event_key(FL_Escape)) return -1;
|
|
return rc;} {}
|
|
}
|
|
|
|
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);} {}
|
|
}
|
|
|
|
Function {display_end()} {C return_type void
|
|
} {
|
|
code {} {}
|
|
}
|
|
|
|
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;
|
|
|
|
} {}
|
|
}
|