# 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;
} {} }