1889 lines
50 KiB
C
1889 lines
50 KiB
C
/* #includes */ /*{{{C}}}*//*{{{*/
|
|
#ifndef NO_POSIX_SOURCE
|
|
#undef _POSIX_SOURCE
|
|
#define _POSIX_SOURCE 1
|
|
#undef _POSIX_C_SOURCE
|
|
#define _POSIX_C_SOURCE 2
|
|
#undef _XOPEN_SOURCE
|
|
#define _XOPEN_SOURCE 500
|
|
#endif
|
|
|
|
#ifdef DMALLOC
|
|
#include "dmalloc.h"
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <locale.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
extern char *optarg;
|
|
extern int optind,opterr,optopt;
|
|
int getopt(int argc, char * const *argv, const char *optstring);
|
|
extern char *strdup(const char* s);
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
|
|
#include "default.h"
|
|
#include "display.h"
|
|
#include "eval.h"
|
|
#include "htmlio.h"
|
|
#include "latex.h"
|
|
#include "context.h"
|
|
#include "main.h"
|
|
#include "misc.h"
|
|
#include "sc.h"
|
|
#include "scanner.h"
|
|
#include "utf8.h"
|
|
#include "parser.h"
|
|
#include "sheet.h"
|
|
#include "wk1.h"
|
|
#include "xdr.h"
|
|
/*}}}*/
|
|
|
|
/* variables */ /*{{{*/
|
|
char helpfile[PATH_MAX];
|
|
bool batch = false;
|
|
unsigned int batchln=0;
|
|
PrecisionLevel def_precision = DEF_PRECISION;
|
|
StringFormat quote = DIRECT_STRING;
|
|
bool header = true;
|
|
bool always_redraw = false;
|
|
int debug_level = 0;
|
|
static bool usexdr = false;
|
|
/*}}}*/
|
|
|
|
void moveto(Sheet *sheet, int x, int y, int z)
|
|
{
|
|
int need_redraw = 0;
|
|
int xdir = x > sheet->cur[X]?1:-1;
|
|
|
|
if (x >= 0) sheet->cur[X] = x;
|
|
if (y >= 0) sheet->cur[Y] = y;
|
|
if (z >= 0) need_redraw++, sheet->cur[Z] = z;
|
|
while (sheet->cur[X] > 0 && shadowed(sheet, sheet->cur))
|
|
sheet->cur[X] += xdir;
|
|
|
|
if (getmarkstate(sheet) == MARKING) LOCATION_GETS(sheet->mark2, sheet->cur);
|
|
|
|
if (sheet->cur[X] <= sheet->offx && sheet->offx) need_redraw++, sheet->offx = (sheet->cur[X]?sheet->cur[X]-1:0);
|
|
if (sheet->cur[Y] <= sheet->offy && sheet->offy) need_redraw++, sheet->offy = (sheet->cur[Y]?sheet->cur[Y]-1:0);
|
|
if (sheet->cur[X] >= sheet->offx+sheet->maxx) need_redraw++, sheet->offx = sheet->cur[X]-sheet->maxx+2;
|
|
if (sheet->cur[Y] >= sheet->offy+sheet->maxy) need_redraw++, sheet->offy = sheet->cur[Y]-sheet->maxy+2;
|
|
|
|
if (need_redraw) redraw_sheet(sheet);
|
|
else if (x != sheet->cur[X] || y != sheet->cur[Y] || z != sheet->cur[Z]) redraw_cell(sheet, sheet->cur);
|
|
}
|
|
|
|
void movetoloc(Sheet *sheet, const Location dest) {
|
|
moveto(sheet, dest[X], dest[Y], dest[Z]);
|
|
}
|
|
|
|
void relmoveto(Sheet *sheet, int x, int y, int z)
|
|
{
|
|
moveto(sheet, sheet->cur[X]+x, sheet->cur[Y]+y, (z?sheet->cur[Z]+z:-1));
|
|
}
|
|
|
|
/* line_numedit -- number line editor function */ /*{{{*/
|
|
static int line_numedit(int *n, const char *prompt)
|
|
{
|
|
assert(prompt != NULL);
|
|
|
|
char buf[20];
|
|
Token *t = NULLTOKEN;
|
|
sprintf(buf, "%d", *n);
|
|
char *s = buf+strlen(buf);
|
|
do
|
|
{
|
|
free(t);
|
|
size_t x = s - buf;
|
|
size_t offx = 0;
|
|
int c = line_edit((Sheet*)0, buf, sizeof(buf), prompt, &x, &offx);
|
|
if (c < 0) return c;
|
|
s = buf;
|
|
t = scan_integer(&s);
|
|
} while (*s != '\0');
|
|
if (t == NULLTOKEN) *n = -1;
|
|
else { *n = t->u.integer; free(t); }
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* line_lidedit -- label identifier line editor function */ /*{{{*/
|
|
static int line_idedit(char *ident, size_t size, const char *prompt, size_t *x, size_t *offx)
|
|
{
|
|
Token *t = NULLTOKEN;
|
|
char *s = ident+strlen(ident);
|
|
do
|
|
{
|
|
free(t);
|
|
*x = s - ident;
|
|
int c = line_edit((Sheet*)0, ident, size, prompt, x, offx);
|
|
if (c < 0) return c;
|
|
s = ident;
|
|
t = scan_ident(&s);
|
|
} while (*s != '\0' || t == NULLTOKEN || t->type != LIDENT);
|
|
free(t);
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* doanyway -- ask if action should be done despite unsaved changes */ /*{{{*/
|
|
bool doanyway(Sheet *sheet, const char *msg)
|
|
{
|
|
if (sheet->changed && line_ok(msg, 0) <= 0) return false;
|
|
return true;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_edit -- set or modify cell contents */ /*{{{*/
|
|
static int do_edit(Sheet *cursheet, Key c, char *expr, TokVariety tv)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
char buf[1024];
|
|
const char *prompt;
|
|
char *s;
|
|
size_t x,offx;
|
|
Location scur;
|
|
Token **t;
|
|
Token newcont;
|
|
Cell *cell;
|
|
/*}}}*/
|
|
|
|
cell = curcell(cursheet);
|
|
if (locked(cell)) line_msg(_("Edit cell:"),_("Cell is locked"));
|
|
else
|
|
{
|
|
newcont.type = EMPTY;
|
|
LOCATION_GETS(scur, cursheet->cur);
|
|
if (expr)
|
|
{
|
|
s = expr;
|
|
t = scan(&s);
|
|
prompt = _("Cell contents:");
|
|
if (tv == ITER_CONT) prompt = _("Clocked cell contents");
|
|
if (tv == STYLE_CONT) prompt = _("Style expression");
|
|
if (*s != '\0')
|
|
if (t == EMPTY_TVEC)
|
|
line_msg(prompt, "XXX invalid expression");
|
|
else
|
|
{
|
|
newcont = eval_safe(t, LITERAL);
|
|
if (newcont.type = EEK)
|
|
line_msg(prompt, "XXX unparseable expression");
|
|
}
|
|
tvecfree(t);
|
|
}
|
|
else
|
|
{
|
|
Token cntt;
|
|
offx=0;
|
|
if (c == K_NONE)
|
|
{
|
|
cntt = gettok(cell, tv);
|
|
printtok(buf, sizeof(buf), 0, QUOTE_STRING, FLT_COMPACT, -1,
|
|
TRUNCATED_ERROR, &cntt);
|
|
s = buf+strlen(buf);
|
|
}
|
|
else if (c == K_BACKSPACE)
|
|
{
|
|
cntt = gettok(cell, tv);
|
|
printtok(buf, sizeof(buf), 0, QUOTE_STRING, FLT_COMPACT, -1,
|
|
TRUNCATED_ERROR, &cntt);
|
|
if (strlen(buf)) *mbspos(buf+strlen(buf),-1)='\0';
|
|
s = buf+strlen(buf);
|
|
}
|
|
else if (c == K_DC)
|
|
{
|
|
cntt = gettok(cell, tv);
|
|
printtok(buf, sizeof(buf), 0, QUOTE_STRING, FLT_COMPACT, -1,
|
|
TRUNCATED_ERROR, &cntt);
|
|
memmove(buf,mbspos(buf,1),strlen(mbspos(buf,1))+1);
|
|
s = buf;
|
|
}
|
|
else if (isalpha(c))
|
|
{
|
|
buf[0] = '"';
|
|
buf[1] = c;
|
|
buf[2] = 0;
|
|
s=buf+2;
|
|
}
|
|
else
|
|
{
|
|
if (c < 256) buf[0]=c;
|
|
else buf[0] = 0;
|
|
buf[1]='\0';
|
|
s=buf+1;
|
|
}
|
|
do
|
|
{
|
|
int r;
|
|
|
|
tfree(&newcont);
|
|
newcont.type = EEK;
|
|
newcont.u.err = (char *)0;
|
|
x = mbslen(buf)-mbslen(s);
|
|
prompt = _("Cell contents:");
|
|
if (tv == ITER_CONT) prompt = _("Clocked cell contents:");
|
|
if ((r = line_edit(cursheet, buf, sizeof(buf), prompt, &x, &offx)) < 0)
|
|
return r;
|
|
s = buf;
|
|
if (buf[0] == '"' && buf[strlen(buf)-1] != '"'
|
|
&& strlen(buf)+1 < sizeof(buf))
|
|
{
|
|
buf[strlen(buf)+1] = 0;
|
|
buf[strlen(buf)] = '"';
|
|
}
|
|
t = scan(&s);
|
|
if (t != EMPTY_TVEC) {
|
|
newcont = eval_safe(t, LITERAL);
|
|
}
|
|
tvecfree(t);
|
|
} while (*s != '\0' && newcont.type == EEK);
|
|
}
|
|
movetoloc(cursheet, scur);
|
|
puttok(cursheet, cursheet->cur, newcont, tv);
|
|
forceupdate(cursheet);
|
|
}
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_label -- modify cell label */ /*{{{*/
|
|
static int do_label(Sheet *sheet)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
char buf[1024],oldlabel[1024];
|
|
size_t edx,offx,ok;
|
|
Token t;
|
|
Location w;
|
|
int tried;
|
|
int c;
|
|
/*}}}*/
|
|
|
|
assert(sheet != (Sheet*)0);
|
|
do_mark(sheet, GET_MARK_ALL);
|
|
if (SAME_LOC(sheet->mark1,sheet->mark2) &&
|
|
locked(CELL_AT(sheet, sheet->mark1)))
|
|
{
|
|
line_msg(_("Cell label:"),_("Cell is locked"));
|
|
}
|
|
else
|
|
{
|
|
ok=edx=offx=0;
|
|
(void)strcpy(buf, getlabel(curcell(sheet)));
|
|
(void)strcpy(oldlabel, buf);
|
|
tried = 0;
|
|
do
|
|
{
|
|
if (tried) {
|
|
line_msg(_("Cell label:"), _("Label already in use"));
|
|
}
|
|
if ((c=line_idedit(buf,sizeof(buf),_("Cell label:"),&edx,&offx))<0) return c;
|
|
tried = 1;
|
|
if (buf[0]=='\0') ok=1;
|
|
else
|
|
{
|
|
ok=((t=findlabel(sheet,buf)).type==EEK ||
|
|
(t.type == LOCATION && SAME_LOC(t.u.location, sheet->cur)));
|
|
tfree(&t);
|
|
}
|
|
} while (!ok);
|
|
setlabel(sheet, sheet->cur, buf,1);
|
|
if (buf[0] != '\0' && oldlabel[0] != '\0')
|
|
for (ALL_LOCS_IN_REGION(sheet,w))
|
|
relabel(sheet, w, oldlabel, buf);
|
|
cachelabels(sheet);
|
|
forceupdate(sheet);
|
|
}
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_columnwidth -- set the column width */ /*{{{*/
|
|
static int do_columnwidth(Sheet *cursheet)
|
|
{
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
int n = columnwidth(cursheet, cursheet->mark1[X], cursheet->mark1[Z]);
|
|
do {
|
|
int c = line_numedit(&n, _("Column width:"));
|
|
if (c < 0) return c;
|
|
} while (n <= 0);
|
|
/*}}}*/
|
|
for (int x = cursheet->mark1[X]; x <= cursheet->mark2[X]; ++x)
|
|
for (int z = cursheet->mark1[Z]; z <= cursheet->mark2[Z]; ++z)
|
|
setwidth(cursheet,x,z,n);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_attribute -- set cell attributes */ /*{{{*/
|
|
static void do_attribute(Sheet *cursheet, Key action)
|
|
{
|
|
Location w;
|
|
Adjust adj = LEFT;
|
|
FloatFormat ff = FLT_DECIMAL;
|
|
do_mark(cursheet, GET_MARK_CUR);
|
|
bool onecell = SAME_LOC(cursheet->mark1, cursheet->mark2);
|
|
Cell *fcell = safe_cell_at(cursheet, cursheet->mark1);
|
|
Style fs = getstyle(cursheet, cursheet->mark1);
|
|
bool changed = false;
|
|
if (action != ADJUST_LOCK && onecell && locked(fcell))
|
|
{
|
|
line_msg(_("Cell attribute:"),_("Cell is locked"));
|
|
return;
|
|
}
|
|
ColorAspect ca = FOREGROUND;
|
|
switch ((int)action)
|
|
{
|
|
case ADJUST_CENTER: ++adj; /* drop through */
|
|
case ADJUST_RIGHT: ++adj; /* drop through */
|
|
case ADJUST_LEFT:
|
|
{
|
|
const char *templ = _("Change adjustment of block to %s?");
|
|
char *prompt = malloc(strlen(templ) + MAX_ADJUST_NAME_LENGTH + 1);
|
|
sprintf(prompt, templ, Adjust_Name[adj]);
|
|
if (!onecell && line_ok(prompt, 0) <= 0) break;
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = setadjust(cursheet, w, adj) || changed;
|
|
break;
|
|
}
|
|
/* set float format */ /*{{{*/
|
|
case ADJUST_HEXACT: ++ff; /* drop through */
|
|
case ADJUST_COMPACT: ++ff; /* drop through */
|
|
case ADJUST_SCIENTIFIC: ++ff; /* drop through */
|
|
case ADJUST_DECIMAL:
|
|
{
|
|
const char* templ = _("Change float format of block to %s?");
|
|
char *prompt = malloc(strlen(templ) + MAX_FLOATFORM_NAME_LENGTH +1);
|
|
sprintf(prompt, templ, FloatFormat_Name[ff]);
|
|
if (!onecell && line_ok(prompt, 0) <= 0) break;
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = setfltformat(cursheet, w, ff) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 5 -- set precision */ /*{{{*/
|
|
case ADJUST_PRECISION:
|
|
{
|
|
int n = fs.precision;
|
|
const char* prompt = _("Precision for block:");
|
|
if (onecell) prompt = _("Precision for cell:");
|
|
int c = line_numedit(&n, prompt);
|
|
if (c < 0) return;
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = setprecision(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* Set a color */ /*{{{*/
|
|
case ADJUST_BACKGROUND:
|
|
ca = BACKGROUND;
|
|
/* FALL THROUGH */
|
|
case ADJUST_FOREGROUND: {
|
|
int n = fs.aspect[ca];
|
|
const char* prompt = _("%s for block:");
|
|
if (onecell) prompt = _("%s for cell:");
|
|
char pbuf[256];
|
|
sprintf(pbuf, prompt, ColorAspect_Name[ca]);
|
|
int c = line_numedit(&n, pbuf);
|
|
if (c < 0) return;
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = setcolor(cursheet, w, ca, (ColorNum)n) || changed;
|
|
break;
|
|
}
|
|
/* 6 -- shadow */ /*{{{*/
|
|
case ADJUST_SHADOW:
|
|
{
|
|
int n;
|
|
Location r;
|
|
LOCATION_GETS(r, cursheet->mark1); ++r[X];
|
|
if (onecell) n = !(fs.shadowed);
|
|
else n = line_binary(_("Set block to:"),
|
|
_("uU)nshadowed"), _("sS)hadowed"),
|
|
!(fs.shadowed));
|
|
if (cursheet->mark1[X] == 0 && n == 1) {
|
|
line_msg(_("Shadow cell:"),_("You can not shadow cells in column 0"));
|
|
break;
|
|
}
|
|
|
|
if (n >= 0) {
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
{
|
|
Location r;
|
|
|
|
if (n == 0)
|
|
{
|
|
LOCATION_GETS(r, w);
|
|
if (!shadowed(cursheet, r)) ++(r[X]);
|
|
for (; shadowed(cursheet, r); ++(r[X]))
|
|
changed = shadow(cursheet, r, false) || changed;
|
|
}
|
|
else if (w[X]>0) changed = shadow(cursheet, w, true) || changed;
|
|
}
|
|
}
|
|
if (n>0) do_mark(cursheet, UNMARKED);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 7 -- transparent */ /*{{{*/
|
|
case ADJUST_TRANSPARENT:
|
|
{
|
|
int n;
|
|
|
|
if (onecell) n = !(fs.transparent);
|
|
else n = line_binary(_("Set block to:"),
|
|
_("pP)rotected"), _("tT)ransparent:"),
|
|
!(fs.transparent));
|
|
if (n >= 0)
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = maketrans(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 8 -- bold */ /*{{{*/
|
|
case ADJUST_BOLD:
|
|
{
|
|
int n;
|
|
|
|
if (onecell) n = !(fs.bold);
|
|
else n = line_binary(_("Set block weight to:"),
|
|
_("rR)egular"), _("bB)old"), !(fs.bold));
|
|
if (n >= 0)
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = bold(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 9 -- underline */ /*{{{*/
|
|
case ADJUST_UNDERLINE:
|
|
{
|
|
int n;
|
|
|
|
if (onecell) n = !(fs.underline);
|
|
else n = line_binary(_("Set block to:"), _("nN)ot underline"),
|
|
_("uU)nderline"), !(fs.underline));
|
|
if (n >= 0)
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = underline(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 1 -- edit label and goto end */ /*{{{*/
|
|
case ADJUST_LABEL:
|
|
{
|
|
do_label(cursheet);
|
|
return;
|
|
}
|
|
/*}}}*/
|
|
/* 2 -- lock */ /*{{{*/
|
|
case ADJUST_LOCK:
|
|
{
|
|
int n;
|
|
|
|
if (onecell) n = !locked(fcell);
|
|
else n = line_binary(_("Set block to:"), _("uU)nlocked"), _("lL)ocked"),
|
|
!locked(fcell));
|
|
if (n >= 0)
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = lockcell(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 3 -- ignore */ /*{{{*/
|
|
case ADJUST_IGNORE:
|
|
{
|
|
int n;
|
|
|
|
if (onecell) n = !ignored(fcell);
|
|
else n = line_binary(_("Set block to:"), _("cC)omputed"), _("iI)gnored"),
|
|
!ignored(fcell));
|
|
if (n >= 0)
|
|
for (ALL_LOCS_IN_REGION(cursheet,w))
|
|
changed = igncell(cursheet, w, n) || changed;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* default -- should not happen */ /*{{{*/
|
|
default: assert(0);
|
|
/*}}}*/
|
|
}
|
|
if (changed) forceupdate(cursheet);
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_saveport -- save sheet as portable ASCII file */ /*{{{*/
|
|
static int do_saveport(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
unsigned int count;
|
|
|
|
if (!name) name = cursheet->name;
|
|
|
|
if ((msg = saveport(cursheet, name, &count))) {
|
|
line_msg(_("Save sheet to ASCII file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save sheet to ASCII file:"),buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savetbl -- save sheet as tbl file */ /*{{{*/
|
|
static int do_savetbl(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
int standalone=0;
|
|
unsigned int count;
|
|
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name) {
|
|
name = cursheet->name;
|
|
if ((standalone=line_ok(_("Save as stand-alone document:"),1))<0) return standalone;
|
|
}
|
|
|
|
if ((msg = savetbl(cursheet, name, !standalone,
|
|
cursheet->mark1, cursheet->mark2, &count))) {
|
|
line_msg(_("Save in tbl format to file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in tbl format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savelatex -- save sheet as LaTeX file */ /*{{{*/
|
|
static int do_savelatex(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
int standalone=0;
|
|
unsigned int count;
|
|
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name) {
|
|
name = cursheet->name;
|
|
if ((standalone=line_ok(_("Save as stand-alone document:"),1))<0) return standalone;
|
|
}
|
|
|
|
if ((msg = savelatex(cursheet, name, !standalone,
|
|
cursheet->mark1, cursheet->mark2, &count))) {
|
|
line_msg(_("Save in LaTeX format to file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in LaTeX format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savecontext -- save sheet as ConTeXt file */ /*{{{*/
|
|
static int do_savecontext(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
int standalone=0;
|
|
int x1,y1,z1,x2,y2,z2;
|
|
unsigned int count;
|
|
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name)
|
|
{
|
|
name = cursheet->name;
|
|
if ((standalone=line_ok(_("Save as stand-alone document:"),1))<0) return standalone;
|
|
}
|
|
|
|
if ((msg = savecontext(cursheet, name, !standalone,
|
|
cursheet->mark1, cursheet->mark2, &count)))
|
|
{
|
|
line_msg(_("Save in ConTeXt format to file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in ConTeXt format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savehtml -- save sheet as HTML file */ /*{{{*/
|
|
static int do_savehtml(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
int standalone=0;
|
|
int x1,y1,z1,x2,y2,z2;
|
|
unsigned int count;
|
|
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name) {
|
|
name = cursheet->name;
|
|
if ((standalone=line_ok(_("Save as stand-alone document:"),1))<0) return standalone;
|
|
}
|
|
|
|
if ((msg = savehtml(cursheet, name, !standalone,
|
|
cursheet->mark1, cursheet->mark2, &count))) {
|
|
line_msg(_("Save in HTML format to file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in HTML format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savetext -- save sheet as formatted text file */ /*{{{*/
|
|
static int do_savetext(Sheet *cursheet, const char *name)
|
|
{
|
|
char buf[PATH_MAX];
|
|
const char *msg;
|
|
int x1,y1,z1,x2,y2,z2;
|
|
unsigned int count;
|
|
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name) name = cursheet->name;
|
|
|
|
if ((msg = savetext(cursheet, name,
|
|
cursheet->mark1, cursheet->mark2, &count))) {
|
|
line_msg(_("Save in plain text format to file:"),msg);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in plain text format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_savecsv -- save sheet as CSV file */ /*{{{*/
|
|
static int do_savecsv(Sheet *cursheet, const char *name)
|
|
{
|
|
do_mark(cursheet, GET_MARK_ALL);
|
|
if (!name) name = cursheet->name;
|
|
const char *menu[] =
|
|
{ _("cC)omma (,)"), _("sS)emicolon (;)"), _("tT)ab (\\t)"), NULL };
|
|
const char seps[4] = ",;\t";
|
|
int sep = line_menu(_("Choose separator:"), menu, 0);
|
|
if (sep < 0) return sep;
|
|
|
|
unsigned int count;
|
|
const char *msg;
|
|
if ((msg = savecsv(cursheet, name, seps[sep],
|
|
cursheet->mark1, cursheet->mark2, &count)))
|
|
{
|
|
line_msg(_("Save in CSV format to file:"), msg);
|
|
return -2;
|
|
}
|
|
|
|
char buf[1024];
|
|
snprintf(buf, sizeof(buf), _("%u cells written"), count);
|
|
if (!batch) line_msg(_("Save in CSV format to file:"), buf);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_loadxdr -- load sheet from XDR file */ /*{{{*/
|
|
static int do_loadxdr(Sheet *cursheet)
|
|
{
|
|
const char *msg;
|
|
|
|
if ((msg=loadxdr(cursheet,cursheet->name))!=(const char*)0) line_msg(_("Load sheet from XDR file:"),msg);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_loadport -- load sheet from portable ASCII file */ /*{{{*/
|
|
static int do_loadport(Sheet *cursheet)
|
|
{
|
|
const char *msg;
|
|
/*}}}*/
|
|
|
|
if ((msg=loadport(cursheet,cursheet->name))!=(const char*)0) line_msg(_("Load sheet from ASCII file:"),msg);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
/* do_loadsc -- load sheet from SC file */ /*{{{*/
|
|
static int do_loadsc(Sheet *cursheet)
|
|
{
|
|
const char *msg;
|
|
|
|
if ((msg=loadsc(cursheet,cursheet->name))!=(const char*)0) line_msg(_("Load sheet from SC file:"),msg);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
/* do_loadwk1 -- load sheet from WK1 file */ /*{{{*/
|
|
static int do_loadwk1(Sheet *cursheet)
|
|
{
|
|
const char *msg;
|
|
|
|
if ((msg=loadwk1(cursheet,cursheet->name))!=(const char*)0) line_msg(_("Load sheet from WK1 file:"),msg);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
/* do_loadcsv -- load/merge sheet from CSV file */ /*{{{*/
|
|
static int do_loadcsv(Sheet *cursheet)
|
|
{
|
|
const char *msg;
|
|
|
|
if ((msg=loadcsv(cursheet,cursheet->name))!=(const char*)0) line_msg(_("Load sheet from CSV file:"),msg);
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_mark -- set mark */ /*{{{*/
|
|
void do_mark(Sheet *cursheet, MarkState ms)
|
|
{
|
|
MarkState ps;
|
|
Dimensions dim;
|
|
|
|
ps = getmarkstate(cursheet);
|
|
|
|
if (ms == MARK_CYCLE)
|
|
{
|
|
if (ps == UNMARKED) ms = MARKING;
|
|
else ms = ps + 1;
|
|
}
|
|
if (ps == ms) return;
|
|
switch (ms)
|
|
{
|
|
case MARKING:
|
|
{
|
|
LOCATION_GETS(cursheet->mark1, cursheet->cur);
|
|
LOCATION_GETS(cursheet->mark2, cursheet->cur);
|
|
break;
|
|
}
|
|
case UNMARKED:
|
|
break;
|
|
case MARKED:
|
|
case GET_MARK_CUR:
|
|
case GET_MARK_ALL:
|
|
{
|
|
switch (ps)
|
|
{
|
|
case MARKED: {
|
|
ms = MARKED;
|
|
break;
|
|
}
|
|
case MARKING:
|
|
{
|
|
for (dim = X; dim < HYPER; ++dim)
|
|
posorder(&(cursheet->mark1[dim]), &(cursheet->mark2[dim]));
|
|
ms = MARKED;
|
|
break;
|
|
}
|
|
case UNMARKED:
|
|
{
|
|
if (ms == GET_MARK_CUR)
|
|
{
|
|
LOCATION_GETS(cursheet->mark1, cursheet->cur);
|
|
LOCATION_GETS(cursheet->mark2, cursheet->cur);
|
|
ms = UNMARKED;
|
|
}
|
|
else if (ms == GET_MARK_ALL)
|
|
{
|
|
OLOCATION(cursheet->mark1);
|
|
cursheet->mark2[X] = cursheet->dimx - 1;
|
|
cursheet->mark2[Y] = cursheet->dimy - 1;
|
|
cursheet->mark2[Z] = cursheet->dimz - 1;
|
|
ms = UNMARKED;
|
|
}
|
|
else assert(ms == MARKED);
|
|
break;
|
|
}
|
|
default: assert(0);
|
|
}
|
|
break;
|
|
}
|
|
default: assert(0);
|
|
}
|
|
cursheet->marking = ms;
|
|
}
|
|
/*}}}*/
|
|
|
|
static int do_name(Sheet *cursheet);
|
|
|
|
/* do_save -- save sheet */ /*{{{*/
|
|
static int do_save(Sheet *cursheet)
|
|
{
|
|
const char *ext = cursheet->name;
|
|
if (ext==(char*)0) return do_name(cursheet);
|
|
|
|
ext += strlen(ext)-1;
|
|
|
|
if (!strcmp(ext-3, ".tbl")) return do_savetbl(cursheet, NULL);
|
|
if (!strcmp(ext-5, ".latex")) return do_savelatex(cursheet, NULL);
|
|
if (!strcmp(ext-4, ".html")) return do_savehtml(cursheet, NULL);
|
|
if (!strcmp(ext-3, ".csv")) return do_savecsv(cursheet, NULL);
|
|
if (!strcmp(ext-3, ".txt")) return do_savetext(cursheet, NULL);
|
|
if (!strcmp(ext-3, ".tex")) return do_savecontext(cursheet, NULL);
|
|
return do_saveport(cursheet, NULL);
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_name -- (re)name sheet */ /*{{{*/
|
|
static int do_name(Sheet *cursheet)
|
|
{
|
|
const char *name;
|
|
|
|
name = line_file(cursheet->name, _("Teapot ASCII \t*.tpa\ntbl \t*.tbl\nLaTeX \t*.latex\nHTML \t*.html\nCSV \t*.csv\nFormatted ASCII \t*.txt\nConTeXt \t*.tex"), _("New file name:"), 1);
|
|
if (!name) return -1;
|
|
|
|
if (cursheet->name!=(char*)0) free(cursheet->name);
|
|
cursheet->name=strdup(name);
|
|
return do_save(cursheet);
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_load -- load sheet */ /*{{{*/
|
|
static int do_load(Sheet *cursheet)
|
|
{
|
|
const char *name, *ext;
|
|
|
|
if (doanyway(cursheet, _("Sheet modified, load new file anyway?")) != 1) return -1;
|
|
|
|
name = line_file(cursheet->name,
|
|
_("Teapot ASCII \t*.tpa\n"
|
|
"CSV \t*.csv\n"
|
|
"Legacy binary Teapot \t*.tp\n"
|
|
"SC Spreadsheet Calculator \t*.sc\n"
|
|
"Lotus 1-2-3 \t*.wk1\n"
|
|
), _("Load sheet:"), 0);
|
|
if (!name) return -1;
|
|
if (cursheet->name!=(char*)0) free(cursheet->name);
|
|
cursheet->name=strdup(name);
|
|
|
|
ext = name+strlen(name)-1;
|
|
if (!strcmp(ext-2, ".tp")) return do_loadxdr(cursheet);
|
|
if (!strcmp(ext-2, ".sc")) return do_loadsc(cursheet);
|
|
if (!strcmp(ext-3, ".wk1")) return do_loadwk1(cursheet);
|
|
if (!strcmp(ext-3, ".csv")) return do_loadcsv(cursheet);
|
|
return do_loadport(cursheet);
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_clear -- clear block */ /*{{{*/
|
|
static int do_clear(Sheet *sheet)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
Location w;
|
|
bool onecell;
|
|
int c;
|
|
/*}}}*/
|
|
|
|
do_mark(sheet, GET_MARK_CUR);
|
|
onecell = SAME_LOC(sheet->mark1, sheet->mark2);
|
|
if (onecell && locked(CELL_AT(sheet, sheet->mark1)))
|
|
line_msg(_("Clear cell:"),_("Cell is locked"));
|
|
else
|
|
{
|
|
if (!onecell)
|
|
{
|
|
if ((c=line_ok(_("Clear block:"),0))<0) return c;
|
|
else if (c!=1) return -1;
|
|
}
|
|
|
|
for (ALL_LOCS_IN_REGION(sheet, w)) freecellofsheet(sheet, w);
|
|
cachelabels(sheet);
|
|
forceupdate(sheet);
|
|
}
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_insert -- insert block */ /*{{{*/
|
|
static int do_insert(Sheet *sheet)
|
|
{
|
|
int reply;
|
|
/* ask for direction of insertion */ /*{{{*/
|
|
{
|
|
const char* menu[] =
|
|
{ _("cC)olumn"), _("rR)ow"), _("dD)epth"), NULL };
|
|
reply = line_menu(_("Insert:"), menu, 0);
|
|
if (reply<0) return reply;
|
|
}
|
|
/*}}}*/
|
|
do_mark(sheet, GET_MARK_CUR);
|
|
Location beg, end;
|
|
LOCATION_GETS(beg, sheet->mark1);
|
|
LOCATION_GETS(end, sheet->mark2);
|
|
bool onecell = SAME_LOC(beg, end);
|
|
if (onecell)
|
|
/* ask if current cell or whole dimension should be used */ /*{{{*/
|
|
{
|
|
const char *menu[3];
|
|
/* show menu */ /*{{{*/
|
|
switch (reply)
|
|
{
|
|
case 0: menu[0] = _("wW)hole column"); break;
|
|
case 1: menu[0] = _("wW)hole line"); break;
|
|
case 2: menu[0] = _("wW)hole sheet"); break;
|
|
default: assert(0);
|
|
}
|
|
menu[1] = _("sS)ingle cell");
|
|
menu[2] = NULL;
|
|
int r = line_menu(_("Insert:"), menu, 0);
|
|
/*}}}*/
|
|
switch (r)
|
|
{
|
|
/* 0 -- use whole dimension */ /*{{{*/
|
|
case 0:
|
|
{
|
|
switch (reply)
|
|
{
|
|
/* 0 -- use whole column */ /*{{{*/
|
|
case 0:
|
|
{
|
|
beg[Y] = 0; end[Y] = sheet->dimy;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 1 -- use whole line */ /*{{{*/
|
|
case 1:
|
|
{
|
|
beg[X] = 0; end[X] = sheet->dimx;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 2 -- use whole layer */ /*{{{*/
|
|
case 2:
|
|
{
|
|
beg[X] = 0; end[X] = sheet->dimx;
|
|
beg[Y] = 0; end[Y] = sheet->dimy;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* default -- should not happen */ /*{{{*/
|
|
default: assert(0);
|
|
/*}}}*/
|
|
}
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 1 -- use current cell */ /*{{{*/
|
|
case 1: break;
|
|
/*}}}*/
|
|
/* -2,-1 -- go up or abort */ /*{{{*/
|
|
case -2:
|
|
case -1: return r;
|
|
/*}}}*/
|
|
/* default -- should not happen */ /*{{{*/
|
|
default: assert(0);
|
|
/*}}}*/
|
|
}
|
|
}
|
|
/*}}}*/
|
|
/*}}}*/
|
|
switch (reply)
|
|
{
|
|
/* 0 -- columns */ /*{{{*/
|
|
case 0: insertcube(sheet, beg, end, IN_X); break;
|
|
/*}}}*/
|
|
/* 1 -- rows */ /*{{{*/
|
|
case 1: insertcube(sheet, beg, end, IN_Y); break;
|
|
/*}}}*/
|
|
/* 2 -- depth */ /*{{{*/
|
|
case 2: insertcube(sheet, beg, end, IN_Z); break;
|
|
/*}}}*/
|
|
}
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_delete -- delete block */ /*{{{*/
|
|
static int do_delete(Sheet *sheet)
|
|
{
|
|
int reply;
|
|
|
|
firstmenu:
|
|
/* ask for direction of deletion */ /*{{{*/
|
|
{
|
|
const char* menu[] =
|
|
{ _("cC)olumn"), _("rR)ow"), _("dD)epth"), NULL };
|
|
reply = line_menu(_("Delete:"), menu, 0);
|
|
if (reply < 0) return reply;
|
|
}
|
|
/*}}}*/
|
|
|
|
do_mark(sheet, GET_MARK_CUR);
|
|
Location beg, end;
|
|
LOCATION_GETS(beg, sheet->mark1);
|
|
LOCATION_GETS(end, sheet->mark2);
|
|
bool onecell = SAME_LOC(beg, end);
|
|
if (onecell)
|
|
/* ask if range is the current cell or whole dimension should be used */ /*{{{*/
|
|
{
|
|
const char *menu[3];
|
|
|
|
/* show menu */ /*{{{*/
|
|
switch (reply)
|
|
{
|
|
case 0: menu[0] = _("wW)hole column"); break;
|
|
case 1: menu[0] = _("wW)hole line"); break;
|
|
case 2: menu[0] = _("wW)hole sheet"); break;
|
|
default: assert(0);
|
|
}
|
|
menu[1] = _("sS)ingle cell");
|
|
menu[2] = NULL;
|
|
int r = line_menu(_("Delete:"), menu, 0);
|
|
/*}}}*/
|
|
switch (r)
|
|
{
|
|
/* 0 -- use whole dimension */ /*{{{*/
|
|
case 0:
|
|
{
|
|
switch (reply)
|
|
{
|
|
/* 0 -- use whole column */ /*{{{*/
|
|
case 0:
|
|
{
|
|
beg[Y] = 0; end[Y] = sheet->dimy;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 1 -- use whole line */ /*{{{*/
|
|
case 1:
|
|
{
|
|
beg[X] = 0; end[X] = sheet->dimx;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 2 -- use whole layer */ /*{{{*/
|
|
case 2:
|
|
{
|
|
beg[X] = 0; end[X] = sheet->dimx;
|
|
beg[Y] = 0; end[Y] = sheet->dimy;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* default -- should not happen */ /*{{{*/
|
|
default: assert(0);
|
|
/*}}}*/
|
|
}
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* 1 -- use current cell */ /*{{{*/
|
|
case 1: break;
|
|
/*}}}*/
|
|
/* -1 -- abort */ /*{{{*/
|
|
case -1: return -1;
|
|
/*}}}*/
|
|
/* -2 -- go back to previous menu */ /*{{{*/
|
|
case -2: goto firstmenu;
|
|
/*}}}*/
|
|
/* default -- should not happen */ /*{{{*/
|
|
default: assert(0);
|
|
/*}}}*/
|
|
}
|
|
}
|
|
/*}}}*/
|
|
/*}}}*/
|
|
switch(reply)
|
|
{
|
|
/* 0 -- columns */ /*{{{*/
|
|
case 0: deletecube(sheet, beg, end, IN_X); break;
|
|
/*}}}*/
|
|
/* 1 -- rows */ /*{{{*/
|
|
case 1: deletecube(sheet, beg, end, IN_Y); break;
|
|
/*}}}*/
|
|
/* 2 -- depth */ /*{{{*/
|
|
case 2: deletecube(sheet, beg, end, IN_Z); break;
|
|
/*}}}*/
|
|
}
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_move -- copy or move a block */ /*{{{*/
|
|
static int do_move(Sheet *sheet, int copy, int force)
|
|
{
|
|
int c;
|
|
|
|
c=-1;
|
|
|
|
if (getmarkstate(sheet) == UNMARKED) line_msg(copy ? _("Copy block:") : _("Move block:"),_("No block marked"));
|
|
else if (force || (c=line_ok(copy ? _("Copy block:") : _("Move block:"),0))==1)
|
|
{
|
|
do_mark(sheet, MARKED);
|
|
moveblock(sheet, sheet->mark1, sheet->mark2, sheet->cur, copy);
|
|
if (!copy) sheet->marking = UNMARKED;
|
|
}
|
|
if (c<0) return c; else return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_fill -- fill a block */ /*{{{*/
|
|
static int do_fill(Sheet *sheet)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
int cols,rows,layers;
|
|
int x,y,z;
|
|
Location wid, go;
|
|
int c;
|
|
/*}}}*/
|
|
|
|
if (getmarkstate(sheet) == UNMARKED) line_msg(_("Fill block:"),_("No block marked"));
|
|
else
|
|
{
|
|
do_mark(sheet, MARKED);
|
|
cols=rows=layers=1;
|
|
firstmenu:
|
|
do {
|
|
int c = line_numedit(&cols, _("Number of column-wise repetitions:"));
|
|
if (c < 0) return c;
|
|
} while (cols <= 0);
|
|
secondmenu:
|
|
do
|
|
{
|
|
int c = line_numedit(&rows, _("Number of row-wise repetitions:"));
|
|
if (c == -1) return -1;
|
|
else if (c == -2) goto firstmenu;
|
|
} while (rows <= 0);
|
|
do
|
|
{
|
|
int c = line_numedit(&layers, _("Number of depth-wise repetitions:"));
|
|
if (c == -1) return -1;
|
|
else if (c == -2) goto secondmenu;
|
|
} while (layers <= 0);
|
|
LOCATION_GETS(wid, sheet->mark2);
|
|
LOCATION_SUB(wid, sheet->mark1);
|
|
wid[X]++; wid[Y]++; wid[Z]++;
|
|
LOCATION_GETS(go, sheet->cur);
|
|
for (z=0; z<layers; ++z, go[Z] += wid[Z])
|
|
for (y=0, go[Y] = sheet->cur[Y]; y<rows; ++y, go[Y] += wid[Y])
|
|
for (x=0, go[X] = sheet->cur[X]; x<cols; ++x, go[X] += wid[X])
|
|
moveblock(sheet, sheet->mark1, sheet->mark2, go, 1);
|
|
}
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* fill the entire marked region using the current cell */
|
|
void fillwith(Sheet *she)
|
|
{
|
|
do_mark(she, GET_MARK_ALL);
|
|
Cell *src = curcell(she);
|
|
Location dest;
|
|
bool scan_labels = (src != NULLCELL && getlabel(src) != (const char*)0);
|
|
/* the following is safe since we have handled copying a cell to itself */
|
|
for (ALL_LOCS_IN_REGION(she, dest))
|
|
copycelltosheet(src, she, dest, ALTER_LABEL);
|
|
if (scan_labels) cachelabels(she);
|
|
forceupdate(she);
|
|
}
|
|
|
|
/* do_sort -- sort block */ /*{{{*/
|
|
static int do_sort(Sheet *sheet)
|
|
{
|
|
do_mark(sheet, GET_MARK_ALL);
|
|
/* build menus */ /*{{{*/
|
|
const char* menu1[] =
|
|
{ _("cC)olumn"), _("rR)ow"), _("dD)epth"), NULL };
|
|
const char* menu2[] =
|
|
{ _("sS)ort region"), _("aA)dd key"), NULL };
|
|
const char* menu3[] =
|
|
{ _("aA)scending"), _("dD)escending"), NULL };
|
|
/*}}}*/
|
|
|
|
int last = -1;
|
|
Direction in_dir = (Direction)-2; /* cause run time error */
|
|
int dir;
|
|
/* ask for sort direction */ /*{{{*/
|
|
zero:
|
|
dir = line_menu(_("Sort block:"), menu1, 0);
|
|
switch (dir)
|
|
{
|
|
case 0: in_dir = IN_X; break;
|
|
case 1: in_dir = IN_Y; break;
|
|
case 2: in_dir = IN_Z; break;
|
|
case -2: case -1: return dir;
|
|
default: assert(0);
|
|
}
|
|
last=0;
|
|
/*}}}*/
|
|
Sortkey sk[MAX_SORTKEYS];
|
|
unsigned int key = 0;
|
|
bool doit = false;
|
|
do
|
|
{
|
|
/* ask for positions */ /*{{{*/
|
|
one: if (in_dir==IN_X) sk[key].x=0; else /* ask for x position */ /*{{{*/
|
|
{
|
|
sk[key].x = 0;
|
|
do
|
|
{
|
|
int c = line_numedit(&(sk[key].x), _("X position of key vector:"));
|
|
if (c == -1) return -1;
|
|
else if (c == -2) switch (last)
|
|
{
|
|
case -1: return -2;
|
|
case 0: goto zero;
|
|
case 2: goto two;
|
|
case 3: goto three;
|
|
case 5: goto five;
|
|
}
|
|
} while (sk[key].x < 0);
|
|
last = 1;
|
|
}
|
|
/*}}}*/
|
|
two: if (in_dir==IN_Y) sk[key].y=0; else /* ask for y position */ /*{{{*/
|
|
{
|
|
sk[key].y = 0;
|
|
do
|
|
{
|
|
int c = line_numedit(&(sk[key].y), _("Y position of key vector:"));
|
|
if (c == -1) return -1;
|
|
else if (c == -2) switch (last)
|
|
{
|
|
case -1: return -2;
|
|
case 0: goto zero;
|
|
case 1: goto one;
|
|
case 3: goto three;
|
|
case 5: goto five;
|
|
default: assert(0);
|
|
}
|
|
} while (sk[key].y < 0);
|
|
last = 2;
|
|
}
|
|
/*}}}*/
|
|
three: if (in_dir==IN_Z) sk[key].z=0; else /* ask for z position */ /*{{{*/
|
|
{
|
|
sk[key].z = 0;
|
|
do
|
|
{
|
|
int c = line_numedit(&(sk[key].z), _("Z position of key vector:"));
|
|
if (c == -1) return -1;
|
|
else if (c == -2) switch (last)
|
|
{
|
|
case -1: return -2;
|
|
case 0: goto zero;
|
|
case 1: goto one;
|
|
case 2: goto two;
|
|
case 5: goto five;
|
|
default: assert(0);
|
|
}
|
|
} while (sk[key].z < 0);
|
|
last = 3;
|
|
}
|
|
/*}}}*/
|
|
/*}}}*/
|
|
/* ask for sort key */ /*{{{*/
|
|
four: sk[key].sortkey=0;
|
|
int ckey = line_menu(_("Sort block:"), menu3, 0);
|
|
switch (ckey)
|
|
{
|
|
case 0: sk[key].sortkey |= ASCENDING; break;
|
|
case 1: sk[key].sortkey &= ~ASCENDING; break;
|
|
case -1: return -1;
|
|
case -2: switch (last)
|
|
{
|
|
case -1: return -2;
|
|
case 1: goto one;
|
|
case 2: goto two;
|
|
case 3: goto three;
|
|
default: assert(0);
|
|
}
|
|
default: assert(0);
|
|
}
|
|
last = 4;
|
|
/*}}}*/
|
|
++key;
|
|
five:
|
|
if (key == MAX_SORTKEYS) /* ask for sort comfirmation */ /*{{{*/
|
|
{
|
|
int c = line_ok(_("Sort block:"),0);
|
|
if (c == -1) return -1;
|
|
else if (c == -2) goto four;
|
|
else if (c == 0) doit = true;
|
|
}
|
|
/*}}}*/
|
|
else /* ask for sort or adding another key */ /*{{{*/
|
|
switch (line_menu(_("Sort block:"), menu2, 0))
|
|
{
|
|
case 0: doit = true; break;
|
|
case 1: doit = false; break;
|
|
case -1: return -1;
|
|
case -2: goto four;
|
|
default: assert(0);
|
|
}
|
|
/*}}}*/
|
|
last = 5;
|
|
} while (!doit);
|
|
const char *msg =
|
|
sortblock(sheet, sheet->mark1, sheet->mark2, in_dir, sk, key);
|
|
if (msg != NULL) line_msg(_("Sort block:"), msg);
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_batchsort -- sort block in a batch*/ /*{{{*/
|
|
static void do_batchsort(Sheet *sheet, Direction dir, char* arg)
|
|
{
|
|
Sortkey sk[MAX_SORTKEYS];
|
|
int x1,y1,z1,x2,y2,z2;
|
|
unsigned int key = 0;
|
|
char* next;
|
|
while( *arg != '\0' )
|
|
{
|
|
while (isspace((int)*arg)) arg++;
|
|
sk[key].x=sk[key].y=sk[key].z=sk[key].sortkey=0;
|
|
switch (*arg)
|
|
{
|
|
case 'a': sk[key].sortkey|=ASCENDING; arg++; break;
|
|
case 'd': sk[key].sortkey&=~ASCENDING; arg++; break;
|
|
}
|
|
if ( *arg != '\0' && dir != IN_X ) { sk[key].x=strtol(arg, &next, 10); arg = next; }
|
|
if ( *arg != '\0' && dir != IN_Y ) { sk[key].y=strtol(arg, &next, 10); arg = next; }
|
|
if ( *arg != '\0' && dir != IN_Z ) { sk[key].z=strtol(arg, &next, 10); arg = next; }
|
|
key++;
|
|
}
|
|
do_mark(sheet, GET_MARK_ALL);
|
|
sortblock(sheet, sheet->mark1, sheet->mark2, dir, sk, key);
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_mirror -- mirror block */ /*{{{*/
|
|
static int do_mirror(Sheet *sheet)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
int x1,y1,z1,x2,y2,z2,reply;
|
|
/*}}}*/
|
|
|
|
do_mark(sheet, GET_MARK_ALL);
|
|
/* ask for direction of mirroring */ /*{{{*/
|
|
{
|
|
const char *menu[] =
|
|
{ _("lL)eft-right"), _("uU)pside-down"), _("fF)ront-back"), NULL};
|
|
reply = line_menu(_("Mirror block:"), menu, 0);
|
|
if (reply < 0) return reply;
|
|
}
|
|
/*}}}*/
|
|
switch (reply)
|
|
{
|
|
/* 0 -- left-right */ /*{{{*/
|
|
case 0: mirrorblock(sheet, sheet->mark1, sheet->mark2, IN_X); break;
|
|
/*}}}*/
|
|
/* 1 -- upside-down */ /*{{{*/
|
|
case 1: mirrorblock(sheet, sheet->mark1, sheet->mark2, IN_Y); break;
|
|
/*}}}*/
|
|
/* 2 -- front-back */ /*{{{*/
|
|
case 2: mirrorblock(sheet, sheet->mark1, sheet->mark2, IN_Z); break;
|
|
/*}}}*/
|
|
default: assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
/* do_goto -- go to a specific cell */ /*{{{*/
|
|
static int do_goto(Sheet *sheet, const char *expr)
|
|
{
|
|
assert(sheet != (Sheet*)0);
|
|
|
|
size_t x = 0;
|
|
size_t offx = 0;
|
|
char buf[1024];
|
|
buf[0]='\0';
|
|
if (expr) strcpy(buf,expr);
|
|
else {
|
|
int c = line_edit(sheet, buf, sizeof(buf), _("Go to location:"), &x, &offx);
|
|
if (c < 0) return c;
|
|
}
|
|
char *s = buf;
|
|
Token **t = scan(&s);
|
|
if (t != EMPTY_TVEC)
|
|
{
|
|
Token value;
|
|
|
|
LOCATION_GETS(upd_l, sheet->cur);
|
|
upd_sheet = sheet;
|
|
value = eval_safe(t, FULL);
|
|
tvecfree(t);
|
|
if (value.type == LOCATION && IN_OCTANT(value.u.location))
|
|
movetoloc(sheet, value.u.location);
|
|
else
|
|
line_msg(_("Go to location:"), _("Not a valid location"));
|
|
tfree(&value);
|
|
}
|
|
return -1;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* do_sheetcmd -- process one key press */ /*{{{*/
|
|
int do_sheetcmd(Sheet *cursheet, Key c, int moveonly)
|
|
{
|
|
switch ((int)c)
|
|
{
|
|
case K_GOTO: do_goto(cursheet, (const char *)0); break;
|
|
case K_COLWIDTH: do_columnwidth(cursheet); break;
|
|
case BLOCK_CLEAR: do_clear(cursheet); update(cursheet); break;
|
|
case BLOCK_INSERT: do_insert(cursheet); update(cursheet); break;
|
|
case BLOCK_DELETE: do_delete(cursheet); update(cursheet); break;
|
|
case BLOCK_MOVE: do_move(cursheet,0,0); update(cursheet); break;
|
|
case BLOCK_COPY: do_move(cursheet,1,0); update(cursheet); break;
|
|
case BLOCK_FILL: do_fill(cursheet); update(cursheet); break;
|
|
case FILL_BLOCK: fillwith(cursheet); update(cursheet); break;
|
|
case BLOCK_SORT: do_sort(cursheet); update(cursheet); break;
|
|
case BLOCK_MIRROR: do_mirror(cursheet); update(cursheet); break;
|
|
case ADJUST_LEFT:
|
|
case ADJUST_RIGHT:
|
|
case ADJUST_CENTER:
|
|
case ADJUST_DECIMAL:
|
|
case ADJUST_SCIENTIFIC:
|
|
case ADJUST_COMPACT:
|
|
case ADJUST_HEXACT:
|
|
case ADJUST_PRECISION:
|
|
case ADJUST_SHADOW:
|
|
case ADJUST_BOLD:
|
|
case ADJUST_UNDERLINE:
|
|
case ADJUST_FOREGROUND:
|
|
case ADJUST_BACKGROUND:
|
|
case ADJUST_TRANSPARENT:
|
|
case ADJUST_LABEL:
|
|
case ADJUST_LOCK:
|
|
case ADJUST_IGNORE: do_attribute(cursheet, c); break;
|
|
/* UP -- move up */ /*{{{*/
|
|
case K_UP:
|
|
{
|
|
relmoveto(cursheet, 0, -1, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* DOWN -- move down */ /*{{{*/
|
|
case K_DOWN:
|
|
{
|
|
relmoveto(cursheet, 0, 1, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* LEFT -- move left */ /*{{{*/
|
|
case K_LEFT:
|
|
{
|
|
relmoveto(cursheet, -1, 0, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* RIGHT -- move right */ /*{{{*/
|
|
case K_RIGHT:
|
|
{
|
|
relmoveto(cursheet, 1, 0, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* FIRSTL -- move to first line */ /*{{{*/
|
|
case K_FIRSTL:
|
|
case '<':
|
|
{
|
|
moveto(cursheet, -1, 0, -1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* LASTL -- move to last line */ /*{{{*/
|
|
case K_LASTL:
|
|
case '>':
|
|
{
|
|
moveto(cursheet, -1, (cursheet->dimy ? cursheet->dimy-1 : 0), -1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* HOME -- move to beginning of line */ /*{{{*/
|
|
case K_HOME:
|
|
{
|
|
moveto(cursheet, 0, -1, -1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* END -- move to end of line */ /*{{{*/
|
|
case K_END:
|
|
{
|
|
moveto(cursheet, (cursheet->dimx ? cursheet->dimx-1 : 0), -1, -1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* + -- move one sheet down */ /*{{{*/
|
|
case K_NSHEET:
|
|
case '+':
|
|
{
|
|
relmoveto(cursheet, 0, 0, 1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* - -- move one sheet up */ /*{{{*/
|
|
case K_PSHEET:
|
|
case '-':
|
|
{
|
|
relmoveto(cursheet, 0, 0, -1);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* * -- move to bottom sheet */ /*{{{*/
|
|
case K_LSHEET:
|
|
case '*':
|
|
{
|
|
moveto(cursheet, -1, -1, (cursheet->dimz ? cursheet->dimz-1 : 0));
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* _ -- move to top sheet */ /*{{{*/
|
|
case K_FSHEET:
|
|
case '_':
|
|
{
|
|
moveto(cursheet, -1, -1, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* ENTER -- edit current cell */ /*{{{*/
|
|
case K_ENTER:
|
|
if (moveonly) break;
|
|
do_edit(cursheet, '\0', NULL, BASE_CONT);
|
|
break;
|
|
/*}}}*/
|
|
/* MENTER -- edit current clocked cell */ /*{{{*/
|
|
case K_MENTER:
|
|
if (moveonly) break;
|
|
do_edit(cursheet, '\0', NULL, ITER_CONT);
|
|
break;
|
|
/*}}}*/
|
|
case K_EDIT_STYLE_EXPR: /* edit style expression */ /*{{{*/
|
|
if (moveonly) break;
|
|
do_edit(cursheet, '\0', NULL, STYLE_CONT);
|
|
break;
|
|
/*}}}*/
|
|
/* ", @, digit -- edit current cell with character already in buffer */ /*{{{*/
|
|
case K_BACKSPACE:
|
|
case K_DC:
|
|
case '"':
|
|
case '@':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
if (moveonly) break;
|
|
do_edit(cursheet, c, NULL, BASE_CONT);
|
|
break;
|
|
/*}}}*/
|
|
/* MARK -- toggle block marking */ /*{{{*/
|
|
case '.':
|
|
case K_MARK: if (moveonly) break; do_mark(cursheet, 0); break;
|
|
/*}}}*/
|
|
/* _("Save sheet file format:") -- save menu */ /*{{{*/
|
|
case K_SAVEMENU: if (moveonly) break; do_save(cursheet); break;
|
|
/*}}}*/
|
|
/* _("Load sheet file format:") -- load menu */ /*{{{*/
|
|
case K_LOAD:
|
|
case K_LOADMENU: if (moveonly) break; do_load(cursheet); break;
|
|
/*}}}*/
|
|
/* _("nN)ame") -- set name */ /*{{{*/
|
|
case K_NAME: if (moveonly) break; do_name(cursheet); break;
|
|
/*}}}*/
|
|
#ifdef ENABLE_HELP
|
|
case K_HELP: show_text(helpfile); break;
|
|
#else
|
|
case K_HELP: show_text(_("Sorry, manual is not installed.")); break;
|
|
#endif
|
|
case K_DUMPCELL: dump_current_cell(cursheet); break;
|
|
case K_ABOUT: show_text(_("<html><head><title>About teapot</title></head><body><center><pre>\n\n"
|
|
" ` ',` ' ' \n"
|
|
" ` ' ` ' ' \n"
|
|
" `' ' '`' \n"
|
|
" ' ` ' '` \n"
|
|
" ' '` ' ` '`` ` \n"
|
|
" `. Table Editor And Planner, or: \n"
|
|
" , . , , . . \n"
|
|
" ` ' ` ' ' \n"
|
|
" `::\\ /:::::::::::::::::\\ ___ \n"
|
|
" `::\\ /:::::::::::::::::::\\,'::::\\ \n"
|
|
" :::\\/:::::::::::::::::::::\\/ \\:\\ \n"
|
|
" :::::::::::::::::::::::::::\\ ::: \n"
|
|
" ::::::::::::::::::::::::::::; /:;' \n"
|
|
" `::::::::::::::::::::::::::::_/:;' \n"
|
|
" `::::::::::::::::::::::::::::' \n"
|
|
" `////////////////////////' \n"
|
|
" `:::::::::::::::::::::' \n"
|
|
"</pre>\n"
|
|
"<p>Teapot " VERSION "</p>\n"
|
|
"\n"
|
|
"<p>Original Version: Michael Haardt<br>\n"
|
|
"Current Maintainer: Joerg Walter<br>\n"
|
|
"Contibutions by: Glen Whitney<br>\b"
|
|
"Home Page: <a href='http://www.syntax-k.de/projekte/teapot/'>http://www.syntax-k.de/projekte/teapot/</a></p>\n"
|
|
"This distribution: <a href='https://code.studioinfinity.org/glen/teapot-spreadsheet/'>https://code.studioinfinity.org/glen/teapot-spreadsheet/</a></p>\n"
|
|
"\n"
|
|
"<p>Copyright 1995-2006 Michael Haardt,<br>\n"
|
|
"Copyright 2009-2010 Joerg Walter (<a href='mailto:info@syntax-k.de'>info@syntax-k.de</a>)<br>"
|
|
"Copyright 2019 Glen Whitney</p></center>\n"
|
|
"\f"
|
|
"<p>This program is free software: you can redistribute it and/or modify\n"
|
|
"it under the terms of the GNU General Public License as published by\n"
|
|
"the Free Software Foundation, either version 3 of the License, or\n"
|
|
"(at your option) any later version.</p>\n"
|
|
"\n"
|
|
"<p>This program is distributed in the hope that it will be useful,\n"
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
"GNU General Public License for more details.</p>\n"
|
|
"\n"
|
|
"<p>You should have received a copy of the GNU General Public License\n"
|
|
"along with this program. If not, see <a href='http://www.gnu.org/licenses/'>http://www.gnu.org/licenses/</a>.</p>"
|
|
"</body></html>"));
|
|
break;
|
|
/* MENU, / -- main menu */ /*{{{*/
|
|
case '/': if (!moveonly && do_sheetcmd(cursheet, show_menu(cursheet), 0)) return 1; break;
|
|
/*}}}*/
|
|
/* _("sS)ave") -- save in current native format */ /*{{{*/
|
|
case K_SAVE: do_save(cursheet); break;
|
|
/*}}}*/
|
|
/* _("cC)opy") -- copy block */ /*{{{*/
|
|
case K_COPY: if (moveonly) break; do_move(cursheet,1,1); break;
|
|
/*}}}*/
|
|
/* RECALC -- recalculate */ /*{{{*/
|
|
case K_RECALC: if (moveonly) break; forceupdate(cursheet); break;
|
|
/*}}}*/
|
|
/* _("Usage: clock(condition,location[,location])") -- clock */ /*{{{*/
|
|
case K_CLOCK:
|
|
{
|
|
Location w;
|
|
|
|
for (ALL_LOCS_IN_SHEET(cursheet, w))
|
|
clk(cursheet, w);
|
|
update(cursheet);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* NPAGE -- page down */ /*{{{*/
|
|
case K_NPAGE:
|
|
{
|
|
cursheet->offy+=(cursheet->maxy-3);
|
|
relmoveto(cursheet, 0, cursheet->maxy-3, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* PPAGE -- page up */ /*{{{*/
|
|
case K_PPAGE:
|
|
{
|
|
cursheet->offy = (cursheet->offy>=(cursheet->maxy-3) ? cursheet->offy-(cursheet->maxy-3) : 0);
|
|
relmoveto(cursheet, 0, (cursheet->cur[Y] >= (cursheet->maxy-3) ? -(cursheet->maxy-3) : -cursheet->cur[Y]), 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* FPAGE -- page right */ /*{{{*/
|
|
case K_FPAGE:
|
|
{
|
|
cursheet->offx+=cursheet->width;
|
|
relmoveto(cursheet, cursheet->width, 0, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* BPAGE -- page left */ /*{{{*/
|
|
case K_BPAGE:
|
|
{
|
|
cursheet->offx=(cursheet->offx>=cursheet->width ? cursheet->offx-cursheet->width : 0);
|
|
relmoveto(cursheet, (cursheet->cur[X]>=cursheet->width ? -cursheet->width : -cursheet->cur[X]), 0, 0);
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* SAVEQUIT -- save and quit */ /*{{{*/
|
|
case K_SAVEQUIT:
|
|
{
|
|
if (moveonly) break;
|
|
if (do_save(cursheet)!=-2) return 1;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* _("qQ)uit") -- quit */ /*{{{*/
|
|
case K_QUIT: if (moveonly) break; return 1;
|
|
/*}}}*/
|
|
default:
|
|
if (isalpha(c) && !moveonly) do_edit(cursheet, c, NULL, BASE_CONT);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
/*}}}*/
|
|
|
|
/* main */ /*{{{*/
|
|
int main(int argc, char *argv[])
|
|
{
|
|
/* variables */ /*{{{*/
|
|
Sheet sheet,*cursheet;
|
|
int o;
|
|
const char *loadfile;
|
|
char ln[1024];
|
|
/*}}}*/
|
|
|
|
setlocale(LC_ALL, "");
|
|
find_helpfile(helpfile, sizeof(helpfile), argv[0]);
|
|
|
|
/* parse options */ /*{{{*/
|
|
while ((o=getopt(argc,argv,"bdhnrqHp:?"))!=EOF) switch (o)
|
|
{
|
|
/* b -- run batch */ /*{{{*/
|
|
case 'b': batch = true; break;
|
|
/*}}}*/
|
|
/* d -- increase debug level */ /*{{{*/
|
|
case 'd': ++debug_level; break;
|
|
/*}}}*/
|
|
/* n -- no quoted strings */ /*{{{*/
|
|
case 'n': quote = DIRECT_STRING; break;
|
|
/*}}}*/
|
|
/* q -- force quoted strings */ /*{{{*/
|
|
case 'q': quote = QUOTE_STRING; break;
|
|
/*}}}*/
|
|
/* H -- no row/column headers */ /*{{{*/
|
|
case 'H': header = false; break;
|
|
/*}}}*/
|
|
/* r -- always redraw */ /*{{{*/
|
|
case 'r':
|
|
{
|
|
always_redraw = true;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* p -- precision */ /*{{{*/
|
|
case 'p':
|
|
{
|
|
long n;
|
|
char *end;
|
|
|
|
n=strtol(optarg,&end,0);
|
|
if (*end || n < 0 || n > LDBL_DIG)
|
|
{
|
|
fprintf(stderr,
|
|
_("teapot: precision must be between 0 and %d.\n"), LDBL_DIG);
|
|
exit(1);
|
|
}
|
|
def_precision=n;
|
|
break;
|
|
}
|
|
/*}}}*/
|
|
/* default -- includes ? and h */ /*{{{*/
|
|
default:
|
|
{
|
|
fprintf(stderr,_(
|
|
"Usage: %s [-a] [-b] [-d]* [-h] [-n|-q] [-H] [-r] [-p digits] [file]\n"
|
|
" -a: use ASCII file format as default\n"
|
|
" -b: batch mode\n"
|
|
" -d: increase debug level, once for each occurrence\n"
|
|
" -h: print this message and exit\n"
|
|
" -n|-q: DO NOT or DO display strings in quotes, respectively\n"
|
|
" -H: hide row/column headers\n"
|
|
" -r: redraw more often\n"
|
|
" -p: set decimal precision\n"
|
|
), argv[0]);
|
|
exit(1);
|
|
}
|
|
/*}}}*/
|
|
}
|
|
loadfile = (optind<argc ? argv[optind] : (const char*)0);
|
|
/*}}}*/
|
|
cursheet = &sheet;
|
|
initialize_sheet(cursheet);
|
|
if (loadfile) /* load given sheet */ /*{{{*/
|
|
{
|
|
const char *msg;
|
|
|
|
cursheet->name=strdup(loadfile);
|
|
if (usexdr)
|
|
{
|
|
if ((msg=loadxdr(cursheet, cursheet->name)) != NULL)
|
|
line_msg(_("Load sheet from XDR file:"), msg);
|
|
}
|
|
else
|
|
if ((msg=loadport(cursheet, cursheet->name)) != NULL)
|
|
line_msg(_("Load sheet from ASCII file:"),msg);
|
|
}
|
|
/*}}}*/
|
|
if (batch) /* process batch */ /*{{{*/
|
|
while (fgets(ln,sizeof(ln),stdin)!=(char*)0)
|
|
{
|
|
/* variables */ /*{{{*/
|
|
size_t len;
|
|
char *cmd,*arg;
|
|
/*}}}*/
|
|
|
|
/* set cmd and arg */ /*{{{*/
|
|
++batchln;
|
|
len=strlen(ln);
|
|
if (len && ln[len-1]=='\n') ln[len-1]='\0';
|
|
cmd=ln; while (isspace((int)*cmd)) ++cmd;
|
|
arg=cmd;
|
|
while (*arg && !isspace((int)*arg)) ++arg;
|
|
while (isspace((int)*arg)) *arg++='\0';
|
|
/*}}}*/
|
|
|
|
/* goto location */ /*{{{*/
|
|
if (strcmp(cmd,"goto")==0) do_goto(cursheet,arg);
|
|
/*}}}*/
|
|
/* from location */ /*{{{*/
|
|
else if (strcmp(cmd,"from")==0)
|
|
{
|
|
do_goto(cursheet,arg);
|
|
do_mark(cursheet,1);
|
|
}
|
|
/*}}}*/
|
|
/* to location */ /*{{{*/
|
|
else if (strcmp(cmd,"to")==0)
|
|
{
|
|
do_goto(cursheet,arg);
|
|
do_mark(cursheet,2);
|
|
}
|
|
/*}}}*/
|
|
/* save-tbl file */ /*{{{*/
|
|
else if (strcmp(cmd,"save-tbl")==0) do_savetbl(cursheet,arg);
|
|
/*}}}*/
|
|
/* save-latex file */ /*{{{*/
|
|
else if (strcmp(cmd,"save-latex")==0) do_savelatex(cursheet,arg);
|
|
/*}}}*/
|
|
/* save-context file */ /*{{{*/
|
|
else if (strcmp(cmd,"save-context")==0) do_savecontext(cursheet,arg);
|
|
/*}}}*/
|
|
/* save-csv file */ /*{{{*/
|
|
else if (strcmp(cmd,"save-csv")==0) do_savecsv(cursheet,arg);
|
|
/*}}}*/
|
|
/* save-html file */ /*{{{*/
|
|
else if (strcmp(cmd,"save-html")==0) do_savehtml(cursheet,arg);
|
|
/*}}}*/
|
|
/* load-csv file */ /*{{{*/
|
|
else if (strcmp(cmd,"load-csv")==0) { loadcsv(cursheet,arg); forceupdate(cursheet); }
|
|
/*}}}*/
|
|
/* sort in x direction */ /*{{{*/
|
|
else if (strcmp(cmd,"sort-x")==0) do_batchsort(cursheet, IN_X, arg);
|
|
/*}}}*/
|
|
/* sort in y direction */ /*{{{*/
|
|
else if (strcmp(cmd,"sort-y")==0) do_batchsort(cursheet, IN_Y, arg);
|
|
/*}}}*/
|
|
/* sort in z direction */ /*{{{*/
|
|
else if (strcmp(cmd,"sort-z")==0) do_batchsort(cursheet, IN_Z, arg);
|
|
/*}}}*/
|
|
/* this is an unknown command */ /*{{{*/
|
|
else line_msg(_("Unknown batch command:"),cmd);
|
|
/*}}}*/
|
|
}
|
|
/*}}}*/
|
|
else /* process interactive input */ /*{{{*/
|
|
display_main(cursheet);
|
|
/*}}}*/
|
|
freesheet(cursheet,1);
|
|
fclose(stdin);
|
|
return 0;
|
|
}
|
|
/*}}}*/
|