132cd3e790
Files correlati : ba8.exe ba8300c.msk Ricompilazione Demo : [ ] Commento : Aggiunto supporto per body splittatbili in due pagine git-svn-id: svn://10.65.10.50/trunk@12273 c028cbd2-c16b-5b4b-a496-9718f37d4682
1434 lines
33 KiB
C++
Executable File
1434 lines
33 KiB
C++
Executable File
#include <xinclude.h>
|
|
|
|
#include <applicat.h>
|
|
#include <automask.h>
|
|
#include <colors.h>
|
|
#include <defmask.h>
|
|
#include <execp.h>
|
|
#include <modaut.h>
|
|
#include <prefix.h>
|
|
#include <printer.h>
|
|
#include <reprint.h>
|
|
|
|
#include "ba8300.h"
|
|
#include "ba8301.h"
|
|
#include <bagn003.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Utility
|
|
///////////////////////////////////////////////////////////
|
|
|
|
static TString16 _str;
|
|
|
|
const TString& num2str(int num)
|
|
{
|
|
const real n(num / 100.0);
|
|
_str = n.stringa(0, 2);
|
|
const int comma = _str.find(',');
|
|
if (comma > 0)
|
|
{
|
|
if (_str[comma+2] == '0')
|
|
{
|
|
if (_str[comma+1] == '0')
|
|
_str.cut(comma);
|
|
else
|
|
_str.cut(comma+2);
|
|
}
|
|
}
|
|
return _str;
|
|
}
|
|
|
|
short str2num(const TString& str)
|
|
{
|
|
_str = str;
|
|
_str.replace(',', '.');
|
|
real n(_str);
|
|
n *= CENTO;
|
|
return (short)n.integer();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReport_base_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReport_base_mask : public TAutomask
|
|
{
|
|
TReport_font _font;
|
|
bool _font_changed;
|
|
|
|
protected:
|
|
TReport& _report;
|
|
char _halign, _valign;
|
|
COLOR _fgcolor, _bgcolor;
|
|
|
|
virtual void update();
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
|
|
public:
|
|
void set_font_info(const TReport_font& font);
|
|
bool get_font_info(TReport_font& font) const;
|
|
|
|
TReport_base_mask(const char* name, TReport& rep);
|
|
};
|
|
|
|
void TReport_base_mask::update()
|
|
{
|
|
const TMask_field& fld = field(F_FONT_SELECT);
|
|
if (fld.active() && win() == fld.parent())
|
|
{
|
|
RCT rctfld; fld.get_rect(rctfld);
|
|
const int x = rctfld.right / CHARX + 1;
|
|
const int y = rctfld.top / ROWY + 1;
|
|
RCT& rct = resize_rect(x, y, -3, 2, W_PLAIN, win());
|
|
rct.top = rctfld.top; rct.bottom = rctfld.bottom;
|
|
xi_draw_3d_rect((XinWindow)win(), (XinRect*)&rct, TRUE, 2, MASK_LIGHT_COLOR,
|
|
_bgcolor, MASK_DARK_COLOR);
|
|
|
|
rct.left += 2; rct.right -= 2;
|
|
rct.top += 2; rct.bottom -= 2;
|
|
xvt_dwin_set_clip(win(), &rct);
|
|
|
|
XVT_FNTID fontid = _font.get_xvt_font(*this);
|
|
xvt_font_set_size(fontid, _font.size());
|
|
xvt_dwin_set_font(win(), fontid);
|
|
set_color(_fgcolor, _bgcolor);
|
|
advanced_draw_text(*this, _font.name(), rct, _halign, _valign);
|
|
}
|
|
}
|
|
|
|
bool TReport_base_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch (o.dlg())
|
|
{
|
|
case F_FGCOLOR:
|
|
if (e == fe_button)
|
|
{
|
|
_fgcolor = xvt_dm_post_choose_color(win(), _fgcolor);
|
|
force_update();
|
|
}
|
|
break;
|
|
case F_BGCOLOR:
|
|
if (e == fe_button)
|
|
{
|
|
_bgcolor = xvt_dm_post_choose_color(win(), _bgcolor);
|
|
force_update();
|
|
}
|
|
break;
|
|
case F_PATTERN:
|
|
if (e == fe_modify)
|
|
force_update();
|
|
break;
|
|
case F_FONT_SELECT:
|
|
if (e == fe_button)
|
|
{
|
|
XVT_FNTID font = xvt_font_create();
|
|
xvt_font_copy(font, _font.get_xvt_font(*this), XVT_FA_ALL);
|
|
xvt_font_set_size(font, _font.size());
|
|
if (xvt_dm_post_font_sel(win(), font, NULL, 0))
|
|
{
|
|
TString name;
|
|
xvt_font_get_family(font, name.get_buffer(), name.size());
|
|
const int size = xvt_font_get_size(font);
|
|
const XVT_FONT_STYLE_MASK style = xvt_font_get_style(font);
|
|
_font.create(name, size, style);
|
|
|
|
_font_changed = true;
|
|
force_update();
|
|
}
|
|
xvt_font_destroy(font);
|
|
}
|
|
break;
|
|
case F_HALIGN:
|
|
case F_VALIGN:
|
|
if (e == fe_init || e == fe_modify)
|
|
{
|
|
_halign = get(F_HALIGN)[0];
|
|
_valign = get(F_VALIGN)[0];
|
|
force_update();
|
|
}
|
|
break;
|
|
case F_PRESCRIPT:
|
|
case F_POSTSCRIPT:
|
|
if (e == fe_close)
|
|
{
|
|
TReport_script s;
|
|
s.set(o.get());
|
|
_report.set_interactive(true);
|
|
s.compile(_report);
|
|
_report.set_interactive(false);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TReport_base_mask::set_font_info(const TReport_font& font)
|
|
{
|
|
_font = font;
|
|
}
|
|
|
|
bool TReport_base_mask::get_font_info(TReport_font& font) const
|
|
{
|
|
const bool ok = _font_changed;
|
|
if (ok)
|
|
font = _font;
|
|
return ok;
|
|
}
|
|
|
|
TReport_base_mask::TReport_base_mask(const char* name, TReport& rep)
|
|
: TAutomask(name), _report(rep),
|
|
_font_changed(false),
|
|
_halign('C'), _valign('C'),
|
|
_fgcolor(COLOR_BLACK), _bgcolor(COLOR_WHITE)
|
|
{
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReport_field_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReport_field_mask : public TReport_base_mask
|
|
{
|
|
protected:
|
|
void vedo_non_vedo();
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
virtual void update();
|
|
|
|
public:
|
|
void set_num(short id, long n);
|
|
long get_num(short id) const;
|
|
|
|
void set_field(const TReport_field& rf);
|
|
void get_field(TReport_field& rf) const;
|
|
|
|
TReport_field_mask(TReport_field& rf);
|
|
};
|
|
|
|
void TReport_field_mask::set_num(short id, long num)
|
|
{
|
|
set(id, num2str(num));
|
|
}
|
|
|
|
long TReport_field_mask::get_num(short id) const
|
|
{
|
|
return str2num(get(id));
|
|
}
|
|
|
|
void TReport_field_mask::update()
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
TMask_field& fld = field(i == 0 ? F_FGCOLOR : F_BGCOLOR);
|
|
if (fld.active() && fld.parent() == win())
|
|
{
|
|
RCT rctfld; fld.get_rect(rctfld);
|
|
const int x = rctfld.right / CHARX + 1;
|
|
const int y = rctfld.top / ROWY + 1;
|
|
RCT& rct = resize_rect(x, y, -3, 1, W_PLAIN, win());
|
|
rct.top = rctfld.top; rct.bottom = rctfld.bottom;
|
|
xi_draw_3d_rect((XinWindow)win(), (XinRect*)&rct, TRUE, 2, MASK_LIGHT_COLOR,
|
|
i == 0 ? _fgcolor : _bgcolor, MASK_DARK_COLOR);
|
|
}
|
|
}
|
|
TReport_base_mask::update();
|
|
}
|
|
|
|
void TReport_field_mask::vedo_non_vedo()
|
|
{
|
|
const char type = get(F_TYPE)[0];
|
|
const bool is_currency = type == 'P' || type == 'V';
|
|
const bool is_numeric = is_currency || type == 'N';
|
|
const bool is_text = is_numeric || strchr("ADST", type) != NULL;
|
|
|
|
show(F_HIDE_ZEROES, is_numeric || type == 'D'),
|
|
show(F_HALIGN, is_text);
|
|
if (is_numeric)
|
|
{
|
|
disable(F_HALIGN);
|
|
set(F_HALIGN, "R"); // Allineo a destra i numeri
|
|
}
|
|
else
|
|
enable(F_HALIGN);
|
|
|
|
show(F_VALIGN, is_text);
|
|
show(F_TEXT, is_text && !is_currency);
|
|
show(F_HIDE_DOTS, is_currency);
|
|
show(F_DYNAMIC_HEIGHT, type == 'S');
|
|
show(F_FGCOLOR, type != 'I');
|
|
show(F_BGCOLOR, type != 'L');
|
|
show(F_PATTERN, type != 'L' && type != 'I');
|
|
show(F_RADIUS, type != 'E' && type != 'L' && type != 'I');
|
|
show(F_SHADE_OFFSET,type != 'E' && type != 'L');
|
|
show(F_FONT_SELECT, is_text);
|
|
show(F_SOURCE, (is_text || type == 'I') && type != 'T');
|
|
show(F_SOURCE2, is_text && type != 'T');
|
|
show(DLG_FINDREC, is_text && type != 'T');
|
|
show(F_CODVAL, is_currency); // Codice valuta di riferimento
|
|
show(F_LINK, strchr("DNS", type) != NULL); // Chi puo' essere un link?
|
|
show(F_PRESCRIPT, is_text);
|
|
show(F_POSTSCRIPT, is_text);
|
|
enable_page(3, type == 'A');
|
|
|
|
if (is_running())
|
|
force_update();
|
|
}
|
|
|
|
bool TReport_field_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch(o.dlg())
|
|
{
|
|
case F_TYPE:
|
|
if (e == fe_init || e == fe_modify)
|
|
{
|
|
vedo_non_vedo();
|
|
if (e == fe_modify)
|
|
{
|
|
if (strchr("ELR", o.get()[0]) != NULL && get_int(F_BORDER) == 0)
|
|
set(F_BORDER, 2); // Propongo un bordo visibile per le linee
|
|
}
|
|
}
|
|
break;
|
|
case F_X:
|
|
case F_Y:
|
|
case F_DX:
|
|
case F_DY:
|
|
case F_RADIUS:
|
|
case F_SHADE_OFFSET:
|
|
if (e == fe_modify)
|
|
{
|
|
const int num = get_num(o.dlg());
|
|
set_num(o.dlg(), num); // Reformat
|
|
}
|
|
break;
|
|
case F_LIST:
|
|
if (e == fe_close)
|
|
{
|
|
TSheet_field& sheet = sfield(F_LIST);
|
|
TAssoc_array ass;
|
|
FOR_EACH_SHEET_ROW(sheet, i, row)
|
|
{
|
|
if (ass.add(row->get(0)))
|
|
return error_box(TR("E' necessario specificare codici diversi"));
|
|
}
|
|
if (ass.items() < 2)
|
|
return error_box(TR("Specificare almeno due codici"));
|
|
}
|
|
break;
|
|
case DLG_FINDREC:
|
|
if (e == fe_button)
|
|
{
|
|
TRecordset* rex = _report.recordset();
|
|
if (rex != NULL && rex->columns() > 0)
|
|
{
|
|
TArray_sheet sheet(-1, -1, -1, 20, "Colonne Query", "Nome@16|Tipo@8|Dimensoni@R");
|
|
TToken_string row;
|
|
for (size_t i = 0; i < rex->columns(); i++)
|
|
{
|
|
const TRecordset_column_info& info = rex->column_info(i);
|
|
row = info._name;
|
|
switch (info._type)
|
|
{
|
|
case _alfafld: row.add("Stringa"); break;
|
|
case _boolfld: row.add("Logico"); break;
|
|
case _datefld: row.add("Data"); break;
|
|
case _memofld: row.add("Memo"); break;
|
|
default : row.add("Numero"); break;
|
|
}
|
|
row.add(info._width);
|
|
sheet.add(row);
|
|
}
|
|
if (sheet.run() == K_ENTER)
|
|
{
|
|
row = sheet.row(-1);
|
|
set(F_SOURCE, row.get(0));
|
|
}
|
|
}
|
|
else
|
|
warning_box("Query non definita");
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TReport_base_mask::on_field_event(o, e, jolly);
|
|
}
|
|
|
|
void TReport_field_mask::set_field(const TReport_field& rf)
|
|
{
|
|
char str[2] = { rf.type(), '\0' };
|
|
set(F_TYPE, str, true);
|
|
|
|
const TRectangle& r = rf.get_rect();
|
|
set(F_ID, rf.id());
|
|
set_num(F_X, r.left());
|
|
set_num(F_Y, r.top());
|
|
set_num(F_DX, r.width());
|
|
set_num(F_DY, r.height());
|
|
set(F_HIDDEN, rf.hidden() ? "X" : "");
|
|
set(F_DISABLED, rf.deactivated() ? "X" : "");
|
|
set(F_HIDE_ZEROES, rf.zeroes_hidden() ? "X" : "");
|
|
set(F_HIDE_DOTS, rf.picture().find('.') < 0);
|
|
set(F_DYNAMIC_HEIGHT, rf.dynamic_height() ? "X" : "");
|
|
set(F_GROUPS, rf.groups());
|
|
set(F_CODVAL, rf.codval());
|
|
set(F_LINK, rf.link());
|
|
|
|
str[0] = rf.horizontal_alignment();
|
|
set(F_HALIGN, str);
|
|
str[0] = rf.vertical_alignment();
|
|
set(F_VALIGN, str);
|
|
set(F_BORDER, rf.border());
|
|
set(F_PATTERN, rf.pattern());
|
|
set_num(F_RADIUS, rf.radius());
|
|
set_num(F_SHADE_OFFSET, rf.shade_offset());
|
|
_fgcolor = rf.fore_color();
|
|
_bgcolor = rf.back_color();
|
|
set(F_TEXT, rf.picture());
|
|
set(F_SOURCE, rf.field());
|
|
set(F_SOURCE2, rf.alternate_field());
|
|
set_font_info(rf.font());
|
|
|
|
set(F_PRESCRIPT, rf.prescript());
|
|
set(F_POSTSCRIPT, rf.postscript());
|
|
|
|
if (rf.type() == 'A')
|
|
{
|
|
TSheet_field& list = sfield(F_LIST);
|
|
rf.get_list(list.rows_array());
|
|
}
|
|
}
|
|
|
|
void TReport_field_mask::get_field(TReport_field& rf) const
|
|
{
|
|
rf.set_type(get(F_TYPE)[0]);
|
|
rf.set_id(get_int(F_ID));
|
|
rf.set_pos(get_num(F_X), get_num(F_Y));
|
|
rf.set_size(get_num(F_DX), get_num(F_DY));
|
|
rf.show(!get_bool(F_HIDDEN));
|
|
rf.activate(!get_bool(F_DISABLED));
|
|
rf.hide_zeroes(field(F_HIDE_ZEROES).active() && get_bool(F_HIDE_ZEROES));
|
|
rf.set_dynamic_height(get_bool(F_DYNAMIC_HEIGHT));
|
|
rf.set_groups(get(F_GROUPS));
|
|
rf.set_codval(get(F_CODVAL));
|
|
rf.set_link(get(F_LINK));
|
|
rf.set_horizontal_alignment(get(F_HALIGN)[0]);
|
|
rf.set_vertical_alignment(get(F_VALIGN)[0]);
|
|
rf.set_pattern((PAT_STYLE)get_int(F_PATTERN));
|
|
rf.set_border(get_int(F_BORDER));
|
|
rf.set_radius(get_num(F_RADIUS));
|
|
rf.set_shade_offset(get_num(F_SHADE_OFFSET));
|
|
rf.set_fore_color(_fgcolor);
|
|
rf.set_back_color(_bgcolor);
|
|
if (strchr("VP", rf.type()) != NULL)
|
|
rf.set_picture(get_bool(F_HIDE_DOTS) ? "#########,@@" : "###.###.###,@@");
|
|
else
|
|
rf.set_picture(get(F_TEXT));
|
|
rf.set_field(get(F_SOURCE));
|
|
rf.set_alternate_field(get(F_SOURCE2));
|
|
TReport_font f;
|
|
if (get_font_info(f))
|
|
rf.set_font(f);
|
|
|
|
rf.set_prescript(get(F_PRESCRIPT));
|
|
rf.set_postscript(get(F_POSTSCRIPT));
|
|
if (rf.type() == 'A')
|
|
{
|
|
TSheet_field& list = sfield(F_LIST);
|
|
rf.set_list(list.rows_array());
|
|
}
|
|
}
|
|
|
|
TReport_field_mask::TReport_field_mask(TReport_field& rf)
|
|
: TReport_base_mask("ba8300b", rf.section().report())
|
|
{
|
|
set_field(rf);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReport_sheet
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReport_sheet : public TSheet
|
|
{
|
|
TReport_section& _section;
|
|
|
|
protected:
|
|
virtual long get_items() const { return _section.items(); }
|
|
virtual void get_row(long r, TToken_string& row);
|
|
|
|
public:
|
|
virtual KEY run();
|
|
int selection(int& first, int& last) const;
|
|
TReport_sheet(TReport_section& sec);
|
|
};
|
|
|
|
void TReport_sheet::get_row(long r, TToken_string& row)
|
|
{
|
|
const TReport_field& rf = (const TReport_field&)_section[r];
|
|
const TRectangle& rect = rf.get_rect();
|
|
row.cut(0);
|
|
row.add(checked(r) ? "X" : " ");
|
|
row.add(rf.type_name());
|
|
row.add(rf.id());
|
|
row.add(num2str(rect.top()));
|
|
row.add(num2str(rect.left()));
|
|
row.add(num2str(rect.width()));
|
|
row.add(num2str(rect.height()));
|
|
if (rf.field().not_empty())
|
|
row.add(rf.field());
|
|
else
|
|
row.add(rf.picture());
|
|
}
|
|
|
|
int TReport_sheet::selection(int& first, int& last) const
|
|
{
|
|
int tot = 0;
|
|
first = items()+1;
|
|
last = -1;
|
|
FOR_EACH_ARRAY_ITEM_BACK(_section, i, o)
|
|
{
|
|
const TReport_field& rf = *(const TReport_field*)o;
|
|
if (rf.selected())
|
|
{
|
|
if (i < first) first = i;
|
|
if (i > last) last = i;
|
|
tot++;
|
|
}
|
|
}
|
|
return tot;
|
|
}
|
|
|
|
KEY TReport_sheet::run()
|
|
{
|
|
int first = -1;
|
|
uncheck(-1);
|
|
FOR_EACH_ARRAY_ITEM(_section, i, o)
|
|
{
|
|
const TReport_field& rf = *(const TReport_field*)o;
|
|
if (rf.selected())
|
|
{
|
|
check(i);
|
|
if (first < 0)
|
|
first = i;
|
|
}
|
|
}
|
|
if (first > 0)
|
|
select(first);
|
|
const KEY k = TSheet::run();
|
|
if (k != K_ESC)
|
|
{
|
|
FOR_EACH_ARRAY_ITEM(_section, i, o)
|
|
{
|
|
TReport_field& rf = *(TReport_field*)o;
|
|
rf.select(checked(i));
|
|
}
|
|
}
|
|
return k;
|
|
}
|
|
|
|
TReport_sheet::TReport_sheet(TReport_section& sec)
|
|
: TSheet(-1, -1, -2, -4, "Campi", "@1|Tipo@10|ID@4R|Riga@R|Col.@R|Larg.@R|Alt.@R|Testo@50", 0xE),
|
|
_section(sec)
|
|
{
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSection_properties_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TSection_properties_mask : public TReport_base_mask
|
|
{
|
|
protected:
|
|
virtual void update();
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
void set_num(short id, long num);
|
|
short get_num(short id) const;
|
|
|
|
void vedo_non_vedo();
|
|
void set_section(const TReport_section& rs);
|
|
|
|
public:
|
|
void get_section(TReport_section& rs) const;
|
|
TSection_properties_mask(TReport_section& rs);
|
|
};
|
|
|
|
void TSection_properties_mask::update()
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
TMask_field& fld = field(i == 0 ? F_FGCOLOR : F_BGCOLOR);
|
|
if (fld.active() && fld.parent() == win())
|
|
{
|
|
RCT rctfld; fld.get_rect(rctfld);
|
|
const int x = rctfld.right / CHARX + 1;
|
|
const int y = rctfld.top / ROWY + 1;
|
|
RCT& rct = resize_rect(x, y, -3, 1, W_PLAIN, win());
|
|
rct.top = rctfld.top; rct.bottom = rctfld.bottom;
|
|
xi_draw_3d_rect((XinWindow)win(), (XinRect*)&rct, TRUE, 2, MASK_LIGHT_COLOR,
|
|
i == 0 ? _fgcolor : _bgcolor, MASK_DARK_COLOR);
|
|
}
|
|
}
|
|
TReport_base_mask::update();
|
|
}
|
|
|
|
void TSection_properties_mask::set_num(short id, long num)
|
|
{
|
|
set(id, num2str(num));
|
|
}
|
|
|
|
short TSection_properties_mask::get_num(short id) const
|
|
{
|
|
return str2num(get(id));
|
|
}
|
|
|
|
void TSection_properties_mask::vedo_non_vedo()
|
|
{
|
|
const char type = get(F_TYPE)[0];
|
|
const int level = get_int(F_LEVEL);
|
|
const bool can_pos = (type != 'H' && level == 0) || (type == 'F' && level == 1);
|
|
show(F_X, can_pos); show(F_Y, can_pos);
|
|
show(F_CONDITION, type == 'B' && level > 0);
|
|
show(F_GROUP_BY, type == 'H' && level > 1);
|
|
show(F_KEEP_WITH_NEXT, level > 1 && type == 'H');
|
|
show(F_CAN_BREAK, level > 0 && type == 'B');
|
|
show(F_HIDE_IF_NEEDED, level == 0 && type != 'B');
|
|
show(F_REPEAT, level > 1 && type == 'H');
|
|
enable(DLG_DELREC, level > 1);
|
|
}
|
|
|
|
bool TSection_properties_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch(o.dlg())
|
|
{
|
|
case F_TYPE:
|
|
case F_LEVEL:
|
|
if (e == fe_modify)
|
|
vedo_non_vedo();
|
|
break;
|
|
case F_DX:
|
|
case F_DY:
|
|
if (e == fe_modify)
|
|
{
|
|
const int num = get_num(o.dlg());
|
|
set_num(o.dlg(), num); // Reformat
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TReport_base_mask::on_field_event(o, e, jolly);
|
|
}
|
|
|
|
void TSection_properties_mask::set_section(const TReport_section& rs)
|
|
{
|
|
char s[2] = { rs.type(), '\0' };
|
|
set(F_TYPE, s);
|
|
set(F_LEVEL, rs.level());
|
|
|
|
vedo_non_vedo();
|
|
|
|
if (field(F_X).active())
|
|
{
|
|
set_num(F_X, rs.pos().x);
|
|
set_num(F_Y, rs.pos().y);
|
|
}
|
|
set_num(F_DX, rs.width());
|
|
set_num(F_DY, rs.height());
|
|
set(F_CONDITION, rs.condition());
|
|
set(F_GROUP_BY, rs.grouped_by());
|
|
|
|
set(F_HIDE_IF_NEEDED, rs.hidden_if_needed());
|
|
set(F_HIDDEN, rs.hidden());
|
|
set(F_PAGE_BREAK, rs.page_break());
|
|
set(F_KEEP_WITH_NEXT, rs.keep_with_next());
|
|
set(F_CAN_BREAK, rs.can_be_broken());
|
|
set(F_REPEAT, rs.repeat_on_page());
|
|
set(F_DISABLED, rs.deactivated());
|
|
|
|
set(F_BORDER, rs.border());
|
|
set(F_PATTERN, rs.pattern());
|
|
set_num(F_RADIUS, rs.radius());
|
|
_fgcolor = rs.fore_color();
|
|
_bgcolor = rs.back_color();
|
|
set_font_info(rs.font());
|
|
|
|
set(F_PRESCRIPT, rs.prescript());
|
|
set(F_POSTSCRIPT, rs.postscript());
|
|
|
|
}
|
|
|
|
void TSection_properties_mask::get_section(TReport_section& rs) const
|
|
{
|
|
if (field(F_X).active())
|
|
{
|
|
const TPoint pos(get_num(F_X), get_num(F_Y));
|
|
rs.set_pos(pos);
|
|
}
|
|
rs.set_width(get_num(F_DX));
|
|
rs.set_height(get_num(F_DY));
|
|
rs.show(!get_bool(F_HIDDEN));
|
|
rs.activate(!get_bool(F_DISABLED));
|
|
|
|
rs.set_condition(get(F_CONDITION));
|
|
rs.group_by(get(F_GROUP_BY));
|
|
rs.hide_if_needed(get_bool(F_HIDE_IF_NEEDED));
|
|
rs.force_page_break(get_bool(F_PAGE_BREAK));
|
|
rs.keep_with_next(get_bool(F_KEEP_WITH_NEXT));
|
|
rs.can_break(get_bool(F_CAN_BREAK));
|
|
rs.set_repeat_on_page(get_bool(F_REPEAT));
|
|
|
|
rs.set_pattern((PAT_STYLE)get_int(F_PATTERN));
|
|
rs.set_border(get_int(F_BORDER));
|
|
rs.set_radius(get_num(F_RADIUS));
|
|
rs.set_fore_color(_fgcolor);
|
|
rs.set_back_color(_bgcolor);
|
|
|
|
TReport_font f;
|
|
if (get_font_info(f))
|
|
rs.set_font(f);
|
|
|
|
rs.set_prescript(get(F_PRESCRIPT));
|
|
rs.set_postscript(get(F_POSTSCRIPT));
|
|
}
|
|
|
|
TSection_properties_mask::TSection_properties_mask(TReport_section& rs)
|
|
: TReport_base_mask("ba8300c", rs.report())
|
|
{
|
|
set_section(rs);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReport_properties_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReport_properties_mask : public TReport_base_mask
|
|
{
|
|
protected:
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
void set_report(const TReport& r);
|
|
|
|
public:
|
|
void get_report(TReport& r) const;
|
|
TReport_properties_mask(TReport& rep) : TReport_base_mask("ba8300d", rep) { set_report(rep); }
|
|
};
|
|
|
|
bool TReport_properties_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
return TReport_base_mask::on_field_event(o, e, jolly);
|
|
}
|
|
|
|
void TReport_properties_mask::set_report(const TReport& r)
|
|
{
|
|
set(F_FONT_AUTO, r.use_printer_font());
|
|
set(F_DY, r.lpi());
|
|
set_font_info(r.font());
|
|
set(F_INCLUDE, ((TReport&)r).get_libraries());
|
|
set(F_PRESCRIPT, r.prescript());
|
|
set(F_POSTSCRIPT, r.postscript());
|
|
|
|
sfield(F_PARAMS).rows_array() = r.params();
|
|
}
|
|
|
|
void TReport_properties_mask::get_report(TReport& r) const
|
|
{
|
|
const bool af = get_bool(F_FONT_AUTO);
|
|
r.set_use_printer_font(af);
|
|
if (!af)
|
|
{
|
|
r.set_lpi(get_int(F_DY));
|
|
TReport_font f;
|
|
if (get_font_info(f))
|
|
r.set_font(f);
|
|
}
|
|
|
|
const TString& oldlib = r.get_libraries();
|
|
if (oldlib != get(F_INCLUDE))
|
|
{
|
|
r.set_libraries(get(F_INCLUDE));
|
|
r.include_libraries(); // reload
|
|
}
|
|
r.set_prescript(get(F_PRESCRIPT));
|
|
r.set_postscript(get(F_POSTSCRIPT));
|
|
|
|
r.set_params(sfield(F_PARAMS).rows_array());
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReport_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReport_mask : public TAutomask
|
|
{
|
|
TReport _report;
|
|
TReport_section* _curr_section;
|
|
|
|
TReport_tree _tree;
|
|
TFilename _curr_report;
|
|
bool _is_dirty;
|
|
|
|
protected:
|
|
virtual TMask_field* parse_field(TScanner& scanner);
|
|
virtual void notify_focus_field(short id);
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
|
|
protected:
|
|
bool select_query();
|
|
bool select_report();
|
|
void select_section();
|
|
void update_report() const;
|
|
|
|
TReport_section& curr_section();
|
|
void add_field();
|
|
void edit_field(TReport_field& rf);
|
|
void fields_properties();
|
|
bool add_section();
|
|
void section_properties();
|
|
void report_properties();
|
|
|
|
bool get_rep_path(TFilename& path) const;
|
|
void set_num_attr(TXmlItem& item, const char* attr, short num, short def = 0) const;
|
|
void set_col_attr(TXmlItem& item, const char* attr, COLOR col, COLOR def) const;
|
|
|
|
public:
|
|
void on_print();
|
|
bool save_report();
|
|
bool save_if_needed();
|
|
void global_reset();
|
|
bool delete_report();
|
|
bool load_report();
|
|
|
|
TReport_tree& sections() { return _tree; }
|
|
TReport_mask();
|
|
};
|
|
|
|
TMask_field* TReport_mask::parse_field(TScanner& scanner)
|
|
{
|
|
if (scanner.token().starts_with("RE"))
|
|
return new TReport_drawer(this);
|
|
return TAutomask::parse_field(scanner);
|
|
}
|
|
|
|
bool TReport_mask::select_report()
|
|
{
|
|
TFilename path;
|
|
const bool ok = select_custom_file(path, "rep");
|
|
if (ok)
|
|
{
|
|
path = path.name(); path.ext("");
|
|
set(F_CODICE, path);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TReport_mask::select_query()
|
|
{
|
|
TFilename path;
|
|
bool ok = select_custom_file(path, "qry");
|
|
if (ok)
|
|
{
|
|
TXmlItem item; item.Load(path);
|
|
const TXmlItem* sql = item.FindFirst("sql");
|
|
ok = sql != NULL;
|
|
if (ok)
|
|
{
|
|
TString str; sql->GetEnclosedText(str);
|
|
set(F_SQL, str, true);
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TReport_mask::get_rep_path(TFilename& path) const
|
|
{
|
|
const TString& name = get(F_CODICE);
|
|
const bool ok = name.not_empty();
|
|
if (ok)
|
|
{
|
|
path = name;
|
|
if (!path.is_absolute_path())
|
|
{
|
|
path = firm2dir(-1);
|
|
path.add("custom");
|
|
if (!path.exist())
|
|
xvt_fsys_mkdir(path);
|
|
path.add(name);
|
|
}
|
|
path.ext("rep");
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TReport_mask::save_report()
|
|
{
|
|
bool ok = _curr_report.not_empty();
|
|
if (!ok)
|
|
ok = get_rep_path(_curr_report);
|
|
if (!ok)
|
|
return field(F_CODICE).on_key(K_ENTER); // Segnala errore
|
|
_report.set_description(get(F_DESCR));
|
|
_report.set_recordset(get(F_SQL));
|
|
ok = _report.save(_curr_report);
|
|
if (ok)
|
|
_is_dirty = false;
|
|
return ok;
|
|
}
|
|
|
|
bool TReport_mask::save_if_needed()
|
|
{
|
|
if (!_is_dirty)
|
|
return true;
|
|
if (!yesno_box(TR("Si desidera registrare il report?")))
|
|
return false;
|
|
return save_report();
|
|
}
|
|
|
|
void TReport_mask::global_reset()
|
|
{
|
|
_report.destroy();
|
|
reset();
|
|
update_report();
|
|
}
|
|
|
|
bool TReport_mask::load_report()
|
|
{
|
|
TFilename path; get_rep_path(path);
|
|
bool ok = path.exist();
|
|
if (ok)
|
|
{
|
|
_curr_report = path;
|
|
global_reset();
|
|
ok = _report.load(path);
|
|
if (ok)
|
|
{
|
|
path = path.name(); path.ext("");
|
|
set(F_CODICE, path);
|
|
|
|
const TRecordset* rs = _report.recordset();
|
|
if (rs != NULL)
|
|
set(F_SQL, rs->query_text(), true);
|
|
set(F_DESCR, _report.description());
|
|
field(F_SQL).set_dirty(false);
|
|
_is_dirty = false;
|
|
|
|
TTree_field& sections = tfield(F_SECTIONS);
|
|
_tree.goto_node('B', 1);
|
|
sections.select_current();
|
|
select_section();
|
|
}
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool TReport_mask::delete_report()
|
|
{
|
|
TFilename path; get_rep_path(path);
|
|
const bool ok = path.exist() && yesno_box(FR("Si desidera eliminare il file '%s'"), (const char*)path);
|
|
if (ok)
|
|
{
|
|
::remove(path);
|
|
global_reset();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
void TReport_mask::on_print()
|
|
{
|
|
#ifdef DBG
|
|
TFilename tmp; tmp.tempdir();
|
|
tmp.add("ba8300.txt");
|
|
TReport_book book(tmp);
|
|
#else
|
|
TReport_book book;
|
|
#endif
|
|
book.add(_report);
|
|
book.print_or_preview();
|
|
}
|
|
|
|
TReport_section& TReport_mask::curr_section()
|
|
{
|
|
return *_curr_section;
|
|
}
|
|
|
|
void TReport_mask::select_section()
|
|
{
|
|
TTree_field& tf = tfield(F_SECTIONS);
|
|
tf.select_current();
|
|
_curr_section = &_tree.curr_section();
|
|
|
|
TReport_drawer& rd = (TReport_drawer&)field(F_REPORT);
|
|
rd.set_report_section(*_curr_section);
|
|
|
|
const char type = _curr_section->type();
|
|
const int level = _curr_section->level();
|
|
|
|
char htype = 'H';
|
|
int hlevel = level;
|
|
|
|
switch (type)
|
|
{
|
|
case 'H':
|
|
{
|
|
if (level <= 1)
|
|
hlevel = 1-level;
|
|
else
|
|
{
|
|
if (_report.find_section('H', level-1))
|
|
hlevel = level-1;
|
|
}
|
|
}
|
|
break;
|
|
case 'B':
|
|
{
|
|
if (level >= 1)
|
|
{
|
|
hlevel = _report.find_max_level('H');
|
|
if (hlevel <= 1)
|
|
hlevel = 0;
|
|
}
|
|
else
|
|
hlevel = 0;
|
|
}
|
|
break;
|
|
case 'F':
|
|
{
|
|
if (level <= 1)
|
|
hlevel = 1-level;
|
|
else
|
|
{
|
|
if (_report.find_section('F', level-1))
|
|
hlevel = level-1;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
TReport_drawer& rdh = (TReport_drawer&)field(F_REPORTH);
|
|
rdh.set_report_section(_report.section(htype, hlevel));
|
|
|
|
update_report();
|
|
}
|
|
|
|
void TReport_mask::update_report() const
|
|
{
|
|
TTree_field& tf = tfield(F_SECTIONS);
|
|
tf.win().force_update();
|
|
|
|
TReport_drawer& rdh = (TReport_drawer&)field(F_REPORTH);
|
|
rdh.win().force_update();
|
|
|
|
TReport_drawer& rd = (TReport_drawer&)field(F_REPORT);
|
|
rd.win().force_update();
|
|
}
|
|
|
|
void TReport_mask::add_field()
|
|
{
|
|
TReport_section& rs = curr_section();
|
|
TReport_field* rf = new TReport_field(&rs);
|
|
rf->set_type('S');
|
|
rf->set_pos(0, rs.compute_size().y);
|
|
TReport_field_mask m(*rf);
|
|
m.disable(DLG_DELREC);
|
|
if (m.run() == K_ENTER)
|
|
{
|
|
m.get_field(*rf);
|
|
rs.add(rf);
|
|
update_report();
|
|
}
|
|
else
|
|
delete rf;
|
|
}
|
|
|
|
void TReport_mask::edit_field(TReport_field& rf)
|
|
{
|
|
TReport_section& rs = rf.section();
|
|
TReport_field_mask m(rf);
|
|
const KEY key = m.run();
|
|
switch(key)
|
|
{
|
|
case K_ENTER:
|
|
m.get_field(rf);
|
|
break;
|
|
case K_DEL:
|
|
{
|
|
for (int i = rs.last(); i >= 0; i--) if (rs.objptr(i) == &rf)
|
|
{
|
|
rs.destroy(i, true);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
if (key != K_ESC)
|
|
{
|
|
_is_dirty = true;
|
|
rs.sort();
|
|
update_report();
|
|
}
|
|
}
|
|
|
|
void TReport_mask::fields_properties()
|
|
{
|
|
TReport_section& rs = curr_section();
|
|
TReport_sheet sheet(rs);
|
|
|
|
int first, last;
|
|
int selected = sheet.selection(first, last);
|
|
if (selected == 1)
|
|
{
|
|
TReport_field& rf = rs.field(first);
|
|
edit_field(rf);
|
|
return;
|
|
}
|
|
|
|
KEY key = K_ENTER;
|
|
while (key != K_ESC)
|
|
{
|
|
key = sheet.run();
|
|
selected = sheet.selection(first, last);
|
|
if (selected == 0 && (key == K_ENTER || key == K_DEL))
|
|
{
|
|
first = last = sheet.selected();
|
|
selected = 1;
|
|
sheet.check(first);
|
|
}
|
|
|
|
switch (key)
|
|
{
|
|
case K_INS:
|
|
add_field();
|
|
break;
|
|
case K_ENTER:
|
|
{
|
|
for (int i = first; i <= last; i++) if (sheet.checked(i))
|
|
{
|
|
TReport_field& rf = rs.field(i);
|
|
edit_field(rf);
|
|
}
|
|
}
|
|
break;
|
|
case K_DEL:
|
|
if (selected > 0 && yesno_box(FR("Comfermare la cancellazione di %d elementi"), selected))
|
|
{
|
|
for (int i = last; i >= first; i--) if (sheet.checked(i))
|
|
rs.destroy(i, true);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
update_report();
|
|
}
|
|
}
|
|
|
|
bool TReport_mask::add_section()
|
|
{
|
|
TMask m(TR("Nuova sezione"), 1, 32, 5);
|
|
m.add_radio(101, 0, "", 1, 0, 22, "H|B", TR("Raggruppamento|Corpo alternativo"), "");
|
|
m.add_button(DLG_OK, 0, "", -12, -1, 10, 2);
|
|
m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
|
|
if (m.run() == K_ENTER)
|
|
{
|
|
const char type = m.get(101)[0];
|
|
int level = 0;
|
|
if (type == 'H')
|
|
{
|
|
const int hl = _report.find_max_level('H');
|
|
const int fl = _report.find_max_level('F');
|
|
level = max(hl, fl) + 1;
|
|
}
|
|
else
|
|
level = _report.find_max_level('B')+1;
|
|
|
|
if (level > 1 && level <= 9)
|
|
{
|
|
_tree.goto_node(type, level);
|
|
tfield(F_SECTIONS).select_current();
|
|
_curr_section = &_report.section(type, level);
|
|
section_properties();
|
|
return true;
|
|
}
|
|
else
|
|
error_box(TR("Livello non ammesso: %d"), level);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void TReport_mask::section_properties()
|
|
{
|
|
TReport_section& rs = curr_section();
|
|
TSection_properties_mask m(rs);
|
|
switch (m.run())
|
|
{
|
|
case K_ENTER:
|
|
m.get_section(rs);
|
|
_tree.goto_node(rs.type(), rs.level());
|
|
_is_dirty = true;
|
|
break;
|
|
case K_DEL:
|
|
if (yesno_box(TR("Confermare l'eliminazione della sezione")))
|
|
{
|
|
const char t = rs.type();
|
|
const int l = rs.level();
|
|
rs.report().kill_section(t, l);
|
|
_tree.goto_node(t, l-1);
|
|
_is_dirty = true;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (_is_dirty)
|
|
select_section();
|
|
}
|
|
|
|
void TReport_mask::report_properties()
|
|
{
|
|
TReport_properties_mask m(_report);
|
|
if (m.run() == K_ENTER)
|
|
{
|
|
m.get_report(_report);
|
|
_is_dirty = true;
|
|
update_report();
|
|
}
|
|
}
|
|
|
|
void TReport_mask::notify_focus_field(short id)
|
|
{
|
|
TAutomask::notify_focus_field(id);
|
|
if (id == F_REPORTH || id == F_REPORT)
|
|
{
|
|
TReport_drawer& rd = (TReport_drawer&)field(id);
|
|
_curr_section = &rd.curr_section();
|
|
}
|
|
}
|
|
|
|
bool TReport_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch (o.dlg())
|
|
{
|
|
case F_CODICE:
|
|
if (e == fe_init)
|
|
{
|
|
if (main_app().argc() >= 3)
|
|
{
|
|
set(F_CODICE, main_app().argv(2));
|
|
load_report();
|
|
}
|
|
}
|
|
if (e == fe_button)
|
|
{
|
|
if (select_report())
|
|
e = fe_modify;
|
|
}
|
|
if (e == fe_modify)
|
|
{
|
|
save_if_needed();
|
|
load_report();
|
|
}
|
|
break;
|
|
case F_SECTIONS:
|
|
if (e == fe_init || e == fe_modify)
|
|
{
|
|
select_section();
|
|
const TReport_section& rs = _tree.curr_section();
|
|
const bool ok = strchr("HBF", rs.type()) != NULL;
|
|
enable(-1, ok);
|
|
}
|
|
break;
|
|
case F_FLD_ADD:
|
|
if (e == fe_button && o.active())
|
|
add_field();
|
|
break;
|
|
case F_FLD_PROPERTIES:
|
|
if (e == fe_button && o.active())
|
|
fields_properties();
|
|
break;
|
|
case F_SEC_ADD:
|
|
if (e == fe_button && o.active())
|
|
add_section();
|
|
break;
|
|
case F_SEC_PROPERTIES:
|
|
if (e == fe_button && o.active())
|
|
section_properties();
|
|
break;
|
|
case F_REP_PROPERTIES:
|
|
if (e == fe_button)
|
|
report_properties();
|
|
break;
|
|
case F_SQL:
|
|
if (e == fe_init || e == fe_modify)
|
|
enable(F_SHOW_QRY, !o.empty());
|
|
break;
|
|
case F_NEW_QRY:
|
|
if (e == fe_button)
|
|
{
|
|
TExternal_app q("ba8 -1");
|
|
q.run();
|
|
}
|
|
break;
|
|
case F_IMPORT_QRY:
|
|
if (e == fe_button)
|
|
select_query();
|
|
break;
|
|
case F_SHOW_QRY:
|
|
if (e == fe_button)
|
|
{
|
|
TRecordset* rex = NULL;
|
|
|
|
const TString& sql = get(F_SQL);
|
|
if (sql.starts_with("SELECT "))
|
|
rex = new TSQL_recordset(sql);
|
|
else
|
|
rex = new TISAM_recordset(sql);
|
|
|
|
if (rex->columns() > 0)
|
|
{
|
|
TRecordset_sheet sht(*rex);
|
|
sht.run();
|
|
}
|
|
else
|
|
warning_box(TR("Nessuna riga risultato"));
|
|
|
|
delete rex;
|
|
}
|
|
break;
|
|
case DLG_PRINT:
|
|
if (e == fe_button)
|
|
{
|
|
on_print();
|
|
return false;
|
|
}
|
|
break;
|
|
case DLG_NEWREC:
|
|
if (e == fe_button)
|
|
{
|
|
save_if_needed();
|
|
global_reset();
|
|
}
|
|
break;
|
|
case DLG_FINDREC:
|
|
if (e == fe_button)
|
|
send_key(K_F9, F_CODICE);
|
|
case DLG_SAVEREC:
|
|
if (e == fe_button)
|
|
{
|
|
get_rep_path(_curr_report);
|
|
save_report();
|
|
}
|
|
break;
|
|
case DLG_DELREC:
|
|
if (e == fe_button && jolly == 0) // Elimina della Toolbar
|
|
{
|
|
delete_report();
|
|
return false; // Do not exit!
|
|
}
|
|
break;
|
|
case DLG_QUIT:
|
|
save_if_needed();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TReport_mask::TReport_mask() : _tree(_report), _is_dirty(false)
|
|
{
|
|
read_mask("ba8300a", 0, -1);
|
|
set_handlers();
|
|
|
|
TTree_field& albero = tfield(F_SECTIONS);
|
|
RCT rct_sec; albero.get_rect(rct_sec);
|
|
|
|
const short sec[2] = { F_REPORT, F_REPORTH };
|
|
for (int s = 0; s < 2; s++)
|
|
{
|
|
TReport_drawer& rd = (TReport_drawer&)field(sec[s]);
|
|
RCT rct_rep; rd.get_rect(rct_rep);
|
|
rct_rep.left = rct_sec.right+ROWY;
|
|
rct_rep.right -= ROWY;
|
|
rct_rep.bottom -= ROWY;
|
|
rd.set_rect(rct_rep);
|
|
|
|
switch (s)
|
|
{
|
|
case 1 : rd.set_report_section(_report.section('H', 0)); break;
|
|
default:
|
|
_curr_section = &_report.section('B', 1);
|
|
rd.set_report_section(*_curr_section);
|
|
break;
|
|
}
|
|
}
|
|
|
|
_tree.goto_node('B',1);
|
|
const int ih = _tree.image_height();
|
|
if (ih > CHARY)
|
|
albero.set_row_height(ih);
|
|
albero.set_tree(&_tree);
|
|
|
|
_tree.goto_root();
|
|
_tree.expand_all();
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TReporter_app
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TReporter_app : public TSkeleton_application
|
|
{
|
|
TReport_mask* _msk;
|
|
|
|
protected:
|
|
virtual bool create();
|
|
virtual void main_loop();
|
|
virtual bool destroy();
|
|
virtual void print();
|
|
|
|
public:
|
|
TReporter_app() : _msk(NULL) { }
|
|
};
|
|
|
|
void TReporter_app::print()
|
|
{
|
|
if (_msk != NULL)
|
|
_msk->on_print();
|
|
}
|
|
|
|
bool TReporter_app::create()
|
|
{
|
|
if (!has_module(RSAUT))
|
|
return error_box(TR("Modulo non autorizzato"));
|
|
|
|
_msk = new TReport_mask;
|
|
xvt_sys_sleep(500);
|
|
return TSkeleton_application::create();
|
|
}
|
|
|
|
bool TReporter_app::destroy()
|
|
{
|
|
if (_msk != NULL)
|
|
{
|
|
delete _msk;
|
|
_msk = NULL;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TReporter_app::main_loop()
|
|
{
|
|
_msk->run();
|
|
}
|
|
|
|
int ba8300(int argc, char* argv[])
|
|
{
|
|
TReporter_app app;
|
|
app.run(argc, argv, TR("Report Generator"));
|
|
return 0;
|
|
}
|