#include <msksheet.h>
#include <real.h>
#include <urldefid.h>
#include <utility.h>

const short FIRST_FIELD = 101;

#if XVT_OS == XVT_OS_WIN

#include <xil.h>
#include <colors.h>

///////////////////////////////////////////////////////////
// TSpreadsheet
// /////////////////////////////////////////////////////////

#define K_PLUS '+'

class TSpreadsheet:public TWindow
{
  enum
    {
      ITF_CID = 0, LIST_CID = 1
    };

  TArray _str;                  // Array di TToken_strings

  TBit_array _column_disabled;
  TArray _disabled;             // Array di TBit_array

  TMask _mask;
  int _columns;
  bool _dirty;

  XI_OBJ *_list;

  SPREADSHEET_NOTIFY _notify;

  static void xiev_handler (XI_OBJ * itf, XI_EVENT * xiev);
  void init ();

    protected:
  void list_handler (XI_EVENT * xiev);

  TMask_field *cell2field (const XI_OBJ * cell) const;
  void update_rec (int rec);
  void set_focus_cell (int riga, int colonna);

  void mask2str (int n);
  void str2mask (int n);
  KEY edit (int n);

  TMask_field *field (short id) const;

  int rec2row (int rec);
  int row2rec (int row);

  bool notify (int r, KEY k);

    public:
  void update (int row);

    TToken_string & row (int n);
    TArray & rows_array () const
  {
    return (TArray &) _str;
  }
  int add (TToken_string &);
  int insert (int rec);
  bool destroy (int rec = -1);

  void enable_column (int col, bool on = TRUE);
  void enable_cell (int row, int column, bool on = TRUE);
  bool cell_disabled (int row, int column) const;

    TMask & mask ()
  {
    return _mask;
  }

  int items () const
  {
    return _str.items ();
  }

  int columns () const
  {
    return _columns;
  }

  bool dirty () const
  {
    return _dirty;
  }

  void set_notify (SPREADSHEET_NOTIFY n)
  {
    _notify = n;
  }

  void set_dirty (bool spork = TRUE)
  {
    _dirty = spork;
    }

    TSpreadsheet (short x, short y, short dx, short dy, const char *maskname, int maskno,
                  const char *head, WINDOW parent);
    };

// Certified 99%
void TSpreadsheet ::init ()
    {
    static bool first = TRUE;

    if (!first) return;

    xvt_set_font (TASK_WIN, FF_FIXED, 0);
    DRAW_CTOOLS ct;
    win_get_draw_ctools (TASK_WIN, &ct);
    xi_set_font (&ct.font);

    xi_init ();
    xi_set_pref (XI_PREF_3D_LOOK, TRUE);
// xi_set_pref(XI_PREF_COLOR_LIGHT, COLOR_CYAN);
  // xi_set_pref(XI_PREF_COLOR_CTRL, MASK_BACK_COLOR);
  // xi_set_pref(XI_PREF_COLOR_DARK, COLOR_GRAY);

    first = FALSE;
    }

TSpreadsheet ::TSpreadsheet (short x, short y, short dx, short dy,
                  const char *maskname, int maskno,
                  const char *head, WINDOW parent)
:  _mask (maskname, NO_MODE, maskno), _notify (NULL)

    {
    const int NUMBER_WIDTH = 3;
    const int MAX_COL = 32;
    int width[MAX_COL];

    init ();

  // Calcolo larghezza massima tabella

    TToken_string header (head);
    TToken_string new_header (256);
    int i = 0, tot_width = NUMBER_WIDTH + 1;
    for (const char *h = header.get (); h; h = header.get (), i++)
    {
    CHECKD (i < MAX_COL, "Tu meni calumns in scit: ", i);
    int w;
    char *at = strchr (h, '@');
    if (at)
    {
    w = atoi (at + 1);
    *at = '\0';
    }
    else
    w = strlen (h);

    width[i] = w + 1;

    const int cid = FIRST_FIELD + i;	// Column & Field ID
     const TMask_field * f = field (cid);	// Field on mask
     CHECKD (f, "The spreadsheet mask needs ALSO field ", cid);
    if (f->has_query ())w += 2;

    tot_width += w;
    new_header.add (h);
    }
    _columns = i;

    if (x < 0) x = 0;
    if (y < 0) y = 0;
    if (dx == 0)
    {
    dx = tot_width;
    if (dx > 76) dx = -x;
    }

    RCT rct = resize_rect (x, y, dx, dy, WO_TE, parent);
    rct.right -= 20;
    rct.bottom -= 8;

    XI_OBJ_DEF * itfdef = xi_create_itf_def (ITF_CID,
		   (XI_EVENT_HANDLER) xiev_handler, &rct, (char *) maskname,
					     PTR_LONG (this));
    itfdef->v.itf->automatic_back_color = FALSE;
    itfdef->v.itf->back_color = MASK_BACK_COLOR;

    XI_OBJ_DEF * listdef = xi_add_list_def (itfdef, LIST_CID,
					    0, 0, rct.bottom - rct.top,
					    XI_ATR_ENABLED | XI_ATR_VISIBLE,
					    NORMAL_COLOR, NORMAL_BACK_COLOR,
			    NORMAL_COLOR, DISABLED_BACK_COLOR, NORMAL_COLOR,
					    LIST_CID);
    listdef->v.list->scroll_bar = TRUE;
    listdef->v.list->sizable_columns = TRUE;
    listdef->v.list->movable_columns = TRUE;
    listdef->v.list->scroll_bar_button = TRUE;
    listdef->v.list->fixed_columns = 1;
    listdef->v.list->width = rct.right - rct.left;
    listdef->v.list->min_cell_height = CHARY;
    listdef->v.list->min_heading_height = CHARY;
    listdef->v.list->white_space_color = COLOR_GRAY;

    XI_OBJ_DEF * coldef = xi_add_column_def (listdef, 0,
			   XI_ATR_RJUST, 0, NUMBER_WIDTH, NUMBER_WIDTH, "");
    coldef->v.column->heading_platform = TRUE;
    coldef->v.column->column_platform = TRUE;
    coldef->v.column->center_heading = TRUE;

    for (h = new_header.get (0), i = 0; h; h = new_header.get (), i++)
    {
    const int cid = FIRST_FIELD + i;	// Column & Field ID
     const TMask_field * f = field (cid);	// Field on mask
     const int w = width[i] + (f->has_query ()? 2 : 0);		// Column
    // width

    long flags = XI_ATR_EDITMENU | XI_ATR_AUTOSCROLL;
    if (f->class_id () == CLASS_REAL_FIELD) flags |= XI_ATR_RJUST;
    if (f->active ())flags |= XI_ATR_ENABLED;
    else
    _column_disabled.set (i);

    coldef = xi_add_column_def (listdef, cid,
				flags, cid, w, width[i], (char *) h);
    coldef->v.column->heading_platform = TRUE;
    coldef->v.column->center_heading = TRUE;
    }

    RCT itfrct;
    xi_get_def_rect (itfdef, &itfrct);
    offset_rect (&itfrct, rct.left, rct.top);
    itfrct.bottom++;

    WINDOW win = create_window (W_NO_BORDER, &itfrct, "", 0, parent,
				0, EM_ALL, (EVENT_HANDLER) xi_event, 0L);
    CHECK (win, "Can't create a window for the spreadsheet");

    set_win (win);		// Set TWindow::_win
     itfdef->v.itf->win = win;

    xi_create (NULL, itfdef);
    xi_tree_free (itfdef);

    XI_OBJ * itf = xi_get_itf (win);
    _list = xi_get_obj (itf, LIST_CID);
    }

// Converts a row number in the correspondig record number
int TSpreadsheet ::row2rec (int row)
    {
    int rows;
    const long *rec = xi_get_list_info (_list, &rows);

#ifdef DBG
    if (row < 0 || row >= rows)
    {
    error_box ("Line %d is not visible", row);
    return 0L;
    }
#endif

    return (int) rec[row];
    }

// Converts a row number in the correspondig record number
int TSpreadsheet ::rec2row (int record)
    {
    int rows;
    const long *rec = xi_get_list_info (_list, &rows);
    int r = int (record - rec[0]);
    if (r < 0 || r >= rows)
    r = -1;

    return r;
    }

// Retrieves the corresponding field of the mask from a spredsheet cell
TMask_field * TSpreadsheet ::cell2field (const XI_OBJ * cell) const
    {
    const int pos = cell->v.cell.column;

    int num;
    XI_OBJ ** column = xi_get_member_list (_list, &num);

    TMask_field * good = NULL;
    for (short id = column[pos]->cid;; id += 100)
    {
    TMask_field * f = field (id);
    if (f == NULL) break;
    good = f;
    if (f->active ())break;
    }

    return good;
    }

void TSpreadsheet ::update_rec (int rec)
    {
    const int riga = rec2row (rec);
    if (riga >= 0)
    {
    XI_OBJ row;
    XI_MAKE_ROW (&row, _list, riga);
    xi_cell_request (&row);	// Update internal values
     xi_set_row_height (&row, CHARY + 1);	// Force row updating
    }
    }

void TSpreadsheet ::set_focus_cell (int riga, int colonna)
    {
    set_front_window (win ());
    XI_OBJ cell;
    XI_MAKE_CELL (&cell, _list, rec2row (riga), colonna);
    xi_set_focus (&cell);
    }

int TSpreadsheet ::insert (int rec)
    {
    const bool ok = notify (rec, K_INS);
    if (!ok) return -1;

    TToken_string s;		// Empty row
     const int r = _str.insert (s, rec);
    _disabled.insert (NULL, rec);

    xi_insert_row (_list, INT_MAX);
    xi_cell_request (_list);

    return r;
    }

bool TSpreadsheet ::destroy (int rec)
    {
    bool ok = TRUE;

    if (rec < 0)
    {
    _disabled.destroy ();
    _str.destroy ();
    }
    else
    {
    _disabled.destroy (rec, TRUE);	// Destroy enable info
     ok = _str.destroy (rec, TRUE);	// Destroy line
     enable_cell (_str.items (), -1);	// Enable last line
    }

    if (ok) xi_cell_request (_list);

    return ok;
    }

void TSpreadsheet ::update (int row)
    {
    if (row < 0)
    {
    xi_cell_request (_list);
    xi_scroll (_list, XI_SCROLL_FIRST);
    set_front_window (win ());
    }
    else
    update_rec (row);
    }

void TSpreadsheet ::xiev_handler (XI_OBJ * itf, XI_EVENT * xiev)
    {
    TSpreadsheet * es = (TSpreadsheet *) xi_get_app_data (itf);
    CHECK (es, "NULL Edit sheet in xi event");
    es->list_handler (xiev);
    }

// Certified 75%
void TSpreadsheet ::list_handler (XI_EVENT * xiev)
    {
    static TMask_field * edit_field = NULL;	// Current edit field
     static int cur_row = 0, cur_col = 0;	// Current cell
     static bool row_dirty = FALSE;	// Current row changed
     static bool check_enabled = TRUE;	// Perform OFF_ROW checks

    switch (xiev->type)
    {
case XIE_GET_FIRST:
    {
    const long max = items ();
    if (max <= 0L)
    {
    xiev->refused = TRUE;
    break;
    }
    long n = max * (long)xiev->v.rec_request.percent / 100L;
    if (n < 0L) n = 0L;
    xiev->v.rec_request.data_rec = n;
    }
    break;
case XIE_GET_LAST:
    xiev->v.rec_request.data_rec = items () - 1;
    break;
case XIE_GET_PREV:
case XIE_GET_NEXT:
    {
    const long n = xiev->v.rec_request.spec_rec +
    (xiev->type == XIE_GET_NEXT ? +1 : -1);
    if (n < 0 || n >= items ())
    xiev->refused = TRUE;
    else
    xiev->v.rec_request.data_rec = n;
    }
    break;
case XIE_CELL_REQUEST:
    {
    const int rec = (int)xiev->v.cell_request.rec;
    const char *src = NULL;
    int nm;
    XI_OBJ ** obj = xi_get_member_list (xiev->v.cell_request.list, &nm);
    const int num = xiev->v.cell_request.col_nbr;
    const int cid = obj[num]->cid;

    if (cid >= FIRST_FIELD)
    {
    if (rec < items ())
    {
    const int col = cid - FIRST_FIELD;
    TMask_field * f = field (cid);
    src = row (rec).get (col);	// Set value for cell
     if (src && *src && f->class_id () == CLASS_REAL_FIELD)
    {
    src = f->picture_data (src, FALSE);		// Get formatted string
    }
    if (field (cid)->has_query ())
    {
    xiev->v.cell_request.button =
    xiev->v.cell_request.button_on_focus = TRUE;
    }
    if (cell_disabled (rec, col))
    xiev->v.cell_request.back_color = MASK_BACK_COLOR;
    }
    }
    else
    src = format ("%d", rec + 1);

    const int len = xiev->v.cell_request.len;
    char *dst = xiev->v.cell_request.s;
    if (src)
    {
    strncpy (dst, src, len);
    if (isspace (*dst))
    {
    TFixed_string d (dst);
    d.ltrim ();
    }
    }
    else
    *dst = '\0';
    }
    break;
case XIE_BUTTON:
    if (xiev->v.xi_obj->type == XIT_CELL)
    {
    if (edit_field)
    {
    const char *val = xi_get_text (xiev->v.xi_obj, NULL, -1);
    edit_field->set (val);	// Update current cell
     check_enabled = FALSE;	// Disable checks
     if (!row_dirty) notify (cur_row, K_SPACE);
    if (edit_field->on_key (K_F9))	// Show search sheet
     {
    mask2str (cur_row);		// Update row
     row_dirty = TRUE;
    }
    check_enabled = TRUE;	// Enable checks
     xi_set_focus (xiev->v.xi_obj);	// Restore focus to cell
    }
    }
    else
    if (xiev->v.xi_obj->type == XIT_LIST)
    insert (-1);
    break;
case XIE_DBL_CELL:
    {
    check_enabled = FALSE;
    cur_row = row2rec (xiev->v.xi_obj->v.cell.row);
    cur_col = xiev->v.xi_obj->v.cell.column;
    const KEY k = edit (cur_row);
    if (k == K_ENTER)
    {
    update_rec (cur_row);
    row_dirty = TRUE;
    }
    xi_set_focus (xiev->v.xi_obj);
    check_enabled = TRUE;
    }
    break;
case XIE_ON_ROW:
    {
    const int rec = row2rec (xiev->v.xi_obj->v.row);
    if (rec < items ())
    {
    cur_row = rec;
    str2mask (rec);
    row_dirty = FALSE;
    }
    else
    xiev->refused = TRUE;
    }
    break;
case XIE_OFF_ROW:
    if (row_dirty && check_enabled)
    {
    check_enabled = FALSE;	// Avoid recursion!
     set_dirty ();
    str2mask (cur_row);		// It shouldn't have to be necessary
     bool ok = _mask.check_fields ();
    if (ok)
    {
    mask2str (cur_row);
    ok = notify (cur_row, K_ENTER);	// Notify edit
    }
    else
    {
    xiev->refused = TRUE;
    set_dirty (2);		// Set error status
     set_focus_cell (cur_row, cur_col);
    }
    check_enabled = TRUE;
    }
    break;
case XIE_ON_CELL:
    {
    TMask_field * f = cell2field (xiev->v.xi_obj);
    const int col = (f->dlg () - FIRST_FIELD) % 100;
    if (!cell_disabled (cur_row, col))
    {
    edit_field = f;
    cur_col = xiev->v.xi_obj->v.cell.column;
    xi_set_color (xiev->v.xi_obj, XIC_BACK, FOCUS_BACK_COLOR);
    }
    else
    {
    xiev->refused = TRUE;	// Refuse focus on disabled cells
    }
    }
    break;
case XIE_OFF_CELL:
    if (edit_field && check_enabled)
    {
    TMask_field * c = edit_field;	// Save field, it could turn out to
      // be NULL on error
     const TString80 old (c->get ());	// Save old value on mask
     const TString80 nuo (c->picture_data (xi_get_text (xiev->v.xi_obj, NULL, -1), TRUE));
    if (old != nuo)
    {
    check_enabled = FALSE;
    if (!row_dirty)
    {
    notify (cur_row, K_SPACE);
    row_dirty = TRUE;
    }
    c->set (nuo);		// Set new mask value
     c->set_dirty ();		// Get it dirty!
     if (c->on_key (K_TAB) == FALSE)	// Test it
     {
    c->set (old);
    xi_set_focus (xiev->v.xi_obj);
    }
    else
    {
    mask2str (cur_row);		// Update sheet row
     edit_field = NULL;		// Reset current field
    }
    check_enabled = TRUE;
    }
    xi_set_color (xiev->v.xi_obj, XIC_BACK, NORMAL_BACK_COLOR);
    }
    break;
case XIE_GET_PERCENT:
    {
    const long rec = xiev->v.get_percent.record;
    long n = items (); if (n < 1) n = 1;
    xiev->v.get_percent.percent = int (rec * 100L / n);
    }
    break;
case XIE_CLEANUP:
    set_win (NULL_WIN);
    break;
case XIE_XVT_EVENT:
    {
    EVENT * ep = &xiev->v.xvte;
    switch (ep->type)
    {
case E_FOCUS:
    if (ep->v.active == FALSE)
    {
    XI_OBJ * itf = xi_get_itf (win ());
    const bool ok = (bool) xi_move_focus (itf);
    if (!ok)
    xiev->refused = TRUE;
    }
    break;
case E_CHAR:
    if (edit_field)
    {
    const KEY k = e_char_to_key (ep);
    switch (k)
    {
case K_F1:
    check_enabled = FALSE;	// Disable checks
     edit_field->on_key (K_F1);
    set_focus_cell (cur_row, cur_col);
    check_enabled = TRUE;	// Enable checks
	    // xiev->refused = TRUE;
     break;
case K_F2:
case K_F3:
case K_F8:
case K_F9:
    {
    check_enabled = FALSE;	// Disable checks
     if (!row_dirty) notify (cur_row, K_SPACE);
    if (edit_field->on_key (k))
    {
    mask2str (cur_row);
    row_dirty = TRUE;
    }
    set_focus_cell (cur_row, cur_col);
    check_enabled = TRUE;	// Enable checks
    }
    break;
case K_PLUS:
    insert (cur_row);
    xiev->refused = TRUE;
    break;
case K_PREV:
    xi_scroll (_list, XI_SCROLL_PGUP);
//       xiev->refused = TRUE;
    break;
case K_NEXT:
    xi_scroll (_list, XI_SCROLL_PGDOWN);
//       xiev->refused = TRUE;
    break;
case K_HOME:
    xi_scroll (_list, XI_SCROLL_FIRST);
//       xiev->refused = TRUE;
    break;
case K_END:
    xi_scroll (_list, XI_SCROLL_LAST);
//       xiev->refused = TRUE;
    break;
default:
    break;
    }
    }
    break;
default:
    break;
    }
    }
    break;
default:
    break;
    }
    }

int TSpreadsheet ::add (TToken_string & t)
    {
    return _str.add (t);
    }

TToken_string & TSpreadsheet ::row (int n)
    {
    return (TToken_string &) _str[n];
    }

#else

#include <sheet.h>

///////////////////////////////////////////////////////////
// TSpreadsheet
// /////////////////////////////////////////////////////////

class TSpreadsheet:public TArray_sheet
{
  TMask _mask;
  SPREADSHEET_NOTIFY _notify;
  bool _dirty;

  TBit_array _column_disabled;
  TArray _disabled;		// Array di TBit_array

    protected:
    virtual bool on_key (KEY key);
  KEY edit (int n);
  bool notify (int r, KEY k);

  TMask_field *field (short id) const;

  void mask2str (int riga);
  void str2mask (int riga);

    public:
    TSpreadsheet (short x, short y, short dx, short dy, const char *maskname, int maskno,
		  const char *head, WINDOW parent);

    TArray & rows_array () const
  {
    return data ();
  }

  TMask & mask ()
  {
    return _mask;
  }
  void set_notify (SPREADSHEET_NOTIFY n)
  {
    _notify = n;
  }
  void set_dirty (bool spork = TRUE)
  {_dirty = spork;
   }
   bool dirty ()const
   {
   return _dirty;
   }

   void enable_column (int col, bool on);
   void enable_cell (int row, int column, bool on = TRUE);
   bool cell_disabled (int row, int column) const;
   };

TSpreadsheet ::TSpreadsheet (short x, short y, short dx, short dy,
		 const char *maskname, int maskno,
		 const char *head, WINDOW parent)
   :TArray_sheet (x, y, dx, dy, maskname, head, 0, parent),
   _mask (maskname, NO_MODE, maskno), _notify (NULL)
   {
   }

bool TSpreadsheet ::on_key (KEY k)
   {
   switch (k)
   {
case K_SHIFT_ENTER:
case K_ESC:
   mask ().send_key (k, 0);
   return TRUE;
case K_ENTER:			// Selezione riga per editing

   if (items () < 1) k = K_INS;	// Se vuoto crea riga da editare 
 case K_INS:
case 'A':			// Aggiunge dopo

case 'I':			// Aggiunge prima

   {
   int n = (int)selected ();
   if (k != K_ENTER)
   {
   if (k == K_INS) n = items ();
   else				// Aggiunge alla fine

   if (k == 'A') n++;

   if (n < 0) n = 0;
   else
   if (n > items ())n = items ();	// Controlla range n 

   if (notify (n, K_INS) == FALSE)	// Chiede l'ok alla applicazione
    return FALSE;

   insert (TToken_string (80), n);	// Aggiunge una riga vuota
    k = K_INS;			// Inserimento in corso
   }

   edit (n);			// Edita riga selezionata o creata

   set_front_window (win ());	// Aggiorna sheet a video
    open ();
   }
   break;
case K_TAB:
case K_BTAB:
case K_SHIFT_TAB:
   dispatch_e_char (get_parent (win ()), k);
   return TRUE;
default:
   break;
   }

return TArray_sheet ::on_key (k);
   }

#endif

TMask_field * TSpreadsheet ::field (short id) const
   {
   const int pos = _mask.id2pos (id);
   if (pos < 0) return NULL;
   return &_mask.fld (pos);
   }

void TSpreadsheet ::mask2str (int riga)
   {
   TToken_string & r = row (riga);
   r.cut (0);
   for (short id = FIRST_FIELD;; id++)
   {
   const int pos = _mask.id2pos (id);
   if (pos < 0) break;
   r.add (_mask.fld (pos).get ());
   }
#if XVT_OS == XVT_OS_WIN
   update_rec (riga);
#endif
   }

// Certified 50%
void TSpreadsheet ::enable_cell (int row, int column, bool on)
   {
   TBit_array * ba = (TBit_array *) _disabled.objptr (row);
   if (ba == NULL)
   {
   if (on) return;		// Don't waste time and memory
    ba = new TBit_array (_column_disabled);
   _disabled.add (ba, row);
   }

   if (column >= 0)
   ba->set (column, !on);
   else
   {
   if (on)
   _disabled.destroy (row, FALSE);	// Let's save some memory!
    else
   {
#if XVT_OS == XVT_OS_WIN
   ba->set (_columns);		// Force right array size
#else
   ba->set (32);		// Force array size
#endif
   ba->set ();			// Set all bits
   }
   }
   }

void TSpreadsheet ::enable_column (int col, bool on)
   {
   _column_disabled.set (col, !on);
   }

// Certified 99%
bool TSpreadsheet ::cell_disabled (int row, int column) const
   {
   TBit_array * ba = (TBit_array *) _disabled.objptr (row);
   if (ba == NULL) return _column_disabled[column];	// Use default
    return (*ba)[column];
   }

// Certified 75%
void TSpreadsheet ::str2mask (int riga)
   {
   if (riga == items ())
   {
   _mask.reset ();
   mask2str (riga);
   return;
   }
   TToken_string & r = row (riga);
   r.restart ();

   TString80 val;
   for (short id = FIRST_FIELD;; id++)
   {
   int pos = _mask.id2pos (id);
   if (pos < 0) break;

   val = r.get ();		// Value to set

   int rid = id;
   while (pos >= 0)
   {
   TMask_field & f = _mask.fld (pos);
   f.set (val);
   f.enable (!cell_disabled (riga, id - FIRST_FIELD));
   if (f.active () || f.ghost ())
   {
   if (f.has_check ())f.check (STARTING_CHECK);
   f.on_hit ();
   }
   f.set_dirty (FALSE);

   rid += 100;
   pos = _mask.id2pos (rid);
   }
   }

   _mask.set_caption (format ("Riga %d", riga + 1));
   }

// Certified 100%
bool TSpreadsheet ::notify (int n, KEY k)
   {
   return _notify ? _notify (n, k) : TRUE;
   }

// Certified 99%
KEY TSpreadsheet ::edit (int n)
   {
   str2mask (n);
   notify (n, K_SPACE);		// Notifica intenzione di modificare
    const KEY k = _mask.run ();
   if (k == K_ENTER)
   {
   mask2str (n);
   }
   else
   if (k == K_DEL)
   {
   const bool ok = notify (n, K_DEL);	// Notifica intenzione di cancellare
    if (ok)
   {
   destroy (n);
   str2mask (n);
   }
   }
   return k;
   }

///////////////////////////////////////////////////////////
// TSheet_field
// /////////////////////////////////////////////////////////

// Certified 100%
TSheet_field ::TSheet_field (TMask * m)
: TMask_field (m), _sheet (NULL)
   {
   }

// Certified 100%
word TSheet_field ::class_id ()const
   {
   return CLASS_SHEET_FIELD;
   }

// Certified 100%
TSheet_field ::~TSheet_field ()
   {
   CHECK (_sheet, "Can't delete NULL sheet");
   delete _sheet;
   }

// Certified 100%
void TSheet_field ::reset ()
   {
   _sheet->destroy ();
   }

void TSheet_field ::parse_head (TScanner & scanner)
   {
   _width = scanner.integer ();
   _size = scanner.integer ();
   if (_size == 0) _size = -1;
   }

// Certified 100%
bool TSheet_field ::parse_item (TScanner & scanner)
   {
   if (scanner.key () == "IT")
   {
   _head.add (scanner.string ());
   return TRUE;
   }
return TMask_field ::parse_item (scanner);
   }

// Certified 100%
void TSheet_field ::create (WINDOW parent)
   {
   const TMask & m = mask ();
   _sheet = new TSpreadsheet (_x, _y, _width, _size, m.source_file (), m.sheets (),
			      _head, parent);

   _win = _sheet->win ();
   enable_window (_win, enabled ());
   show_window (_win, showed ());
   }

// Certified 100%
TArray & TSheet_field ::rows_array ()const
   {
   return _sheet->rows_array ();
   }

// Certified 100%
// Ritorna l'indice della prima riga vuota dello sheet
int TSheet_field ::first_empty ()const
   {
   const int max = _sheet->items ();
   for (int n = 0; n < max; n++)
   if (_sheet->row (n).empty_items ())
   break;
   return n;
   }

TToken_string & TSheet_field ::row (int n)
   {
   const int max = _sheet->items ();
   if (n < 0 || n >= max)
   {
   if (n < 0) n = first_empty ();
   if (n >= max) n = _sheet->add (TToken_string (80));
   }
   return _sheet->row (n);
   }

void TSheet_field ::force_update (int r)
   {
#if XVTWS == WMWS
   _sheet->open ();
#else
   _sheet->update (r);
#endif
   }

void TSheet_field ::set_window_data (const char *)
   {
   _sheet->set_dirty (FALSE);
   set_dirty (FALSE);
   }

void TSheet_field ::set_field_data (const char *)
   {
   set_dirty (_sheet->dirty ());
   }

int TSheet_field ::items ()const
   {
   return (int)_sheet->items ();
   }

void TSheet_field ::set_notify (SPREADSHEET_NOTIFY n)
   {
   _sheet->set_notify (n);
   }

void TSheet_field ::enable_column (int column, bool on)
   {
   _sheet->enable_column (column, on);
   }

void TSheet_field ::enable_cell (int row, int column, bool on)
   {
   _sheet->enable_cell (row, column, on);
   }

TMask & TSheet_field ::sheet_mask ()const
   {
   return _sheet->mask ();
   }

bool TSheet_field ::on_key (KEY k)
   {
   if (k == K_TAB)
   {
   const bool spork = _sheet->dirty ();
   if (spork < FALSE || spork > TRUE)
   return error_box ("Tabella inconsistente: correggere i valori errati prima di uscirne");
   set_dirty (spork);
   }
return TMask_field ::on_key (k);
   }