root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/ba0100.cpp
guy fab5abc300 Patch level :10.0 patch 24 
Files correlati     : tutta la base ed anche l'ipotenusa
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@16462 c028cbd2-c16b-5b4b-a496-9718f37d4682
2008-04-04 16:03:36 +00:00

1921 lines
47 KiB
C++
Executable File
Raw Blame History

#include <xinclude.h>
#include <applicat.h>
#include <automask.h>
#include <controls.h>
#include <dongle.h>
#include <execp.h>
#include <modaut.h>
#include <execp.h>
#include <recarray.h>
#include <relation.h>
#include <msksheet.h>
#include <progind.h>
#include <sheet.h>
#include <utility.h>
#include <urldefid.h>
#include <nditte.h>
#include <user.h>
#include "ba0.h"
#include "ba0101.h"
#include "ba0102.h"
#include "ba0103.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;
bool ask_user_password(TString& utente);
protected:
void deconnect_user();
virtual void main_loop();
void test_temp();
int do_level();
int do_tree();
int do_explore();
int do_outlook();
int get_user_status(const char* usr) const;
bool set_user_status(const char* usr, int status) const;
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();
bool copy_setup(const TString& remote_path);
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 - 10 * 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;
//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 - imgy - 1;
//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", "jpeg", NULL };
for (int i = 0; ext[i]; i++)
{
logoname = "logo"; logoname.ext(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;
}
///////////////////////////////////////////////////////////
// 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;
COLOR cid2syscolor(short cid, const XVT_COLOR_COMPONENT* cc) 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 211:
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 212:
if (e == fe_button)
{
XVT_COLOR_COMPONENT* cc = (XVT_COLOR_COMPONENT*)xvt_vobj_get_attr(NULL_WIN, ATTR_APP_CTL_COLORS);
for (short bid = 101; bid <= 113; bid++)
{
const char* name = cid2name(bid);
const COLOR color = cid2syscolor(bid, cc);
set_color_entry(name, color);
}
xvt_mem_free((DATA_PTR)cc);
update();
}
break;
case DLG_USER:
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;
case DLG_EDIT:
if (e == fe_button)
dispatch_e_menu(TASK_WIN, MENU_ITEM(2));
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(214, NATIVE_CONTROLS ? "X" : "");
set(215, ADVANCED_GRAPHICS ? "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("NativeControls", get_bool(214) ? "X" : "");
colors.set("AdvancedGraphics", get_bool(215) ? "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[] = { MAKE_COLOR(201,194,188), 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];
}
COLOR TColor_mask::cid2syscolor(short cid, const XVT_COLOR_COMPONENT* cc) const
{
int entry[] = { XVT_COLOR_BACKGROUND, XVT_COLOR_BLEND, XVT_COLOR_BORDER,
XVT_COLOR_FOREGROUND, XVT_COLOR_BACKGROUND, XVT_COLOR_BACKGROUND,
XVT_COLOR_HIGHLIGHT, XVT_COLOR_SELECT,
XVT_COLOR_BLEND, XVT_COLOR_BORDER,
XVT_COLOR_BACKGROUND, XVT_COLOR_BLEND, XVT_COLOR_BORDER };
const unsigned int component = entry[cid-101];
for (int i = 0; cc[i].type != XVT_COLOR_NULL; i++)
{
if (cc[i].type == component)
{
switch (cid)
{
case 105: return COLOR_WHITE;
case 106: return blend_colors(cid2syscolor(105, cc), cid2syscolor(108, cc), 0.60);
default : return cc[i].color;
}
}
}
return COLOR_BLACK;
}
///////////////////////////////////////////////////////////
// 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);
TPicture_mask mask(curr.caption(), 0, 0, curr, 0, 0);
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();
}
bool TMenu_application::ask_user_password(TString& utente)
{
bool ok = false;
// 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;
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(USR_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 && 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("E' necessario inserire una nuova password"));
user() = utente;
TExternal_app app("ba1 -3");
app.run();
users.reread();
}
}
}
// Abilita le voci di personalizzazione
for (mi = 2; mi <= 7; mi++)
enable_menu_item(MENU_ITEM(mi));
return ok;
}
// Testa stato utente: 0 inesistente; 1 = esiste; 2 connesso; 4 conversione in corso
// ATTENZIONE: non usare mai cache() in ba0!
int TMenu_application::get_user_status(const char* usr) const
{
CHECK(usr && *usr, "Utente nullo");
int status = 0;
if (prefix_valid())
{
TLocalisamfile utonti(LF_USER);
utonti.put(USR_USERNAME, usr);
status = utonti.read() == NOERR;
if (status)
{
if (utonti.get_bool(USR_CONNECTED))
status |= 2;
if (dongle().administrator() == usr && utonti.get(USR_AUTSTR) == "CONVERTING")
status |= 4;
}
}
else
{
// Senza file aperti questo e' il massimo che posso fare
status = dongle().administrator() == usr;
}
return status;
}
bool TMenu_application::set_user_status(const char* usr, int status) const
{
CHECK(usr && *usr, "Utente nullo");
bool ok = false;
if (prefix_valid())
{
TLocalisamfile utonti(LF_USER);
utonti.put(USR_USERNAME, usr);
if (utonti.read(_isequal, _lock) == NOERR)
{
utonti.put(USR_CONNECTED, status & 2 ? "X" : "");
ok = utonti.rewrite() == NOERR;
}
}
if (status & 2)
{
// Memorizza utente per riproporlo la prossima volta
TConfig campo_ini(CONFIG_INSTALL, "Main");
campo_ini.set("User", usr);
}
return ok;
}
bool TMenu_application::check_user()
{
bool ok = dongle().type() == _no_dongle;
if (!ok)
{
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)
ok = ask_user_password(utente);
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)
set_user_status(utente, 3); // Esistente e connesso (1 | 2 = 3)
}
}
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::copy_setup(const TString& remote_path)
{
bool ok = false;
const TFilename local_setupdir = "setup";
TFilename remote_setupdir = remote_path;
remote_setupdir.add(local_setupdir.name());
//controlla se esiste la directory;<3B> necessario in quanto se <20> una vecchia 4.0 potrebbe non esserci
if (remote_setupdir.exist())
{
remote_setupdir.add("*.*");
TString_array ar;
list_files(remote_setupdir, ar);
if (!ar.empty())
{
make_dir(local_setupdir);
ok = true;
TFilename strsrc, strdst;
FOR_EACH_ARRAY_ROW (ar, i, row)
{
strsrc = *row;
strdst = local_setupdir;
strdst.add(strsrc.name());
//se la copia dei files si inchioda esce
if (!fcopy(strsrc, strdst))
{
ok = false;
break;
}
} //FOR_EACH_ARRAY...
} //if(!ar.empty...
} //if(remote_setupdir...
return ok;
}
bool TMenu_application::test_programs()
{
TToken_string dangerous;
int update_needed = 0;
bool is_client = false;
//parentesi necessaria per richiudere subito il .ini!
{
TConfig prawin(CONFIG_INSTALL, "Main");
const int type = prawin.get_int("Type");
if (type == 3)
is_client = true;
else
is_client = prawin.get_bool("TestPrograms");
}
if (is_client)
{
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:\n");
//giro su tutti i moduli che sono sul server
const TDongle& chiavetta = dongle();
FOR_EACH_ASSOC_STRING(his_modules, h, str_code, str_tok)
{
//per prima cosa controlla se deve aggiornare SY e/o BA
int module = 0;
const TString4 code = str_code;
if (code != "sy" && code != "ba")
module = chiavetta.module_name2code(code);
if (chiavetta.active(module) && chiavetta.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)
{
// Non disabilitare mai il modulo base! Se non funzionasse qualcosa (vedi anno di assistenza)...
//...non lascierebbe funzionare nulla!!!!
if (module > 0)
dangerous.add(code);
if (msg.len() < 200)
{
TString name;
if (code == "sy")
name = TR("Sistema");
else
name = chiavetta.module_code2desc(module);
if (update_needed > 0)
msg << ", ";
msg << name;
}
else
{
if (msg.right(1) != ".")
msg << ",etc.";
}
update_needed++;
} //if (!v1.blank()...
} //if (chiavetta.active(module...
} //FOR_EACH_ASSOC_STR
if (update_needed > 0)
warning_box(msg);
} //if(remote_name.exist()...
if (update_needed > 0 && yesno_box(TR("Si desidera aggiornare i moduli adesso?")))
{
//copia il contenuto della setup del server nella setup del client
if (copy_setup(remote_name.path()))
{
//mette il flag di installing
set_installing_flag();
//lancia setup in modalita' aggiornamento client e si suicida! (banzai!!)
xvt_sys_execute("setup\\setup.exe -uc", false, false);
}
else //lancia l'installazione moduli alla vecchia maniera (e' una vecchia 4.0)
{
TExternal_app app("ba1 -6 /uADMIN");
app.run(true);
}
//se lancia un'installazione->esce!!!
return false;
} //(if(update_needed>0...
} //if(is_client..
_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
if (dongle().type() == _no_dongle)
warning_box(TR("ATTENZIONE\nQuesto programma <20> in versione dimostrativa.\n"
"Esso funzionera' per circa due ore al giorno con un numero limitato di registrazioni."));
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 (get_user_status(user()) & 2) // Se e' connesso
set_user_status(user(), 1); // Sconnettilo
}
bool TMenu_application::destroy()
{
deconnect_user();
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;
case 3: m = do_outlook(); break;
default: m = do_level(); break;
}
if (m > 0)
_menu.perform();
else
run = m >= -1;
if (installing()) //esce dal ciclo se ha lanciato una installazione moduli
break;
}
}
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() || path.find(' ') >= 0)
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;
if (dirgen.find(' ') < 0)
{
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()
{
// Disbilita le voci di personalizzazione
int mi;
for (mi = 2; mi <= 7; mi++)
disable_menu_item(MENU_ITEM(mi));
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
}
// Abilita le voci di personalizzazione
for (mi = 2; mi <= 7; mi++)
enable_menu_item(MENU_ITEM(mi));
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);
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();
TTree_field& tf = f.mask().tfield(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", NULL, -1, 3);
_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;
}
int TMenu_application::do_outlook()
{
CHECK(_mask == NULL, "Two masks are better than one?");
TOutlook_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.compare("Administrator", -1, true) == 0) // 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;
}
Reference in New Issue View Git Blame Copy Permalink