campo-sirio/include/reprint.cpp

#include <automask.h>
#include <defmask.h>
#include <diction.h>
#include <printer.h>
#include <reprint.h>
#include <statbar.h>

#include <bagn003.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; }