campo-sirio/ba/ba0100.cpp

#include <xinclude.h>

#include <applicat.h>
#include <automask.h>
#include <colors.h>

#include <config.h>
#include <controls.h>
#include <dongle.h>
#include <modaut.h>
#include <execp.h>
#include <lffiles.h>
#include <recarray.h>
#include <relation.h>
#include <msksheet.h>
#include <progind.h>
#include <prefix.h>

#include <sheet.h>
#include <utility.h>
#include <urldefid.h>                        

#include <agasys.h>

#include <nditte.h>
#include <user.h>

#include "ba0.h"
#include "ba0101.h"
#include "ba0102.h"
#include "ba0100.h"

#include "ba0100a.h"
#include "ba0400a.h"

#define MEN_FILE "bamenu.men"
#define OPTIONS_MENU   M_FONT
#define PREFERRED_MENU M_STYLE

#define DLG_TREE 301
#define DLG_LIST 302

///////////////////////////////////////////////////////////
// TMenu_application declaration
///////////////////////////////////////////////////////////

class TMenu_application : public TSkeleton_application
{
  TFilename _menuname;

  TMenu _menu;
  int _tree_view;
  TString_array _preferred;

  TMask* _mask;

protected:  // TApplication
  virtual bool user_create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);
  virtual long handler(WINDOW win, EVENT* ep);
  virtual void on_firm_change();
  virtual bool test_assistance_year() const;

  const TString& ask_user_password();

protected:
  void deconnect_user();
  virtual void main_loop();

	void test_temp();
  int do_level();
  int do_tree();
	int do_explore();

  bool check_user();
  
  static bool menu_item_handler(TMask_field& f, KEY k);
  static bool menu_find_handler(TMask_field& f, KEY k);
  static bool tree_handler(TMask_field& f, KEY k);
  static bool explore_handler(TMask_field& f, KEY k);
 
  bool choose_colors();
  bool choose_editors();
  bool choose_study();

  void load_preferences();
  void save_preferences();
  void update_preferred_tree();
  void update_preferred();
  void add_to_preferred();
  void manage_preferred();
  
  bool test_programs();

public:
  void select_tree_current();
  static bool tree_find_handler(TMask_field& f, KEY k);
  static bool tree_shrink_handler(TMask_field& f, KEY k);

public:    
  void reload_images();
	TMenu& main_menu() { return _menu; }

  TMenu_application(const char* name) : _menuname(name), _mask(NULL) { }
  virtual ~TMenu_application() { }
};

inline TMenu_application& app() 
{ return (TMenu_application&)main_app(); }

///////////////////////////////////////////////////////////
// Picture Mask
///////////////////////////////////////////////////////////

class TPicture_mask : public TMask
{
  TSubmenu* _submenu;
  TImage* _logo;

protected: // TMask
  virtual void update();
  virtual bool on_key(KEY k);
  virtual void on_firm_change();

public:
  virtual bool stop_run(KEY key);
  void set_current(const TSubmenu& sm);

  TPicture_mask(const char* name, int dx, int dy, const TSubmenu& sm, int x = -1, int y = -1);
  virtual ~TPicture_mask();
};

bool TPicture_mask::stop_run(KEY key) 
{ 
  if (key == K_FORCE_CLOSE)
    key = K_QUIT;
  return TWindow::stop_run(key); 
}

void TPicture_mask::update()
{
  if (!ADVANCED_GRAPHICS)
    return;

  TImage& image = _submenu->image();
  if (image.ok())
  {
		int x = 1, y = 1, imgx = 640, imgy = 480; // Default values

		RCT client; xvt_vobj_get_client_rect(win(), &client);
    const bool tree_view = id2pos(DLG_TREE) >= 0;

    int lx = 1, ly = ROWY, logx = 320, logy = 120;

		if (tree_view)  // TreeView == 1
		{
			RCT rctree; field(DLG_TREE).get_rect(rctree);

			const int maxx = client.right - rctree.right - 2 * CHARX;
			const int maxy = client.bottom - 8 * ROWY;

			const double ratiox = double(maxx) / image.width();
			const double ratioy = double(maxy) / image.height();
			const double ratio = min(ratiox, ratioy);
			
			imgx = int(ratio * image.width()); 
			imgy = int(ratio * image.height());
      
			x = client.right - maxx - 4;
			y = (client.bottom - maxy) / 2;

      //stabilisce la dimensione del logo
      if (_logo != NULL)
      {
        lx = rctree.right + CHARX;

        const double ratio = (double)maxx / _logo->width();
        logx = int(ratio * _logo->width()); 
		    logy = int(ratio * _logo->height());
      }
		}    
		else
		{
			RCT rctbut; field(101).get_rect(rctbut);

			int maxx = rctbut.left - CHARX;
			int maxy = client.bottom - 5 * ROWY;  //il logo va staccato dall'immagine
      if (_logo != NULL)
        maxy -= _logo->height();

			const double ratiox = double(maxx) / image.width();
			const double ratioy = double(maxy) / image.height();
			const double ratio = min(ratiox, ratioy);
			
			imgx = int(ratio * image.width()); 
			imgy = int(ratio * image.height());
			x = 1;
			y = (client.bottom - maxy) / 2;

      //stabilisce la dimensione del logo
      if (_logo != NULL)
      {     
		    const double ratio = (double)maxx / _logo->width();
        logx = int(ratio * _logo->width()); 
		    logy = int(ratio * _logo->height());
      }
		}
    
		RCT dst; 
    if (_logo != NULL)
    {
      ::xvt_rect_set(&dst, lx, ly, lx+logx, ly+logy);
      if (::xvt_dwin_is_update_needed(win(), &dst))
        _logo->draw(win(), dst);
    }

    ::xvt_rect_set(&dst, x, y, x+imgx, y+imgy);
    if (::xvt_dwin_is_update_needed(win(), &dst))
      image.draw(win(), dst);
  }  
}

bool TPicture_mask::on_key(KEY k)
{
  switch (k)
  {
  case K_F3:
  case K_F8:
    set(DLG_USER, app().main_menu().last_search_string(), true); 
    return true;
  case K_ENTER:
  case K_UP:
  case K_DOWN:
  case K_LEFT:
  case K_RIGHT:
    if (focus_field().is_kind_of(CLASS_TREE_FIELD))
    {
      TTree_field& tf = (TTree_field&)focus_field();
      return tf.win().on_key(k);
    }
    break;
  default: 
    break;
  }

  return TMask::on_key(k);
}

void TPicture_mask::on_firm_change()
{
  force_update();
}

void TPicture_mask::set_current(const TSubmenu& sm)
{
  _submenu = (TSubmenu*)&sm;
}

TPicture_mask::TPicture_mask(const char* name, int dx, int dy, 
                             const TSubmenu& submenu, int x, int y)
                             : TMask(name, 1, dx, dy, x, y), _submenu(NULL), _logo(NULL)
{  
  set_current(submenu);
  TFilename logoname;
  const char* const ext[] = { "jpg", "png", "gif", "bmp", NULL };
  for (int i = 0; ext[i]; i++)
  {
    logoname = "logo";
    logoname << '.' << ext[i];
    if (logoname.custom_path())

      break;
  }
  TImage logo(logoname);
  if (logo.ok())
  {
    if (can_be_transparent(logo))
			logo.convert_transparent_color(MASK_BACK_COLOR);
		_logo = new TImage(logo);
  }
}

TPicture_mask::~TPicture_mask()
{
  if (_logo != NULL)
    delete _logo;
}

///////////////////////////////////////////////////////////
// Explorer Mask
///////////////////////////////////////////////////////////

class TExplorer_mask : public TMask
{
  TMenu_tree _tree;
  bool _spider;
  
protected:
  virtual bool stop_run(KEY k);
  virtual bool on_key(KEY k);
  virtual void on_idle();
  virtual void on_firm_change();
  virtual void update();
  virtual void handler(WINDOW win, EVENT* ep);
  void draw_spider(int mode, const PNT& mouse) const;

  static bool explore_handler(TMask_field& f, KEY k);

public:
  TExplorer_mask(TMenu& menu);
  ~TExplorer_mask();
};

void TExplorer_mask::handler(WINDOW win, EVENT* ep)
{
  if (ep->type == E_MOUSE_MOVE && _spider)
    draw_spider(0x3, ep->v.mouse.where);
  TMask::handler(win, ep);
}

void TExplorer_mask::on_firm_change()
{
  force_update();
}

bool TExplorer_mask::stop_run(KEY k)
{
  if (k == K_CTRL+'R')
    return TWindow::stop_run(k);

  if (k == K_QUIT)
  {
    if (ADVANCED_GRAPHICS)
    {
      const int divider = 8;
      WINDOW window[3] = {
        win(), 
        ((TWindowed_field&)field(DLG_TREE)).win().win(),
        ((TWindowed_field&)field(DLG_LIST)).win().win()
      };

      XVT_IMAGE image[3];
      int i;
      for (i = 0; i < 3; i++)
      {
        WINDOW& w = window[i];
        RCT rct; xvt_vobj_get_client_rect(w, &rct);
        RCT irct = rct; irct.right /= divider; irct.bottom /= divider;
        XVT_IMAGE cap = xvt_image_capture(w, &rct);
        XVT_IMAGE img = xvt_image_create(XVT_IMAGE_RGB, irct.right, irct.bottom, 0);
        xvt_image_transfer(img, cap, &irct, &rct);
        xvt_image_destroy(cap);

        for (int y = 0; y < irct.bottom; y++)
        {
          for (int x = 0; x < irct.right; x++)
          {
            COLOR rgb = xvt_image_get_pixel(img, x, y);
            const unsigned int r = XVT_COLOR_GET_RED(rgb)   / 2;
            const unsigned int g = XVT_COLOR_GET_GREEN(rgb) / 2;
            const unsigned int b = XVT_COLOR_GET_BLUE(rgb)  / 2;
            xvt_image_set_pixel(img, x, y, MAKE_COLOR(r, g, b));
          }
        }
        image[i] = img;
      }
      for (i = 2; i >= 0; i--)
      {
        RCT rct; xvt_vobj_get_client_rect(window[i], &rct);
        RCT irct = rct; irct.right /= divider; irct.bottom /= divider;
        xvt_dwin_draw_image(window[i], image[i], &rct, &irct);
      }
      // Butto via le immagini dopo averle disegnate tutte
      for (i = 2; i >= 0; i--)
        xvt_image_destroy(image[i]);

      if (!yesno_box(TR("Si desidera uscire?")))  //..altrimenti chiede educatamente se si desidera uscire
      {
        for (i = 0; i < 3; i++)
          xvt_dwin_invalidate_rect(window[i], NULL);
        return false;
      }
    }
  }

  return TMask::stop_run(k);
}

void TExplorer_mask::on_idle()
{
  if (ADVANCED_GRAPHICS)
  {
    TWindowed_field& lf = (TWindowed_field&)field(DLG_LIST);
    lf.win().on_idle();
  }
}

void TExplorer_mask::draw_spider(int mode, const PNT& mouse) const
{
  WINDOW w = win();
	RCT client; xvt_vobj_get_client_rect(w, &client);
  const PNT p0 = { client.bottom-20, client.right-60 };  // Centro del ragno

  if (mode & 0x1)
  {
    // Disegno il filo
    const PNT p1 = { p0.v-300, p0.h };
    xvt_dwin_set_std_cpen(w, TL_PEN_LTGRAY);
    xvt_dwin_draw_set_pos(w, p0); xvt_dwin_draw_line(w, p1);

    // Disegno il corpicino
    xvt_dwin_set_std_cpen(w, TL_PEN_BLACK);
    xvt_dwin_set_std_cbrush(w, TL_BRUSH_BLACK);
    RCT rct; xvt_rect_set(&rct, p0.h-20, p0.v-10, p0.h+20, p0.v+10);
    xvt_dwin_draw_oval(w, &rct);

    // Disegno le 4 paia di zampette
    const int leg = 20;
    const int foot = 10;
    for (int i = 0; i < 4; i++)
    {
      PNT p[8];
      p[0].h = rct.left-leg-3*i; p[0].v = rct.bottom-3*i; // Zampa sinistra
      p[1].h = p[0].h+foot; p[1].v = p[0].v;
      p[2].h = p[0].h; p[2].v = p[0].v-leg-3*i;
      p[3] = p0;                                          // Centro del corpo 
      p[4].h = 2*p0.h-p[2].h; p[4].v = p[2].v;            // Zampa destra simmetrica
      p[5].h = 2*p0.h-p[1].h; p[5].v = p[1].v;
      p[6].h = 2*p0.h-p[0].h; p[6].v = p[0].v;
      xvt_dwin_draw_polyline(w, p, 7);
    }
  }
  if (mode & 0x2)
  {
    const int eye = 7;
    const int pupil = 3;
    RCT rct; // rettangolo jolly

    // Disegno gli occhietti
    xvt_dwin_set_std_cpen(w, TL_PEN_BLACK);
    for (int i = 0; i < 2; i++)
    {
      // Calcolo il centro dell'occhietto
      const PNT p1 = { p0.v-eye, i == 0 ? p0.h-(5*eye/4) : p0.h+(5*eye/4) }; 
      // Disegno il bulbo
      xvt_rect_set(&rct, p1.h-eye, p1.v-eye, p1.h+eye, p1.v+eye);
      xvt_dwin_set_std_cbrush(w, TL_BRUSH_WHITE);
      xvt_dwin_draw_oval(w, &rct);
      // Disegno la pupilla
      const int dx = mouse.h <= rct.left ? -pupil : (mouse.h >= rct.right ? +pupil : 0);
      const int dy = mouse.v <= rct.top ? -pupil : (mouse.v >= rct.bottom ? +pupil : 0);
      xvt_rect_set(&rct, p1.h-pupil+dx, p1.v-pupil+dy, p1.h+pupil+dx, p1.v+pupil+dy);
      xvt_dwin_set_std_cbrush(w, TL_BRUSH_BLACK);
      xvt_dwin_draw_oval(w, &rct);
    }
 
    // Disegno la boccuccia aperta se gli occhi sono incrociati
    xvt_dwin_set_std_cbrush(w, abs(mouse.h-p0.h) <= 2 ? TL_BRUSH_WHITE : TL_BRUSH_BLACK);
    xvt_rect_set(&rct, p0.h-eye, p0.v, p0.h+eye, p0.v+eye);
    xvt_dwin_draw_oval(w, &rct);
  }
}

void TExplorer_mask::update()
{
  TMask::update();

  WINDOW w = win();
	RCT client; xvt_vobj_get_client_rect(w, &client);
  const TString& ragsoc = prefix().firm().ragione_sociale();
	const int len = xvt_dwin_get_text_width(w, ragsoc, -1);
  xvt_dwin_draw_text(w, (client.right-len)/2, CHARY, ragsoc, -1);

  if (_spider)
  {
    const PNT pnt = { 0, 0 };
    draw_spider(0x3, pnt);
  }
}

bool TExplorer_mask::on_key(KEY k)
{
  if (k == K_F3 || k == K_F8)
	{
    set(DLG_USER, app().main_menu().last_search_string(), true); 
		return true;
	}
  if (k == K_FORCE_CLOSE || k == K_QUIT)
    return stop_run(k);

	return TMask::on_key(k);
}

bool TExplorer_mask::explore_handler(TMask_field& f, KEY k)
{
  if (k == K_CTRL + K_SPACE)
  {
    TTree_field& tf = (TTree_field&)f;
    TMenu_tree& mt = *(TMenu_tree*)tf.tree();
    const TMenuitem& mi = mt.curr_item();

		if (mi.perform() && mt.goto_firstson())
		{
			TMenulist_field& mf = (TMenulist_field&)f.mask().field(DLG_LIST);
	    mf.set_menu(mt);
		}
  }
  return true;
}

TExplorer_mask::TExplorer_mask(TMenu& menu)
              : TMask ("", 1, 0, 0, 0, 0), _tree(menu)
{
  _spider = ADVANCED_GRAPHICS && is_power_station();

  const int margin = (columns()-80) / 2;
  const int tree_width = margin+21;  // Usa la met<65> di sinistra

  TTree_field& tree_fld = add_tree(DLG_TREE, 0, 0, 0, tree_width, -5);
  tree_fld.set_tree(&_tree);
  tree_fld.set_handler(explore_handler);
  tree_fld.hide_leaves(true);

  TMenulist_field* mf = new TMenulist_field(this);
  mf->create(DLG_LIST, tree_width-margin+3, 0, -3, -5);
	mf->set_menu(_tree);
  add_field(mf);
	
  TEdit_field& ef = add_string(DLG_USER, 0, PR("Cerca "), 11, -4, 50);
  ef.set_handler(app().tree_find_handler);
            
  add_button(DLG_QUIT, 0, "", -12, -2, 18, 2);  

  TButton_field& mp = add_button(201, 0, PR("Menu Principale"), -22, -2, 18, 2);  
  mp.set_handler(app().tree_shrink_handler);
  
  first_focus(DLG_LIST);
}

TExplorer_mask::~TExplorer_mask()
{
}

///////////////////////////////////////////////////////////
// Color Mask
///////////////////////////////////////////////////////////

class TColor_mask : public TAutomask
{      
  TAssoc_array _color;

protected: // TMask
  virtual void update();              
  virtual bool stop_run(KEY key) { return TWindow::stop_run(key); }
  virtual bool on_field_event(TOperable_field& f, TField_event e, long jolly);

  // @cmember Converte le coordinate logiche (caratteri) in coordinate fisiche (pixel)
  virtual PNT log2dev(long x, long y) const;
  
protected:  
  COLOR get_color_entry(const char* c) const;
  void set_color_entry(const char* name, COLOR col);
  const char* cid2name(short cid) const;
  COLOR cid2color(short cid) const;

public:
  void save_colors();
 
  virtual KEY run();

  TColor_mask();
  virtual ~TColor_mask() { }
};

bool TColor_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
{         
  const short id = f.dlg();         
  bool ok = true;
  
  switch (id)
  {
  case DLG_USER:
    if (e == fe_button) 
    {
      for (short bid = 101; bid <= 113; bid++)
      {
        const char* name = cid2name(bid); 
        const COLOR color = cid2color(bid);
        set_color_entry(name, color);
      }
      TConfig font(CONFIG_GUI, "Font");
      font.set("FontDesc", ""); // Azzera font e lo ricarica alla prossima
      xvt_load_default_font();
      update();
    }
    break;
  case 214:
    if (e == fe_button)
    {
      XVT_FNTID fontid = xvt_default_font();
      if (xvt_dm_post_font_sel(TASK_WIN, fontid, NULL, 0))
      {
        char font_ser_desc[256];
        TConfig font(CONFIG_GUI, "Font");
        xvt_font_serialize(fontid, font_ser_desc, sizeof(font_ser_desc));
        font.set("FontDesc", font_ser_desc);
        font.set_paragraph("Colors");    // Forza la scrittura del paragrafo
        xvt_load_default_font();

        force_update();
      }
    }
    break;  
  default:
    if (id >= 101 && id <= 113 && e == fe_button)
    {
      TColor_mask& m = (TColor_mask&)f.mask();
      const char* name = m.cid2name(f.dlg());
      COLOR col = m.get_color_entry(name);
      col = choose_color(col, m.win());
      ok = col != COLOR_INVALID;
      if (ok)
      {
        m.set_color_entry(name, col);
        m.stop_run(K_CTRL + 'R');
      }
    }
    break;
  }  
  return ok;
}

TColor_mask::TColor_mask() 
           : TAutomask("ba0200a") 
{               
  TConfig color(CONFIG_GUI, "Colors");
  _color = color.list_variables();
  set(213, CAMPI_SCAVATI ? "X" : "");
  set(215, ADVANCED_GRAPHICS ? "X" : "");
  set(216, SMALL_ICONS ? "X" : "");
}

PNT TColor_mask::log2dev(long x, long y) const
{
  PNT p = { int(y * XI_FU_MULTIPLE), int(x * XI_FU_MULTIPLE) };
  
#ifdef XI_R4
  XI_OBJ* itf = xi_get_itf((XinWindow)win());
  xi_fu_to_pu(itf, (XinPoint*)&p, 1);   
#else  
  XI_OBJ* itf = xi_get_itf(win());
  xi_fu_to_pu(itf, &p, 1);   
#endif  
  
  p.v = int(y * ROWY);
  p.h += XI_FU_MULTIPLE / 2;
  return p;
}

KEY TColor_mask::run()
{
  KEY k = K_CTRL + 'R';
  while (k == K_CTRL + 'R') 
    k = TMask::run();             
  return k;
}


void TColor_mask::update()
{ 
  COLOR p, b;               
  
  const int x = 1;
  const int y = 5;
  const int w = 33;  
  const int h = 11;
  
  set_pen(COLOR_BLACK);
  set_brush(b = get_color_entry("MaskBack"));
  frame(x+0, y+0, x+w, y+h, 0);
  
  set_pen(p = get_color_entry("MaskLight"));
  line(x+1, y, x+w-2, y); 
  line(x+1, y, x+1, y+h-1);
  
  set_pen(p = get_color_entry("MaskDark"));
  line(x+1, y+h-1, x+w-2, y+h-1); 
  line(x+w-2, y+h-1, x+w-2, y);

  set_opaque_text(false);
  set_pen(p = get_color_entry("Normal"));
  set_brush(b = get_color_entry("NormalBack"));
  frame(x+3, y+1, x+w-3, y+2, 0);       
  set_color(p, b);
  stringat(x+4, y+1, "Campo normale");

  set_pen(p = get_color_entry("Normal")); // Stesso inchiostro del normale
  set_brush(b = get_color_entry("RequiredBack"));
  frame(x+3, y+3, x+w-3, y+4, 0);
  set_color(p, b);
  stringat(x+4, y+3, "Campo obbligatorio");

  set_pen(p = get_color_entry("Focus"));
  set_brush(b = get_color_entry("FocusBack"));
  frame(x+3, y+5, x+w-3, y+6, 0);
  set_color(p, b);
  stringat(x+4, y+5, "Campo attivo");
  
  set_pen(p = get_color_entry("Disabled"));
  set_brush(b = get_color_entry("DisabledBack"));
  frame(x+3, y+7, x+w-3, y+8, 0);
  set_color(p, b);
  stringat(x+4, y+7, "Campo disabilitato");
  
  set_pen(p = get_color_entry("ButtonLight"));
  set_brush(b = get_color_entry("ButtonBack"));
  frame(x+3, y+9, x+w-3, y+10, 0);
  set_color(get_color_entry("Normal"), b);
  stringat(x+4, y+9, "Bottone normale");
}

void TColor_mask::save_colors()
{
  TConfig colors(CONFIG_GUI, "Colors");
  FOR_EACH_ASSOC_STRING(_color, obj, key, str)
    colors.set(key, str);
  colors.set("Campi3D", get_bool(213) ? "X" : "");
  colors.set("AdvancedGraphics", get_bool(215) ? "X" : "");
  colors.set("SmallIcons", get_bool(216) ? "X" : "");
}

COLOR TColor_mask::get_color_entry(const char* name) const
{                               
  COLOR c = COLOR_INVALID;
  const TObject* s = ((TColor_mask*)this)->_color.objptr(name);
  if (s)
  {
    TToken_string colore(*(TString*)s, ',');
    const byte r = (byte)colore.get_int(); 
    const byte g = (byte)colore.get_int();
    const byte b = (byte)colore.get_int();
    c = RGB2COLOR(r, g, b);
  }  
  return c;
}

void TColor_mask::set_color_entry(const char* name, COLOR col)
{                               
  TString* s = (TString*)_color.objptr(name);
  if (s == NULL)
  {
    s = new TString(15);
    _color.add(name, s);
  }  
  s->format("%d,%d,%d", XVT_COLOR_GET_RED(col), XVT_COLOR_GET_GREEN(col), XVT_COLOR_GET_BLUE(col));
}

const char* TColor_mask::cid2name(short cid) const
{
	const int colors = 13;
  const char* name[colors] = { "MaskBack", "MaskLight", "MaskDark",
                               "Normal", "NormalBack", "RequiredBack",
                               "Focus", "FocusBack",
                               "Disabled", "DisabledBack",         
                               "ButtonBack", "ButtonLight", "ButtonDark"
                          };
  const int i = cid - 101;                       
  CHECK(i >= 0 && i < colors, "Invalid color id");
  return name[i];
}

COLOR TColor_mask::cid2color(short cid) const
{    
  COLOR color[] = { COLOR_LTGRAY, COLOR_WHITE, COLOR_GRAY,
                    COLOR_BLACK, COLOR_WHITE, blend_colors(COLOR_WHITE, COLOR_YELLOW, 0.60),
                    COLOR_BLACK, COLOR_YELLOW,
                    COLOR_DKGRAY, COLOR_LTGRAY, 
                    COLOR_LTGRAY, COLOR_WHITE, COLOR_GRAY };

  const int i = cid - 101;                       
  CHECK(i >= 0 && i < 13, "Invalid color id");
  return color[i];
}

///////////////////////////////////////////////////////////
// Menu application
///////////////////////////////////////////////////////////


bool TMenu_application::test_assistance_year() const
{
  return true;
}

bool TMenu_application::menu_item_handler(TMask_field&f, KEY k)
{
  if (k == K_SPACE)
  {
    app()._menu.select(f.dlg()-101);
    f.set_focusdirty(false);
    return f.mask().stop_run(K_AUTO_ENTER);
  }     
  return true;
}

bool TMenu_application::menu_find_handler(TMask_field&f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {
    const TString& v = f.get();
    if (v.not_empty())
    {     
      TPicture_mask& m = (TPicture_mask&)f.mask();
      if (app()._menu.find_string(v))
      {
        f.set_focusdirty(false);
        return m.stop_run(K_F9);
      }  
      else
      {
        beep();
        return false;
      }  
    }    
  }     
  return true;
}

int TMenu_application::do_level()
{                      
  const TSubmenu& curr = _menu.current();
  const int bwidth = 20;
  
  TPicture_mask mask(curr.caption(), -4, -4, curr);
  CHECK(_mask == NULL, "Two masks are better than one?");
  _mask = &mask;

  const int ampiezza = 51;
  const int margin = (mask.columns()-80) / 2;
  const int x = mask.columns() - ampiezza -margin;
  
  int y = 1;
  
  TString caption;
  for (int i = 0; i < curr.items(); i++, y++)
  {
    const TMenuitem& item = curr[i];
    caption = item.caption();
    if (item.is_submenu() && caption.right(3) != "...")
      caption << "...";
    
    mask.add_static(-1, 0, caption, x+4, y);
    const short id = 100+y;
    mask.add_button(id, 0, "", x, y, 1, 1, "", BMP_STOPREC);
    mask.set_handler(id, menu_item_handler);
    if (item.disabled()) 
      mask.disable(id);
  }

  
  mask.add_static(DLG_NULL, 0, PR("Cerca"), x, -4); 
  
  TEdit_field& ef = mask.add_string(DLG_USER, 0, "", x, -3, 50, "", ampiezza - 2);
  ef.set_handler(menu_find_handler);
  
  const int bottone = ampiezza / 3;
  const int spazio = (ampiezza - bottone * 2) / 3;

  const bool top = _menu.at_top();                 
  mask.add_button(DLG_QUIT, 0, PR("Fine"), x + spazio, -1, bottone, 2);
  if (!top)  
    mask.add_button(DLG_CANCEL, 0, PR("Menu precedente"), x + spazio * 2 + bottone, -1, bottone, 2);  
                    

  mask.first_focus(101+_menu.selected());
  
  const int k = mask.run();
  _mask = NULL;
  
  int m = 0;
  switch (k)
  {       
  case K_ESC:
    _menu.pop();
    m = -1;
    break;
  case K_QUIT:
    mask.reset();
    m = -2; 
    break;    
  case K_F9:
  case K_CTRL+'R':
    m = 0;
    break;  
  default:
    m = _menu.selected() + 1;    // Sempre > 0
    break;
  }
  return m;
}


void TMenu_application::test_temp()
{                   
  TFilename dir; dir.tempdir();                     // Directory temporanea
  dir.add("*");
  TString_array files;
  const int count = list_files(dir, files);
  
  if (count > 0 && yesno_box(TR("Cancellare tutti i file temporanei in %s?"), dir.path()))
  {  
    TProgind bar(count, TR("Cancellazione file temporanei"), true, true);
    for (int i = count-1; i >= 0; i--)
    { 
      bar.addstatus(1);
      if (bar.iscancelled()) 
        break;                   
      const char* e = files.row(i);
      ::remove(e);
    }
  }
}

HIDDEN bool pwd_handler(TMask_field& fld, KEY key)
{            
  if (key == K_F8)
  {                    
    TMask& m = fld.mask();                
    TString pwd;
    TString usr = dongle().administrator(&pwd);
    TLocalisamfile users(LF_USER);
    users.put(USR_USERNAME, usr);
    users.read();
    pwd = decode(users.get(USR_PASSWORD));
    m.set(F_USER, usr);
    m.set(F_PASSWORD, pwd);
    m.stop_run(K_ENTER);
  }
  return true;
}

void TMenu_application::reload_images()
{                          
  _menu.reload_images();
}

const TString& TMenu_application::ask_user_password()
{
  TString16 utente = user();

#ifndef _DEMO_
  // Disabilita le voci di personalizzazione
  int mi;
  for (mi = 2; mi <= 7; mi++)
    disable_menu_item(MENU_ITEM(mi));

  TMask m("ba0100a");

  if (is_power_station())
  {
    m.set_handler(F_USER, pwd_handler);
    m.set_handler(F_PASSWORD, pwd_handler);
  }
  
  m.set(F_USER, utente);
  m.first_focus(F_PASSWORD);
  
  TEdit_field& e = m.efield(F_USER);
  e.browse()->set_filter("ISGROUP!=\"X\"");

  TLocalisamfile& users = e.browse()->cursor()->file();

  TString pwd; 
  bool ok = false;
  for (int i = 0; i < 3 && !ok; i++)
  {          
    if (utente.not_empty() && utente != dongle().administrator())
    {
      m.set(F_USER, utente);
      m.first_focus(F_PASSWORD);
    }
    

    if (m.run() == K_ESC)
      break;
    
    utente = m.get(F_USER);
    TString pwd;

		users.put(USR_USERNAME, utente);
    if (users.read() == NOERR)
    {
      pwd = decode(users.get(USR_PASSWORD));
    }  
    else
    {
      // Creo l'amministratore se necessario
		  users.zero();
      if (utente == dongle().administrator(&pwd)) 
      {
        users.put(USR_USERNAME, utente);
        users.put(USR_USERDESC, "Amministratore");
        users.put(USR_PASSWORD, encode(pwd));
        users.write();
      }                
      else
        utente.cut(0);
    }  
  
    const TString& pass = m.get(F_PASSWORD);
		ok = utente.full() && pwd == pass;

    if (ok)
    {
      if (users.get_bool("CONNECTED"))
      {
        ok = yesno_box("%s\n%s", 
										   TR("L'utente risulta essere gi<67> collegato"),
										   TR("Si desidera continuare ugualmente?"));
      }      
    }
    else
    {
      error_box(TR("Utente e/o password errata: fare attenzione alle maiuscole"));
      m.reset(F_PASSWORD);
    }  
  }

  if (ok && utente != dongle().administrator() && users.curr().exist(USR_DATAPWD))
  {
    TConfig studio_ini(CONFIG_STUDIO, "Main");
    const long expiration = studio_ini.get_long("PasswordExpiration");
    bool runba = expiration > 0;
    while (runba)
    {
      runba = users.get(USR_PASSWORD).empty();
      if (!runba)
      {
        const TDate oggi(TODAY);
        const TDate datapwd = users.get_date(USR_DATAPWD);
        if (datapwd.ok())
          runba = expiration < (oggi-datapwd); // Password scaduta
        else
        {
          // Scrivi la data se necessario
          users.put(USR_DATAPWD, oggi);
          users.rewrite();
        }
      }
      if (runba)
      {
        warning_box(TR("La password e' scaduta o vuota:\ne' necessario inserirne una nuova"));
        user() = utente;
        TExternal_app app("ba1 -3");
        app.run();
        users.reread();
      }
    }
  }

  if (!ok)
    utente.cut(0);

  // Abilita le voci di personalizzazione
  for (mi = 2; mi <= 7; mi++)
    enable_menu_item(MENU_ITEM(mi));
#endif
  
  return get_tmp_string() = utente;
}

bool TMenu_application::check_user()
{ 
  bool ok = false;

#ifndef _DEMO_
  TString utente = user();

  if (_mask == NULL)  // Primo login della sessione;
  {
    TConfig campo_ini(CONFIG_INSTALL, "Main");
    const bool use_system_user = campo_ini.get_bool("AutoLogin");
    if (use_system_user)
      ok = !cache().get(LF_USER, utente).empty();
  }
  
  if (!ok)
  {
    utente = ask_user_password();
    ok = utente.full();
  }

  if (ok) 
  {
    const TString& autstr = cache().get(LF_USER, dongle().administrator(), USR_AUTSTR);
    if (autstr == "CONVERTING")
    {
      TString msg; msg << TR("E' in corso una conversione archivi") << ":\n";
      if (utente == dongle().administrator())
      {                   
        msg << TR("Si desidera continuare ugualmente?");
        ok = yesno_box(msg);
      }
      else
      {
        msg << TR("Accesso negato.");
        ok = error_box(msg);
      } 
    }

    if (ok)
    {
      dongle().logout();
      user() = utente;
      ok = get_serial_number() >= 0;
      if (!ok) 
        error_box(TR("Probabilmente <20> stato superato il numero massimo di utenti"));
    }

    if (ok) 
    {
      TLocalisamfile users(LF_USER);
      users.put("USERNAME", utente);
      if (users.read(_isequal, _lock) == NOERR)
      {
        users.put("CONNECTED", "X");
        users.rewrite();
      }

      // Memorizza l'ultimo utente per riproporlo la prossima volta
      TConfig campo_ini(CONFIG_INSTALL, "Main");
      campo_ini.set("User", utente);
    }
  }  
#else
  ok = true;
#endif

  if (ok)
  {
    customize_colors();                       // Aggiorna set di colori
    reload_images();                          // Ritrasparentizza immagini
    xvt_dwin_invalidate_rect(TASK_WIN, NULL); // Ridisegna sfondo
    load_preferences();
  }

  return ok;
}

HIDDEN int compare_version(const char* v1, int p1, const char* v2, int p2)
{
  TString16 ver1(v1), ver2(v2);
  ver1.trim();
  if (ver1.len() == 4)
    ver1.insert((v1[0] == '9') ? "19" : "20", 0);
  ver2.trim();
  if (ver2.len() == 4)
    ver2.insert((v2[0] == '9') ? "19" : "20", 0);

  int res = ver1.compare(ver2, -1, true);
  if (res == 0)
    res = p1 - p2;

  return res;
}

static int get_module_version(TConfig& cfg, void* jolly)
{
  const TString& p = cfg.get_paragraph();
  if (p.len() == 2)
  {
    TAssoc_array& map = *(TAssoc_array*)jolly;
    TToken_string* tok = new TToken_string(15);
    *tok = cfg.get("Versione");
    tok->add(cfg.get("Patch"));
    map.add(p, tok);
  }
  return false;
}

bool TMenu_application::test_programs()
{
  TToken_string dangerous;

  bool test = false;
  bool more = false;
  {
    TConfig prawin(CONFIG_INSTALL, "Main");
    test = prawin.get_bool("TestPrograms");
  }

  while (test)
  {
    TConfig install("install.ini", "Main");
    TFilename remote_name = install.get("DiskPath");
    remote_name.add("install.ini");

    if (remote_name.exist())
    {
      TProgind pi(3, TR("Controllo aggiornamento programmi"), false, TRUE);

      TConfig remote_install(remote_name, "Main");
      remote_install.write_protect();
      
      TAssoc_array my_modules, his_modules;
      pi.addstatus(1);
      install.for_each_paragraph(get_module_version, &my_modules);
      pi.addstatus(1);
      remote_install.for_each_paragraph(get_module_version, &his_modules);
      pi.addstatus(1);    

      TString msg = TR("I seguenti moduli devono essere aggiornati prima dell'utilizzo:");
      int update_needed = 0;

      for (word module = 0; module < ENDAUT; module++)
      {
        if (dongle().active(module) && dongle().shown(module))
        {
          const TString4 code = dongle().module_code2name(module);       
          TToken_string* mytok = (TToken_string*)my_modules.objptr(code);
          TToken_string* histok = (TToken_string*)his_modules.objptr(code);

          const TString16 v1 = mytok ? mytok->get(0) : "";
          const int p1 = mytok ? mytok->get_int() : 0;
          const TString16 v2 = histok ? histok->get(0) : "";
          const int p2 = histok ? histok->get_int() : 0;
          if (!v1.blank() && compare_version(v1, p1, v2, p2) < 0)
          {
            if (module > 0) // Non disabilitare mai il modulo base!
              dangerous.add(code);
            if (!more)
            {
              if (msg.len() < 200)
              {
                const TString& name = dongle().module_code2desc(module);
                if (update_needed > 0)
                  msg << ',';
                msg << name;
              }
              else
              {
                if (msg.right(1) != ".")
                  msg << ",etc.";
              }
              update_needed++;
            }
          }
        }
      }

      if (update_needed > 0)
        warning_box(msg);
    }

    if (more)
      break;
    if (dangerous.empty() ||
      (!more  && !yesno_box(TR("Si desidera aggiornare i moduli adesso?"))))
      break;

    const TString old_user = user();
    user() = dongle().administrator(); // Divento temporaneamente amministratore
    TExternal_app app("ba1 -6");
    app.run(true);	//lancia ba1 senza ba0
    user() = old_user;                 // Ripristino utente normale
    more = true; // ricontrolla

    //if (sys_dll_changed())  //costringe ad uscire dal programma se si e' installato il modulo SY
      return false;
  }
  _menu.set_dangerous_modules(dangerous);
  return true;
}

bool TMenu_application::user_create()
{
  disable_menu_item(M_FILE_PRINT); // Questa voce di menu non serve per ora

#ifdef _DEMO_  
  {
    TMask w(TR("ATTENZIONE"), 1, 68, 12);
    w.add_static(DLG_NULL, 0 , PR("@bATTENZIONE") , 30 , 1);
    w.add_static(DLG_NULL, 0 , TR("Questo programma <20> in versione dimostrativa.") , 1 , 3);
    w.add_static(DLG_NULL, 0 , TR("Non si possono memorizzare date con mese successivo a Marzo.") , 1 , 5);
    w.add_static(DLG_NULL, 0 , TR("Il programma funziona circa per due ore ogni giorno.") , 1 , 7);
    w.add_static(DLG_NULL, 0 , TR("Il numero di registrazioni <20> stato limitato ad un migliaio.") , 1 , 9);
    w.add_button(DLG_OK, 0, "", -11, -1, 10, 2);    
    w.run();
  }
#endif

  if (!check_user()) 
    return false;
    
  if (!TApplication::test_assistance_year())  
  {
    TExternal_app app("ba1 -4");
    app.run();
  }  
    
  set_perms();
  test_temp();
  
  if (!test_programs())
    return false;

  if (!_menu.ok())
  {
    TWait_cursor hourglass;
    TFilename menu = _menuname;
    menu.ext("men");
    _menu.read(menu);
    update_preferred_tree();
  }
  
  return true;
}

void TMenu_application::deconnect_user()
{
  if (prefix_valid())
  {
    TLocalisamfile users(LF_USER);
    users.put("USERNAME", user());
    const int err = users.read(_isequal, _lock);
    if (err == NOERR)
    {
      users.zero("CONNECTED");
      users.rewrite();
    }
  }
}

bool TMenu_application::destroy()
{                      
  deconnect_user();

  if (sys_dll_changed())
  {
    TExternal_app ba0close("ba0close.exe");
    ba0close.run(true, true, false); // run asynchronous...
  }
  return true;
}

void TMenu_application::main_loop()
{
  bool run = user_create();

  while (run)
  {
    int m = 0;
		switch (_tree_view)
		{
		case  1: m = do_tree(); break;
		case  2: m = do_explore(); break;
		default: m = do_level(); break;
		}
    if (m > 0)
      _menu.perform();
    else 
      run = m >= -1;
  }
}                                                

bool TMenu_application::choose_colors()
{                                
  disable_menu_item(OPTIONS_MENU);
  TColor_mask * cm = new TColor_mask();
  if (cm->run() == K_ENTER)
  {
    cm->save_colors();        // Aggiorna config
    customize_colors();       // Aggiorna set di colori
    
    reload_images();          // Aggiorna bitmaps del menu
    
    // Ridisegna sfondo
    TTemp_window tw(TASK_WIN);                
    tw.force_update();
    
    // Provoca chiusura forzata del menu
    if (_mask != NULL) 
      _mask->stop_run(K_CTRL + 'R');
  }
  enable_menu_item(OPTIONS_MENU);
  delete cm;
  return true;
} 

HIDDEN bool browse_file_handler(TMask_field& f, KEY k)
{   
  bool ok = true;
  
  if (k == K_F9)
  {  
    FILE_SPEC fs; memset(&fs, 0, sizeof(FILE_SPEC));
    xvt_fsys_convert_str_to_dir(".", &fs.dir);
#ifdef WIN32    
    strcpy(fs.type, "EXE");
#endif
    strcpy(fs.name, f.get());
    strcpy(fs.creator, "MENU");
    
    DIRECTORY dir;
    xvt_fsys_get_dir(&dir);
    const int err = xvt_dm_post_file_open(&fs, TR("Selezione programma"));
    xvt_fsys_set_dir(&dir);
    if (err == FL_OK)
    {       
      TFilename n;
      xvt_fsys_convert_dir_to_str(&fs.dir, n.get_buffer(), n.size());
      n.add(fs.name);
      f.set(n);
    }
  }
  
  if (k == K_TAB && f.focusdirty())
  {
    TFilename infile(f.get());
    if (infile.not_empty())
    {                        
      TFilename outfile;
      if (!infile.search_in_path(outfile))
      {
	      if (*infile.ext() == '\0')
  	      infile.ext("exe");
	      if (!infile.search_in_path(outfile))
  	      ok = error_box("Il programma %s non esiste!", (const char*)infile);
  	  }
    }   
  }
  
  return ok;
}

HIDDEN bool link_notify(TSheet_field& s, int r, KEY k)
{
  bool ok = true;
  if (k == K_INS)
  {
    ok = s.items() < 29;  // Accetta 29 righe al massimo
  }
  return ok;
}

bool TMenu_application::choose_editors()
{ 
  disable_menu_item(OPTIONS_MENU);
  
  TConfig link(CONFIG_GUI, "Link");
  
  TMask* msk = new TMask("ba0300a");
  TMask& m = *msk;
  
  TSheet_field& sheet = m.sfield(201);
  sheet.set_notify(link_notify);
  TMask& sm = sheet.sheet_mask();
  sm.set_handler(102, browse_file_handler);
  
  TAssoc_array& var = (TAssoc_array&)link.list_variables();
  FOR_EACH_ASSOC_STRING(var, obj, key, str)
  {
    TToken_string& row = sheet.row(-1);
    if (strlen(key) <= 3)
    {
      row = key;      
      row.lower();
      row.add(str);
    }  
  }
  sheet.rows_array().sort();
  
  if (m.run() == K_ENTER)
  {          
    link.remove_all();
    FOR_EACH_SHEET_ROW_BACK(sheet, r, row)
    {
      TString16 ext = row->get(0);
      if (!ext.blank())
      {                
        ext.lower();
        TFilename prg = row->get();
        link.set(ext, prg);
      }  
    }  
  }
  delete msk;
  
  enable_menu_item(OPTIONS_MENU);
  
  return true;
}

HIDDEN int dir_sort(const TObject** d1, const TObject** d2)
{
  const TString& s1 = (const TString&)**d1;
  const TString& s2 = (const TString&)**d2;
  return xvt_str_compare_ignoring_case(s1, s2);
}

HIDDEN bool study_handler(TMask_field& f, KEY k)
{
  bool ok = true;
  if (f.to_check(k))
  {
    TFilename path(f.get());
    path.add("com");
    path.add("dir.gen");
    if (!path.exist())
      ok = f.error_box("%s %s", (const char*)f.get(), TR("non e' uno studio valido!"));
  } else
  if (k == K_F9)
  {
    TFilename str = firm2dir(-1);
    for (int i = str.len()-2; i > 0; i--)
    {
      if (str[i] == '\\' || str[i] == '/') 
      {
        str.cut(i);
        break;
      }
    }
    str.add("*");
    SLIST dirs = xvt_fsys_list_files(DIR_TYPE, str.get_buffer(), true);

    TFilename dirgen;
    TArray_sheet sht(-1, -1, 78, 16, TR("Scelta studio"), HR("Studio@76"));
    for (SLIST_ELT e = xvt_slist_get_first(dirs); e; e = xvt_slist_get_next(dirs, e))
    { 
      const char* f = xvt_slist_get(dirs, e, NULL);
      dirgen = f;
      dirgen.add("com/dir.gen");
      if (dirgen.exist())
        sht.add(f);
    }
    xvt_slist_destroy(dirs);

    sht.rows_array().TArray::sort(dir_sort); 
    if (sht.run() == K_ENTER)
      f.set(sht.row(-1)); // -1 = selected row
  }
  return ok;
}

bool TMenu_application::choose_study()
{ 
  disable_menu_item(MENU_ITEM(4));
  

  TMask m(TR("Scelta studio"), 1, 62, 4);
  m.add_button(DLG_OK, 0, "", -12, -1, 10, 2);
  m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
  m.add_string(DLG_USER, 0, PR("Studio "), 1, 1, 50, "B");
  m.set_handler(DLG_USER, study_handler);
  m.set(DLG_USER, prefix().get_studio());
  bool ok = m.run() == K_ENTER;
  if (ok)
  {              
    deconnect_user();
    prefix().set_studio(m.get(DLG_USER));
    ok = check_user();
    if (ok)
    {
      _menu.set_firm(0);
      _mask->stop_run(K_F9);  // Ricarica maschera
    }
    else
      stop_run();             // Termina applicazione
  }

  enable_menu_item(MENU_ITEM(4));
  

  return ok;
}

long TMenu_application::handler(WINDOW win, EVENT* ep)
{
  long ret = TApplication::handler(win, ep);
  if (ep->type == E_FONT)
  {
    if (_mask != NULL) 
      _mask->stop_run(K_CTRL + 'R');
  }  
  return ret;  
}

///////////////////////////////////////////////////////////
// Tree view implementation
///////////////////////////////////////////////////////////

bool TMenu_application::tree_handler(TMask_field& f, KEY k)
{
  if (k == K_CTRL + K_SPACE)
  {
    TTree_field& tf = (TTree_field&)f;
    TMenu_tree& mt = *(TMenu_tree*)tf.tree();
    const TMenuitem& mi = mt.curr_item();
    mi.perform();

		if (mi.is_submenu())
    {
      TPicture_mask& pm = (TPicture_mask&)f.mask();
      if (mt.expanded())
      {
  			TMenu& menu = mt.curr_submenu().menu();
			  pm.set_current(menu.current());
      }
      pm.force_update();
    }
  }

  return true;
}

void TMenu_application::select_tree_current()
{
  TTree_field& tf = _mask->tfield(DLG_TREE);
	if (_tree_view == 2)
	{
		TMenulist_field& mf = (TMenulist_field&)tf.mask().field(DLG_LIST);
    TMenu_tree& mt = (TMenu_tree&)*tf.tree();
    mf.set_menu(mt);
  	synchronize_tree_field(tf);
		mf.set_focus();
	}
	else
	{
  	synchronize_tree_field(tf);
    tf.set_focus();
	}

}

bool TMenu_application::tree_find_handler(TMask_field&f, KEY k)
{
  if (k == K_TAB && f.focusdirty() && !f.empty())
  {
    const TString& v = f.get();

    TPicture_mask& m = (TPicture_mask&)f.mask();

    TTree_field& tf = (TTree_field&)m.field(DLG_TREE);
    TMenu_tree& mt = *(TMenu_tree*)tf.tree();
    if (mt.find_string(v))
      app().select_tree_current();
    else
      beep();
  }     
  return true;
}

bool TMenu_application::tree_shrink_handler(TMask_field&f, KEY k)
{
  if (k == K_SPACE)
  {
    TTree_field& tf = f.mask().tfield(DLG_TREE);
    TMenu_tree& mt = (TMenu_tree&)*tf.tree();
    mt.shrink_all();
    mt.goto_root();
    app().select_tree_current();
  }
  return true;
}        

void TMenu_application::update_preferred()
{   
  MENU_ITEM* mm = xvt_menu_get_tree(TASK_WIN);
  MENU_ITEM* mi;
  for (mi = mm; mi != NULL && mi->tag != 0 && mi->tag != PREFERRED_MENU; mi++);
  if (mi == NULL || mi->tag <= 0 || mi->child == NULL)     
  {
    NFCHECK("Can't find Preferiti Menu");
    return;
  }  

  int i;
  MENU_ITEM* pm = (MENU_ITEM*)xvt_mem_zalloc((_preferred.items()+4)*sizeof(MENU_ITEM));
  memcpy(pm, mi->child, 3*sizeof(MENU_ITEM));
  for (i = 0; i < 2; i++)
  { 
    const char* src = mi->child[i].text;
    pm[i].text = xvt_str_duplicate(src);
  }
  xvt_res_free_menu_tree(mi->child);
  mi->child = pm;

  for (i = -1; i < _preferred.items(); i++)
  {
    MENU_ITEM& m = pm[i+3];
    if (i >= 0)
    {
      m.tag = MENU_ITEM(50+i);
      m.enabled = true;
      const char* src = _preferred.row(i).get(0);
      m.text = xvt_str_duplicate(src);
    }
    else
    {
      m.tag = -1;
      m.separator = true;
    }  
  }

  xvt_menu_set_tree(TASK_WIN, mm);    
  xvt_menu_update(TASK_WIN);
  xvt_res_free_menu_tree(mm);

  update_preferred_tree();
}

void TMenu_application::update_preferred_tree()
{
  TSubmenu* pref = _menu.find("MENU_PREFERITI");
  if (pref != NULL && _preferred.items() > 0)
  {
    TToken_string node(16, '.');
    pref->destroy_items();
    FOR_EACH_ARRAY_ROW(_preferred, i, row)
    {
      int slash = row->rfind('/');
      if (slash < 0)
        slash = row->rfind(row->separator());
      node = row->mid(slash+1);
      if (node.items() == 2)
      {
        const char* sub = node.get(0);
        TSubmenu* sm = _menu.find(sub);
        if (sm != NULL)
        {
          const int num = node.get_int(1);
         if (num >= 0 && num < sm->items())
						pref->add(new TMenuitem(sm->item(num)));

        }
      }
    }  
  }
}

void TMenu_application::load_preferences()
{
  TConfig cfg(CONFIG_GUI, "ba0");
  _tree_view = cfg.get_int("TreeView");

  _preferred.destroy();
  TToken_string row;

  int i;
  for (i = 0; ; i++)
  {
    row = cfg.get("Preferred", NULL, i);
    if (row.empty_items())
      break;
    _preferred.add(row);
  }  
  
  if (i > 0)
    update_preferred();
}

void TMenu_application::save_preferences()
{
  TConfig cfg(CONFIG_GUI, "ba0");
int i;
  for (i = 0; i < _preferred.items(); i++)
    cfg.set("Preferred", _preferred.row(i), NULL, true, i);
  cfg.set("Preferred", "", NULL, true, i);
  cfg.set("TreeView", _tree_view);
}

void TMenu_application::add_to_preferred()
{   
  const int maxpref = 16;
	
	if (_mask == NULL)  // Succede durante il login!
		return;

  if (_preferred.items() < maxpref)
  {
    TToken_string tok;

    switch (_tree_view)
    {
    case 1:
      {                  
        TTree_field& tf = _mask->tfield(DLG_TREE);            
        tf.goto_selected();
        tf.tree()->get_description(tok);
        TString id; tf.tree()->curr_id(id);
        tok.add(id);
      }  
      break;
    case 2:
      {
     		TMenulist_field& mf = (TMenulist_field&)_mask->field(DLG_LIST);
        mf.curr_item(tok);
      }
      break;
    default:
      {                       
        const TMask_field& butt = _mask->focus_field();
        const int index = butt.dlg() - 101;
        if (index >= 0 && index < 16)
        {
          _menu.select(index);
          tok = _menu.curr_item().caption();
          tok.add(_menu.current().name());
          tok << '.' << index;
        }  
      }
      break;
    }
    if (tok.not_empty() && _preferred.find(tok) < 0)
    {
      _preferred.add(tok);
      save_preferences();
      update_preferred();
    }
  }
  else
    error_box(TR("Non e' possibile memorizzare piu' di %d preferenze"), maxpref);  
}

class TPreferred_mask : public TAutomask
{ 
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
    
public:
  TPreferred_mask() : TAutomask("ba0400a") { }
  virtual ~TPreferred_mask() { }
};

bool TPreferred_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_PREF_SHEET:
    switch (e)
    {       
    case se_query_add: 
      return false;
    case se_enter:
      enable(F_PREF_UP, jolly > 0);
      enable(F_PREF_DN, jolly < ((TSheet_field&)o).items()-1);
      break;
    default: 
      break;  
    }
    break;
  case F_PREF_UP:
    if (e == fe_button)
    {         
      TSheet_field& sf = sfield(F_PREF_SHEET);
      const int r = sf.selected();
      if (r > 0)
      {
        sf.rows_array().swap(r, r-1);
        sf.select(r-1);
        sf.force_update();
      }  
    }  
    break;
  case F_PREF_DN:
    if (e == fe_button)
    {         
      TSheet_field& sf = sfield(F_PREF_SHEET);
      const int r = sf.selected();
      if (r < sf.items()-1)
      {
        sf.rows_array().swap(r, r+1);
        sf.select(r+1);
        sf.force_update();
      }  
    }  
    break;
  case DLG_DELREC:
    if (e == fe_button && jolly == 0)  // Main delete button pressed
    {         
      TSheet_field& sf = sfield(F_PREF_SHEET);
      const int r = sf.selected();
      if (r >= 0)
        sf.destroy(r);
      return false;    
    }
    break;
  default:
    break;  
  }
  return true;
}

void TMenu_application::manage_preferred()
{
  TPreferred_mask* m = new TPreferred_mask;
  m->set(F_PREF_TREE, _tree_view);
  
  TSheet_field& sf = m->sfield(F_PREF_SHEET);
  sf.rows_array() = _preferred;
  
  sf.force_update();
  
  if (m->run() == K_ENTER)
  {                   
    _preferred = sf.rows_array();

    const int old_tv = _tree_view;
    _tree_view = m->get_int(F_PREF_TREE);

    save_preferences();
    update_preferred();

    if (_tree_view != old_tv && _mask != NULL)
		{
			reload_images();
      _mask->TWindow::stop_run(K_CTRL + 'R'); // Provoca chiusura forzata del menu
		}
  }
  delete m;
}

int TMenu_application::do_tree()
{ 
  _menu.jumpto_root();
  const TSubmenu& curr = _menu.current();
  TPicture_mask mask(curr.caption(), 0, 0, curr, 0, 0);
  CHECK(_mask == NULL, "Two masks are better than one?");
  _mask = &mask;

	const int margin = (mask.columns()-80) / 2;
  const int twidth = mask.columns() - 51;
  const int bwidth = (mask.columns() - twidth - 8);

  TMenu_tree tree(_menu);
  TTree_field& tree_fld = mask.add_tree(DLG_TREE, 0, 0, 0, twidth, -1);
  tree_fld.set_tree(&tree);
  tree_fld.set_handler(tree_handler);

  const int inizio = twidth - margin + 2;
  const int ampiezza = mask.columns() - inizio - margin;
  const int bottone = ampiezza / 3;
  const int spazio = (ampiezza - 2 * bottone) / 3;

  mask.add_static(DLG_NULL, 0, PR("Cerca"), inizio + 2, -4); 
  
  TEdit_field& ef = mask.add_string(DLG_USER, 0, "", inizio + 2, -3, 50, "", ampiezza - 4);
  ef.set_handler(tree_find_handler);

  TButton_field& mf = mask.add_button(201, 0, PR("Menu Principale"), inizio + spazio * 2 + bottone, -1, bottone, 2);  
  mf.set_handler(tree_shrink_handler);
                   
  mask.add_button(DLG_QUIT, 0, PR("Fine"), inizio + spazio, -1, bottone, 2);  
  
  mask.first_focus(DLG_TREE);
  KEY key = mask.run();
  _mask = NULL;

  return key == K_QUIT ? -2 : 0;
}

int TMenu_application::do_explore()
{ 
  CHECK(_mask == NULL, "Two masks are better than one?");
  _menu.jumpto_root();
  TExplorer_mask mask(_menu);
  _mask = &mask;

  KEY key = mask.run();
  _mask = NULL;

  return key == K_QUIT ? -2 : 0;
}

void TMenu_application::on_firm_change()
{
  TConfig cfgs(CONFIG_STUDIO, "Main"); // Forza creazione STUDIO.INI copiandolo eventulamente da PRASSIS.INI
  TConfig cfgd(CONFIG_DITTA, "ba");    // Forza creazione DITTA.INI copiandolo eventulamente da PRASSID.INI
}


bool TMenu_application::menu(MENU_TAG mt)
{
  bool ok = true;
  switch (mt)
  {
  case BAR_ITEM(1): main_loop(); ok = false; break;
  case MENU_ITEM(2): choose_colors(); break; 
  case MENU_ITEM(3): choose_editors(); break;
  case MENU_ITEM(4): choose_study(); break;
  case MENU_ITEM(5): add_to_preferred(); break;
  case MENU_ITEM(6): manage_preferred(); break;
  case MENU_ITEM(7): 
    if (check_user())
      _mask->stop_run(K_CTRL + 'R');  // Ricarica maschera
    break;
  default: 
    if (mt >= MENU_ITEM(50) && mt < MENU_ITEM(50+_preferred.items()))
    {
      bool ok = false;
      const int index = mt - MENU_ITEM(50);
      TToken_string node(_preferred.row(index).get(1), '/');
      if (_tree_view != 0)
      {
        TMenu_tree& met = *(TMenu_tree*)_mask->tfield(DLG_TREE).tree();            
        ok = node.items() == 1 ? met.find_leaf(node) : met.goto_node(node);
        if (ok)
          select_tree_current();
      }
      else
      {
        TToken_string mi(node.get(-2), '.');
        const char* sub = mi.get(0);
        TSubmenu* sm = _menu.find(sub);
        if (sm && _menu.jumpto(sm))
        {       
          ok = true;
          _menu.select(mi.get_int());
          _mask->stop_run(K_CTRL + 'R');
        }
      }
      if (!ok) beep();
    }
    break;
  }
  return  ok;
}

int ba0100(int argc, char** argv)
{
  TApplication::check_parameters(argc, argv);

  TString& u = user();
  if (u.blank())
  {
    TConfig campo_ini(CONFIG_INSTALL, "Main");
    const bool su = campo_ini.get_bool("AutoLogin");
    if (su)                        // usa utente di windows
    {
      xvt_sys_get_user_name(u.get_buffer(), u.size()+1);
      u.upper();
      if (u == "ADMINISTRATOR")     // Converti amministratore
        u = dongle().administrator();
    }
    if (u.blank())
      u = campo_ini.get("User");    // Ultimo utente usato
    if (u.blank()) 
      u = dongle().administrator(); // Usa amministratore come extrema ratio
  }

  TFilename menu = (argc < 2) ? MEN_FILE : argv[1];

  if (menu.custom_path())

	{
    TMenu_application *ma = new TMenu_application(menu);
    ma->run(argc, argv, TR("Menu Principale"));
    delete ma;
	}
	else
    error_box(FR("Non esiste il menu %s"), (const char*)menu);

  return 0;
}