root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/ba0100.cpp
guy 30408610e1 Patch level : 2.2 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Aggiunta ragione sociale ditta corrente nel menu principale


git-svn-id: svn://10.65.10.50/trunk@13764 c028cbd2-c16b-5b4b-a496-9718f37d4682
2006-02-07 11:46:18 +00:00

1997 lines
49 KiB
C++
Executable File
Raw Blame History

#include <xinclude.h>
#include <applicat.h>
#include <automask.h>
#include <colors.h>
#include <controls.h>
#include <dongle.h>
#include <execp.h>
#include <isam.h>
#include <msksheet.h>
#include <progind.h>
#include <sheet.h>
#include <utility.h>
#include <urldefid.h>
#include <agasys.h>
#include <nditte.h>
#include "ba0.h"
#include "ba0101.h"
#include "ba0102.h"
#include "ba0100.h"
#include "ba0100a.h"
#include "ba0400a.h"
#define OPTIONS_MENU M_FONT
#define PREFERRED_MENU M_STYLE
#define DLG_TREE 301
#define DLG_LIST 302
#ifdef XVAGA
#define MEN_FILE "bamenu.men"
#else
#define MEN_FILE "baprassi.men"
#endif
///////////////////////////////////////////////////////////
// TMenu_application declaration
///////////////////////////////////////////////////////////
class TMenu_application : public TSkeleton_application
{
const char* _name;
TMenu _menu;
int _tree_view;
TString_array _preferred;
TMask* _mask;
static int _last_button;
static bool _find_button;
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;
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();
bool test_network();
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) : _name(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* ext[3] = { "jpg", "gif", "bmp" };
for (int i = 0; i < 3; 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 (sys_dll_changed()) //se e' stato installato SY..
xvt_sys_sleep(1000); //..aspetta un secondo poi forza l'uscita
else
{
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;
}
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
///////////////////////////////////////////////////////////
int TMenu_application::_last_button = 0;
bool TMenu_application::_find_button = false;
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();
TString16 pwd;
TString16 usr = dongle().administrator(&pwd);
TLocalisamfile users(LF_USER);
users.put("USERNAME", usr);
users.read();
pwd = decode(users.get("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::check_user()
{
// Disabilita le voci di personalizzazione
for (int mi = 2; mi <= 6; mi++)
disable_menu_item(MENU_ITEM(mi));
TString utente(user());
#ifdef _DEMO_
user() = utente = dongle().administrator();
const bool ok = TRUE;
#else
TMask m("ba0100a");
if (is_power_station())
{
m.set_handler(F_USER, pwd_handler);
m.set_handler(F_PASSWORD, pwd_handler);
}
TEdit_field& e = m.efield(F_USER);
e.browse()->set_filter("ISGROUP!=\"X\"");
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);
const TString& pass = m.get(F_PASSWORD);
pwd = "";
TLocalisamfile users(LF_USER);
users.put("USERNAME", utente);
if (users.read() == NOERR)
{
pwd = decode(users.get("PASSWORD"));
}
else
{
users.zero();
if (utente == dongle().administrator(&pwd))
{
users.put("USERNAME", utente);
users.put("USERDESC", "Amministratore");
users.put("PASSWORD", encode(pwd));
users.write();
}
else
utente.cut(0);
}
ok = utente.not_empty() && pwd.not_empty() && pwd == pass;
if (ok)
{
ok = !users.get_bool("CONNECTED");
if (!ok)
{
ok = yesno_box("%s\n%s",
TR("L'utente risulta essere gi<67> collegato"),
TR("Si desidera continuare ugualmente?"));
}
if (ok)
{
users.put("USERNAME", dongle().administrator());
users.read();
if (users.get("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"));
}
}
else
{
error_box(TR("Utente e/o password errata: fare attenzione alle maiuscole"));
m.set(F_PASSWORD,"");
}
if (ok)
{
TLocalisamfile users(LF_USER);
users.put("USERNAME", utente);
users.read(_isequal, _lock);
users.put("CONNECTED", "X");
users.rewrite();
}
}
#endif // _DEMO_
if (ok)
{
if (utente != dongle().administrator())
{
TConfig prawin(CONFIG_INSTALL, "Main");
prawin.set("User", utente);
}
// Abilita le voci di personalizzazione
for (int mi = 2; mi <= 6; mi++)
enable_menu_item(MENU_ITEM(mi));
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_network()
{
if (!xvt_sys_test_network_version())
return error_box(TR("Il driver di rete VREDIR.VXD contiene un bug riconosciuto da Microsoft.\n"
"Consultare la documentazione sul sito AGA per eliminare questo inconveniente."));
return true;
}
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);
TScanner scan(AUT_FILE);
TString msg = TR("I seguenti moduli devono essere aggiornati prima dell'utilizzo:");
int update_needed = 0;
for (int module = 0; scan.line().not_empty(); module++)
{
if (dongle().active(module))
{
const TString4 code = scan.token().left(2);
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)
{
dangerous.add(code);
if (!more)
{
const TString& name = scan.token().mid(3);
if (msg.len() < 200)
{
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 TString16 old_user = user();
user() = dongle().administrator(); // Divento temporaneamente amministratore
TExternal_app app("ba1 -6");
app.run();
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()
{
if (!test_network())
return false;
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 = _name;
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,TRUE); // 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"), "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 < 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;
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);
if (user().blank())
{
TConfig prawin(CONFIG_INSTALL, "Main");
TString16 u = prawin.get("User");
if (u.blank())
u = dongle().administrator();
user() = u;
}
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