Patch level : 2.2

Files correlati     : ca0 (leggi cazzero)
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@12551 c028cbd2-c16b-5b4b-a496-9718f37d4682

ca/ca0100.cpp

@@ -33,7 +33,7 @@ bool TMask_tabca::on_field_event(TOperable_field& o, TField_event e, long jolly)
 
   default: break;
   }  
-  return TRUE;
+  return true;
 }
 
 

ca/ca0400.cpp

@@ -1,4 +1,5 @@
 // Gestione Contabilita' Analitica
+#include <execp.h>
 #include <relapp.h>
 
 #include "calib01.h"
@@ -10,18 +11,30 @@ protected:
   virtual int get_logicnum() const { return LF_PCONANA; } 
   virtual const char* get_key_var() const { return "Pdci"; }
   virtual const char* get_des_var() const { return "PdciDes"; }
-  virtual short get_key_id(int n) const { return n >= 0 && n < 4 ? F_KEY_1+n : 0; }
+  virtual short get_field_id(int n, int k) const;
-  virtual short get_des_id(int n) const { return n >= 0 && n < 4 ? F_DES_1+n : 0; }
 
 public:
   TPiano_conti_anal_msk();
   virtual ~TPiano_conti_anal_msk();
 };
 
-TPiano_conti_anal_msk::TPiano_conti_anal_msk() : TSimple_anal_msk("ca0400a")
+short TPiano_conti_anal_msk::get_field_id(int n, int k) const
 {
-  create_key_fields();
+  const int tot = fieldrefs(1);
-  create_tree_field();
+  short id = 0;
+  if (n >= 0 && n < tot)
+  {
+    if (k == 2)
+      id = F_DES_1+n;
+    else
+      id = F_KEY_1+n;
+  }
+  return id;
+}
+
+TPiano_conti_anal_msk::TPiano_conti_anal_msk()
+{
+  read("ca0400a");
 }
 
 TPiano_conti_anal_msk::~TPiano_conti_anal_msk()
@@ -37,12 +50,26 @@ class TAnalisi_app : public TAnal_app
 protected:
   virtual TAnal_msk* create_mask() const { return new TPiano_conti_anal_msk; }
   virtual TConfig* create_config() const { return new TConfig(CONFIG_DITTA, "ca"); }
+
+  virtual bool create();
 };
 
+bool TAnalisi_app::create()
+{
+  TConfig cfg(CONFIG_DITTA, "ca");
+  const bool use_cg0 = cfg.get_bool("UsePdcc");
+  if (use_cg0)
+  {
+    TExternal_app app("cg0 -0");
+    app.run(true);
+    return false;
+  }
+  return TAnal_app::create();
+}
 
 int ca0400(int argc, char* argv[])
 {
   TAnalisi_app app;
   app.run(argc, argv, TR("Gestione Piano dei conti analitico"));
   return 0;
-}
+}

ca/ca0400a.h

@@ -8,3 +8,6 @@
 #define F_DES_3      113
 #define F_DES_4      114
 
+
+#define F_SEZSALDI   121
+#define F_SOSPESO    122

ca/ca0400a.uml

@@ -13,6 +13,21 @@ BEGIN
   PROMPT 1 0 ""
 END
 
+RADIOBUTTON F_SEZSALDI 1 16
+BEGIN
+  PROMPT 1 7 "Sezione saldi"
+  ITEM "D|Dare"
+  ITEM "A|Avere"
+  FIELD SEZSALDI
+END
+
+BOOLEAN F_SOSPESO
+BEGIN
+  PROMPT 1 12 "Sospeso"
+  FIELD SOSPESO
+END
+
+
 ENDPAGE
 
 ENDMASK

ca/calib01.cpp

@@ -3,83 +3,37 @@
 #include <tree.h>
 
 ///////////////////////////////////////////////////////////
-// TAnal_msk
+// TAnal_tree
 ///////////////////////////////////////////////////////////
 
-bool TAnal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
+struct TAnal_tree_pos : public TObject
 {
-  return true;
+  TRecnotype _recno;
+  TToken_string _key;
+
+  void as_string(TString& id) const;
+  int level() const { return _key.items(); }
+  void reset();
+};
+
+void TAnal_tree_pos::as_string(TString& id) const
+{
+  id.format("%ld|%s", _recno, (const char*)_key);
 }
 
-int TAnal_msk::compute_offset() const
+void TAnal_tree_pos::reset()
 {
-  int delta = 0;
+  _recno = 0;
-  RCT rct; xvt_vobj_get_client_rect(TASK_WIN, &rct);
+  _key.cut(0);
-  if (rct.right > 720)
-    delta = (rct.right - 720) / 2 / CHARX;
-  return delta;
 }
 
-TAnal_msk::TAnal_msk(const char* name)
+class TAnal_tree : public TBidirectional_tree
-{
-  const TFilename outname = "anal.msk";
-  TFilename inpname = name; inpname.ext("msk");
-  inpname.custom_path();
-
-  ofstream out(outname);
-
-  int delta = compute_offset();
-  TString line;
-
-  TScanner inp(inpname);
-  while (!inp.eof())
-  {
-    line = inp.line();
-    if (line.starts_with("PR "))
-    {
-      TToken_string l(line, ' ');
-      l.strip_d_spaces();
-      int x = l.get_int(1);
-      if (x >= 0)
-      {
-        x += delta;
-        l.add(x, 1);
-        line = l;
-      }
-    }
-    out << line << endl;
-  }
-  out.close();
-
-  read_mask(outname, 0, 0);
-  xvt_fsys_removefile(outname);
-}
-
-short TAnal_msk::create_tree_field()
-{
-  short id = 0;
-  const int delta = compute_offset();
-  if (delta > 0)
-  {
-    id = 99;
-    add_tree(id, 0, 0, 1, delta*2, -1);
-  }
-  return id;
-}
-
-///////////////////////////////////////////////////////////
-// TSimple_anal_tree
-///////////////////////////////////////////////////////////
-
-class TSimple_anal_tree : public TBidirectional_tree
 {
   TLocalisamfile _file;
-  TString16 _key_field, _des_field;
+  const TArray& _key1_fields;
-  
+  const TArray& _key2_fields;
-  TRecnotype _curr;
+
-  TString _str_curr;
+  TAnal_tree_pos  _curr;
-  
-  void update_curr();
 
 protected:
   virtual void node2id(const TObject* node, TString& id) const;
@@ -92,194 +46,488 @@ protected:
   virtual bool goto_lbrother();
   virtual bool get_description(TString& desc) const;
 
+protected:
+  void update_curr();
+  const char* get_key_field(int key = 1) const;
+  int level_of(const TToken_string& key) const;
+  int level_of_file() const;
+  const TToken_string& curr_of_file() const;
+  int curr_level() const;
+  int max_level() const;
+  const TToken_string& father_of(const TToken_string& key) const;
+  const TToken_string& father_of_file() const;
+  bool repos() const;
+
 public:
   virtual bool goto_root();
 
-  TSimple_anal_tree(int logicnum);
+  TAnal_tree(int logicnum, const TArray& key1, const TArray& key2);
 };
 
-void TSimple_anal_tree::update_curr()
+///////////////////////////////////////////////////////////
-{
+// TAnal_msk
-  _curr = _file.recno();
+///////////////////////////////////////////////////////////
-  _str_curr.format("%ld", _curr);
-}
 
-void TSimple_anal_tree::node2id(const TObject* node, TString& id) const
+#define F_TREE 99
-{
-  id = *(TString*)node;
-}
 
-bool TSimple_anal_tree::goto_root()
+bool TAnal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
 {
-  const int err = _file.first();
+  switch (o.dlg())
-  if (err == NOERR)
-    update_curr();
-  return err == NOERR;
-}
-
-bool TSimple_anal_tree::goto_firstson()
-{
-  int err = _file.readat(_curr);
-  if (err == NOERR)
   {
-    const TString pref = _file.curr().get(_key_field);
+  case F_TREE:
-    err = _file.next();
+    if (e == fe_select)
-    if (err == NOERR)
     {
-      const TString now = _file.curr().get(_key_field);
+      if (edit_mode() && !dirty())
-      if (now.starts_with(pref))
+        set_mode(MODE_QUERY);
-        update_curr();
+      if (query_mode())
-      else
-        err = _iskeynotfound;
-    }
-  }
-  return err == NOERR;
-}
-
-bool TSimple_anal_tree::goto_rbrother()
-{
-  int err = _file.readat(_curr);
-  if (err == NOERR)
-  {
-    const TString pref = _file.curr().get(_key_field);
-    err = _file.next();
-    if (err == NOERR)
-    {
-      const TString now = _file.curr().get(_key_field);
-      if (now.len() == pref.len())
-        update_curr();
-      else
-        err = _iskeynotfound;
-    }
-  }
-  return err == NOERR;
-}
-
-bool TSimple_anal_tree::goto_node(const TString &id)
-{
-  const int err = _file.readat(atol(id));
-  if (err == NOERR)
-    update_curr();
-  return err == NOERR;
-}
-
-bool TSimple_anal_tree::goto_father()
-{
-  int err = _file.readat(_curr);
-  if (err == NOERR)
-  {
-    const TString pref = _file.curr().get(_key_field);
-    while (err == NOERR)
-    {
-      err = _file.prev();
-      if (err == NOERR)
       {
-        const TString prev = _file.curr().get(_key_field);
+        const TTree_field& fld = (const TTree_field&)o;
-        if (prev.len() < pref.len())
+        const TTree& tree = *fld.tree();
+        TToken_string curr; tree.curr_id(curr);
+        for (int i = 0; ; i++)
         {
-          update_curr();
+          const short id = get_field_id(i);
-          break;
+          if (id <= 0)
+            break;
+          const char* tok = curr.get(i+1);
+          TEdit_field& e = efield(id);
+          e.set(tok);
+          e.show();
         }
+        stop_run(K_AUTO_ENTER);
       }
-    }
-  }
-  return err == NOERR;
-}
-
-bool TSimple_anal_tree::goto_lbrother()
-{
-  int err = _file.readat(_curr);
-  if (err == NOERR)
-  {
-    const TString pref = _file.curr().get(_key_field);
-    err = _file.prev();
-    if (err == NOERR)
-    {
-      const TString prev = _file.curr().get(_key_field);
-      if (prev.len() == pref.len())
-        update_curr();
       else
-        err = _iskeynotfound;
+        beep(0);
+    }
+    break;
+  default: 
+    break;
+  }
+  return true;
+}
+
+int TAnal_msk::compute_offset() const
+{
+  int delta = 0;
+  RCT rct; xvt_vobj_get_client_rect(TASK_WIN, &rct);
+  if (rct.right > 720)
+    delta = (rct.right - 720) / 2 / CHARX;
+  return delta;
+}
+
+void TAnal_msk::read(const char* name)
+{
+  const int delta = compute_offset();
+
+  if (delta > 0)
+  {
+    const TFilename outname = "anal.msk";
+    TFilename inpname = name; inpname.ext("msk");
+    inpname.custom_path();
+
+    ofstream out(outname);
+
+    TString line;
+    int status = 0;
+    TScanner inp(inpname);
+    while (!inp.eof())
+    {
+      line = inp.line();
+      switch (status)
+      {
+      case 0:
+        if (line.starts_with("PA "))
+          status = 1;
+        break;
+      case 1:
+        if (line.starts_with("PR "))
+        {
+          TToken_string l(line, ' ');
+          l.strip_d_spaces();
+          int x = l.get_int(1);
+          if (x >= 0)
+          {
+            x += delta;
+            l.add(x, 1);
+            line = l;
+          }
+        } else
+        if (line.starts_with("PA "))
+        {
+          status = 2;
+        }
+        break;
+      default:
+        break;
+      }
+      out << line << endl;
+    }
+    out.close();
+
+    read_mask(outname, 0, 0);
+    xvt_fsys_removefile(outname);
+  }
+  else
+    read_mask(name, 0, 0);
+
+  create_key_fields();
+  create_tree_field();
+}
+
+int TAnal_msk::create_key_fields()
+{
+  return 0;
+}
+
+short TAnal_msk::create_tree_field()
+{
+  short id = 0;
+  const int delta = compute_offset();
+  if (delta > 0)
+  {
+    id = F_TREE;
+    add_tree(id, 0, 0, 1, delta*2, -1);
+
+    TAnal_tree* t = new TAnal_tree(get_logicnum(), _key1_fields, _key2_fields);
+    tfield(id).set_tree(t);
+    t->goto_root();
+    t->expand();
+  }
+  set_handlers();
+  return id;
+}
+
+void TAnal_msk::update_tree_field()
+{
+  const int pos = id2pos(F_TREE);
+  if (pos >= 0)
+  {
+    TTree_field& t = tfield(F_TREE);
+    t.win().force_update();
+  }
+}
+
+void TAnal_msk::add_fieldref(const char* name, int from, int to, int key)
+{
+  TArray& a = key == 1 ? _key1_fields : _key2_fields;
+  TString80 str; str << name;
+  if (from > 0)
+    str << '[' << from << ',' << to << ']';
+
+  TFieldref* fr = new TFieldref(str, get_logicnum());
+  a.add(fr);
+}
+
+int TAnal_msk::fieldrefs(int k) const
+{
+  const TArray& a = k == 1 ? _key1_fields : _key2_fields;
+  return a.items();
+}
+
+const TFieldref& TAnal_msk::fieldref(int n, int k) const
+{
+  const TArray& a = k == 1 ? _key1_fields : _key2_fields;
+  return (const TFieldref&)a[n];
+
+}
+
+const TToken_string& TAnal_msk::get_key_value(const TRectype& rec, int c) const
+{
+  TToken_string& val = get_tmp_string();
+  const int tot = fieldrefs(c);
+  for (int i = 0; i < tot; i++)
+  {
+    const TFieldref& field = fieldref(i, c);
+    val.add(field.read(rec));
+  }
+  return val;
+}
+
+const TToken_string& TAnal_msk::get_key_value(int c) const
+{
+  TToken_string& val = get_tmp_string();
+  for (TEditable_field* f = get_key_field(c, true); f != NULL; f = get_key_field(c, false))
+  {
+    val.add(f->get());
+  }
+  return val;
+}
+
+
+///////////////////////////////////////////////////////////
+// TAnal_tree
+///////////////////////////////////////////////////////////
+
+const TToken_string& TAnal_tree::curr_of_file() const
+{
+  TToken_string& k = get_tmp_string();
+  const TRectype& rec = _file.curr();
+  for (int i = 0; i < max_level(); i++)
+  {
+    const TFieldref& fld = (const TFieldref&)_key1_fields[i];
+    k.add(fld.read(rec));
+  }
+
+  for (int j = k.len()-1; j >= 0; j--)
+  {
+    if (k[j] == ' ' || k[j] == k.separator())
+      k.cut(j);
+    else
+      break;
+  }
+
+  return k;
+}
+
+int TAnal_tree::level_of(const TToken_string& k) const
+{
+  return k.items();
+}
+
+int TAnal_tree::level_of_file() const
+{
+  const TToken_string& str = curr_of_file();
+  return level_of(str);
+}
+
+int TAnal_tree::curr_level() const
+{
+  return level_of(_curr._key);
+}
+
+int TAnal_tree::max_level() const
+{
+  return _key1_fields.items();
+}
+
+const TToken_string& TAnal_tree::father_of(const TToken_string& key) const
+{
+  const int pos = key.rfind(key.separator());
+  if (pos <= 0)
+    return EMPTY_STRING;
+
+  TToken_string& k = get_tmp_string();
+  k = key.left(pos);
+  return k;
+}
+
+const TToken_string& TAnal_tree::father_of_file() const
+{
+  const TToken_string& k = curr_of_file();
+  return father_of(k);
+}
+
+void TAnal_tree::update_curr()
+{
+  _curr._key = curr_of_file();
+  if (_curr._key.not_empty())
+    _curr._recno = _file.recno();
+  else
+    _curr.reset();
+}
+
+bool TAnal_tree::repos() const
+{
+  bool ok = false;
+  if (_curr.level() > 0)
+  {
+    if (_file.recno() != _curr._recno)
+      ok = ((TLocalisamfile&)_file).readat(_curr._recno) == NOERR;
+    else
+      ok = true;
+  }
+  return ok;
+}
+
+void TAnal_tree::node2id(const TObject* node, TString& id) const
+{
+  const TAnal_tree_pos* pos = (const TAnal_tree_pos*)node;
+  pos->as_string(id);
+}
+
+bool TAnal_tree::goto_root()
+{
+  const bool ok = _file.first() == NOERR;
+  if (ok)
+    update_curr();
+  else
+    _curr.reset();
+  return ok;
+}
+
+bool TAnal_tree::goto_firstson()
+{
+  bool ok = _curr.level() < max_level() && repos();
+  if (ok)
+  {
+    ok = _file.next() == NOERR;
+    if (ok)
+    {
+      ok = father_of_file() == _curr._key; 
+      if (ok)
+        update_curr();
     }
   }
-  return err == NOERR;
+  return ok;
 }
 
-TObject* TSimple_anal_tree::curr_node() const
+bool TAnal_tree::goto_rbrother()
 {
-  return (TObject*)&_str_curr;
+  bool ok = false;
-}
+  if (repos())
-
-bool TSimple_anal_tree::get_description(TString& desc) const
-{
-  int err = ((TLocalisamfile&)_file).readat(_curr);
-  if (err == NOERR)
   {
-    desc = _file.curr().get(_key_field);
+    const TToken_string curr_father = father_of(_curr._key);
-    desc << ' ' << _file.curr().get(_des_field);
+    while (_file.next() == NOERR)
+    {
+      const int lev = level_of_file();
+      if (lev > _curr.level())
+        continue;
+
+      const TToken_string& next_father = father_of_file();
+      ok = next_father == curr_father;
+      break;
+    }
+    if (ok)
+      update_curr();
   }
+  return ok;
+}
+
+bool TAnal_tree::goto_node(const TString &id)
+{
+  const TRecnotype rec = atol(id); 
+  const int err = _file.readat(rec);
+  
+  if (err == NOERR)
+    update_curr();
+  
   return err == NOERR;
 }
 
-TSimple_anal_tree::TSimple_anal_tree(int logicnum)
+bool TAnal_tree::goto_father()
-                 : _file(logicnum)
+{
+  const int lev = _curr.level();
+  bool ok = lev > 1;
+  if (ok)
+  {
+    TRectype& rec = _file.curr();
+    rec.zero();
+    
+    for (int i = 0; i < lev-1; i++)
+    {
+      const char* val = _curr._key.get(i);
+      const TFieldref& fld = (const TFieldref&)_key1_fields[i];
+      fld.write(val, rec);
+    }
+    ok = _file.read() == NOERR;
+    if (ok)
+      update_curr();
+  }
+  return ok;
+}
+
+bool TAnal_tree::goto_lbrother()
+{
+  bool ok = false;
+  if (repos())
+  {
+    const TString curr_father = father_of(_curr._key);
+    while (_file.prev() == NOERR)
+    {
+      const int lev = level_of_file();
+      if (lev > _curr.level())
+        continue;
+
+      const TString& next_father = father_of_file();
+      ok = next_father == curr_father;
+      break;
+    }
+    if (ok)
+      update_curr();
+  }
+  return ok;
+}
+
+TObject* TAnal_tree::curr_node() const
+{
+  return (TObject*)&_curr;
+}
+
+bool TAnal_tree::get_description(TString& desc) const
+{
+  const bool ok = repos();
+  if (ok)
+  {
+    const int lev = _curr.level();
+    if (lev > 0)
+    {
+      const TFieldref& fld1 = (const TFieldref&)_key1_fields[lev-1];
+      const TFieldref& fld2 = (const TFieldref&)_key2_fields[0];
+      desc = fld1.read(_file.curr());
+      desc << ' ' << fld2.read(_file.curr());
+    }
+  }
+  return ok;
+}
+
+TAnal_tree::TAnal_tree(int logicnum, const TArray& key1, const TArray& key2) 
+          : _file(logicnum), _key1_fields(key1), _key2_fields(key2)
 {
-  _key_field = _file.curr().fieldname(0);
-  _des_field = "DESCR";
 }
 
 ///////////////////////////////////////////////////////////
 // TSimple_anal_msk
 ///////////////////////////////////////////////////////////
 
-void TSimple_anal_msk::get_key_fields(TString& key1, TString& key2) const
+const char* TSimple_anal_msk::get_key_fieldname(int k) const
 {
-  const RecDes& des = prefix().get_recdes(get_logicnum());
+  const RecDes& rd = prefix().get_recdes(get_logicnum());
-  
+  CHECKD(k > 0 && k <= rd.NKeys, "Invalid key ", k);
-  const KeyDes k1 = des.Ky[0];
+  const KeyDes& ky = rd.Ky[k-1];
-  key1 = des.Fd[k1.FieldSeq[0] % MaxFields].Name;
+  const int pos = ky.FieldSeq[0] % MaxFields;
-
+  return rd.Fd[pos].Name;
-  const KeyDes k2 = des.Ky[1];
-  key2 = des.Fd[k2.FieldSeq[0] % MaxFields].Name;
 }
 
-int TSimple_anal_msk::get_key_len(int level, TConfig& cfg) const
+void TSimple_anal_msk::append_select_clause(ostream& out, int level) const
 {
-  int len = 0;
+  const TFieldref& key = fieldref(level-1, 1);
-  for (int i = 1; i <= level; i++)
+
+  TString str;
+  str << " SE STR(";
+  if (level > 1)
+    str << "(NUM(LEN(" << key.name() << "))>" << key.from() << ')'; // SE LEN(CODCONTO)>=4
+  if (level < fieldrefs())
   {
-    const TString& picture = cfg.get(get_key_var(), NULL, i);
+    if (level > 1) str << "&&";
-    len += picture.len();
+    str << "(NUM(LEN(" << key.name() << "))<=" << key.to() << ')';  // SE LEN(CODCONTO)<=7
   }
-  return len;
+  str << ')';
+  out << str << endl;
 }
 
 void TSimple_anal_msk::create_key_browse(TEdit_field& kfld, int level, TConfig& cfg)
 {
-  TString16 key1, key2;
-  get_key_fields(key1, key2);
-
-  const TString q(get_key_len(level, cfg), '?');
-
   TFilename tmp; tmp.temp();
   ofstream out(tmp);
-  out << "US " << get_logicnum() << " SE " << key1 << "?=\"" << q << '"' << endl;
+  out << "US " << get_logicnum() << " KE 1";
+  append_select_clause(out, level);
   out << "KE 1" << endl;
 
-  int from = 1, to = 1;
   for (int i = 1; i <= level; i++)
   {
     const TString& picture = cfg.get(get_key_var(), NULL, i);
     const TString& prompt = cfg.get(get_des_var(), NULL, i);
-    to = from + picture.len()-1;
+    const TFieldref& field = fieldref(i-1, 1);
-    TString field; field.format("%s[%d,%d]", (const char*)key1, from, to);
+    const int length = field.to() - field.from();
-    out << "IN " << field << ' ' << get_key_id(i-1) << endl;
+    out << "IN " << field << ' ' << get_field_id(i-1, 1) << endl;
-    out << "DI \"" << prompt << '@' << (to-from+1) << "\" " << field << endl;
+    out << "DI \"" << prompt << '@' << length << "\" " << field << endl;
-    out << "OU " << get_key_id(i-1) << ' ' << field << endl;
+    out << "OU " << get_field_id(i-1, 1) << ' ' << field << endl;
-    from = to+1;
+    if (i == level)
+      out << "FI " << field << endl;
   }
-  out << "DI \"Descrizione@50\" " << key2 << endl;
+  const TFieldref& field = fieldref(0, 2);
-  out << "OU " << get_des_id(level-1) << ' ' << key2 << endl;
+  out << "DI \"Descrizione@50\" " << fieldref(0, 2) << endl;
+  out << "OU " << get_field_id(level-1, 2) << ' ' << field << endl;
   out << "CH " << (level == 1 ? "RE" : "NO") << endl;
   out << "EN" << endl;
   out.close();
@@ -293,16 +541,13 @@ void TSimple_anal_msk::create_key_browse(TEdit_field& kfld, int level, TConfig&
 
 void TSimple_anal_msk::create_des_browse(TEdit_field& kfld, int level, TConfig& cfg)
 {
-  TString16 key1, key2;
+  TString key2; key2 << fieldref(0, 2);
-  get_key_fields(key1, key2);
-
-  const TString q(get_key_len(level, cfg), '?');
 
   TFilename tmp; tmp.temp();
   ofstream out(tmp);
-  out << "US " << get_logicnum() << " KE 2" << " SE " << key1 << "?=\"" << q << '"' << endl;
+  out << "US " << get_logicnum() << " KE 2";
+  append_select_clause(out, level);
   out << "KE 2" << endl;
-
   out << "DI \"Descrizione@50\" " << key2 << endl;
   out << "IN " << key2 << ' ' << kfld.dlg() << endl;
   out << "OU " << kfld.dlg() << ' ' << key2 << endl;
@@ -312,10 +557,10 @@ void TSimple_anal_msk::create_des_browse(TEdit_field& kfld, int level, TConfig&
   {
     const TString& picture = cfg.get(get_key_var(), NULL, i);
     const TString& prompt = cfg.get(get_des_var(), NULL, i);
-    to = from + picture.len()-1;
+    const TFieldref& field = fieldref(i-1, 1);
-    TString field; field.format("%s[%d,%d]", (const char*)key1, from, to);
+    const int length = field.to() - field.from();
-    out << "DI \"" << prompt << '@' << (to-from+1) << "\" " << field << endl;
+    out << "DI \"" << prompt << '@' << length << "\" " << field << endl;
-    out << "OU " << get_key_id(i-1) << ' ' << field << endl;
+    out << "OU " << get_field_id(i-1, 1) << ' ' << field << endl;
     from = to+1;
   }
   out << "CH NO" << endl;
@@ -338,6 +583,7 @@ int TSimple_anal_msk::create_key_fields()
 
   int maxkeylen = 0, maxdeslen = 0;
   int level;
+  int from = 1, to = 1;
   for (level = 1; ; level++)
   {
     const TString& prompt = cfg.get(desvar, NULL, level);
@@ -348,53 +594,85 @@ int TSimple_anal_msk::create_key_fields()
     const int deslen = prompt.len();
     if (keylen > maxkeylen) maxkeylen = keylen;
     if (deslen > maxdeslen) maxdeslen = deslen;
+
+    to = from+keylen-1;
+    add_fieldref(get_key_fieldname(1), from, to, 1);
+    from = to+1;
   }
+  add_fieldref(get_key_fieldname(2), 0, 0, 2);
+
   maxdeslen++;
   const int tab0 = compute_offset()+2;
   const int tab1 = tab0 + maxdeslen + maxkeylen + 4;
-  for (int i = 1; i < level; i++)
+
+  int i;
+  for (i = 1; i < level; i++)
   {
-    const short kid = get_key_id(i-1);
+    const short kid = get_field_id(i-1, 1);
     CHECKD(kid > 100, "Invalid field id:", kid);
 
     const TString& picture = cfg.get(keyvar, NULL, i);
     TString80 prompt = cfg.get(desvar, NULL, i);
     prompt.left_just(maxdeslen);
-    TEdit_field& kfld = add_string(kid, 0, prompt, tab0, i, picture.len(), "B");
+    TEdit_field& kfld = add_string(kid, 0, prompt, tab0, i, picture.len(), "BU");
     create_key_browse(kfld, i, cfg);
+  }
 
-    const short did = get_des_id(i-1);
+  for (i = 1; i < level; i++)
-    if (did > kid)
+  {
-    {
+    const short did = get_field_id(i-1, 2);
-      TEdit_field& dfld = add_string(did, 0, "", tab1, i, 50, "B", 72+tab0-tab1);
+    TEdit_field& dfld = add_string(did, 0, "", tab1, i, 50, "B", 72+tab0-tab1);
-      create_des_browse(dfld, i, cfg);
+    create_des_browse(dfld, i, cfg);
-    }
   }
   
   return level;
 }
 
-short TSimple_anal_msk::create_tree_field()
-{
-  const short tree_id = TAnal_msk::create_tree_field();
-  if (tree_id != 0)
-  {
-    TSimple_anal_tree* t = new TSimple_anal_tree(get_logicnum());
-    tfield(tree_id).set_tree(t);
-    t->goto_root();
-    t->expand();
-  }
-  return tree_id;
-}
-
-TSimple_anal_msk::TSimple_anal_msk(const char* name) : TAnal_msk(name) 
-{ 
-}
-
 ///////////////////////////////////////////////////////////
 // TAnal_app
 ///////////////////////////////////////////////////////////
 
+void TAnal_app::init_key_fields() const
+{
+  int maxlev = 0;
+  for (maxlev = 0; maxlev < 4; maxlev++)
+  {
+    const short id = _msk->get_field_id(maxlev, 1);
+    if (id <= 0 || _msk->id2pos(id) < 0)
+      break;
+    _msk->disable(id);
+
+    const short did = _msk->get_field_id(maxlev, 2);
+    _msk->disable(did);
+  }
+
+  for (int i = maxlev-1; i >= 0; i--)
+  {
+    const short id = _msk->get_field_id(i, 1);
+    TEdit_field& e = _msk->efield(id);
+    const short did = _msk->get_field_id(i, 2);
+    TEdit_field& d = _msk->efield(did);
+
+    if (e.empty())
+    {
+      e.hide();
+      d.hide();
+    }
+    else
+    {
+      TString key2; key2 << _msk->fieldref(0, 2);
+      e.show();
+      e.check(STARTING_CHECK);
+      d.show();
+      d.set_field(key2);
+      d.enable();
+      d.enable_check(false);
+      break;
+    }
+  }
+}
+
+
 TRelation* TAnal_app::create_relation() const 
 { 
   return new TRelation(_msk->get_logicnum()); 
@@ -407,6 +685,48 @@ bool TAnal_app::user_create()
   return true;
 }
 
+void TAnal_app::init_query_mode(TMask& mask)
+{
+  TAnal_msk& m = (TAnal_msk&)mask;
+  for (int i = 0; ; i++)
+  {
+    const short id = m.get_field_id(i, 1);
+    if (id <= 0 || m.id2pos(id) < 0)
+      break;
+
+    TEdit_field& e = m.efield(id);
+    e.show(); e.enable();
+
+    const short did = m.get_field_id(i, 2);
+    TEdit_field& d = m.efield(did);
+    d.show(); d.enable();
+    d.set_field(EMPTY_STRING);
+    d.enable_check();
+  }
+}
+
+void TAnal_app::init_modify_mode(TMask& m)
+{
+  init_key_fields();
+}
+
+void TAnal_app::init_insert_mode(TMask& m)
+{
+  init_key_fields();
+}
+
+int TAnal_app::write(const TMask& m)
+{
+  _msk->update_tree_field();
+  return TRelation_application::write(m);
+}
+
+int TAnal_app::rewrite(const TMask& m)
+{
+  _msk->update_tree_field();
+  return TRelation_application::rewrite(m);
+}
+
 bool TAnal_app::user_destroy()
 {
   if (_msk != NULL)

ca/calib01.h

@@ -15,18 +15,33 @@
 
 class TAnal_msk : public TAutomask
 {
+  TArray _key1_fields;
+  TArray _key2_fields;
+
 protected:
-  virtual int create_key_fields() pure;
+  void add_fieldref(const char* name, int from, int to, int key = 1);
 
 protected:
   virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
+  virtual void read(const char* msk);
 
+  virtual int create_key_fields();
   virtual short create_tree_field();
   int compute_offset() const;
-  TAnal_msk(const char* name);
+  TAnal_msk() { }
 
 public:
+  void update_tree_field();
+
+  const TFieldref& fieldref(int n, int key = 1) const;
+  int fieldrefs(int key = 1) const;
+  
   virtual int get_logicnum() const pure;
+  virtual short get_field_id(int n, int key = 1) const pure;
+  
+  virtual const TToken_string& get_key_value(const TRectype& rec, int k = 1) const;
+  virtual const TToken_string& get_key_value(int k = 1) const;
+
 };
 
 ///////////////////////////////////////////////////////////
@@ -38,19 +53,15 @@ class TSimple_anal_msk : public TAnal_msk
 protected:
   virtual const char* get_key_var() const pure;
   virtual const char* get_des_var() const pure;
-  virtual short get_key_id(int n) const pure;
+  const char* get_key_fieldname(int k) const;
-  virtual short get_des_id(int n) const pure;
-  
-  void get_key_fields(TString& key1, TString& key2) const;
-  int get_key_len(int level, TConfig& cfg) const;
   
+  void append_select_clause(ostream& out, int level) const;
   void create_key_browse(TEdit_field& kfld, int level, TConfig& cfg);
   void create_des_browse(TEdit_field& kfld, int level, TConfig& cfg);
   virtual int create_key_fields();
-  virtual short create_tree_field();
 
 protected:
-  TSimple_anal_msk(const char* name);
+  TSimple_anal_msk() { }
 };
 
 ///////////////////////////////////////////////////////////
@@ -68,6 +79,12 @@ protected:
   virtual TRelation* get_relation() const { return _rel; }
   virtual bool user_create();
   virtual bool user_destroy();
+  virtual int write(const TMask& m);
+  virtual int rewrite(const TMask& m);
+  void init_key_fields() const;
+  virtual void init_query_mode(TMask& m);
+  virtual void init_modify_mode(TMask& m);
+  virtual void init_insert_mode(TMask& m);
 
 protected:
   virtual TAnal_msk* create_mask() const pure;