root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 2.1 nopatch

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Spostato tutto in libreria


git-svn-id: svn://10.65.10.50/trunk@12063 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2004-05-07 10:27:35 +00:00
parent ccde3b0440
commit b4ee199cbc
16 changed files with 83 additions and 7424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ba/alex.alx
View File

@ -18,15 +18,6 @@
SWAP OVER
;
: +! ( a1 n1 -- ) \ Incrementa la variabile a1 di n1
DUP
IF
OVER @ + SWAP !
ELSE
2DROP
THEN
;
: INCR ( a1 -- )
1 +!
1 SWAP +!
;

2
ba/ba8200.cpp
View File

@ -6,6 +6,7 @@
#include <extcdecl.h>
#include <prefix.h>
#include <progind.h>
#include <recset.h>
#include <relation.h>
#include <sheet.h>
#include <tree.h>
@ -15,7 +16,6 @@
#include "../sqlite/sqlite.h"
#include "ba8200.h"
#include "ba8201.h"
///////////////////////////////////////////////////////////
// TRelation_node & TRelation_tree

2057
ba/ba8201.cpp
View File

File diff suppressed because it is too large Load Diff

238
ba/ba8201.h
View File

@ -1,238 +0,0 @@
#ifndef __RECORDSET_H
#define __RECORDSET_H
#ifndef __ASSOC_H
#include <assoc.h>
#endif
#ifndef __RECTYPES_H
#include <rectypes.h>
#endif
#ifndef __SHEET_H
#include <sheet.h>
#endif
struct TRecordset_column_info : public TObject
{
TString _name; // Table.Column
int _width;
TFieldtypes _type;
};
///////////////////////////////////////////////////////////
// TVariant
///////////////////////////////////////////////////////////
class TVariant : public TSortable
{
TFieldtypes _type;
void* _ptr;
protected:
virtual TObject* dup() const { return new TVariant(*this); }
void copy(const TVariant& var);
public:
TFieldtypes type() const { return _type; } // Internal use only
bool is_string() const { return _type == _alfafld; }
bool is_null() const { return _type == _nullfld; }
bool is_zero() const;
void set_null();
void set(const char* str);
void set(const real& r);
void set(const long n);
void set(const TDate& d);
TVariant& operator=(const TVariant& var) { copy(var); return *this; }
TVariant& operator=(const char* str) { set(str); return *this; }
TVariant& operator=(const real& r) { set(r); return *this; }
TVariant& operator=(const long n) { set(n); return *this; }
TVariant& operator=(const TDate& d) { set(d); return *this; }
const TString& as_string() const;
bool as_string(TString& str) const;
real as_real() const;
long as_int() const;
TDate as_date() const;
bool as_bool() const;
COLOR as_color() const;
void convert_to(TFieldtypes ft);
virtual int compare(const TSortable& s) const;
TVariant& add(const TVariant& var);
TVariant& sub(const TVariant& var);
TVariant() : _type(_nullfld), _ptr(NULL) { }
TVariant(const char* str) : _type(_alfafld), _ptr(new TString(str)) { }
TVariant(const real& num) : _type(_realfld), _ptr(new real(num)) { };
TVariant(const TDate& d) : _type(_datefld), _ptr(new TDate(d)) { };
TVariant(long num) : _type(_longfld), _ptr((void*)num) { };
TVariant(bool ok) : _type(_longfld), _ptr((void*)ok) { };
TVariant(const TVariant& var) : _type(_nullfld), _ptr(NULL) { copy(var); }
virtual ~TVariant() { set_null(); }
};
extern const TVariant NULL_VARIANT;
///////////////////////////////////////////////////////////
// TRecordset
///////////////////////////////////////////////////////////
enum TRecordsetExportFormat { fmt_unknown, fmt_html, fmt_text, fmt_silk, fmt_campo };
class TRecordset : public TObject
{
TAssoc_array _var;
TString_array _varnames;
protected:
bool save_as_html(const char* path);
bool save_as_silk(const char* path);
bool save_as_text(const char* path);
bool save_as_campo(const char* path);
void find_and_reset_vars();
void parsed_text(TString& sql) const;
public: // Absolutely needed methods
virtual TRecnotype items() const pure;
virtual bool move_to(TRecnotype pos) pure;
virtual TRecnotype current_row() const pure;
virtual bool move_first() { return move_to(0); }
virtual bool move_prev() { return move_to(current_row()-1); }
virtual bool move_next() { return move_to(current_row()+1); }
virtual bool move_last() { return move_to(items()-1); }
virtual bool bof() const { return current_row() <= 0; }
virtual bool eof() const { return current_row() >= items(); }
virtual unsigned int columns() const pure;
virtual const TRecordset_column_info& column_info(unsigned int column) const pure;
virtual const TVariant& get(unsigned int column) const pure;
virtual const TString_array& variables() const { return _varnames; }
virtual const TVariant& get_var(const char* name) const;
virtual bool set_var(const char* name, const TVariant& var, bool create = false);
virtual bool ask_variables(bool all);
virtual const TString& query_text() const;
virtual int find_column(const char* column_name) const;
virtual const TVariant& get(const char* column_name) const;
virtual const TToken_string& sheet_head() const;
virtual bool save_as(const char* path, TRecordsetExportFormat fmt = fmt_unknown);
};
///////////////////////////////////////////////////////////
// TSQL_recordset
///////////////////////////////////////////////////////////
class TSQL_recordset : public TRecordset
{
TString _sql;
TRecnotype _first_row, _pagesize, _items, _current_row;
TArray _column;
TArray _page;
protected:
void reset();
void parsed_sql_text(TString& sql) const;
public: // TRecordset
virtual TRecnotype items() const;
virtual bool move_to(TRecnotype pos);
virtual TRecnotype current_row() const { return _current_row; }
virtual unsigned int columns() const;
virtual const TRecordset_column_info& column_info(unsigned int c) const;
virtual const TVariant& get(unsigned int column) const;
virtual bool ask_variables(bool all);
const TString& query_text() const { return _sql; }
public:
void set(const char* sql);
// Internal use only
virtual int on_get_items(int argc, char** values, char** columns);
virtual int on_get_rows(int argc, char** values, char** columns);
const TArray* row(TRecnotype n);
TSQL_recordset(const char* sql);
virtual ~TSQL_recordset() { }
};
///////////////////////////////////////////////////////////
// TISAM_recordset
///////////////////////////////////////////////////////////
class TISAM_recordset : public TRecordset
{
TString _use;
TRelation* _relation;
TCursor* _cursor;
TArray _column; // Column infos
protected:
void reset();
TVariant& get_tmp_var() const;
const TVariant& get(int logic, const char* field) const;
public:
void set(const char* use);
virtual TRecnotype items() const;
virtual bool move_to(TRecnotype pos);
virtual TRecnotype current_row() const;
virtual unsigned int columns() const;
virtual const TRecordset_column_info& column_info(unsigned int c) const;
virtual const TVariant& get(unsigned int column) const;
virtual const TVariant& get(const char* column_name) const;
virtual bool ask_variables(bool all);
virtual const TString& query_text() const { return _use; }
TISAM_recordset(const char* use);
virtual ~TISAM_recordset();
};
///////////////////////////////////////////////////////////
// TRecordset_sheet
///////////////////////////////////////////////////////////
class TRecordset_sheet : public TSheet
{
TRecordset& _query;
protected:
virtual void get_row(long r, TToken_string& row);
virtual long get_items() const;
public:
TRecordset_sheet(TRecordset& sql);
};
///////////////////////////////////////////////////////////
// Utility
///////////////////////////////////////////////////////////
class TProfiler : public TObject
{
TString _desc;
clock_t _start;
public:
void show() const;
TProfiler(const char* desc = "");
~TProfiler();
};
bool select_custom_file(TFilename& path, const char* ext);
const TString& logic2table(int logic_num);
int table2logic(const TString& name);
#endif

3
ba/ba8300.cpp
View File

@ -7,11 +7,10 @@
#include <execp.h>
#include <prefix.h>
#include <printer.h>
#include <reprint.h>
#include "ba8201.h"
#include "ba8300.h"
#include "ba8301.h"
#include "ba8303.h"
#include <bagn003.h>
///////////////////////////////////////////////////////////

49
ba/ba8300m.uml Executable file
View File

@ -0,0 +1,49 @@
PAGE "Monitor" -1 -1 50 20
LIST 101 24 -3
BEGIN
PROMPT 0 0 ""
END
STACK 102 -3 10
BEGIN
PROMPT 27 0 ""
END
STACK 103 -3 -3
BEGIN
PROMPT 27 11 ""
END
BUTTON DLG_NEXTREC 9 2
BEGIN
PROMPT -14 -1 ""
PICTURE 124
MESSAGE EXIT,K_F11
END
BUTTON DLG_LASTREC 9 2
BEGIN
PROMPT -24 -1 ""
PICTURE 1671
MESSAGE EXIT,K_F10
END
BUTTON DLG_ELABORA 9 2
BEGIN
PROMPT -34 -1 ""
PICTURE BMP_LASTREC
MESSAGE EXIT,K_F5
END
BUTTON DLG_QUIT 9 2
BEGIN
PROMPT -44 -1 ""
MESSAGE EXIT,K_QUIT
END
ENDPAGE
ENDMASK

2
ba/ba8301.h
View File

@ -7,7 +7,7 @@
#endif
#ifndef __REPORT_H
#include "ba8302.h"
#include <report.h>
#endif
///////////////////////////////////////////////////////////

2265
ba/ba8302.cpp
View File

File diff suppressed because it is too large Load Diff

466
ba/ba8302.h
View File

@ -1,466 +0,0 @@
#ifndef __REPORT_H
#define __REPORT_H
#ifndef __ASSOC_H
#include <assoc.h>
#endif
#ifndef __IMAGE_H
#include <image.h>
#endif
#ifndef __WINDOW_H
#include <window.h>
#endif
#ifndef __XML_H
#include <xml.h>
#endif
#ifndef __RECORDSET_H
#include "ba8201.h"
#endif
#ifndef __ALEX_H
#include "ba8304.h"
#endif
///////////////////////////////////////////////////////////
// TReport_font
///////////////////////////////////////////////////////////
class TReport_font : public TSortable
{
enum { DEFAULT_FONT_SIZE = 10 };
TString _name;
int _size, _cpi;
XVT_FONT_STYLE_MASK _style;
WINDOW _win_mapped;
XVT_FNTID _fontid;
int _leading, _ascent, _descent;
protected:
virtual int compare(const TSortable& s) const;
void copy(const TReport_font& f);
public:
const TString& name() const { return _name; }
int size() const { return _size; }
XVT_FONT_STYLE_MASK style() const { return _style; }
int cpi() const { return _cpi; }
XVT_FNTID get_xvt_font(const TWindow& win) const;
void unmap();
int leading() const { return _leading; }
int ascent() const { return _ascent; }
int descent() const { return _descent; }
void save(TXmlItem& root) const;
bool load(const TXmlItem& root);
void create(const char* name, int size, XVT_FONT_STYLE_MASK style);
TReport_font& operator=(const TReport_font& f) { copy(f); return *this; }
TReport_font();
TReport_font(const TReport_font& f);
virtual ~TReport_font();
};
class TReport;
class TReport_field;
///////////////////////////////////////////////////////////
// Cache varie
///////////////////////////////////////////////////////////
class TReport_expr;
class TReport_expr_cache : public TCache
{
TReport* _report;
protected:
virtual TObject* key2obj(const char* key);
public:
TReport_expr& operator[](const char* key);
void set_report(TReport* rep) { _report = rep; }
TReport_expr_cache() : _report(NULL) { }
};
class TReport_image_cache : public TCache
{
protected:
virtual TObject* key2obj(const char* key);
public:
TImage* image(const TString& name);
TReport_image_cache();
};
///////////////////////////////////////////////////////////
// TReport_script
///////////////////////////////////////////////////////////
class TReport_script : public TObject
{
TBytecode* _bc; // Chesire's cat class
TString _src, _desc;
protected:
void destroy();
TString& translate_message(TReport& report) const;
void copy(const TReport_script& rs);
public:
virtual bool ok() const { return !_src.blank(); }
void set(const char* source);
const TString& get() const { return _src; }
void set_description(const char* d) { _desc = d; }
bool compile(TReport& report);
bool execute(TReport& report, TString& output);
bool execute(TReport_field& rf);
void save(TXmlItem& root, const char* tag) const;
bool load(const TXmlItem& root, const char* tag);
TReport_script& operator =(const TReport_script& rs) { copy(rs); return *this; }
TReport_script();
TReport_script(const TReport_script& rs) { copy(rs); }
virtual ~TReport_script();
};
///////////////////////////////////////////////////////////
// TReport_section
///////////////////////////////////////////////////////////
enum TReport_draw_mode { rdm_edit, rdm_print, rdm_print_preview, rdm_spooler, rdm_textonly };
class TReport_section : public TArray
{
TReport& _report;
char _type; // Head,Body,Tail
int _level; // 0,1,2,...
TPoint _pos; // Posizione assoluta in centesimi, default (0,0)
TPoint _size; // Dimensioni in centesimi, default (0,0)
TString _groupby;
bool _page_break, _hidden_if_needed, _keep_with_next;
bool _hidden, _deactivated;
TReport_script _prescript, _postscript;
TReport_font* _font;
protected:
virtual const char* class_name() const { return "ReportSection"; }
TReport_section* father_section() const;
public:
virtual int add(TObject* obj);
virtual int add(TObject& obj);
TReport_field& field(int i) { return *(TReport_field*)objptr(i); }
const TReport_field& field(int i) const { return *(TReport_field*)objptr(i); }
int find_field_pos(int id);
TReport_field* find_field(int id);
TReport& report() { return _report; }
char type() const { return _type; }
int level() const { return _level; }
int width() const { return _size.x; }
int height() const { return _size.y; }
void set_width(short w) { _size.x = w; }
void set_height(short h) { _size.y = h; }
const TPoint& size() const { return _size; }
TPoint compute_size() const;
bool compute_rect(TRectangle& rct) const;
const TPoint& pos() const { return _pos; }
void set_pos(const TPoint& p) { _pos = p; }
bool page_break() const { return _page_break; }
void force_page_break(bool pb) { _page_break = pb; }
const TString& grouped_by() const { return _groupby; }
void group_by(const char* gb) { _groupby = gb; }
bool hidden_if_needed() const { return _hidden_if_needed; }
void hide_if_needed(bool h) { _hidden_if_needed = h; }
bool keep_with_next() const { return _keep_with_next; }
void keep_with_next(bool k) { _keep_with_next = k; }
bool hidden() const { return _hidden; }
bool shown() const { return !hidden(); }
void show(bool on) { _hidden = !on; }
void hide() { show(false); }
bool deactivated() const { return _deactivated; }
bool active() const { return !deactivated(); }
void activate(bool on) { _deactivated = !on; }
void deactivate() { activate(false); }
const TString& prescript() const;
void set_prescript(const char* src);
const TString& postscript() const;
void set_postscript(const char* src);
bool has_font() const { return _font != NULL; }
const TReport_font& font() const;
void set_font(const TReport_font& f);
void unmap_font();
bool load_fields();
bool execute_prescript();
bool execute_postscript();
void draw(TWindow& win, TReport_draw_mode mode) const;
void save(TXmlItem& report) const;
void load(const TXmlItem& sec);
TReport_section(TReport& r, char t, int l);
virtual ~TReport_section();
};
class TReport_field : public TSortable
{
TReport_section* _section;
int _id;
char _type; // Text, String, Numeric, Price, Valuta, Date, Line, Rectangle, Image
TRectangle _rct, _rct_draw; // In centesimi
COLOR _fgcolor, _bgcolor;
short _border;
char _halign, _valign;
TBit_array _groups;
TString _picture, _field, _codval, _link;
TVariant _var;
TReport_script _prescript, _postscript;
TToken_string _list; // Elementi di un campo lista
TReport_font* _font;
bool _hidden, _deactivated, _hide_zeroes, _selected;
protected:
virtual const char* class_name() const { return "ReportField"; }
virtual int compare(const TSortable& s) const;
void copy(const TReport_field& rf);
TFieldtypes var_type() const;
const TString& formatted_text() const;
void get_currency(TCurrency& cur) const;
void compute_draw_rect() const;
public:
virtual TObject* dup() const { return new TReport_field(*this); }
TReport_field& operator=(const TReport_field& rf) { copy(rf); return *this; }
TReport_section& section() const { return *_section; }
void set_section(TReport_section* sec) { _section = sec; }
bool has_font() const { return _font != NULL; }
const TReport_font& font() const;
void set_font(const TReport_font& f);
void unmap_font();
const TString& picture() const { return _picture; }
void set_picture(const char* str) { _picture = str; }
const TString& field() const { return _field; }
void set_field(const char* str) { _field = str; }
const TVariant& get() const { return _var; }
void set(const char* str);
void set(const TVariant& var);
bool load_field();
bool execute_prescript();
bool execute_postscript();
void get_list(TString_array& list) const;
void set_list(const TString_array& list);
int id() const { return _id; }
void set_id(int id) { _id = id; }
char type() const { return _type; }
const char* type_name() const;
void set_type(char t) { _type = t; }
void set_pos(long x, long y);
void set_row(long y) { _rct.y = y; }
void set_column(long x) { _rct.x = x; }
void set_size(long w, long h);
void set_width(long dx) { _rct.set_width(dx); }
void set_height(long dy) { _rct.set_height(dy); }
const TRectangle& get_rect() const { return _rct; }
void set_draw_pos(long x, long y);
void set_draw_size(long x, long y);
const TRectangle& get_draw_rect() const { return _rct_draw; }
bool hidden() const { return _hidden; }
bool shown() const { return !hidden(); }
void show(bool on) { _hidden = !on; }
void hide() { show(false); }
bool deactivated() const { return _deactivated; }
bool active() const { return !deactivated(); }
void activate(bool on) { _deactivated = !on; }
void deactivate() { activate(false); }
bool zeroes_hidden() const { return _hide_zeroes; }
void hide_zeroes(bool hz) { _hide_zeroes = hz; }
void set_groups(const TString& groups);
const TString& groups() const;
bool in_group(int group) const;
void set_codval(const char* cod) { _codval = cod; }
const TString& codval() const { return _codval; }
void set_link(const char* l) { _link = l; }
const TString& link() const { return _link; } // TABLE.FIELD
void set_fore_color(COLOR c) { _fgcolor = c; }
COLOR fore_color() const { return _fgcolor; }
void set_back_color(COLOR c) { _bgcolor = c; }
COLOR back_color() const { return _bgcolor; }
COLOR link_color() const;
void set_border(short b) { _border = b; }
short border() const { return _border; }
void set_horizontal_alignment(char a) { _halign = a; }
char horizontal_alignment() const { return _halign; }
void set_vertical_alignment(char a) { _valign = a; }
char vertical_alignment() const { return _valign; }
const TString& prescript() const;
void set_prescript(const char* src);
const TString& postscript() const;
void set_postscript(const char* src);
void select(bool ok = true) { _selected = ok; }
bool selected() const { return _selected; }
void offset(const TPoint& pt);
virtual void draw_rect(TWindow& win) const;
virtual void draw_text(TWindow& win, const char* text, TReport_draw_mode mode) const;
virtual void draw(TWindow& win, TReport_draw_mode mode) const;
void save(TXmlItem& root) const;
bool load(const TXmlItem& root);
TReport_field(TReport_section* sec);
TReport_field(const TReport_field& rf);
virtual ~TReport_field();
};
class TReport_link : public TSortable
{
TString _table;
TAssoc_array _fields;
RCT _rct;
protected:
virtual int compare(const TSortable& s) const;
public:
const TString& table() const { return _table; }
void set(const char* field, const TVariant& value);
const TVariant& get(const char* field) const;
void add_rect(const RCT& rct); // Aggiunge un rettangolo al link
int hit_test(const PNT& p) const;
TAssoc_array& fields() const { return (TAssoc_array&)_fields; }
TReport_link(const char* table);
virtual ~TReport_link() { }
};
// Internal usage only
typedef void (*FLDMSG_FUNC)(TReport_field& rf, void* jolly);
class TReport : public TAlex_virtual_machine
{
TAssoc_array _sections;
TFilename _path;
TString _description;
TReport_font _font;
int _lpi; // Lines per inch
TToken_string _include;
TReport_script _prescript, _postscript;
TRecordset* _recordset;
TReport_expr_cache _expressions;
TReport_image_cache _images;
word _curr_page;
TReport_field* _curr_field;
protected:
virtual const char* class_name() const { return "Report"; }
virtual size_t get_usr_words(TString_array& words) const;
virtual bool execute_usr_word(unsigned int opcode, TVariant_stack& stack);
virtual bool get_usr_val(const TString& name, TVariant& var) const;
virtual bool set_usr_val(const TString& name, const TVariant& var);
KEY run_form(const TString& msk);
bool do_message(const TVariant& var, FLDMSG_FUNC msg, void* jolly);
void build_section_key(char type, int level, TString& key) const;
short get_num_attr(const TXmlItem& item, const char* attr, short def = 0) const;
COLOR get_col_attr(const TXmlItem& item, const char* attr, COLOR defcol = COLOR_BLACK) const;
void load_sections(const TXmlItem& xml);
void save_section(const TReport_section& rs, TXmlItem& item) const;
bool get_report_field(const TString& name, TVariant& var) const;
bool get_record_field(const TString& name, TVariant& var) const;
public:
TReport_section* find_section(char type, int level) const;
TReport_section& section(char type, int level);
bool kill_section(char type, int level);
int find_max_level(char type) const;
virtual bool on_link(const TReport_link& link);
const TReport_font& font() const { return _font; }
void set_font(const TReport_font& f) { _font = f; }
void unmap_font();
int cpi() const { return _font.cpi(); }
int lpi() const { return _lpi; }
void set_lpi(int lpi) { _lpi= lpi; }
bool set_recordset(const TString& sql);
bool set_recordset(TRecordset* sql);
TRecordset* recordset() const { return _recordset; }
bool evaluate_atom(const char* atom, TVariant& var);
bool evaluate(const char* expr, TVariant& var, TFieldtypes force_type);
const TString& prescript() const;
void set_prescript(const char* src);
const TString& postscript() const;
void set_postscript(const char* src);
bool execute_prescript();
bool execute_postscript();
void set_libraries(const char* inc) { _include = inc; }
TToken_string& get_libraries() { return _include; }
void set_description(const char* d) { _description = d; }
const TString& description() const { return _description; }
TImage* image(const TString& name) { return _images.image(name); }
const TFilename& filename() const { return _path; }
bool save(const char* fname) const;
bool load(const char* fname);
// Used by TReport_printer
void set_curr_page(word p) { _curr_page = p; }
word curr_page() const { return _curr_page; }
void set_curr_field(TReport_field* fld) { _curr_field = fld; }
TReport_field* curr_field() const { return _curr_field; }
int parse_field(const char* code, char& type, int& level, int& id) const;
TReport_field* field(const TString& code);
void destroy();
TReport();
virtual ~TReport();
};
void advanced_draw_rect(TWindow& win, const RCT& r, int border, COLOR fore, COLOR back);
void advanced_draw_text(TWindow& win, const char* text, const RCT& r,
char halign, char valign);
#endif

918
ba/ba8303.cpp
View File

@ -1,918 +0,0 @@
#include <automask.h>
#include <defmask.h>
#include <diction.h>
#include <printer.h>
#include <statbar.h>
#include <bagn003.h>
#include "ba8201.h"
#include "ba8303.h"
static bool _print_aborted = false;
///////////////////////////////////////////////////////////
// TPrint_preview_window
///////////////////////////////////////////////////////////
class TPrint_preview_window : public TField_window
{
TPage_printer* _printer;
word _page, _last;
int _zoom;
static bool _locked;
protected:
void page_select();
void popup_menu(EVENT* ep);
virtual void handler(WINDOW win, EVENT* ep);
virtual void update();
virtual bool on_key(KEY k);
public:
virtual PNT log2dev(long lx, long ly) const;
static void lock_preview_update(bool yes) { _locked = yes; }
void set_printer(TPage_printer* printer) { _printer = printer; }
TPrint_preview_window(int x, int y, int dx, int dy, WINDOW parent,
TWindowed_field* owner, TPage_printer* printer);
};
bool TPrint_preview_window::_locked = false;
PNT TPrint_preview_window::log2dev(long lx, long ly) const
{
PNT pnt;
pnt.h = short(lx * _zoom / 1000);
pnt.v = short(ly * _zoom / 1000);
const TPoint orig = origin();
pnt.h -= short(orig.x*10);
pnt.v -= short(orig.y*10);
return pnt;
}
void TPrint_preview_window::update()
{
if (!_locked)
{
_printer->print_page(_page);
TString80 str;
str.format(FR("Pagina %u di %u"), _page, _last);
statbar_set_title(TASK_WIN, str);
}
}
#define POPUP_FIRST 20883
#define POPUP_PREV 20884
#define POPUP_NEXT 20885
#define POPUP_SEARCH 20886
#define POPUP_LAST 20887
#define POPUP_ZOOMIN 20888
#define POPUP_ZOOMOUT 20889
#define POPUP_GRID 20890
void TPrint_preview_window::popup_menu(EVENT* ep)
{
MENU_ITEM menu[16]; // Stiamo larghi
memset(menu, 0, sizeof(menu));
menu[0].tag = POPUP_FIRST; menu[0].text = (char*)TR("Prima"); menu[0].enabled = true;
menu[1].tag = POPUP_PREV; menu[1].text = (char*)TR("Indietro"); menu[1].enabled = _page > 1;
menu[2].tag = POPUP_NEXT; menu[2].text = (char*)TR("Avanti"); menu[2].enabled = _last == 0 || _page < _last;
menu[3].tag = POPUP_LAST; menu[3].text = (char*)TR("Ultima"); menu[3].enabled = true;
menu[4].tag = -1; menu[4].separator = true;
menu[5].tag = POPUP_ZOOMIN; menu[5].text = (char*)TR("Zoom +"); menu[5].enabled = _zoom < 300;
menu[6].tag = POPUP_ZOOMOUT; menu[6].text = (char*)TR("Zoom -"); menu[6].enabled = _zoom > 75;
menu[7].tag = -1; menu[7].separator = true;
menu[8].tag = POPUP_GRID; menu[8].text = (char*)TR("Griglia"); menu[8].enabled = true;
menu[8].checkable = true; menu[8].checked = _printer->show_preview_grid();
const PNT& p = ep->v.mouse.where;
xvt_menu_popup(menu, win(), p, XVT_POPUP_CENTER, 0);
}
void TPrint_preview_window::page_select()
{
TMask m("Ricerca", 1, 28, 4);
m.add_number(101, 0, "Pagina ", 1, 1, 4, "U").check_type(CHECK_REQUIRED);
m.add_button(DLG_OK, 0, "", -12, -1, 10, 2);
m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
if (m.run())
{
_page = m.get_int(101);
if (_last > 0 && _page > _last)
_page = _last;
}
}
void TPrint_preview_window::handler(WINDOW win, EVENT* ep)
{
switch (ep->type)
{
case E_MOUSE_MOVE:
if (_printer->find_link(ep->v.mouse.where) != NULL)
xvt_win_set_cursor(win, CURSOR_CROSS);
else
xvt_win_set_cursor(win, CURSOR_ARROW);
break;
case E_MOUSE_DOWN:
if (ep->v.mouse.button == 0)
{
const TReport_link* lnk = _printer->find_link(ep->v.mouse.where);
if (lnk != NULL)
_printer->on_link(*lnk);
}
else
popup_menu(ep);
break;
case E_COMMAND:
{
bool processed = true;
switch(ep->v.cmd.tag)
{
case POPUP_FIRST : _page = 1; break;
case POPUP_PREV : if (_page > 1) _page--; break;
case POPUP_SEARCH : page_select(); break;
case POPUP_NEXT : if (_last == 0 || _page < _last) _page++; break;
case POPUP_LAST :
if (_last == 0)
{
_printer->print_page(9999);
_last = _printer->last_printed_page();
}
_page = _last;
break;
case POPUP_ZOOMIN : if (_zoom < 300) { _zoom += 25; } break;
case POPUP_ZOOMOUT: if (_zoom > 75) { _zoom -= 25; } break;
case POPUP_GRID : _printer->toggle_preview_grid(); break;
default:processed = false; break;
}
if (processed)
{
_print_aborted = false;
force_update();
}
}
break;
default:
break;
}
TField_window::handler(win, ep);
}
bool TPrint_preview_window::on_key(KEY k)
{
bool ok = true;
switch (k)
{
case '+' : dispatch_e_menu(win(), POPUP_ZOOMIN); break;
case '-' : dispatch_e_menu(win(), POPUP_ZOOMOUT); break;
case K_HOME :
case K_LHOME : dispatch_e_menu(win(), POPUP_FIRST); break;
case K_LEFT : dispatch_e_menu(win(), POPUP_PREV); break;
case K_RIGHT : dispatch_e_menu(win(), POPUP_NEXT); break;
case K_END:
case K_LEND : dispatch_e_menu(win(), POPUP_LAST); break;
case 'G' :
case 'g' : dispatch_e_menu(win(), POPUP_GRID); break;
default : ok = TField_window::on_key(k); break;
};
return ok;
}
TPrint_preview_window::TPrint_preview_window(int x, int y, int dx, int dy, WINDOW parent,
TWindowed_field* owner, TPage_printer* printer)
: TField_window(x, y, dx, dy, parent, owner), _printer(printer),
_page(1), _last(0), _zoom(120)
{
RCT rct; xvt_vobj_get_client_rect(win(), &rct);
set_scroll_max(rct.right, rct.bottom);
}
///////////////////////////////////////////////////////////
// TPrint_preview_field
///////////////////////////////////////////////////////////
class TPrint_preview_field : public TWindowed_field
{
TPage_printer* _printer;
protected:
virtual TField_window* create_window(int x, int y, int dx, int dy, WINDOW parent);
public:
TPrint_preview_field(TMask* m, TPage_printer* printer) : TWindowed_field(m), _printer(printer) { }
};
TField_window* TPrint_preview_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
{
return new TPrint_preview_window(x, y, dx, dy, parent, this, _printer);
}
///////////////////////////////////////////////////////////
// TPreview_mask
///////////////////////////////////////////////////////////
class TPreview_mask : public TAutomask
{
TPage_printer* _printer;
protected:
virtual bool on_key(KEY k);
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
virtual TMask_field* parse_field(TScanner& scanner);
public:
TPreview_mask(TPage_printer* printer);
};
bool TPreview_mask::on_key(KEY k)
{
switch (k)
{
case '+' :
case '-' :
case K_HOME :
case K_LHOME:
case K_LEFT :
case K_RIGHT:
case K_END :
case K_LEND :
case 'G' :
case 'g' :
dispatch_e_char(_printer->win(), k);
return true;
default:
break;
}
return TAutomask::on_key(k);
}
bool TPreview_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
if (e == fe_button)
{
switch (o.dlg())
{
case DLG_FIRSTREC: dispatch_e_menu(_printer->win(), POPUP_FIRST); break;
case DLG_PREVREC : dispatch_e_menu(_printer->win(), POPUP_PREV); break;
case DLG_FINDREC : dispatch_e_menu(_printer->win(), POPUP_SEARCH);break;
case DLG_NEXTREC : dispatch_e_menu(_printer->win(), POPUP_NEXT); break;
case DLG_LASTREC : dispatch_e_menu(_printer->win(), POPUP_LAST); break;
default: break;
}
}
return true;
}
TMask_field* TPreview_mask::parse_field(TScanner& scanner)
{
if (scanner.token().starts_with("PR"))
return new TPrint_preview_field(this, _printer);
return TAutomask::parse_field(scanner);
}
TPreview_mask::TPreview_mask(TPage_printer* printer)
: _printer(printer)
{
read_mask("ba8303", 0, -1);
set_handlers();
int pos = id2pos(DLG_FINDREC);
if (pos >= 0 && id2pos(DLG_FIRSTREC) >= 0) //se e' un bottone pentapartito...
{
TButton_field& f_find = (TButton_field &)fld(pos);
RCT rct_base; f_find.get_rect(rct_base);
const int bwidth = (rct_base.right - rct_base.left);
const int bheight = (rct_base.bottom - rct_base.top);
if (bwidth > 3*bheight/2) // Controllo se ho gia' ridimensionato i bottoni in precedenza
{
int bx = bwidth / 3;
int by = bheight / 2;
RCT r = rct_base; r.left += bx-2; r.right -= bx-2;
f_find.set_rect(r); // Ridimensiona il bottone centrale di ricerca
bx += 5; by += 3; // Aggiusta dimensioni bottoni sussidiari
pos = id2pos(DLG_FIRSTREC);
if (pos >= 0)
{
r = rct_base; r.top = r.bottom - by; r.right = r.left + bx;
fld(pos).set_rect(r);
}
pos = id2pos(DLG_PREVREC);
if (pos >= 0)
{
r = rct_base; r.bottom = r.top + by; r.right = r.left + bx;
fld(pos).set_rect(r);
}
pos = id2pos(DLG_NEXTREC);
if (pos >= 0)
{
r = rct_base; r.bottom = r.top + by; r.left = r.right - bx;
fld(pos).set_rect(r);
}
pos = id2pos(DLG_LASTREC);
if (pos >= 0)
{
r = rct_base; r.top = r.bottom - by; r.left = r.right - bx;
fld(pos).set_rect(r);
}
}
}
}
///////////////////////////////////////////////////////////
// TPage_printer
///////////////////////////////////////////////////////////
const char* TPage_printer::form_name() const
{
return printer().get_form_name();
}
const char* TPage_printer::font_name() const
{
return printer().fontname();
}
int TPage_printer::font_size() const
{
return printer().get_char_size();
}
bool TPage_printer::ask_pages()
{
if (_pageto <= 0)
_pageto = pages();
TPrinter& p = printer();
TMask msk("bagn003");
msk.set(F_PRINTER, p.printername());
msk.set(F_FORM, form_name());
msk.set(F_FONT, font_name());
msk.set(F_SIZE, font_size());
msk.set(F_ISGRAPHICS, p.isgraphics() ? "X" : "");
msk.set(F_FROMPAGE, _pagefrom);
msk.set(F_TOPAGE, _pageto);
msk.set(F_COPIES, _copies);
const bool ok = msk.run() == K_ENTER;
if (ok)
{
_copies = msk.get_int(F_COPIES);
_pagefrom = msk.get_int(F_FROMPAGE);
_pageto = msk.get_int(F_TOPAGE);
if (_pageto < _pagefrom)
_pageto = 0;
}
return ok;
}
bool TPage_printer::main_loop()
{
TPrinter& p = printer();
_rcd = p.get_printrcd();
if (!xvt_print_is_valid(_rcd))
return false; // aborted
WINDOW prwin = xvt_print_create_win(_rcd, (char*)(const char*)form_name());
if (prwin == NULL_WIN)
return false; // aborted
set_win(prwin);
xvt_app_escape (XVT_ESC_GET_PRINTER_INFO, _rcd, &_ph, &_pw, &_pvr, &_phr);
if (_pw <= 0 || _ph <= 0)
return error_box(TR("Dimensioni pagina NULLE"));
bool ok = true;
if (_pvr < 150 || _phr < 150)
{
ok = yesno_box(TR("Stampante obsoleta o non adeguatamente configurata:\n"
"Risoluzione %ldx%ld. Continuare ugualmente?"), _phr, _pvr);
if (!ok)
return false;
}
_print_aborted = false;
for (word c = 0; c < _copies && ok; c++)
{
_page = 0;
ok = print_loop();
}
_print_aborted = false;
xvt_vobj_destroy(prwin);
set_win(NULL_WIN);
return ok;
}
bool TPage_printer::page_in_range() const
{
if (_page < _pagefrom)
return false;
return _pageto < _pagefrom || _page <= _pageto;
}
PNT TPage_printer::log2dev(long lx, long ly) const
{
if (preview_mode())
return _preview_window->log2dev(lx, ly);
const PNT p = { short(ly), short(lx) };
return p;
}
TPoint TPage_printer::dev2log(const PNT& pnt) const
{
CHECK(0, "dev2log: Pure virtual funtion call");
const TPoint p;
return p;
}
bool TPage_printer::open_page()
{
_page++;
if (page_in_range())
{
if (print_mode())
_page_is_open = xvt_print_open_page(_rcd) != 0;
else
{
_page_is_open = true;
_links.destroy(); // Distrugge elenco dei links
_links_sorted = false;
}
}
else
_page_is_open = false;
return _page_is_open;
}
bool TPage_printer::close_page()
{
const bool was_open = _page_is_open;
if (was_open)
{
if (print_mode())
xvt_print_close_page(_rcd);
_page_is_open = false;
}
return was_open;
}
void TPage_printer::add_link(TReport_link* link)
{
_links.add(link);
_links_sorted = false;
}
static BOOLEAN main_loop_callback(long jolly)
{
TPage_printer* pp = (TPage_printer*)jolly;
return pp->main_loop();
}
bool TPage_printer::do_print()
{
_print_aborted = true;
bool ok = ask_pages();
if (ok)
ok = xvt_print_start_thread(main_loop_callback, long(this)) == FALSE;
return ok;
}
void TPage_printer::print_page(word page)
{
_pagefrom = _pageto = page;
_page = 0;
print_loop();
}
bool TPage_printer::do_preview()
{
_print_aborted = true;
TPrinter& p = printer();
_rcd = p.get_printrcd();
if (!xvt_print_is_valid(_rcd))
return error_box(TR("Stampante non valida"));
xvt_app_escape (XVT_ESC_GET_PRINTER_INFO, _rcd, &_ph, &_pw, &_pvr, &_phr);
if (_pw <= 0 || _ph <= 0)
return error_box(TR("Dimensioni pagina NULLE"));
_preview_mask = new TPreview_mask(this);
TPrint_preview_field& pf = (TPrint_preview_field&)_preview_mask->field(DLG_USER);
_preview_window = &pf.win();
set_win(_preview_window->win());
_pagefrom = _pageto = _page = 1;
_print_aborted = false;
const KEY key = _preview_mask->run();
set_win(NULL_WIN);
delete _preview_mask;
_preview_mask = NULL;
if (key == K_INS)
print();
return true;
}
const TReport_link* TPage_printer::find_link(const PNT& pnt) const
{
if (!_links_sorted)
{
TPage_printer* myself = (TPage_printer*)this;
myself->_links.sort();
myself->_links_sorted = true;
}
int primo = 0, ultimo = _links.last();
while (primo <= ultimo)
{
const int in_mezzo = (primo+ultimo)/2;
const TReport_link* lnk = (const TReport_link*)_links.objptr(in_mezzo);
const int cmp = lnk->hit_test(pnt);
if (cmp == 0)
return lnk;
if (cmp < 0)
ultimo = in_mezzo-1;
else
primo = in_mezzo+1;
}
return NULL;
}
bool TPage_printer::on_link(const TReport_link& lnk)
{
return false;
}
bool TPage_printer::print(bool prev_mode)
{
return prev_mode ? do_preview() : do_print();
}
TPoint TPage_printer::page_size() const
{
return TPoint(_pw, _ph);
}
TPoint TPage_printer::page_res() const
{
TPoint pt(_phr, _pvr);
return pt;
}
TPage_printer::TPage_printer()
: _pagefrom(1), _pageto(0), _copies(1), _preview_mask(NULL), _draw_grid(true)
{
_pixmap = true; // Fondamentale!!!
}
TPage_printer::~TPage_printer()
{ }
///////////////////////////////////////////////////////////
// TReport_printer
///////////////////////////////////////////////////////////
const char* TReport_printer::form_name() const
{
return _report.filename();
}
const char* TReport_printer::font_name() const
{
return _report.font().name();
}
int TReport_printer::font_size() const
{
return _report.font().size();
}
PNT TReport_printer::log2dev(long lx, long ly) const
{
const TPoint res = page_res();
const double cx = (double)res.x / (double)_report.cpi();
const double cy = (double)res.y / (double)_report.lpi();
const long x = long((lx + _delta.x) * cx / 100.0);
const long y = long((ly + _delta.y) * cy / 100.0);
return TPage_printer::log2dev(x, y); // Useful for preview mode
}
long TReport_printer::print_section(char type, int level)
{
long h = 0;
TReport_section* rs = _report.find_section(type, level);
if (rs != NULL)
h = print_section(*rs);
return h;
}
void TReport_printer::draw_preview_page()
{
clear(COLOR_WHITE);
if (_draw_grid)
{
const int max = 192;
const int k = 100;
for (int i = 1; i < max; i++)
{
set_pen((i%10) ? MAKE_COLOR(232,232,232) : COLOR_LTGRAY);
line(0, i*k, max*k, i*k);
line(i*k, 0, i*k, max*k);
}
}
const PNT pag = log2dev(_logical_page_width, _logical_page_height);
hide_pen();
set_brush(COLOR_GRAY);
RCT rct;
xvt_vobj_get_client_rect(win(), &rct); rct.left = pag.h;
xvt_dwin_draw_rect(win(), &rct);
xvt_vobj_get_client_rect(win(), &rct); rct.top = pag.v;
xvt_dwin_draw_rect(win(), &rct);
}
bool TReport_printer::open_page()
{
const bool ok = TPage_printer::open_page();
_report.set_curr_page(_page);
_delta.reset();
_page_break_allowed = false;
if (ok && preview_mode()) // Clear page needed
draw_preview_page();
TReport_section* page_background = _report.find_section('B', 0);
if (page_background != NULL)
{
_delta = page_background->pos();
print_section(*page_background);
_delta.reset();
}
if (_page == 1)
_delta.y += print_section('H', 1);
TReport_section* page_head = _report.find_section('H', 0);
if (page_head != NULL && (_page > 1 || !page_head->hidden_if_needed()))
{
_delta += page_head->pos();
_delta.y += print_section(*page_head);
_delta.x = 0;
}
return ok;
}
bool TReport_printer::close_page()
{
if (_page_is_open)
{
TReport_section* page_foot = _report.find_section('F', 0);
if (page_foot != NULL && (!_is_last_page || !page_foot->hidden_if_needed()))
{
_delta.x = page_foot->pos().x;
_delta.y = _logical_foot_pos;
print_section(*page_foot);
}
}
return TPage_printer::close_page();
}
void TReport_printer::create_links(const TReport_section& rs)
{
TAssoc_array* links = NULL;
for (int i = 0; i < rs.items(); i++)
{
const TReport_field& rf = rs.field(i);
if (rf.link().not_empty())
{
if (links == NULL)
links = new TAssoc_array;
TToken_string tok(rf.link(), '.');
TString table, field;
tok.get(0, table); tok.get(1, field);
TReport_link* rl = (TReport_link*)links->objptr(table);
if (rl == NULL)
{
rl = new TReport_link(table);
links->add(table, rl);
}
RCT rct; TWindow::log2dev(rf.get_rect(), rct);
rl->add_rect(rct);
rl->set(field, rf.get());
}
}
if (links != NULL)
{
FOR_EACH_ASSOC_OBJECT((*links), h, key, l)
add_link((TReport_link*)l);
}
}
long TReport_printer::print_section(TReport_section& rs)
{
if (_print_aborted)
return 0;
rs.load_fields();
rs.execute_prescript();
const long height = rs.compute_size().y; // Compute size after the initilization script!
if (height > 0) // Has some visible fields
{
bool page_break = _page_break_allowed && rs.page_break();
if (!page_break)
{
long h = height;
if (rs.keep_with_next())
h += rs.report().section('B', 1).compute_size().y;
page_break = (_delta.y + h > _logical_foot_pos);
}
if (page_break && rs.level() > 0) // Avoid recursion
{
close_page();
open_page();
}
if (_page_is_open)
rs.draw(*this, preview_mode() ? rdm_print_preview : rdm_print);
if (rs.level() > 0) // Ho stampa qualcosa che non sia lo sfondo!
_page_break_allowed = true;
}
rs.execute_postscript();
if (_page_is_open && height > 0 && preview_mode())
create_links(rs);
return height;
}
bool TReport_printer::print_loop()
{
TRecordset* rex = _report.recordset();
if (rex == NULL || rex->items() <= 0)
return false;
const TPoint siz = page_size();
const TPoint res = page_res();
const double pollici_pagina_y = (double)siz.y / (double)res.y;
const double righe_pagina = pollici_pagina_y * _report.lpi();
_logical_page_height = long(righe_pagina*100.0);
const double pollici_pagina_x = (double)siz.x / (double)res.x;
const double colonne_pagina = pollici_pagina_x * _report.cpi();
_logical_page_width = long(colonne_pagina*100.0);
const TReport_section& footer = _report.section('F',0);
_logical_foot_pos = footer.pos().y;
if (_logical_foot_pos <= 0)
{
const long logical_footer_height = footer.compute_size().y;
_logical_foot_pos = _logical_page_height - logical_footer_height;
}
_report.unmap_font(); // Gestire bene le riscalature
TString_array oldgroup, newgroup;
const int max_group = _report.find_max_level('H');
if (max_group >= 2)
{
for (int g = 2; g <= max_group; g++)
oldgroup.add(EMPTY_STRING, g);
}
const int max_body = _report.find_max_level('B');
int last_body_height = 0;
_is_last_page = false;
open_page();
bool aborted = false;
for (bool ok = rex->move_to(0); ok; ok = rex->move_next())
{
if (_pageto >= _pagefrom && _page > _pageto || _print_aborted) // out of range
{
aborted = true;
break;
}
if (max_group >= 2) // Gestione raggruppamenti
{
int changed = 0;
TVariant var;
for (int g = 2; g <= max_group; g++)
{
const TString& expr = _report.section('H', g).grouped_by();
_report.evaluate(expr, var, _alfafld);
const TString& grp = var.as_string();
newgroup.add(grp, g);
if (newgroup.row(g) != oldgroup.row(g) || rex->current_row() == 0)
changed = g;
}
if (changed)
{
oldgroup = newgroup;
if (_delta.x > 0) // Devo tornare a capo!
_delta.y += last_body_height;
_delta.x = 0;
if (rex->current_row() > 0)
{
for (int g = 2; g <= changed; g++)
_delta.y += print_section('F', g);
}
for (int g = changed; g >= 2 ; g--)
_delta.y += print_section('H', g);
}
}
for (int b = 1; b <= max_body; b++)
{
const int dy = print_section('B', b);
int column_delta = 0;
// Cerco di vedere se e' possibile la stampa etichette
if (dy > 0)
{
const int dx = _report.section('B', b).size().x;
// Se dx > 0 ho una sezione a dimensione fissa
if (dx > 0 && _delta.x+2*dx <= _logical_page_width)
{
column_delta = dx;
last_body_height = dy;
}
}
if (column_delta > 0)
_delta.x += column_delta;
else
{
_delta.x = 0;
_delta.y += dy;
last_body_height = 0; // Non servirebbe strettamente
}
}
}
if (!aborted)
{
if (max_group >= 2) // Devo stampare tutte le code dei raggrupamenti
{
for (int g = 2; g <= max_group; g++)
_delta.y += print_section('F', g);
}
if (rex->eof())
print_section('F', 1);
_is_last_page = true;
close_page();
}
_lastprinted = _page;
return true;
}
bool TReport_printer::print(bool preview_mode)
{
bool ok = _report.execute_prescript();
if (ok)
{
ok = TPage_printer::print(preview_mode);
if (ok)
_report.execute_postscript();
}
return ok;
}
bool TReport_printer::on_link(const TReport_link& lnk)
{
return _report.on_link(lnk);
}
///////////////////////////////////////////////////////////
// Remote control interface
///////////////////////////////////////////////////////////
void lock_preview_update(bool yes)
{ TPrint_preview_window::lock_preview_update(yes); }
void abort_printing()
{ _print_aborted = true; }

100
ba/ba8303.h
View File

@ -1,100 +0,0 @@
#ifndef __REPRINT_H
#define __REPRINT_H
#ifndef __REPORT_H
#include "ba8302.h"
#endif
class TPage_printer : public TWindow
{
PRINT_RCD* _rcd;
long _pw, _ph, _phr, _pvr; // Printer width, height, horizontal and vertical resolution
TArray _links;
bool _links_sorted;
protected:
word _copies, _pagefrom, _pageto, _page, _lastprinted;
bool _page_is_open, _draw_grid;
TMask* _preview_mask; // owned object
TWindow* _preview_window; // referenced object
virtual word pages() const { return 0; }
virtual bool print_loop() pure;
private:
virtual TPoint dev2log(const PNT& p) const; // Never use this!
protected:
virtual PNT log2dev(long lx, long ly) const; // Always override this!
virtual const char* form_name() const;
virtual const char* font_name() const;
virtual int font_size() const;
virtual bool ask_pages();
virtual bool open_page();
virtual bool close_page();
bool page_in_range() const;
// Called by print(bool)
virtual bool do_print();
virtual bool do_preview();
public:
bool main_loop(); // Internal use only
virtual void print_page(word page); // Inefficient default implementation
virtual TPoint page_size() const;
virtual TPoint page_res() const;
virtual word last_printed_page() { return _lastprinted; }
virtual bool print(bool preview = false);
bool print_mode() const { return _preview_mask == NULL; }
bool preview_mode() const { return _preview_mask != NULL; }
void toggle_preview_grid() { _draw_grid = !_draw_grid; }
bool show_preview_grid() const { return _draw_grid; }
void add_link(TReport_link* link);
const TReport_link* find_link(const PNT& pnt) const;
virtual bool on_link(const TReport_link& lnk);
TPage_printer();
virtual ~TPage_printer();
};
class TReport_printer : public TPage_printer
{
TReport& _report;
TPoint _delta;
long _logical_page_height, _logical_page_width;
long _logical_foot_pos;
bool _is_last_page, _page_break_allowed;
protected:
virtual const char* form_name() const;
virtual const char* font_name() const;
virtual int font_size() const;
virtual PNT log2dev(long x, long y) const;
virtual bool print_loop();
virtual void draw_preview_page();
virtual bool open_page();
virtual bool close_page();
long print_section(TReport_section& rs);
long print_section(char type, int level);
void create_links(const TReport_section& rs);
public:
virtual bool print(bool preview = false);
virtual bool on_link(const TReport_link& lnk);
TReport_printer(TReport& r) : _report(r) { }
};
void lock_preview_update(bool yes);
void abort_printing();
#endif

1271
ba/ba8304.cpp
View File

File diff suppressed because it is too large Load Diff

74
ba/ba8304.h
View File

@ -1,74 +0,0 @@
#ifndef __ALEX_H
#define __ALEX_H
#ifndef __RECORDSET_H
#include "ba8201.h"
#endif
class TVariant_stack : public TObject
{
TArray _var;
int _sp;
public:
int items() const { return _sp; }
bool drop();
TVariant& pop();
TVariant& peek(int depth = 0);
void roll(int depth);
void push(const TVariant& var);
void push(long n);
void push(const real& n);
void push(const TString& str);
void reset();
bool overflow() const;
TVariant_stack() : _sp(0) { }
};
// Generic bytecode for any language
class TBytecode : public TArray
{
TString _name;
public:
void set_name(const char* name) { _name = name; }
const TString& name() const { return _name; }
};
// ALEX = Another Language EXtension
class TAVM;
class TAlex_virtual_machine : public TObject
{
TAVM* _avm; // Chesire's cat class
protected:
TAVM& avm();
public:
virtual size_t get_usr_words(TString_array& names) const;
virtual bool execute_usr_word(unsigned int opcode, TVariant_stack& stack);
virtual bool get_usr_val(const TString& name, TVariant& var) const;
virtual bool set_usr_val(const TString& name, const TVariant& var);
const TString& get_last_error() const;
bool compile(istream& instr, TBytecode& bc);
bool compile(const char* cmd, TBytecode& bc);
bool execute(const TBytecode& bc, ostream& outstr);
bool execute(const TBytecode& bc, TString& outstr);
bool include(const char* fname);
void warm_restart();
void cold_restart();
void set_interactive(bool inter);
bool defined(const char* name);
TAlex_virtual_machine();
virtual ~TAlex_virtual_machine();
};
#endif

9
ba/ba8400.cpp
View File

@ -4,9 +4,8 @@
#include <execp.h>
#include <form.h>
#include <prefix.h>
#include <scanner.h>
#include <report.h>
#include "ba8302.h"
#include "ba8400.h"
///////////////////////////////////////////////////////////
@ -83,12 +82,6 @@ void TFormer_mask::parse_field_line(const TString& line, TReport_field& rf) cons
{
if (fld.find("->") < 0)
fld.insert("33->");
if (fld.starts_with("33->"))
{
const TRectype doc(LF_DOC);
if (doc.type((const char*)fld + 4) == _nullfld)
fld.insert("G1:", 4);
}
}
rf.set_field(fld);
} else

6
ba/report.alx
View File

@ -60,12 +60,12 @@
\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
: MESSAGE_ADD ( f1 -- )
#THIS @ +! \ Incrementa f1 col contenuto del campo corrente
#THIS @ SWAP +! \ Incrementa f1 col contenuto del campo corrente
;
: MESSAGE_ALIGN ( s1 -- )
"MESSAGE_ALIGN_" SWAP + \ Si crea il nome della funzione da chiamare
PERFORM
PERFORM \ Chiama MESSAGE_ALIGN_BOTTOM, ecc...
;
: MESSAGE_COPY ( f1 -- )
@ -93,7 +93,7 @@
;
: MESSAGE_PAGENO ( -- ) \ Numero di pagina corrente
#REPORT.PAGE @ THIS !
#REPORT.PAGE @ #THIS !
;
: MESSAGE_RESET ( f1 -- )

36
ba/ve1100.alx
View File

@ -1,30 +1,46 @@
\ Utility
: KILL_STACK
BEGIN
SP
WHILE
DROP
REPEAT
;
\ Messaggi specifici per stampa documenti
: MESSAGE_CLIENTE
DROP
KILL_STACK
;
: MESSAGE_DESCRIGA
#RDOC.DESCR @
#RDOC.DESCLUNGA @ IF
#RDOC.DESCEST @
+
#RDOC.DESCR @ \ Legge campo descrizione riga
#RDOC.DESCLUNGA @ \ Se e' presente una descrizione estesa
IF
#RDOC.DESCEST @ \ Legge memo descrizione
+ \ Lo somma alla descrizione normale
THEN
#THIS !
BEGIN \ Ciclo sugli eventuali parametri successivi
SP 1 > \ Se lo stack e' ancora pieno
WHILE
" " + \ Somma uno spazio
SWAP @ + \ Somma campo successivo alla descrizione
REPEAT
#THIS ! \ Setta il campo corrente con la stringa risultante
;
: MESSAGE_DITTA
DROP
KILL_STACK
;
: MESSAGE_RIEPILOGOIVA
DROP
KILL_STACK
;
: MESSAGE_SCADENZE
DROP
KILL_STACK
;
: MESSAGE_TOTIMPONIBILI
DROP
KILL_STACK
;