681 lines
16 KiB
C++
Executable File
681 lines
16 KiB
C++
Executable File
#include <applicat.h>
|
|
#include <colors.h>
|
|
#include <config.h>
|
|
#include <execp.h>
|
|
#include <golem.h>
|
|
#include <mask.h>
|
|
#include <isam.h>
|
|
#include <prefix.h>
|
|
#include <progind.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
#include <urldefid.h>
|
|
#include <lffiles.h>
|
|
#include <nditte.h>
|
|
|
|
#include "ba0.h"
|
|
#include "ba0100a.h"
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Picture Mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPicture_mask : public TMask
|
|
{
|
|
TImage& _image;
|
|
|
|
protected:
|
|
virtual void handler(WINDOW win, EVENT* ep);
|
|
|
|
public:
|
|
TPicture_mask(const char* name, int dx, int dy, TImage& image);
|
|
virtual ~TPicture_mask() {}
|
|
};
|
|
|
|
|
|
TPicture_mask::TPicture_mask(const char* name, int dx, int dy, TImage& image)
|
|
: TMask(name, 1, dx, dy), _image(image)
|
|
{
|
|
if (_image.ok())
|
|
_image.set_palette(win());
|
|
}
|
|
|
|
|
|
|
|
void TPicture_mask::handler(WINDOW win, EVENT* ep)
|
|
{
|
|
TMask::handler(win, ep);
|
|
|
|
if (ep->type == E_UPDATE)
|
|
{
|
|
#if XVT_OS == XVT_OS_WIN
|
|
if (_image.ok())
|
|
{
|
|
_image.draw(win);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
TTemp_window w(win);
|
|
const int max = 16;
|
|
for (int i = 0; i < max; i++)
|
|
w.rect(i*2, i, max-i*2, max-i);
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Menu application
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TMenu_application : public TApplication
|
|
{
|
|
const char* _name;
|
|
|
|
enum { MAXLEVEL = 512 }; // Non cambiare !! pena di morte . Deve essere < 730
|
|
int _first[MAXLEVEL];
|
|
TArray _menu; // TAG|DESCRIPTION|ACTION
|
|
TBit_array _enabled;
|
|
TArray _modules, _images;
|
|
|
|
int _level, _max;
|
|
|
|
static int _last_button;
|
|
static bool _find_button;
|
|
|
|
protected:
|
|
void test_temp();
|
|
void load_menu();
|
|
int do_level();
|
|
int find_menu(const char* s) const;
|
|
bool check_user();
|
|
virtual bool create();
|
|
virtual bool destroy();
|
|
virtual bool menu(MENU_TAG m);
|
|
virtual bool build_firm_data(long cod, bool flagcom = FALSE);
|
|
|
|
static bool menu_item_handler(TMask_field&f, KEY k);
|
|
static bool menu_find_handler(TMask_field&f, KEY k);
|
|
bool module_enabled(const char * program) const;
|
|
bool module_enabled(int module) const { return has_module(module);}
|
|
|
|
public:
|
|
TMenu_application(const char* name) : _name(name) /*, _ditta_asked(FALSE) */ {}
|
|
};
|
|
|
|
int TMenu_application::_last_button = 0;
|
|
bool TMenu_application::_find_button = FALSE;
|
|
|
|
inline TMenu_application& app()
|
|
{ return (TMenu_application&)main_app(); }
|
|
|
|
|
|
bool TMenu_application::build_firm_data(long codditta, bool flagcom)
|
|
{
|
|
const char * const ndir = "/dir.gen";
|
|
const char * const ntrc = "/trc.gen";
|
|
TFilename s(firm2dir(codditta)); s << ndir;
|
|
bool exist = fexist(s);
|
|
|
|
if (!exist)
|
|
{
|
|
s = s.path(); s.rtrim(1); s << ntrc;
|
|
exist = fexist(s);
|
|
}
|
|
if (exist)
|
|
return message_box("Direttorio dati danneggiato, impossibile attivare la ditta %ld", codditta);
|
|
if (!yesno_box("Gli archivi della ditta %ld non esistono: si desidera generarli?", codditta))
|
|
return FALSE;
|
|
|
|
TLocalisamfile ditte(LF_NDITTE);
|
|
ditte.zero();
|
|
ditte.put(NDT_CODDITTA,codditta);
|
|
if (ditte.read(_isequal,_testandlock) == _islocked)
|
|
{
|
|
message_box("Archivi della ditta %ld in fase di creazione da parte di un altro utente.",codditta);
|
|
return FALSE;
|
|
}
|
|
|
|
set_autoload_new_files(yesno_box("Si desidera precaricare gli archivi standard"));
|
|
s = s.path(); s.rtrim(1);
|
|
|
|
if (!fexist(s) && !make_dir(s))
|
|
return error_box("Impossibile creare il direttorio della ditta %ld (%s)",
|
|
codditta, (const char*)s);
|
|
|
|
s << ndir;
|
|
if (!fcopy(&ndir[1], s))
|
|
return error_box("Impossibile copiare il file %s della ditta %ld",
|
|
&ndir[1], codditta);
|
|
s = s.path(); s << ntrc;
|
|
if (!fcopy(&ntrc[1], s))
|
|
return error_box("Impossibile copiare il file %s della ditta %ld",
|
|
ntrc, codditta);
|
|
|
|
TDir dir, dir1;
|
|
TTrec rec;
|
|
|
|
prefix().set("");
|
|
dir1.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
const long maxeod0 = dir1.eod();
|
|
|
|
prefix().set_codditta(codditta);
|
|
dir.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
if (dir.eod() == 0)
|
|
{
|
|
dir1.eod() = 1L;
|
|
dir1.put(LF_DIR, _nordir, _sysdirop);
|
|
dir.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
}
|
|
const long maxeod1 = dir.eod();
|
|
|
|
if (maxeod0 > maxeod1)
|
|
{
|
|
dir.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
dir.eod() = maxeod0;
|
|
dir.put(LF_DIR, _nordir, _sysdirop);
|
|
rec.zero();
|
|
}
|
|
TString80 mess("Generazione archivi della ditta "); mess << codditta;
|
|
TProgind p(maxeod0 ? maxeod0 : 1, mess, FALSE, TRUE, 70);
|
|
|
|
for (int i = LF_DIR + 1; i <= maxeod0; i++)
|
|
{
|
|
p.addstatus(1);
|
|
prefix().set("");
|
|
dir.get(i, _nolock, _nordir, _sysdirop);
|
|
rec.get(i);
|
|
bool create_now = dir.is_active();
|
|
|
|
prefix().set_codditta(codditta);
|
|
dir.put(i, _nordir, _sysdirop);
|
|
rec.put(i);
|
|
const char* name = dir.name();
|
|
dir.flags() = 0L;
|
|
create_now = create_now && (flagcom ? dir.is_com() : dir.is_firm());
|
|
|
|
if (dir.is_valid() && create_now)
|
|
{
|
|
TSystemisamfile f(i);
|
|
f.build(30);
|
|
}
|
|
else
|
|
{
|
|
dir.put(i, _nordir, _sysdirop);
|
|
rec.put(i);
|
|
}
|
|
}
|
|
|
|
TConfig c(CONFIG_STUDIO, "cg");
|
|
|
|
if (c.get_bool("StiReg"))
|
|
{
|
|
TTable reg("REG");
|
|
for (reg.first(_lock); reg.good(); reg.next(_lock))
|
|
{
|
|
reg.put("B9", "X");
|
|
reg.rewrite();
|
|
}
|
|
}
|
|
ditte.reread(_unlock);
|
|
|
|
set_firm(codditta);
|
|
set_autoload_new_files(TRUE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TMenu_application::module_enabled(const char * program) const
|
|
{
|
|
bool found = FALSE;
|
|
const int nmod = _modules.items();
|
|
for (int aut = 0; aut < nmod; aut++)
|
|
{
|
|
const TString& s = (const TString&) _modules[aut];
|
|
if (s.compare(program, 2) == 0) { found = TRUE; break; }
|
|
}
|
|
return (!found) || has_module(aut);
|
|
}
|
|
|
|
void TMenu_application::load_menu()
|
|
{
|
|
TScanner s(_name);
|
|
|
|
_max = -1;
|
|
|
|
while (s.line().not_empty())
|
|
{
|
|
TToken_string* ts = new TToken_string(s.token());
|
|
int l = ts->get_int();
|
|
|
|
if (l < _max)
|
|
{
|
|
error_box("Item of level %d while %d was expected)", l, _max);
|
|
l = _max;
|
|
}
|
|
if (l > _max)
|
|
{
|
|
if (l >= MAXLEVEL)
|
|
{
|
|
error_box("Too many menu levels: %d", l);
|
|
l = _max;
|
|
}
|
|
_first[_max = l] = _menu.items();
|
|
}
|
|
|
|
_menu.add(ts);
|
|
const TString80 action(ts->get(2));
|
|
const int last = _menu.items() - 1;
|
|
|
|
if (atoi(action) > 0)
|
|
{
|
|
TToken_string list(ts->get(), ',');
|
|
const TString& mod = list.get();
|
|
int module = atoi(mod);
|
|
|
|
if (module == 0)
|
|
{
|
|
bool on = TRUE;
|
|
if (mod[0] == 'P')
|
|
on = user() == "PRASSI";
|
|
_enabled.set(last, on);
|
|
}
|
|
while(!_enabled[last] && module > 0)
|
|
{
|
|
if (has_module(module))
|
|
_enabled.set(last);
|
|
module = list.get_int();
|
|
}
|
|
}
|
|
else
|
|
_enabled.set(last, module_enabled(action));
|
|
}
|
|
_first[++_max] = _menu.items();
|
|
}
|
|
|
|
int TMenu_application::find_menu(const char* s) const
|
|
{
|
|
TString80 str(s); str.upper();
|
|
int found = -1;
|
|
|
|
for (int i = 0; i < _menu.items(); i++)
|
|
{
|
|
if (_enabled[i])
|
|
{
|
|
TToken_string& l = (TToken_string&)_menu[i];
|
|
const int m = l.get_int(0);
|
|
if (m != _level)
|
|
{
|
|
TString80 v(l.get()); v.upper();
|
|
|
|
if (v.find(str) >= 0)
|
|
{
|
|
found = i;
|
|
if (isalpha(l.get_char())) break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
bool TMenu_application::menu_item_handler(TMask_field&f, KEY k)
|
|
{
|
|
if (k == K_SPACE)
|
|
{
|
|
_last_button = f.dlg();
|
|
_find_button = FALSE;
|
|
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())
|
|
{
|
|
_last_button = app().find_menu(v);
|
|
if (_last_button >= 0)
|
|
{
|
|
_find_button = TRUE;
|
|
f.mask().stop_run(K_AUTO_ENTER);
|
|
}
|
|
else
|
|
{
|
|
beep();
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int TMenu_application::do_level()
|
|
{
|
|
const int first = _first[_level];
|
|
const int last = _first[_level+1];
|
|
TToken_string& row = (TToken_string&)_menu[first];
|
|
const TString80 head(row.get(1));
|
|
|
|
const int width = 78;
|
|
const int height = 18;
|
|
const int bwidth = 20;
|
|
const int x = width / 2;
|
|
short id = (short)row.get_int();
|
|
|
|
if (_images.objptr(id) == NULL)
|
|
{
|
|
char* n = format("ba%02d.bmp", id);
|
|
if (id > 0 && !fexist(n))
|
|
n = format("ba%02d.bmp", id = 0);
|
|
|
|
TImage orig(n);
|
|
RCT src; xvt_rect_set(&src, 0, 0, orig.width(), orig.height());
|
|
const short maxx = width * CHARX / 2 - 4;
|
|
const short maxy = short((long)maxx*src.bottom/src.right);
|
|
|
|
TImage* image = new TImage(orig, maxx, maxy);
|
|
if (id == 0 && MASK_BACK_COLOR != COLOR_DKCYAN)
|
|
image->set_clut(6, MASK_BACK_COLOR);
|
|
image->set_pos(1, 1);
|
|
|
|
_images.add(image, id);
|
|
}
|
|
|
|
TPicture_mask menu(head, width, height, (TImage &) _images[id]);
|
|
|
|
int y = 1;
|
|
|
|
#if XVT_OS == XVT_OS_WIN
|
|
TString16 t(format("#%d", BMP_STOPREC));
|
|
#else
|
|
TString16 t;
|
|
#endif
|
|
|
|
for (int i = first+1; i < last; i++, y++)
|
|
{
|
|
TToken_string& row = (TToken_string&)_menu[i];
|
|
TString80 item(row.get(1));
|
|
if (isdigit(*row.get())) item << "...";
|
|
menu.add_static(-1, 0, item, x+4, y);
|
|
const short id = 100+y;
|
|
menu.add_button(id, 0, t, x, y, 1, 1);
|
|
menu.set_handler(id, menu_item_handler);
|
|
if (!_enabled[i]) menu.disable(id);
|
|
}
|
|
menu.add_static(-1, 0, "Cerca", 1,-3);
|
|
menu.add_string(99, 0, "", -12, -3, 50, "", bwidth+1);
|
|
menu.set_handler(99, menu_find_handler);
|
|
|
|
t = first ? "Menu precedente" : "Fine";
|
|
menu.add_button(first ? DLG_CANCEL : DLG_QUIT, 0, t, -22, -1, bwidth, 2);
|
|
if (first)
|
|
menu.add_button(DLG_QUIT, 0, "Fine", -12, -1, bwidth, 2);
|
|
|
|
if (_find_button && _last_button > first)
|
|
menu.first_focus(100+_last_button-first);
|
|
|
|
_last_button = _find_button = 0;
|
|
|
|
const int k = menu.run();
|
|
int m = 0;
|
|
switch (k)
|
|
{
|
|
case K_ESC:
|
|
m = -1; break;
|
|
case K_QUIT:
|
|
menu.reset();
|
|
m = -2; break;
|
|
default:
|
|
if (_find_button)
|
|
m = -1;
|
|
else
|
|
m = first+_last_button-100;
|
|
break;
|
|
}
|
|
return m;
|
|
}
|
|
|
|
|
|
void TMenu_application::test_temp()
|
|
{
|
|
begin_wait();
|
|
|
|
TFilename dir; dir.tempdir(); // Directory temporanea
|
|
dir << '/' << '*';
|
|
TToken_string files(dir);
|
|
const int count = list_files(files);
|
|
|
|
end_wait();
|
|
|
|
if (count > 0 && yesno_box("Cancellare %d file temporane%c in %s?",
|
|
count, (count > 1) ? 'i' : 'o', dir.path()))
|
|
{
|
|
TProgind bar(count, "Cancellazione file temporanei", TRUE, TRUE);
|
|
for (const char* e = files.get(0); e; e = files.get())
|
|
{
|
|
if (bar.iscancelled()) break;
|
|
remove(e);
|
|
bar.addstatus(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TMenu_application::check_user()
|
|
{
|
|
TMask m("ba0100a");
|
|
TLocalisamfile users(LF_USER);
|
|
TString16 utente(user()), pwd;
|
|
|
|
bool ok = FALSE;
|
|
for (int i = 0 ; i < 3 && !ok; i++)
|
|
{
|
|
if (utente.not_empty() && utente != "PRASSI")
|
|
{
|
|
m.set(F_USER, utente);
|
|
m.first_focus(F_PASSWORD);
|
|
}
|
|
|
|
if (m.run() == K_ESC)
|
|
break;
|
|
|
|
utente = m.get(F_USER);
|
|
users.zero();
|
|
users.put("USERNAME", utente);
|
|
|
|
pwd = "";
|
|
|
|
int err = users.read(_isequal, _lock);
|
|
if (err == NOERR)
|
|
{
|
|
pwd = decode(users.get("PASSWORD"));
|
|
}
|
|
else
|
|
if (utente == "PRASSI")
|
|
{
|
|
pwd = "pr.assi";
|
|
users.zero();
|
|
users.put("USERNAME", utente);
|
|
users.put("USERDESC", utente);
|
|
users.put("PASSWORD", encode(pwd));
|
|
users.write();
|
|
err = users.read(_isequal, _lock);
|
|
}
|
|
|
|
ok = pwd.not_empty() && pwd == m.get(F_PASSWORD);
|
|
|
|
if (ok)
|
|
{
|
|
ok = !users.get_bool("CONNECTED");
|
|
if (!ok)
|
|
{
|
|
ok = yesno_box("L'utente %s risulta essere gia' collegato\n"
|
|
"Si desidera continuare ugualmente?", (const char*)utente);
|
|
}
|
|
if (ok)
|
|
user() = utente;
|
|
}
|
|
else
|
|
{
|
|
error_box("Utente e/o password errata:\nfare attenzione alle maiuscole");
|
|
m.set(F_PASSWORD,"");
|
|
}
|
|
|
|
customize_colors();
|
|
if (err == NOERR)
|
|
{
|
|
if (ok)
|
|
{
|
|
users.put("CONNECTED", "X");
|
|
users.rewrite();
|
|
}
|
|
else users.read(_isequal, _unlock);
|
|
}
|
|
}
|
|
|
|
#if XVT_OS == XVT_OS_WIN
|
|
if (ok && utente != "PRASSI")
|
|
{
|
|
TDDE dde;
|
|
if (dde.initiate("PROGMAN", "PROGMAN"))
|
|
{
|
|
dde.execute("[ReplaceItem(PR.A.S.S.I.)]");
|
|
TString80 cmd("[AddItem(");
|
|
cmd << argv(0) << " /u" << utente << ",PR.A.S.S.I.)]";
|
|
dde.execute(cmd);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool TMenu_application::create()
|
|
{
|
|
TApplication::create();
|
|
if (!check_user()) return FALSE;
|
|
set_perms();
|
|
test_temp();
|
|
|
|
TScanner scanner("prassi.aut");
|
|
|
|
for (int aut = 0; scanner.line() != ""; aut++)
|
|
_modules.add(scanner.token());
|
|
|
|
load_menu();
|
|
dispatch_e_menu(BAR_ITEM(1));
|
|
return TRUE;
|
|
}
|
|
|
|
bool TMenu_application::destroy()
|
|
{
|
|
TLocalisamfile users(LF_USER);
|
|
users.put("USERNAME", user());
|
|
int err = users.read(_isequal, _lock);
|
|
if (err == NOERR)
|
|
{
|
|
users.zero("CONNECTED");
|
|
users.rewrite();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TMenu_application::menu(MENU_TAG)
|
|
{
|
|
int refarray[256];
|
|
memset(refarray, 0, sizeof(refarray));
|
|
|
|
int i = 0;
|
|
|
|
_level = 0;
|
|
while (i >= 0)
|
|
{
|
|
const int m = do_level();
|
|
if (m >= 0)
|
|
{
|
|
TToken_string& row = (TToken_string&)_menu[m];
|
|
const TFilename option(row.get(2));
|
|
|
|
if (option.not_empty())
|
|
{
|
|
bool ok = TRUE;
|
|
const int l = atoi(option);
|
|
if (l > 0 && l < MAXLEVEL)
|
|
{
|
|
const TString16 flags(row.get());
|
|
if (flags.find('F') >= 0)
|
|
ok = set_firm();
|
|
if (ok)
|
|
{
|
|
refarray[i++] = _level;
|
|
if (l < _max) _level = l;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const TString16 flags(row.get());
|
|
if (flags.find('P') >= 0)
|
|
{
|
|
TMask mask("ba0100a");
|
|
mask.disable(F_USER);
|
|
mask.set(F_USER, "SERVIZIO");
|
|
ok = FALSE;
|
|
if (mask.run() == K_ENTER)
|
|
{
|
|
const TDate oggi(TODAY);
|
|
TString16 pwd; pwd << "PRASSI" << (oggi.month() + oggi.day());
|
|
ok = pwd == mask.get(F_PASSWORD);
|
|
}
|
|
if (!ok) error_box("Password di servizio errata!\nAccesso negato.");
|
|
}
|
|
if (ok)
|
|
{
|
|
const TString16 module(cmd2name(option));
|
|
if (get_firm() == 0 && module.compare("cg", 2, TRUE) == 0) // Chiede ditta se necessario
|
|
set_firm();
|
|
prefix().set(NULL); // Chiude prefix
|
|
TExternal_app a(option);
|
|
a.run();
|
|
prefix().set("DEF"); // Aggiorna prefix
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m < -1) break;
|
|
if (_find_button)
|
|
{
|
|
TToken_string& row = (TToken_string&)_menu[_last_button];
|
|
_level = row.get_int(0);
|
|
}
|
|
else
|
|
{
|
|
_level = (i > 0) ? refarray[--i] : 0;
|
|
if (_level == 0) i = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
TApplication::check_parameters(argc, argv);
|
|
const char* menu = (argc < 2) ? "prassi.mnu" : argv[1];
|
|
|
|
TMenu_application ma(menu);
|
|
ma.run(argc, argv, "Menu Principale");
|
|
return TRUE;
|
|
}
|