1367 lines
27 KiB
C++
Executable File
1367 lines
27 KiB
C++
Executable File
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <applicat.h>
|
|
#include <form.h>
|
|
#include <msksheet.h>
|
|
#include <relation.h>
|
|
#include <sheet.h>
|
|
#include <utility.h>
|
|
|
|
#include "../ba/ba2100.h"
|
|
|
|
static TForm* _form = NULL;
|
|
|
|
static TForm& form()
|
|
{
|
|
CHECK(_form, "Can't print NULL form");
|
|
return *_form;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_flags
|
|
///////////////////////////////////////////////////////////
|
|
|
|
struct TForm_flags : public TObject
|
|
{
|
|
bool automagic : 1;
|
|
bool enabled : 1;
|
|
bool shown : 1;
|
|
|
|
protected:
|
|
void print_on(ostream& out) const;
|
|
|
|
public:
|
|
TForm_flags();
|
|
|
|
void print_on(TMask& m);
|
|
void read_from(const TMask& m);
|
|
|
|
bool update(const char* s);
|
|
};
|
|
|
|
TForm_flags::TForm_flags()
|
|
{
|
|
automagic = FALSE;
|
|
shown = enabled = TRUE;
|
|
}
|
|
|
|
bool TForm_flags::update(const char* s)
|
|
{
|
|
for (; *s; s++) switch(toupper(*s))
|
|
{
|
|
case 'A':
|
|
automagic = TRUE; break;
|
|
case 'D':
|
|
enabled = FALSE; break;
|
|
case 'H':
|
|
shown = FALSE; break;
|
|
default :
|
|
error_box("Unknown form item flag '%c'", *s); break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void TForm_flags::print_on(ostream& out) const
|
|
{
|
|
TString16 s;
|
|
|
|
if (automagic) s << "A";
|
|
if (!enabled) s << "D";
|
|
if (!shown) s << "H";
|
|
|
|
if (s.not_empty())
|
|
out << " FLAGS \"" << s << '"' << endl;
|
|
}
|
|
|
|
|
|
void TForm_flags::print_on(TMask& m)
|
|
{
|
|
m.set(F_DISABLED, enabled ? " " : "X");
|
|
m.set(F_HIDDEN, shown ? " " : "X");
|
|
m.set(F_AUTOMAGIC, automagic ? "X" : " ");
|
|
}
|
|
|
|
|
|
void TForm_flags::read_from(const TMask& m)
|
|
{
|
|
shown = !m.get_bool(F_HIDDEN);
|
|
enabled = !m.get_bool(F_DISABLED);
|
|
automagic = m.get_bool(F_AUTOMAGIC);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_item
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_item : public TObject
|
|
{
|
|
TPrint_section* _section;
|
|
TString _desc;
|
|
TForm_flags _flag;
|
|
TBit_array _group;
|
|
TString_array _message;
|
|
|
|
protected:
|
|
int _x, _y, _width, _height;
|
|
TString _prompt;
|
|
|
|
virtual void print_on(ostream& out) const;
|
|
virtual void print_body(ostream& out) const;
|
|
|
|
int width() const { return _width; }
|
|
int height() const { return _height; }
|
|
|
|
bool shown() const { return _flag.shown; }
|
|
bool hidden() const { return !_flag.shown; }
|
|
bool enabled() const { return _flag.enabled; }
|
|
bool disabled() const { return !_flag.enabled; }
|
|
bool automagic() const { return !_flag.automagic; }
|
|
|
|
virtual bool parse_head(TScanner&);
|
|
virtual bool parse_item(TScanner&);
|
|
|
|
virtual const char* get() const { return _prompt; }
|
|
virtual bool set(const char* s) { _prompt = s; return TRUE; }
|
|
|
|
TToken_string& message(int m = 0);
|
|
void send_message(const TString& cmd, TForm_item& dest) const;
|
|
bool do_message(int m = 0);
|
|
|
|
void string_at(int x, int y, const char* s);
|
|
|
|
public:
|
|
virtual bool parse(TScanner&);
|
|
virtual bool update();
|
|
|
|
virtual void print_on(TMask& m);
|
|
virtual void read_from(const TMask& m);
|
|
bool edit(TMask& m);
|
|
|
|
TPrint_section& section() const { return *_section; }
|
|
|
|
bool in_group(byte g) const { return g == 0 || _group[g]; }
|
|
const TString& key() const { return _desc; }
|
|
void print_on(TToken_string& row) const;
|
|
|
|
void show(bool on = TRUE) { _flag.shown = on; }
|
|
void hide() { show(FALSE); }
|
|
void enable(bool on = TRUE);
|
|
void disable() { enable(FALSE); }
|
|
|
|
TForm_item(TPrint_section* section);
|
|
virtual ~TForm_item() {}
|
|
};
|
|
|
|
|
|
TForm_item::TForm_item(TPrint_section* section)
|
|
: _section(section), _x(-1), _y(-1), _width(0), _height(0)
|
|
{}
|
|
|
|
|
|
bool TForm_item::parse_head(TScanner& scanner)
|
|
{
|
|
_width = scanner.integer();
|
|
if (_width) _height = scanner.integer();
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void TForm_item::print_on(ostream& out) const
|
|
{
|
|
out << class_name();
|
|
if (_width > 0)
|
|
{
|
|
out << ' ' << _width;
|
|
if (_height > 0)
|
|
out << ' ' << _height;
|
|
}
|
|
out << "\nBEGIN\n";
|
|
|
|
print_body(out);
|
|
|
|
out << "END\n" << endl;
|
|
}
|
|
|
|
|
|
void TForm_item::print_body(ostream& out) const
|
|
{
|
|
out << " KEY \"" << _desc << "\"\n";
|
|
|
|
if (_y >= 0)
|
|
out << " PROMPT " << _x << ' ' << _y << " \"" << _prompt << "\"\n";
|
|
|
|
if (_group.ones())
|
|
out << " GROUP " << _group << "\n";
|
|
|
|
out << _flag;
|
|
|
|
if (_message.items() == 1)
|
|
out << " MESSAGE " << (TToken_string&)_message[0] << endl;
|
|
}
|
|
|
|
|
|
bool TForm_item::parse_item(TScanner& scanner)
|
|
{
|
|
if (scanner.key() == "PR")
|
|
{
|
|
_x = scanner.integer();
|
|
_y = scanner.integer();
|
|
_prompt = scanner.string();
|
|
return TRUE;
|
|
}
|
|
|
|
if (scanner.key() == "FL")
|
|
return _flag.update(scanner.string());
|
|
|
|
if (scanner.key() == "ME")
|
|
{
|
|
TFixed_string m(scanner.line());
|
|
m.strip_spaces();
|
|
message(0).add(m);
|
|
return TRUE;
|
|
}
|
|
|
|
if (scanner.key() == "KE")
|
|
{
|
|
_desc = scanner.string();
|
|
return TRUE;
|
|
}
|
|
|
|
if (scanner.key() == "GR")
|
|
{
|
|
_group.set(scanner.line());
|
|
return TRUE;
|
|
}
|
|
|
|
yesnofatal_box("Unknown symbol in item '%s': '%s'",
|
|
(const char*)key(), (const char*)scanner.token());
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
bool TForm_item::parse(TScanner& scanner)
|
|
{
|
|
bool ok = parse_head(scanner);
|
|
|
|
if (ok && scanner.popkey() != "BE")
|
|
ok = yesnofatal_box("Missing BEGIN in form item %s", (const char*)key());
|
|
|
|
while (ok && scanner.popkey() != "EN")
|
|
ok = parse_item(scanner);
|
|
|
|
return ok;
|
|
}
|
|
|
|
void TForm_item::enable(bool on)
|
|
{
|
|
_flag.enabled = on;
|
|
show(on);
|
|
}
|
|
|
|
|
|
void TForm_item::string_at(int x, int y, const char* s)
|
|
{
|
|
if (hidden()) return;
|
|
|
|
section().offset(x, y);
|
|
TPrintrow& row = section().row(y-1); // Seleziona riga di stampa
|
|
|
|
if (_width > 0 && strlen(s) > (word)_width) // Tronca testo se necessario
|
|
{
|
|
strncpy(__tmp_string, s, width());
|
|
__tmp_string[width()] = '\0';
|
|
s = __tmp_string;
|
|
}
|
|
row.put(s, x-1); // Stampa testo
|
|
}
|
|
|
|
|
|
TToken_string& TForm_item::message(int m)
|
|
{
|
|
TToken_string* t = (TToken_string*)_message.objptr(m);
|
|
if (t == NULL)
|
|
{
|
|
t = new TToken_string(16);
|
|
_message.add(t, m);
|
|
}
|
|
return *t;
|
|
}
|
|
|
|
|
|
void TForm_item::send_message(const TString& cmd, TForm_item& des) const
|
|
{
|
|
if (cmd == "ADD" || cmd == "SUM" || cmd == "INC")
|
|
{
|
|
const real n((cmd[0] == 'I') ? "1.0" : get());
|
|
real r(des.get());
|
|
r += n;
|
|
des.set(r.string());
|
|
} else
|
|
if (cmd == "COPY")
|
|
{
|
|
des.set(get());
|
|
} else
|
|
if (cmd == "APPEND")
|
|
{
|
|
TString256 val = des.get();
|
|
if (val.not_empty()) val << ' ';
|
|
val << get();
|
|
des.set(val);
|
|
} else
|
|
if (cmd == "DISABLE")
|
|
{
|
|
des.disable();
|
|
} else
|
|
if (cmd == "ENABLE")
|
|
{
|
|
des.enable();
|
|
} else
|
|
if (cmd == "HIDE")
|
|
{
|
|
des.hide();
|
|
} else
|
|
if (cmd == "RESET")
|
|
{
|
|
des.set("");
|
|
} else
|
|
if (cmd == "SHOW")
|
|
{
|
|
des.show();
|
|
} else
|
|
if (cmd[0] == '"')
|
|
{
|
|
TString256 val(cmd);
|
|
val.strip("\"");
|
|
des.set(val);
|
|
} else
|
|
error_box("Unknown message in item '%s': '%s'",
|
|
(const char*)key(), (const char*)cmd);
|
|
}
|
|
|
|
|
|
bool TForm_item::do_message(int num)
|
|
{
|
|
TToken_string& messaggio = message(num);
|
|
if (messaggio.empty()) return FALSE;
|
|
|
|
TToken_string msg(16, ',');
|
|
for (const char* m = messaggio.get(0); m; m = messaggio.get())
|
|
{
|
|
msg = m;
|
|
if (*m == '_')
|
|
{
|
|
const char* s = section().form().validate(get(), msg);
|
|
if (s) set(s);
|
|
}
|
|
else
|
|
{
|
|
const TString16 cmd(msg.get()); // Get command
|
|
const word id = msg.get_int(); // Get destination group
|
|
|
|
// Send the message to all fields with the given group
|
|
for (word i = 0; i < section().fields(); i++)
|
|
{
|
|
TForm_item& des = section().field(i);
|
|
if (des.in_group(id))
|
|
send_message(cmd, des);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TForm_item::update()
|
|
{
|
|
string_at(_x, _y, _prompt);
|
|
do_message();
|
|
return TRUE;
|
|
}
|
|
|
|
void TForm_item::print_on(TToken_string& row) const
|
|
{
|
|
row = class_name();
|
|
row.add(_y);
|
|
row.add(_x);
|
|
|
|
const long fu = _group.first_one();
|
|
if (fu > 0) row.add(fu);
|
|
else row.add(" ");
|
|
row.add(key());
|
|
}
|
|
|
|
void TForm_item::print_on(TMask& m)
|
|
{
|
|
m.set(F_CLASS, class_name());
|
|
m.set(F_KEY, key());
|
|
m.set(F_X, _x);
|
|
m.set(F_Y, _y);
|
|
m.set(F_PROMPT, _prompt);
|
|
m.set(F_WIDTH, _width);
|
|
m.set(F_HEIGHT, _height);
|
|
_flag.print_on(m);
|
|
|
|
for (int g = 1; g <= 24; g++)
|
|
m.set(F_GROUP+g, _group[g] ? "X" : " ");
|
|
}
|
|
|
|
void TForm_item::read_from(const TMask& m)
|
|
{
|
|
_desc = m.get(F_KEY);
|
|
_x = atoi(m.get(F_X));
|
|
_y = atoi(m.get(F_Y));
|
|
_prompt = m.get(F_PROMPT);
|
|
_width = atoi(m.get(F_WIDTH));
|
|
_height = atoi(m.get(F_HEIGHT));
|
|
_flag.read_from(m);
|
|
|
|
_group.reset();
|
|
for (int g = 1; g <= 24; g++)
|
|
_group.set(g, m.get_bool(F_GROUP+g));
|
|
}
|
|
|
|
|
|
bool TForm_item::edit(TMask& m)
|
|
{
|
|
m.reset();
|
|
|
|
if (m.insert_mode()) m.enable(F_CLASS);
|
|
else print_on(m);
|
|
|
|
const bool dirty = (m.run() == K_ENTER) && m.dirty();
|
|
|
|
if (m.insert_mode()) m.disable(F_CLASS);
|
|
else if (dirty) read_from(m);
|
|
|
|
return dirty;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_string
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_string : public TForm_item
|
|
{
|
|
TString _str, _picture;
|
|
TArray _field;
|
|
|
|
protected:
|
|
virtual const char* class_name() const { return "STRINGA"; }
|
|
virtual void print_body(ostream& out) const;
|
|
|
|
virtual void print_on(TMask& m);
|
|
virtual void read_from(const TMask& m);
|
|
|
|
virtual bool parse_item(TScanner&);
|
|
virtual bool read();
|
|
virtual bool update();
|
|
|
|
const char* get() const;
|
|
bool set(const char*);
|
|
|
|
const TString& picture() const { return _picture; }
|
|
|
|
TFieldref& field(int i) const { return (TFieldref&)_field[i]; }
|
|
void put_paragraph(const char* s);
|
|
|
|
public:
|
|
TForm_string(TPrint_section* section) : TForm_item(section) {}
|
|
virtual ~TForm_string() {}
|
|
};
|
|
|
|
bool TForm_string::parse_item(TScanner& scanner)
|
|
{
|
|
if (scanner.key() == "FI")
|
|
{
|
|
TFieldref* fr = new TFieldref(scanner.line(), 0);
|
|
_field.add(fr);
|
|
return TRUE;
|
|
}
|
|
|
|
if (scanner.key() == "PI")
|
|
{
|
|
_picture = scanner.string();
|
|
return TRUE;
|
|
}
|
|
|
|
return TForm_item::parse_item(scanner);
|
|
}
|
|
|
|
void TForm_string::print_body(ostream& out) const
|
|
{
|
|
TForm_item::print_body(out);
|
|
if (_picture.not_empty())
|
|
out << " PICTURE \"" << _picture << "\"" << endl;
|
|
for (int i = 0; i < _field.items(); i++)
|
|
out << " FIELD " << field(i) << endl;
|
|
}
|
|
|
|
void TForm_string::print_on(TMask& m)
|
|
{
|
|
TForm_item::print_on(m);
|
|
for (int i = 0; i < 2; i++) if (i < _field.items())
|
|
{
|
|
TString80 f;
|
|
f << field(i);
|
|
m.set(i == 0 ? F_FIELD : F_FIELD2, f);
|
|
}
|
|
|
|
m.set(F_PICTURE, _picture);
|
|
}
|
|
|
|
void TForm_string::read_from(const TMask& m)
|
|
{
|
|
TForm_item::read_from(m);
|
|
_picture = m.get(F_PICTURE);
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
const TString& f = m.get(i == 0 ? F_FIELD : F_FIELD2);
|
|
if (f.not_empty())
|
|
_field.add(new TFieldref(f, 0), i);
|
|
else
|
|
_field.destroy(i);
|
|
}
|
|
}
|
|
|
|
bool TForm_string::set(const char* s)
|
|
{
|
|
_str = s;
|
|
if (width()) _str.cut(width());
|
|
return TRUE;
|
|
}
|
|
|
|
const char* TForm_string::get() const
|
|
{ return _str; }
|
|
|
|
bool TForm_string::read()
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
if (enabled())
|
|
{
|
|
if (_field.items())
|
|
{
|
|
const char* s = "";
|
|
const TRelation* r = section().form().relation();
|
|
for (int i = 0; i < _field.items(); i++)
|
|
{
|
|
s = field(i).read(r);
|
|
if (*s) break;
|
|
}
|
|
set(s);
|
|
}
|
|
} else ok = FALSE;
|
|
|
|
return ok;
|
|
}
|
|
|
|
void TForm_string::put_paragraph(const char* s)
|
|
{
|
|
if (hidden()) return;
|
|
|
|
if (height() > 1)
|
|
{
|
|
TParagraph_string p(s, width());
|
|
int i = _prompt.not_empty() ? 1 : 0;
|
|
for (; (s = p.get()) != NULL && i < height(); i++)
|
|
string_at(_x, _y+i, s);
|
|
}
|
|
else string_at(-1, _y, s);
|
|
}
|
|
|
|
|
|
bool TForm_string::update()
|
|
{
|
|
if (read())
|
|
{
|
|
TForm_item::update();
|
|
if (_picture.not_empty())
|
|
{
|
|
TString80 p;
|
|
p.picture(_picture, get());
|
|
put_paragraph(p);
|
|
}
|
|
else
|
|
put_paragraph(get());
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_number
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_number : public TForm_string
|
|
{
|
|
protected:
|
|
virtual const char* class_name() const { return "NUMERO"; }
|
|
virtual bool parse_head(TScanner& scanner);
|
|
virtual bool update();
|
|
|
|
int decimals() const { return _height; }
|
|
|
|
public:
|
|
TForm_number(TPrint_section* section) : TForm_string(section) {}
|
|
virtual ~TForm_number() {}
|
|
};
|
|
|
|
|
|
bool TForm_number::parse_head(TScanner& scanner)
|
|
{
|
|
_width = 0;
|
|
_height = scanner.integer();
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TForm_number::update()
|
|
{
|
|
if (read())
|
|
{
|
|
TForm_item::update();
|
|
const char* s = get();
|
|
real n(s);
|
|
n.round(decimals());
|
|
s = n.string(picture());
|
|
string_at(-1, _y, s);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_date
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_date : public TForm_string
|
|
{
|
|
protected:
|
|
virtual const char* class_name() const { return "DATA"; }
|
|
virtual bool read();
|
|
virtual bool set(const char*);
|
|
bool set(const TDate& d);
|
|
|
|
public:
|
|
TForm_date(TPrint_section* section);
|
|
virtual ~TForm_date() {}
|
|
};
|
|
|
|
|
|
TForm_date::TForm_date(TPrint_section* section)
|
|
: TForm_string(section)
|
|
{}
|
|
|
|
bool TForm_date::read()
|
|
{
|
|
bool ok = TForm_string::read();
|
|
if (ok && !get()[0] && automagic())
|
|
set(main_app().printer().getdate());
|
|
return ok;
|
|
}
|
|
|
|
bool TForm_date::set(const char* s)
|
|
{
|
|
const TDate d(s);
|
|
TForm_string::set(d.string((width() == 8) ? 2 : 4));
|
|
return TRUE;
|
|
}
|
|
|
|
bool TForm_date::set(const TDate& d)
|
|
{
|
|
TForm_string::set(d.string((width() == 8) ? 2 : 4));
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_list
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_list : public TForm_string
|
|
{
|
|
TToken_string _codes;
|
|
TToken_string _values;
|
|
|
|
protected:
|
|
virtual const char* class_name() const { return "LISTA"; }
|
|
virtual bool parse_item(TScanner& scanner);
|
|
virtual void print_on(TMask& m);
|
|
virtual void read_from(const TMask& m);
|
|
virtual void print_body(ostream& out) const;
|
|
virtual bool update();
|
|
|
|
public:
|
|
TForm_list(TPrint_section* section);
|
|
virtual ~TForm_list() {}
|
|
};
|
|
|
|
TForm_list::TForm_list(TPrint_section* section)
|
|
: TForm_string(section)
|
|
{}
|
|
|
|
bool TForm_list::parse_item(TScanner& scanner)
|
|
{
|
|
if (scanner.key() == "IT")
|
|
{
|
|
TToken_string s(scanner.string());
|
|
_codes.add(s.get());
|
|
_values.add(s.get());
|
|
|
|
TString m(80);
|
|
while (scanner.popkey() == "ME")
|
|
{
|
|
m = scanner.line();
|
|
m.strip_spaces();
|
|
message(_values.items()-1).add(m);
|
|
}
|
|
scanner.push();
|
|
return TRUE;
|
|
}
|
|
|
|
return TForm_string::parse_item(scanner);
|
|
}
|
|
|
|
void TForm_list::print_on(TMask& m)
|
|
{
|
|
TForm_string::print_on(m);
|
|
TSheet_field& s = (TSheet_field&)m.field(F_ITEMS);
|
|
|
|
_codes.restart(); _values.restart();
|
|
for (int i = 0; i < _codes.items(); i++)
|
|
{
|
|
TToken_string& row = s.row(i);
|
|
row = _codes.get();
|
|
row.add(_values.get());
|
|
row.add(message(i));
|
|
}
|
|
s.force_update();
|
|
}
|
|
|
|
void TForm_list::read_from(const TMask& m)
|
|
{
|
|
TForm_string::read_from(m);
|
|
|
|
TSheet_field& s = (TSheet_field&)m.field(F_ITEMS);
|
|
|
|
_codes = _values = "";
|
|
for (int i = 0; i < s.items(); i++)
|
|
{
|
|
TToken_string& row = s.row(i);
|
|
_codes.add(row.get(0));
|
|
_values.add(row.get());
|
|
message(i) = row.get();
|
|
}
|
|
}
|
|
|
|
void TForm_list::print_body(ostream& out) const
|
|
{
|
|
TForm_string::print_body(out);
|
|
|
|
TToken_string& cod = (TToken_string&)_codes; // Trick to skip const
|
|
TToken_string& val = (TToken_string&)_values;
|
|
|
|
int i = 0;
|
|
TString c(cod.get(0));
|
|
TString v(val.get(0));
|
|
|
|
for (; c[0]; c = cod.get(), v = val.get(), i++)
|
|
{
|
|
out << " ITEM \"" << c;
|
|
if (v.not_empty()) out << '|' << v;
|
|
out << '"';
|
|
|
|
const char* m = ((TForm_list*)this)->message(i);
|
|
if (*m) out << " MESSAGE " << m;
|
|
|
|
out << endl;
|
|
}
|
|
}
|
|
|
|
|
|
bool TForm_list::update()
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
if (!read()) return ok;
|
|
|
|
const TString& val =get();
|
|
int pos = _codes.get_pos(val);
|
|
if (pos < 0)
|
|
{
|
|
ok = yesno_box("Il campo '%s' non puo' valere '%s': continuare ugualmente",
|
|
(const char*)key(), (const char*)val);
|
|
set(_codes.get(pos = 0));
|
|
}
|
|
if (ok)
|
|
{
|
|
do_message(pos);
|
|
|
|
if (!hidden())
|
|
{
|
|
const char* c = _values.get(pos);
|
|
if (c == NULL) c = val;
|
|
if (c) string_at(_x, _y, c);
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm_group
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TForm_group : public TForm_item
|
|
{
|
|
protected:
|
|
virtual const char* class_name() const { return "GRUPPO"; }
|
|
virtual bool parse_head(TScanner&) { return TRUE; }
|
|
virtual bool update() { return TRUE; }
|
|
|
|
public:
|
|
TForm_group(TPrint_section* section) : TForm_item(section) {};
|
|
virtual ~TForm_group() {}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPrint_section
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TMask* TPrint_section::_msk = NULL;
|
|
|
|
TPrint_section::TPrint_section(TForm* f) : _height(0), _form(f)
|
|
{}
|
|
|
|
TPrint_section::~TPrint_section()
|
|
{
|
|
if (_msk)
|
|
{
|
|
delete _msk;
|
|
_msk = NULL;
|
|
}
|
|
}
|
|
|
|
const TPrint_section& TPrint_section::copy(const TPrint_section& ps)
|
|
{
|
|
_item = ps._item;
|
|
_height = ps._height;
|
|
return ps;
|
|
}
|
|
|
|
TPrintrow& TPrint_section::row(int num)
|
|
{
|
|
TPrintrow* pr = (TPrintrow*)objptr(num);
|
|
if (!pr)
|
|
{
|
|
pr = new TPrintrow;
|
|
add(pr, num);
|
|
}
|
|
return *pr;
|
|
}
|
|
|
|
void TPrint_section::offset(int& x, int& y) const
|
|
{
|
|
if (x >= 0) x += _x;
|
|
if (y >= 0) y += _y;
|
|
}
|
|
|
|
|
|
TForm_item* TPrint_section::parse_item(const TString& s)
|
|
{
|
|
if (s == "ST")
|
|
return new TForm_string(this);
|
|
if (s == "NU")
|
|
return new TForm_number(this);
|
|
if (s == "DA")
|
|
return new TForm_date(this);
|
|
if (s == "LI")
|
|
return new TForm_list(this);
|
|
if (s == "GR")
|
|
return new TForm_group(this);
|
|
|
|
CHECKS(NULL, "Campo di stampa sconosciuto: ", (const char*)s);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
TForm_item* TPrint_section::parse_item(TScanner& scanner)
|
|
{
|
|
return parse_item(scanner.key());
|
|
}
|
|
|
|
|
|
bool TPrint_section::parse(TScanner& scanner)
|
|
{
|
|
_height = scanner.integer();
|
|
_x = scanner.integer();
|
|
_y = scanner.integer();
|
|
|
|
while (scanner.popkey() != "EN")
|
|
{
|
|
TForm_item *fi = parse_item(scanner);
|
|
if (!fi) return FALSE;
|
|
|
|
if (fi->parse(scanner))
|
|
_item.add(fi);
|
|
else
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Azzera tutte le righe della sezione di stampa
|
|
void TPrint_section::reset()
|
|
{
|
|
for (word i = 0; i < height(); i++)
|
|
row(i).reset();
|
|
}
|
|
|
|
// Aggiorna tutti i campi e li stampa
|
|
bool TPrint_section::update()
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
reset();
|
|
for (word i = 0; i < fields(); i++)
|
|
{
|
|
const bool esito = field(i).update();
|
|
if (!esito) ok = FALSE;
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
bool TPrint_section::edit(const char* title, bool all)
|
|
{
|
|
TMask m("ba2100s");
|
|
m.set_caption(title);
|
|
|
|
m.set(F_HEIGHT, _height);
|
|
m.set(F_X, _x);
|
|
m.set(F_Y, _y);
|
|
|
|
if (m.run() == K_ESC)
|
|
return FALSE;
|
|
|
|
bool dirty = m.dirty() != 0;
|
|
|
|
if (dirty)
|
|
{
|
|
_height = m.get_int(F_HEIGHT);
|
|
_x = m.get_int(F_X);
|
|
_y = m.get_int(F_Y);
|
|
}
|
|
|
|
TArray_sheet a(-1, -1, 0, 0, title, "Tipo@8|Riga|Col.|Gr.|Descrizione@40", all ? 0xE : 0x8);
|
|
|
|
for (word i = 0; i < fields(); i++)
|
|
{
|
|
TToken_string* s = new TToken_string(128);
|
|
field(i).print_on(*s);
|
|
a.add(s);
|
|
}
|
|
|
|
KEY k;
|
|
while ((k = a.run()) != K_ESC)
|
|
{
|
|
i = (word)a.selected();
|
|
|
|
if (_msk == NULL && (k == K_ENTER || k == K_INS))
|
|
{
|
|
_msk = new TMask("ba2100f");
|
|
if (!all) _msk->disable(-7);
|
|
}
|
|
|
|
switch(k)
|
|
{
|
|
case K_ENTER:
|
|
_msk->set_mode(MODE_MOD);
|
|
if (field(i).edit(*_msk))
|
|
{
|
|
field(i).print_on(a.row(i));
|
|
dirty = TRUE;
|
|
}
|
|
break;
|
|
case K_INS:
|
|
if (all)
|
|
{
|
|
_msk->set_mode(MODE_INS);
|
|
TForm_string dummy(this);
|
|
if (dummy.edit(*_msk))
|
|
{
|
|
const TString& c = _msk->get(F_CLASS).left(2);
|
|
TForm_item* item = parse_item(c);
|
|
item->read_from(*_msk);
|
|
_item.insert(item, i);
|
|
|
|
TToken_string s(128); item->print_on(s);
|
|
a.insert(s, i);
|
|
dirty = TRUE;
|
|
}
|
|
} else error_box("L'inserimento e' disabilitato");
|
|
break;
|
|
case K_DEL:
|
|
if (all && yesno_box("Confermare la cancellazione"))
|
|
{
|
|
_item.destroy(i, TRUE);
|
|
a.destroy(i);
|
|
dirty = TRUE;
|
|
} else error_box("La cancellazione e' disabilitata");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return dirty;
|
|
}
|
|
|
|
void TPrint_section::print_on(ostream& out) const
|
|
{
|
|
out << ' ' << _height << ' ' << _x << ' ' << _y << endl;
|
|
for(word i = 0; i < fields(); i++)
|
|
out << field(i);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TForm
|
|
///////////////////////////////////////////////////////////
|
|
|
|
bool TForm::parse_use(TScanner& scanner)
|
|
{
|
|
const int logicnum = scanner.integer();
|
|
const char* tab = NULL;
|
|
|
|
if (logicnum > 0)
|
|
_relation = new TRelation(logicnum);
|
|
else
|
|
{
|
|
tab = scanner.pop();
|
|
_relation = new TRelation(tab);
|
|
}
|
|
|
|
int key = 1;
|
|
if (scanner.popkey() == "KE")
|
|
key = scanner.integer();
|
|
else
|
|
scanner.push();
|
|
|
|
_cursor = new TCursor(_relation, "", key);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TForm::parse_join(TScanner& scanner)
|
|
{
|
|
TString16 j(scanner.pop()); // File or table
|
|
|
|
int to = 0;
|
|
if (scanner.popkey() == "TO") // TO keyword
|
|
{
|
|
const char* n = scanner.pop();
|
|
to = name2log(n);
|
|
}
|
|
else scanner.push();
|
|
|
|
int key = 1;
|
|
if (scanner.popkey() == "KE")
|
|
key = scanner.integer();
|
|
else scanner.push();
|
|
|
|
int alias = 0;
|
|
if (scanner.popkey() == "AL")
|
|
alias = scanner.integer();
|
|
else scanner.push();
|
|
|
|
TToken_string exp(80);
|
|
if (scanner.pop() == "INTO")
|
|
{
|
|
const char* r = scanner.pop();
|
|
while (strchr(r, '=') != NULL)
|
|
{
|
|
exp.add(r);
|
|
r = scanner.pop();
|
|
}
|
|
}
|
|
if (exp.empty())
|
|
yesnofatal_box("JOIN senza espressioni INTO");
|
|
scanner.push();
|
|
|
|
if (isdigit(j[0]))
|
|
_relation->add(atoi(j), exp, key, to, alias); // join file
|
|
else
|
|
_relation->add(j, exp, key, to, alias); // join table
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
TPrint_section* TForm::exist(char s, pagetype t, bool create)
|
|
{
|
|
TArray* a = NULL;
|
|
switch (s)
|
|
{
|
|
case 'H':
|
|
a = &_head; break;
|
|
case 'F':
|
|
a = &_foot; break;
|
|
default:
|
|
a = &_body; break;
|
|
}
|
|
|
|
TPrint_section* sec = (TPrint_section*)a->objptr(t);
|
|
if (sec == NULL && create)
|
|
{
|
|
sec = new TPrint_section(this);
|
|
a->add(sec, t);
|
|
}
|
|
|
|
return sec;
|
|
}
|
|
|
|
|
|
TPrint_section& TForm::section(char s, word p)
|
|
{
|
|
pagetype pos = odd_page;
|
|
if (p == 0 && exist(s, last_page)) pos = last_page;
|
|
if (p == 1 && exist(s, first_page)) pos = first_page;
|
|
if (pos == 0 && (p & 0x1) == 0 && exist(s, even_page)) pos = even_page;
|
|
|
|
TPrint_section* sec = exist(s, pos, TRUE);
|
|
return *sec;
|
|
}
|
|
|
|
|
|
word TForm::set_header(word p, bool u)
|
|
{
|
|
TPrinter& printer = main_app().printer();
|
|
printer.resetheader();
|
|
|
|
TPrint_section& head = section('H', p);
|
|
|
|
if (u) head.update();
|
|
else
|
|
{
|
|
head.reset();
|
|
printer.headerlen(head.height());
|
|
}
|
|
|
|
for (word j = 0; j < head.height(); j++)
|
|
printer.setheaderline(j, head.row(j));
|
|
|
|
return head.height();
|
|
}
|
|
|
|
word TForm::set_body(word p, bool u)
|
|
{
|
|
TPrint_section& body = section('B', p);
|
|
|
|
if (u) body.update();
|
|
else body.reset();
|
|
|
|
if (u)
|
|
{
|
|
TPrinter& printer = main_app().printer();
|
|
for (word j = 0; j < body.height(); j++)
|
|
printer.print(body.row(j));
|
|
}
|
|
|
|
return body.height();
|
|
}
|
|
|
|
word TForm::set_footer(word p, bool u)
|
|
{
|
|
TPrinter& printer = main_app().printer();
|
|
printer.resetfooter();
|
|
|
|
TPrint_section& foot = section('F', p);
|
|
|
|
if (u) foot.update();
|
|
else
|
|
{
|
|
foot.reset();
|
|
printer.footerlen(foot.height());
|
|
}
|
|
|
|
for (word j = 0; j < foot.height(); j++)
|
|
printer.setfooterline(j, foot.row(j));
|
|
|
|
return foot.height();
|
|
}
|
|
|
|
void TForm::header_handler(TPrinter& p)
|
|
{
|
|
const word page = form().page(p);
|
|
form().set_header(page, TRUE);
|
|
form().set_footer(page, FALSE);
|
|
}
|
|
|
|
void TForm::footer_handler(TPrinter& p)
|
|
{
|
|
const word page = form().page(p);
|
|
form().set_footer(page, TRUE);
|
|
if (page)
|
|
form().set_header(page+1, FALSE);
|
|
}
|
|
|
|
|
|
word TForm::page(const TPrinter& p) const
|
|
{
|
|
return _lastpage ? 0 : p.getcurrentpage();
|
|
}
|
|
|
|
long TForm::records() const
|
|
{
|
|
const long r = _cursor ? _cursor->items() : 0;
|
|
return r;
|
|
}
|
|
|
|
// Stampa gli items dal from a to
|
|
// se to < 0 stampa fino alla fine del file
|
|
|
|
bool TForm::print(long from, long to)
|
|
{
|
|
_form = this; // Setta il form corrente
|
|
|
|
TPrinter& printer = main_app().printer(); // Setta handlers
|
|
printer.setheaderhandler(header_handler);
|
|
printer.setfooterhandler(footer_handler);
|
|
printer.formlen(height());
|
|
const bool was_open = printer.isopen();
|
|
|
|
_lastpage = FALSE; // non e' l'ultima pagina
|
|
|
|
if (!was_open && !printer.open())
|
|
return FALSE;
|
|
|
|
if (to < 0) to = records()-1;
|
|
|
|
bool ok = TRUE;
|
|
|
|
for (long i = from; i <= to && ok; i++)
|
|
{
|
|
if (from < 0) to = from;
|
|
else if (_cursor) *_cursor = i;
|
|
|
|
const word h = set_body(page(printer), FALSE);
|
|
if (h > printer.rows_left())
|
|
printer.formfeed();
|
|
|
|
set_body(page(printer), TRUE);
|
|
}
|
|
|
|
if (i > records())
|
|
{
|
|
if (exist('H', last_page) || exist('B', last_page) || exist('F', last_page))
|
|
{
|
|
_lastpage = TRUE;
|
|
set_header(0, TRUE);
|
|
set_body(0, TRUE);
|
|
printer.formfeed();
|
|
}
|
|
}
|
|
|
|
if (!was_open)
|
|
printer.close();
|
|
|
|
_form = NULL; // resetta handlers
|
|
printer.setheaderhandler(NULL);
|
|
printer.setfooterhandler(NULL);
|
|
|
|
return ok;
|
|
}
|
|
|
|
void TForm::print_section(ostream& out, char s) const
|
|
{
|
|
for (pagetype t = odd_page; t <= last_page; t = pagetype(t+1))
|
|
{
|
|
const TPrint_section* sec = ((TForm*)this)->exist(s, t);
|
|
if (sec && sec->ok())
|
|
{
|
|
const char* name = s == 'H' ? "HEADER" : (s == 'F' ? "FOOTER" : "BODY");
|
|
out << "SECTION " << name << ' ' << int(t);
|
|
out << *sec;
|
|
out << "END\n" << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
const char* TForm::validate(const char*, TToken_string&)
|
|
{ return NULL; }
|
|
|
|
void TForm::print_on(ostream& out) const
|
|
{
|
|
main_app().begin_wait();
|
|
|
|
if (relation())
|
|
out << *relation() << endl;
|
|
|
|
print_section(out, 'H');
|
|
print_section(out, 'B');
|
|
print_section(out, 'F');
|
|
|
|
out << "END" << endl;
|
|
|
|
main_app().end_wait();
|
|
}
|
|
|
|
|
|
word TForm::height()
|
|
{
|
|
word h = 0;
|
|
if (_head.items())
|
|
h += section('H', 1).height();
|
|
if (_body.items())
|
|
h += section('B', 1).height();
|
|
if (_foot.items())
|
|
h += section('F', 1).height();
|
|
return h;
|
|
}
|
|
|
|
|
|
TForm::TForm(const char* name)
|
|
: _name(name), _relation(NULL), _cursor(NULL)
|
|
{
|
|
main_app().begin_wait();
|
|
|
|
_name.ext("frm");
|
|
TScanner scanner(_name);
|
|
|
|
bool ok = TRUE;
|
|
if (scanner.popkey() == "US")
|
|
{
|
|
ok = parse_use(scanner);
|
|
while (ok && scanner.popkey() == "JO")
|
|
ok = parse_join(scanner);
|
|
}
|
|
|
|
while (ok)
|
|
{
|
|
scanner.popkey();
|
|
const char sec = toupper(scanner.key()[0]);
|
|
if (sec <= ' ' || sec == 'E')
|
|
break;
|
|
const pagetype p = (pagetype)scanner.integer();
|
|
TPrint_section* ps = exist(sec, p, TRUE);
|
|
ok = ps->parse(scanner);
|
|
}
|
|
|
|
main_app().end_wait();
|
|
}
|
|
|
|
|
|
TForm::~TForm()
|
|
{
|
|
if (_cursor)
|
|
{
|
|
delete _cursor;
|
|
delete _relation;
|
|
}
|
|
}
|