campo-sirio/ba/ba8300.cpp

#include <xinclude.h>

#include <applicat.h>
#include <automask.h>
#include <colors.h>
#include <defmask.h>
#include <execp.h>
#include <prefix.h>
#include <printer.h>

#include "ba8201.h"
#include "ba8300.h"
#include "ba8301.h"
#include "ba8303.h"
#include <bagn003.h>

///////////////////////////////////////////////////////////
// Utility
///////////////////////////////////////////////////////////

static TString8 _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();
}

///////////////////////////////////////////////////////////
// TFont_button_mask
///////////////////////////////////////////////////////////

class TFont_button_mask : public TAutomask
{
  TReport_font _font;
  bool _font_changed;

protected:
  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;
  
  TFont_button_mask(const char* name);
};

void TFont_button_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 TFont_button_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  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;
  default:
    break;
  }
  return true;
}

void TFont_button_mask::set_font_info(const TReport_font& font)
{
  _font = font;
}

bool TFont_button_mask::get_font_info(TReport_font& font) const
{
  const bool ok = _font_changed;
  if (ok)
    font = _font;
  return ok;
}

TFont_button_mask::TFont_button_mask(const char* name) 
                 : TAutomask(name), _font_changed(false),
                   _halign('C'), _valign('C'),
                   _fgcolor(COLOR_BLACK), _bgcolor(COLOR_WHITE)
{
}

///////////////////////////////////////////////////////////
// TReport_field_mask
///////////////////////////////////////////////////////////

class TReport_field_mask : public TFont_button_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() :TFont_button_mask("ba8300b") { }
};

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);
    }
  }
  TFont_button_mask::update();
}

void TReport_field_mask::vedo_non_vedo()
{
  const char type = get(F_TYPE)[0];
  const bool is_text = strchr("DNPSTV", type) != NULL;
  
  show(F_HIDE_ZEROES, strchr("NPV", type) != NULL),
  show(F_HALIGN,      is_text);
  show(F_VALIGN,      is_text);
  show(F_TEXT,        is_text);
  show(F_FGCOLOR,     type != 'I');
  show(F_BGCOLOR,     type != 'L' && type != 'I');
  show(F_FONT_SELECT, is_text);
  show(F_SOURCE,      (is_text || type == 'I') && type != 'T');

  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();
    break;
  case F_X:
  case F_Y:
  case F_DX:
  case F_DY:
    if (e == fe_modify)
    {
      const int num = get_num(o.dlg());
      set_num(o.dlg(), num); // Reformat
    }
    break;
  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;
  default:
    break;
  }
  return TFont_button_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_GROUPS, rf.groups());

  str[0] = rf.horizontal_alignment();
  set(F_HALIGN, str);
  str[0] = rf.vertical_alignment();
  set(F_VALIGN, str);
  set(F_BORDER, rf.border());
  _fgcolor = rf.fore_color();
  _bgcolor = rf.back_color();
  set(F_TEXT, rf.picture());
  set(F_SOURCE, rf.field());
  set_font_info(rf.font());
  
  set(F_PRESCRIPT, rf.prescript());
  set(F_POSTSCRIPT, rf.postscript());
}

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(get_bool(F_HIDE_ZEROES));
  rf.set_groups(get(F_GROUPS));

  rf.set_horizontal_alignment(get(F_HALIGN)[0]);
  rf.set_vertical_alignment(get(F_VALIGN)[0]);
  rf.set_border(get_int(F_BORDER));
  rf.set_fore_color(_fgcolor);
  rf.set_back_color(_bgcolor);
  rf.set_picture(get(F_TEXT));
  rf.set_field(get(F_SOURCE));
  TReport_font f;
  if (get_font_info(f))
    rf.set_font(f);
  
  rf.set_prescript(get(F_PRESCRIPT));
  rf.set_postscript(get(F_POSTSCRIPT));
}

///////////////////////////////////////////////////////////
// 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 TFont_button_mask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  void set_num(short id, short num);
  short get_num(short id) const;

  void vedo_non_vedo();

public:
  void set_section(const TReport_section& rs);
  void get_section(TReport_section& rs) const;
  
  TSection_properties_mask();
};

void TSection_properties_mask::set_num(short id, short 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);
  show(F_GROUP_BY, type == 'H' && level > 1);
  show(F_HIDE_IF_NEEDED, level == 0 && type != 'B');
  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 TFont_button_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());

  set_num(F_DX, rs.width());  
  set_num(F_DY, rs.height());
 
  set(F_GROUP_BY, rs.grouped_by());
  set(F_HIDE_IF_NEEDED, rs.hidden_if_needed() ? "X" : "");
  set(F_HIDDEN, rs.hidden() ? "X" : "");
  set(F_DISABLED, rs.deactivated() ? "X" : "");

  set_font_info(rs.font());
  set(F_PRESCRIPT, rs.prescript());
  set(F_POSTSCRIPT, rs.postscript());

  vedo_non_vedo();
}

void TSection_properties_mask::get_section(TReport_section& rs) const
{
  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.group_by(get(F_GROUP_BY));
  rs.hide_if_needed(get_bool(F_HIDE_IF_NEEDED));

  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() 
                        : TFont_button_mask("ba8300c")
{ }

///////////////////////////////////////////////////////////
// TReport_properties_mask
///////////////////////////////////////////////////////////

class TReport_properties_mask : public TFont_button_mask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  void set_report(const TReport& r);
  void get_report(TReport& r) const;
  TReport_properties_mask() : TFont_button_mask("ba8300d") { }
};

bool TReport_properties_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return TFont_button_mask::on_field_event(o, e, jolly);
}

void TReport_properties_mask::set_report(const TReport& r)
{
  set(F_DY, r.lpi());
  set_font_info(r.font());
  set(F_PRESCRIPT, r.prescript());
  set(F_POSTSCRIPT, r.postscript());
}

void TReport_properties_mask::get_report(TReport& r) const
{
  r.set_lpi(get_int(F_DY));

  TReport_font f;
  if (get_font_info(f))
    r.set_font(f);
  r.set_prescript(get(F_PRESCRIPT));
  r.set_postscript(get(F_POSTSCRIPT));
}

///////////////////////////////////////////////////////////
// TReport_mask
///////////////////////////////////////////////////////////

class TReport_mask : public TAutomask
{
  TReport _report;
  TReport_tree _tree;
  TFilename _curr_report;
  bool _is_dirty;

protected:
  virtual TMask_field* parse_field(TScanner& scanner);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

protected:
  bool select_query();
  bool select_report();
  void update_report() const;

  TReport_section& curr_section();
  void add_field();
  void edit_field(TReport_field& rf);
  void fields_properties();
  void 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 = 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();
      update_report();
    }
  }

  return ok;
}

bool TReport_mask::delete_report()
{
  TFilename path; get_rep_path(path);
  const bool ok = 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()
{
  TReport_printer rp(_report);
  rp.print(printer().printtype() == screenvis);
}

TReport_section& TReport_mask::curr_section()
{
  TTree_field& sections = tfield(F_SECTIONS);
  sections.goto_selected();
  return _tree.curr_section();
}

void TReport_mask::update_report() const
{
  TTree_field& tf = tfield(F_SECTIONS); 
  tf.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_mask m;
  TReport_field* rf = new TReport_field(&rs);
  m.set_field(*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_field_mask m;
  m.set_field(rf);
  const KEY key = m.run();
  switch(key)
  {
    case K_ENTER: 
      m.get_field(rf); 
      break;
    case K_DEL: 
      {
        TReport_section& rs = rf.section();
        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;
    rf.section().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();
  }
}

void 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();
      section_properties();
    }
    else
      error_box(TR("Livello non ammesso: %d"), level);
  }
}

void TReport_mask::section_properties()
{
  TReport_section& rs = curr_section();
  TSection_properties_mask m;
  m.set_section(rs);
  switch (m.run())
  {
  case K_ENTER: 
    m.get_section(rs); 
    _is_dirty = true;
    break;
  case K_DEL: 
    {
      const char t = rs.type();
      const int l = rs.level();
      rs.report().kill_section(t, l); 
      _tree.goto_node(t, l-1);
      tfield(F_SECTIONS).select_current();
      _is_dirty = true;
    }
    break;
  default: 
    break;
  }
  if (_is_dirty)
    update_report();
}

void TReport_mask::report_properties()
{
  TReport_properties_mask m;
  m.set_report(_report);
  if (m.run() == K_ENTER)
  {
    m.get_report(_report); 
    _is_dirty = true;
    update_report();
  }
}


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)
    {
      update_report();
      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)
    {
      TSQL_recordset qry(get(F_SQL));
      if (qry.columns() > 0)
      {
        TRecordset_sheet sheet(qry);
        sheet.run();
      }
    }
    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);
  RCT rct_rep; field(F_REPORT).get_rect(rct_rep);
  rct_rep.left = rct_sec.right+ROWY;
  rct_rep.right -= ROWY;
  rct_rep.bottom -= ROWY;
  field(F_REPORT).set_rect(rct_rep);

  _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();

  TReport_drawer& rd = (TReport_drawer&)field(F_REPORT);
  rd.set_report(&_report);
}

///////////////////////////////////////////////////////////
// TReporter_app 
///////////////////////////////////////////////////////////

class TReporter_app : public TSkeleton_application
{
  TReport_mask* _msk;

protected:
  virtual void print();
  virtual void main_loop();
};

void TReporter_app::print()
{
  if (_msk != NULL)
    _msk->on_print();
}

void TReporter_app::main_loop()
{
  _msk = new TReport_mask;
  _msk->run();
  delete _msk;
  _msk = NULL;
}

int ba8300(int argc, char* argv[])
{     
  TReporter_app app;
  app.run(argc, argv, TR("Report Generator"));
  return 0;
}