#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ba0.h" #include "ba0100a.h" /////////////////////////////////////////////////////////// // TPriority_image /////////////////////////////////////////////////////////// class TTimed_image : public TImage { clock_t _last_time; public: clock_t touch() { return _last_time = clock(); } clock_t last_time() const { return _last_time; } TTimed_image(const char* name) : TImage(name) { touch(); } virtual ~TTimed_image() { } }; /////////////////////////////////////////////////////////// // Picture Mask /////////////////////////////////////////////////////////// class TPicture_mask : public TMask { TImage* _image; static TString _last_string; protected: // TMask virtual void update(); virtual bool on_key(KEY k); public: virtual bool stop_run(KEY key); void set_last_search_string(const char* str) { _last_string = str; } void set_image(TImage* image); TPicture_mask(const char* name, int dx, int dy, TImage* image, int x = -1, int y = -1); virtual ~TPicture_mask() {} }; TString TPicture_mask::_last_string; TPicture_mask::TPicture_mask(const char* name, int dx, int dy, TImage* image, int x, int y) : TMask(name, 1, dx, dy, x, y) { set_image(image); } void TPicture_mask::set_image(TImage* image) { if (image && image->ok()) { _image = image; _image->set_palette(win()); } else _image = NULL; } 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 (_image && _image->ok()) { RCT cli; field(DLG_USER).get_rect(cli); int vy = cli.top; const TMask_field& fld = field(101); fld.get_rect(cli); int vx = cli.left; if (fld.class_id() == CLASS_TREE_FIELD) { vx = -cli.right; ::xvt_vobj_get_client_rect(win(), &cli); vx += cli.right - CHARX; vy = cli.bottom; } const double ratiox = double(vx) / _image->width(); const double ratioy = double(vy) / _image->height(); const double ratio = min(ratiox, ratioy); const int maxx = int(ratio * _image->width()); const int maxy = int(ratio * _image->height()); int x = 1; int y = 1; if (fld.class_id() == CLASS_TREE_FIELD) { x = cli.right - maxx + 1; y = (cli.bottom - maxy) / 2; } RCT dst; ::xvt_rect_set(&dst, x, y, x+maxx-1, y+maxy-1); 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, _last_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); } /////////////////////////////////////////////////////////// // Color Mask /////////////////////////////////////////////////////////// class TColor_mask : public TMask { TAssoc_array _color; protected: // TMask virtual void update(); virtual bool stop_run(KEY key) { return TWindow::stop_run(key); } // @cmember Converte le coordinate logiche (caratteri) in coordinate fisiche (pixel) virtual PNT log2dev(long x, long y) const; protected: static bool color_handler(TMask_field& f, KEY k); static bool azzera_handler(TMask_field& f, KEY k); 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() { } }; TColor_mask::TColor_mask() : TMask("ba0200a") { TConfig color(CONFIG_USER, "Colors"); _color = color.list_variables(); set(113, color.get_bool("Campi3D")); for (int f = fields()-1; f >= 0; f--) { TMask_field& mf = fld(f); if (mf.is_kind_of(CLASS_BUTTON_FIELD)) { if (mf.dlg() > DLG_USER) mf.set_handler(color_handler); else if (mf.dlg() == DLG_USER) mf.set_handler(azzera_handler); } } } PNT TColor_mask::log2dev(long x, long y) const { PNT p = { int(y * XI_FU_MULTIPLE), int(x * XI_FU_MULTIPLE) }; XI_OBJ* itf = xi_get_itf(win()); #ifdef XI_R4 xi_fu_to_pu(itf, (XinPoint*)&p, 1); #else 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 = 7; const int w = 32; const int h = 9; 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("Focus")); set_brush(b = get_color_entry("FocusBack")); frame(x+3, y+3, x+w-3, y+4, 0); set_color(p, b); stringat(x+4, y+3, "Campo attivo"); set_pen(p = get_color_entry("Disabled")); set_brush(b = get_color_entry("DisabledBack")); frame(x+3, y+5, x+w-3, y+6, 0); set_color(p, b); stringat(x+4, y+5, "Campo disabilitato"); set_pen(p = get_color_entry("ButtonLight")); set_brush(b = get_color_entry("ButtonBack")); frame(x+3, y+7, x+w-3, y+8, 0); set_color(get_color_entry("Normal"), b); stringat(x+4, y+7, "Bottone normale"); } void TColor_mask::save_colors() { TConfig colors(CONFIG_USER, "Colors"); FOR_EACH_ASSOC_STRING(_color, obj, key, str) colors.set(key, str); colors.set("Campi3D", get_bool(113) ? "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 char* name[] = { "MaskBack", "MaskLight", "MaskDark", "Normal", "NormalBack", "Focus", "FocusBack", "Disabled", "DisabledBack", "ButtonBack", "ButtonLight", "ButtonDark" }; const int i = cid - 101; CHECK(i >= 0 && i < 12, "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, COLOR_BLACK, COLOR_YELLOW, COLOR_DKGRAY, COLOR_LTGRAY, COLOR_LTGRAY, COLOR_WHITE, COLOR_GRAY}; const int i = cid - 101; CHECK(i >= 0 && i < 12, "Invalid color id"); return color[i]; } bool TColor_mask::color_handler(TMask_field& f, KEY k) { bool ok = TRUE; if (k == K_SPACE) { 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); XVT_PALETTE wp = xvt_vobj_get_palet(m.win()); if (wp != NULL) { XVT_PALETTE up = xvt_palet_create(XVT_PALETTE_USER, 0); if (up != NULL) { const int MAXPAL = 256; COLOR color[MAXPAL]; const int n = xvt_palet_get_colors(wp, color, MAXPAL); if (n < MAXPAL) color[n] = col; xvt_palet_set_tolerance(up, xvt_palet_get_tolerance(wp)); xvt_palet_add_colors(up, color, n+1); xvt_vobj_set_palet(m.win(), up); xvt_palet_destroy(wp); } } m.stop_run(K_CTRL + 'R'); } } return ok; } bool TColor_mask::azzera_handler(TMask_field& f, KEY k) { if (k == K_SPACE) { TColor_mask& cm = (TColor_mask&)f.mask(); for (int i = cm.fields()-1; i >= 0; i--) { TMask_field& mf = cm.fld(i); if (mf.dlg() > DLG_USER && mf.is_kind_of(CLASS_BUTTON_FIELD)) { const char* name = cm.cid2name(mf.dlg()); const COLOR color = cm.cid2color(mf.dlg()); cm.set_color_entry(name, color); } } cm.update(); } return TRUE; } /////////////////////////////////////////////////////////// // Menu mamnagement /////////////////////////////////////////////////////////// static int get_next_string(const char* s, int from, TString& str, char& brace) { if (from < 0) return -1; char closing = '\0'; int start = 0; for (int i = from; s[i]; i++) { if (s[i] == closing) { char* fine = (char*)(s + i); const char old = *fine; *fine = '\0'; str = s + start; *fine = old; return i+1; } if (!closing) { switch(s[i]) { case '\'': case '"' : closing = s[i]; break; case '<' : closing = '>' ; break; case '[' : closing = ']' ; break; default : break; } if (closing) { start = i+1; brace = s[i]; } } } return -1; } class TSubmenu; class TMenu; class TMenuitem : public TObject { TSubmenu* _submenu; TString _caption, _action; char _type; COLOR _color; bool _enabled : 1; bool _firm : 1; bool _password : 1; bool _reloadmenu : 1; protected: bool perform_submenu() const; bool perform_program() const; public: virtual bool ok() { return _caption.not_empty(); } const TString& caption() const { return _caption; } const TString& action() const { return _action; } bool enabled() const; bool disabled() const { return !enabled(); } COLOR color() const { return enabled() ? _color : DISABLED_COLOR; } bool is_submenu() const { return _type == '[' && _action.not_empty(); } bool is_program() const { return _type != '[' && _action.not_empty(); } bool perform() const; TSubmenu& submenu() const { return *_submenu; } TMenu& menu() const; void create(const char* t); TMenuitem(TSubmenu* sm); virtual ~TMenuitem() { } }; class TSubmenu : public TObject { TMenu* _menu; TString _name; TString _caption; TFilename _picture; TArray _items; bool _enabled : 1; bool _firm : 1; public: void read(TScanner& scanner); TMenu& menu() const { return *_menu; } int find_string(const char* str) const; TMenuitem& item(int i) { return (TMenuitem&)_items[i]; } const TMenuitem& item(int i) const { return (const TMenuitem&)_items[i]; } const TMenuitem& operator[](int i) const { return item(i); } const TString& name() const { return _name; } const TString& caption() const { return _caption; } const TString& picture() const { return _picture; } int items() const { return _items.items(); } bool query_firm() const { return _firm; } bool enabled() const { return _enabled; } bool disabled() const { return !enabled(); } bool perform(int i); TSubmenu(TMenu* menu, const char* name); virtual ~TSubmenu() { } }; class TMenu : public TAssoc_array { TSubmenu* _current; int _item; TStack _stack; TFilename _default_bmp; TString _default_menu; TAssoc_array _images; TAssoc_array _modules; public: // TObject virtual bool ok() const { return _current != NULL; } public: bool read(const char* name); // First call bool read(const char* name, TString& root); TSubmenu& current() const { return *_current; } TSubmenu* find(const char* name) const { return (TSubmenu*)objptr(name); } bool jumpto(TSubmenu *next); bool jumpto_root(); TSubmenu& pop(); bool at_top() const { return _stack.count() == 0; } void select(int i) { _item = i; } int selected() const { return _item; } bool perform(); TSubmenu* find_string(const char* str); TImage& image(const char* name); void reload_images(); bool has_module(const char* mod); TMenu() : _current(NULL), _item(0) { } TMenu(const char* name) { read(name); } virtual ~TMenu() { } }; TMenuitem::TMenuitem(TSubmenu* sm) : _submenu(sm), _enabled(TRUE), _firm(FALSE), _password(FALSE), _reloadmenu(FALSE), _color(NORMAL_COLOR) { } TMenu& TMenuitem::menu() const { return _submenu->menu(); } void TMenuitem::create(const char* t) { TString16 flags; char brace; int start = 0; start = get_next_string(t, start, _caption, brace); start = get_next_string(t, start, _action, _type); start = get_next_string(t, start, flags, brace); for (int i = flags.len()-1; i >= 0; i--) { switch(toupper(flags[i])) { case 'D': _enabled = FALSE; break; case 'F': _firm = TRUE; break; case 'P': _password = TRUE; break; case 'R': _reloadmenu = TRUE; break; default : break; } } if (_type == '<') { if (_action.find('.') < 0) _action << ".men"; menu().read(_action, _action); _type = '['; } if (_action.empty()) _enabled = FALSE; // if (_enabled && is_program()) // _enabled = menu().has_module(_action); } bool TMenuitem::enabled() const { bool yes = _enabled; if (yes) { if (is_submenu()) { TSubmenu* mnu = menu().find(_action); yes = mnu && mnu->enabled(); } else { const int endname = _action.find(' '); TFilename name(endname > 0 ? _action.left(endname) : _action); const char* ext[] = { "exe", "pif", "com", "bat", NULL }; yes = FALSE; for (int e = 0; ext[e]; e++) { name.ext(ext[e]); if (name.exist()) { yes = TRUE; break; } } if (!yes) ((TMenuitem*)this)->_enabled = FALSE; } } return yes; } bool TMenuitem::perform_submenu() const { TSubmenu* mnu = menu().find(_action); bool ok = mnu != NULL && mnu->enabled(); if (ok) { /* Cristina 6/11/97 if (mnu->items() == 1) { if (mnu->query_firm()) ok = main_app().set_firm(); if (ok) { const TMenuitem& mi = mnu->item(0); ok = mi.enabled() && mi.perform(); } } else */ menu().jumpto(mnu); } return ok; } bool TMenuitem::perform_program() const { bool ok = TRUE; if (_password) { 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 (_firm && main_app().get_firm() == 0) #ifdef _DEMO_ ok = main_app().set_firm(1); #else ok = main_app().set_firm(); #endif if (ok) { prefix().set(NULL); // Chiude prefix const bool maintenance_app = _action.compare("ba1", 3, TRUE) == 0; TExternal_app a(_action); a.run(FALSE,3); if (maintenance_app) { char line1[16],line2[16]; while (fexist("conv.his")) { FILE* fp = fopen("conv.his","r"); fgets(line1,15,fp); fclose(fp); // Ora aspetta... time_t old_time ; time( &old_time) ; while ( time( (time_t *) 0 ) <= old_time ) do_events(); TExternal_app auto_conv("ba1 -0 -C"); auto_conv.run(); fp = fopen("conv.his","r"); if (fp != NULL) { fgets(line2,15,fp); fclose(fp); } else strcpy(line2,""); if (strcmp(line1,line2) == 0) if (!yesno_box("La conversione non sembra procedere. Continuo?")) break; } } prefix().set("DEF"); // Aggiorna prefix } return ok; } bool TMenuitem::perform() const { bool ok = enabled(); if (ok) { if (is_submenu()) ok = perform_submenu(); else ok = perform_program(); } return ok; } TSubmenu::TSubmenu(TMenu* menu, const char* name) : _menu(menu), _name(name), _enabled(TRUE), _firm(FALSE), _items(12) { } void TSubmenu::read(TScanner& scanner) { while (scanner.ok()) { TString& line = scanner.line(); if (line.empty()) break; if (line[0] == '[') { scanner.push(); break; } char brace; if (line.compare("Caption", 7, TRUE) == 0) get_next_string(line, 8, _caption, brace); else if (line.compare("Module", 6, TRUE) == 0) { const int equal = line.find('='); if (equal > 0) { bool disable = TRUE; TToken_string mod(line.mid(equal+1, -1), ','); FOR_EACH_TOKEN(mod, cod) { const int code = atoi(cod); if (code == 0 || main_app().has_module(code)) { disable = FALSE; break; } } if (disable) _enabled = FALSE; } } else if (line.compare("Picture", 7, TRUE) == 0) get_next_string(line, 8, _picture, brace); else if (line.compare("Flags", 5, TRUE) == 0) { TString16 flags; get_next_string(line, 6, flags, brace); if (flags.find('D') >= 0) _enabled = FALSE; if (flags.find('F') >= 0) _firm = TRUE; } else if (line.compare("Item", 4, TRUE) == 0) { TMenuitem* item = new TMenuitem(this); _items.add(item); item->create(line); } } } int TSubmenu::find_string(const char* str) const { bool found = FALSE; TString caption; caption = _caption; caption.upper(); if (caption.find(str) >= 0) found = TRUE; for (int i = 0; i < items(); i++) { const TMenuitem& mi = item(i); caption = item(i).caption(); caption.upper(); const bool match = caption.find(str) >= 0; found = match && mi.is_program() && mi.enabled(); if (found) return i; } return -1; } bool TSubmenu::perform(int i) { bool ok = i >= 0 && i < items(); if (ok) ok = item(i).perform(); return ok; } bool TMenu::read(const char* name, TString& root) { TString str(255); bool first = TRUE; TScanner scanner(name); while (scanner.ok()) { const TString& line = first ? scanner.line() : scanner.pop(); if (line.empty()) break; char brace = '['; get_next_string(line, 0, str, brace); if (first) { root = str; first = FALSE; } if (objptr(str) == NULL) { TSubmenu* mnu = new TSubmenu(this, str); mnu->read(scanner); add(str, mnu); } else break; // Menu gia' caricato! } return first == FALSE; } bool TMenu::read(const char* name) { TString root; bool ok = read(name, root); if (ok && _current == NULL) { _default_menu = root; _current = find(root); _item = 0; } return ok; } bool TMenu::jumpto(TSubmenu* next) { if (next && next->disabled()) next = NULL; if (next) { if (next->query_firm()) { #ifdef _DEMO_ if (!main_app().set_firm(1)) next = NULL; #else if (!main_app().set_firm()) next = NULL; #endif } if (next) { if (_stack.count() >= 32) _stack.destroy_base(); _stack.push(_current->name()); _current = next; _item = 0; } } return next != NULL; } bool TMenu::jumpto_root() { TSubmenu* sm = find(_default_menu); return jumpto(sm); } TSubmenu& TMenu::pop() { TSubmenu* sm = _current; if (!at_top()) { TString& name = (TString&)_stack.pop(); sm = (TSubmenu*)objptr(name); } if (sm) { _current = sm; _item = 0; } return *sm; } TSubmenu* TMenu::find_string(const char* str) { TString upstr(str); upstr.upper(); restart(); for (TSubmenu* sm = (TSubmenu*)get(); sm; sm = (TSubmenu*)get()) { if (sm != _current && sm->enabled()) { int item = sm->find_string(upstr); if (item >= 0) { jumpto(sm); _item = item; break; } } } return sm; } bool TMenu::perform() { bool ok = _current != NULL; if (ok) ok = _current->perform(_item); return ok; } TImage& TMenu::image(const char* name) { TTimed_image* image = (TTimed_image*)_images.objptr(name); if (image == NULL) { if (fexist(name)) { if (_images.items() == 0) _default_bmp = name; // Store default bitmap name image = new TTimed_image(name); image->convert_transparent_color(MASK_BACK_COLOR); _images.add(name, image); } else { image = (TTimed_image*)_images.objptr(_default_bmp); if (image == NULL) fatal_box("Impossibile trovare l'immagine %s", (const char*)_default_bmp); } if (_images.items() > 3) { TString worst_bmp; clock_t worst_time = image->touch(); // Impedisco di cancellare la prossima _images.restart(); for (THash_object* o = _images.get_hashobj(); o; o = _images.get_hashobj()) { if (o->key() != _default_bmp) { TTimed_image& i = (TTimed_image&)o->obj(); if (i.last_time() < worst_time) { worst_time = i.last_time(); worst_bmp = o->key(); } } } _images.remove(worst_bmp); } } image->touch(); return *image; } void TMenu::reload_images() { _images.restart(); for (THash_object* h = _images.get_hashobj(); h; h = _images.get_hashobj()) { const TString& name = h->key(); TImage& i = (TImage&)h->obj(); i.load(name); i.convert_transparent_color(MASK_BACK_COLOR); } } bool TMenu::has_module(const char* mod) { TString16 key; if (_modules.items() == 0) { TScanner scanner("prassi.aut"); TString16 val; for (int aut = 0; scanner.line() != ""; aut++) { key.strncpy(scanner.token(), 2); key.lower(); val.format("%d", aut); _modules.add(key, val); } } key.strncpy(mod, 2); key.lower(); int module = 0; TString* cod = (TString*)_modules.objptr(key); if (cod) module = atoi(*cod); return main_app().has_module(module); } /////////////////////////////////////////////////////////// // Menu application /////////////////////////////////////////////////////////// class TMenu_application : public TApplication { const char* _name; TMenu _menu; bool _tree_view; TPicture_mask* _mask; static int _last_button; static bool _find_button; protected: // TApplication virtual bool create(); virtual bool destroy(); virtual bool menu(MENU_TAG m); virtual long handler(WINDOW win, EVENT* ep); protected: bool main_loop(); void test_temp(); void load_menu(); int do_level(); int do_tree(); 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 tree_find_handler(TMask_field& f, KEY k); static bool tree_shrink_handler(TMask_field& f, KEY k); bool choose_colors(); bool choose_editors(); bool choose_study(); public: void reload_images() { _menu.reload_images(); } TMenu_application(const char* name) : _name(name), _mask(NULL) { } virtual ~TMenu_application() { } }; int TMenu_application::_last_button = 0; bool TMenu_application::_find_button = FALSE; inline TMenu_application& app() { return (TMenu_application&)main_app(); } 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(); m.set_last_search_string(v); if (app()._menu.find_string(v)) { f.set_focusdirty(FALSE); return f.mask().stop_run(K_F9); } else { beep(); return FALSE; } } } return TRUE; } int TMenu_application::do_level() { const TSubmenu& curr = _menu.current(); const int width = 78; const int height = 18; const int bwidth = 20; TImage& image = _menu.image(curr.picture()); TPicture_mask mask(curr.caption(), width, height, &image); CHECK(_mask == NULL, "Two masks are better than one?"); _mask = &mask; const int x = width / 2; 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, "Cerca", 1,-3); TEdit_field& ef = mask.add_string(DLG_USER, 0, "", -12, -3, 50, "", bwidth+1); ef.set_handler(menu_find_handler); const bool top = _menu.at_top(); TButton_field& bf = mask.add_button(DLG_QUIT, 0, "Fine", top ? -22 : -12, -1, bwidth, 2); if (!top) { RCT e_rct; ef.get_rect(e_rct); // Rettangolo cerca RCT b_rct; bf.get_rect(b_rct); // Rettangolo bottone b_rct.left = e_rct.left-2; // Aggiusta rettangolo b_rct.right = e_rct.right+2; bf.set_rect(b_rct); // Modifica bottone mask.add_button(DLG_CANCEL, 0, "Menu precedente", -22, -1, bwidth, 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("Cancellare %d file temporane%c in %s?", count, (count > 1) ? 'i' : 'o', dir.path())) { TProgind bar(count, "Cancellazione file temporanei", TRUE, TRUE); for (int i = count-1; i >= 0; i--) { if (bar.iscancelled()) break; const char* e = files.row(i); ::remove(e); bar.addstatus(1); } } } #ifdef DBG HIDDEN bool pwd_handler(TMask_field& fld, KEY key) { if (key == K_F8) { TMask& m = fld.mask(); m.set(F_USER, "PRASSI"); m.set(F_PASSWORD, "pr.assi"); m.stop_run(K_ENTER); } return TRUE; } #endif bool TMenu_application::check_user() { TMask m("ba0100a"); #ifdef DBG m.set_handler(F_USER, pwd_handler); m.set_handler(F_PASSWORD, pwd_handler); #endif TLocalisamfile users(LF_USER); TString 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); } ok = utente.not_empty() && 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) { users.put("USERNAME", "PRASSI"); users.read(_isequal); if (users.get("AUTSTR") == "CONVERTING") { TString msg = "E' in corso una conversione archivi:\n"; if (utente == "PRASSI") { msg << "Si desidera continuare ugualmente?"; ok = yesno_box(msg); } else { msg << "Accesso negato."; ok = error_box(msg); } } } if (ok) { user() = utente; dongle().logout(); ok = get_serial_number() >= 0; if (!ok) error_box("Probabilmente e' stato superato il numero massimo di utenti"); } } else { error_box("Utente e/o password errata:\nfare attenzione alle maiuscole"); m.set(F_PASSWORD,""); } if (err == NOERR) { if (ok) { users.put("USERNAME", utente); users.read(_isequal, _lock); users.put("CONNECTED", "X"); users.rewrite(); enable_menu_item(M_FONT); customize_colors(); // Aggiorna set di colori reload_images(); // Ritrasparentizza immagini xvt_dwin_invalidate_rect(TASK_WIN, NULL); // Ridisegna sfondo } } } if (ok) { if (utente != "PRASSI") { TConfig prawin(CONFIG_INSTALL, "Main"); prawin.set("User", utente); } TConfig userini(CONFIG_USER, "ba0"); _tree_view = userini.get_bool("TreeView"); } return ok; } bool TMenu_application::create() { TApplication::create(); #ifdef _DEMO_ { TMask w("Attenzione", 1, 78, 14); w.add_static(DLG_NULL, 0 ,"@bAttenzione" , 35 , 1); w.add_static(DLG_NULL, 0 ,"@bQuesto programma e' in versione dimostrativa." , 1 , 3); w.add_static(DLG_NULL, 0 ,"@bNon si possono memorizzare date posteriori al 1992" , 1 , 5); w.add_static(DLG_NULL, 0 ,"@bcon mese successivo a Marzo." , 1 , 7); w.add_static(DLG_NULL, 0 ,"@bIl programma funziona per due ore ogni giorno." , 1 , 9); w.add_static(DLG_NULL, 0 ,"@bIl numero di registrazioni e' stato limitato a circa 1000." , 1 , 11); w.add_button(DLG_OK, 0, "", -11, -1, 10, 2); w.run(); } #endif #ifndef _DEMO_ if (!check_user()) return FALSE; #else enable_menu_item(M_FONT); #endif set_perms(); test_temp(); if (!_menu.ok()) { TWait_cursor hourglass; TFilename menu = (argc() < 2) ? "baprassi" : argv(1); menu.ext("men"); _menu.read(menu); dispatch_e_menu(MENU_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::main_loop() { bool run = TRUE; while (run) { const int m = _tree_view ? do_tree() : do_level(); if (m > 0) _menu.perform(); else run = m >= -1; } return FALSE; } bool TMenu_application::choose_colors() { disable_menu_item(M_FONT); 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(M_FONT); 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); strcpy(fs.type, "EXE"); strcpy(fs.name, f.get()); strcpy(fs.creator, "ba0"); DIRECTORY dir; xvt_fsys_get_dir(&dir); const int err = xvt_dm_post_file_open(&fs, "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.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(M_FONT); TConfig link(CONFIG_USER, "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(M_FONT); return TRUE; } 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("La directory %s non e' uno studio valido!", (const char*)f.get()); } return ok; } bool TMenu_application::choose_study() { TMask m("Scelta studio", 1, 60, 5); 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, "Studio ", 1, 1, 50); m.set_handler(DLG_USER, study_handler); m.set(DLG_USER, prefix().get_studio()); bool ok = m.run() == K_ENTER; if (ok) { destroy(); prefix().set_studio(m.get(DLG_USER)); ok = create(); if (ok) _mask->stop_run(K_F9); // Ricarica maschera else stop_run(); // Termina applicazione } 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; } bool TMenu_application::menu(MENU_TAG mt) { bool ok = TRUE; switch (mt) { case MENU_ITEM(1): ok = main_loop(); break; case MENU_ITEM(2): choose_colors(); break; case MENU_ITEM(3): choose_editors(); break; case MENU_ITEM(4): choose_study(); break; default: break; } return ok; } HIDDEN bool convert(const char* menuname) { TString tag(_MAX_FNAME); _splitpath(menuname, NULL, NULL, tag.get_buffer(_MAX_FNAME), NULL); tag.upper(); TFilename outname = tag; outname.ext("men"); FILE* out = fopen(outname, "w"); if (out == NULL) { error_box("Can't write output file %s", (const char*)outname); return FALSE; } TToken_string line; TString256 tmp; int lastid = -1; int lastitem = 0; TScanner mnu(menuname); while (mnu.ok()) { line = mnu.line(); if (line.empty()) break; int menuid = line.get_int(0); if (menuid != lastid) { if (lastid >= 0) fputc('\n', out); fprintf(out, "[%s_%03d]\n", (const char*)tag, menuid); fprintf(out, "Caption = \"%s\"\n", line.get()); fprintf(out, "Picture = \n", line.get_int()); fprintf(out, "Module = %d\n", line.get_int()); fputs("Flags = \"\"\n", out); lastid = menuid; lastitem = 0; } else { tmp.format("Item_%02d = \"%s\", ", ++lastitem, line.get()); TString256 action = line.get(); int jump = atoi(action); if (jump > 0 && jump < 730) { action.format("[%s_%03d]", (const char*)tag, jump); tmp << action; } else { if (action == "DISABLED") action.cut(0); tmp << '\"' << action << "\", \""; if (action.empty()) tmp << 'D'; if (action.compare("cg", 2, TRUE) == 0) tmp << 'F'; const char* mod = line.get(); // Eventuale 'P'assword if (mod && *mod == 'P') tmp << 'P'; tmp << '\"'; } tmp << '\n'; fputs(tmp, out); } } fclose(out); return TRUE; } /////////////////////////////////////////////////////////// // TMenu_tree /////////////////////////////////////////////////////////// class TMenu_tree : public TBidirectional_tree { TMenu* _menu; const TSubmenu* _submenu; int _menuitem; TString _root_id, _curr_id; protected: // TTree virtual void node2id(const TObject* node, TString& id) const; public: // TTree virtual bool goto_root(); virtual bool goto_firstson(); virtual bool goto_rbrother(); virtual bool goto_node(const TString &id); virtual bool has_son() const; virtual bool has_rbrother() const; virtual TObject* curr_node() const; virtual bool has_root() const; virtual bool has_father() const; virtual bool has_lbrother() const; virtual bool goto_father(); virtual bool goto_lbrother(); virtual void curr_id(TString& id) const { id = _curr_id; } virtual bool get_description(TString& desc) const; virtual TImage* image(bool selected) const; public: const TSubmenu& curr_submenu() const; const TMenuitem& curr_item() const; bool find_string(const TString& str); TMenu_tree(TMenu& menu); virtual ~TMenu_tree() { } }; const TSubmenu& TMenu_tree::curr_submenu() const { CHECKS(_submenu, "NULL submenu ", (const char*)_curr_id); return *_submenu; } const TMenuitem& TMenu_tree::curr_item() const { const TSubmenu& sm = curr_submenu(); CHECKD(_menuitem >= 0 && _menuitem < sm.items(), "Invalid submenu item ", _menuitem); return sm.item(_menuitem); } struct TFind_string_data { TString _str; TString _ignore; }; HIDDEN bool find_string_callback(TTree& tree, void* jolly, word flags) { if (flags == SCAN_PRE_ORDER) { TMenu_tree& mt = (TMenu_tree&)tree; TFind_string_data& data = *(TFind_string_data*)jolly; const TSubmenu& sm = mt.curr_submenu(); if (sm.name() == data._ignore) return FALSE; TString desc; mt.get_description(desc); desc.upper(); if (desc.find(data._str) >= 0) return TRUE; } return FALSE; } struct TFind_node_data { TString _id; long _count; }; HIDDEN bool find_node_callback(TTree& tree, void* jolly, word flags) { if (flags == SCAN_PRE_ORDER) { TFind_node_data& data = *(TFind_node_data*)jolly; data._count++; TString id; tree.curr_id(id); if (id == data._id) return TRUE; } return FALSE; } bool TMenu_tree::find_string(const TString& str) { static TFind_string_data data; data._str = str; data._str.upper(); goto_root(); bool ok = scan_depth_first(find_string_callback, &data, SCAN_PRE_ORDER); if (ok) data._ignore = curr_submenu().name(); else data._ignore.cut(0); return ok; } void TMenu_tree::node2id(const TObject* node, TString& id) const { TString* str = (TString*)node; id = *str; } bool TMenu_tree::goto_root() { TSubmenu* sm = _menu->find(_root_id); if (sm) { _curr_id = _root_id; _curr_id << ".0"; _submenu = sm; _menuitem = 0; } return sm != NULL; } bool TMenu_tree::goto_firstson() { const TMenuitem& mi = curr_item(); if (mi.is_submenu()) { const TSubmenu* sm = _menu->find(mi.action()); if (sm && sm->items() > 0) { _curr_id << '/' << mi.action() << ".0"; _submenu = sm; _menuitem = 0; return TRUE; } } return FALSE; } bool TMenu_tree::goto_rbrother() { if (_menuitem < _submenu->items()-1) { const int dot = _curr_id.rfind('.'); _curr_id.cut(dot+1); _curr_id << (++_menuitem); return TRUE; } return FALSE; } bool TMenu_tree::goto_node(const TString &id) { const int dot = id.rfind('.'); _menuitem = atoi(id.mid(dot+1)); _curr_id = id.left(dot); const int slash = _curr_id.rfind('/'); _curr_id = _curr_id.mid(slash+1); _submenu = _menu->find(_curr_id); _curr_id = id; return _submenu != NULL; } bool TMenu_tree::has_son() const { const TMenuitem& mi = curr_item(); return mi.is_submenu(); } bool TMenu_tree::has_rbrother() const { return _menuitem < _submenu->items()-1; } bool TMenu_tree::has_root() const { return _root_id.not_empty(); } bool TMenu_tree::has_father() const { return _curr_id.find('/') > 0; } bool TMenu_tree::has_lbrother() const { return _menuitem > 0; } bool TMenu_tree::goto_father() { const int slash = _curr_id.rfind('/'); if (slash > 0) { const TString id = _curr_id.left(slash); return goto_node(id); } return FALSE; } bool TMenu_tree::goto_lbrother() { if (_menuitem > 0) { const int dot = _curr_id.rfind('.'); _curr_id.cut(dot+1); _curr_id << (--_menuitem); return TRUE; } return FALSE; } TObject* TMenu_tree::curr_node() const { return &((TMenu_tree*)this)->_curr_id; } bool TMenu_tree::get_description(TString& desc) const { const TMenuitem& mi = curr_item(); desc = mi.caption(); return desc.not_empty(); } TImage* TMenu_tree::image(bool selected) const { const TMenuitem& mi = curr_item(); if (mi.disabled()) return get_res_image(BMP_STOP); return TTree::image(selected); } TMenu_tree::TMenu_tree(TMenu& menu) : _menu(&menu), _curr_id(128, '/') { _root_id = _menu->current().name(); goto_root(); } /////////////////////////////////////////////////////////// // 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() && mt.expanded()) { TMenu& menu = mt.curr_submenu().menu(); TImage& image = menu.image(menu.current().picture()); TPicture_mask& pm = (TPicture_mask&)f.mask(); pm.set_image(&image); pm.force_update(); } } return TRUE; } 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(); m.set_last_search_string(v); TTree_field& tf = (TTree_field&)m.field(101); TMenu_tree& mt = *(TMenu_tree*)tf.tree(); if (mt.find_string(v)) { tf.select_current(); TString id; mt.curr_id(id); do { mt.expand(); } while (mt.goto_father()); TFind_node_data data; data._id = id; data._count = 0; mt.goto_root(); mt.scan_depth_first(find_node_callback, &data, SCAN_PRE_ORDER | SCAN_IGNORING_UNEXPANDED); TField_window& win = tf.win(); const TPoint& range = win.range(); if (data._count > range.y) win.set_scroll_max(win.columns(), data._count+win.rows()); const int dot = id.rfind('.'); const int pos = atoi(id.mid(dot+1)); win.update_thumb(-1, data._count-pos-2); win.force_update(); tf.set_focus(); } else beep(); } return TRUE; } bool TMenu_application::tree_shrink_handler(TMask_field&f, KEY k) { if (k == K_SPACE) { TTree_field& tf = (TTree_field&)f.mask().field(101); TMenu_tree& mt = *(TMenu_tree*)tf.tree(); mt.shrink_all(); mt.goto_root(); tf.select_current(); tf.win().update_thumb(0,0); tf.win().force_update(); } return TRUE; } HIDDEN void left_align_field(TMask_field& fld, int x) { RCT rct; fld.get_rect(rct); rct.left = x; fld.set_rect(rct); } int TMenu_application::do_tree() { _menu.jumpto_root(); const TSubmenu& curr = _menu.current(); TImage& image = _menu.image(curr.picture()); TPicture_mask mask(curr.caption(), 0, 0, &image, 0, 0); CHECK(_mask == NULL, "Two masks are better than one?"); _mask = &mask; TMenu_tree tree(_menu); TTree_field& tree_fld = mask.add_tree(101, 0, 0, 0, 60, -1); tree_fld.set_tree(&tree); tree_fld.set_handler(tree_handler); RCT rct; tree_fld.get_rect(rct); const int x = rct.right + CHARX; const int bwidth = 20; TMask_field& sf = mask.add_static(DLG_NULL, 0, "Cerca", -1, 0); left_align_field(sf, x); TEdit_field& ef = mask.add_string(DLG_USER, 0, "", -2, 1, 50, "", bwidth); ef.set_handler(tree_find_handler); left_align_field(ef, x); TButton_field& mf = mask.add_button(102, 0, "Menu principale", -1, 2, bwidth, 2); mf.set_handler(tree_shrink_handler); left_align_field(mf, x); TButton_field& bf = mask.add_button(DLG_QUIT, 0, "Fine", -1, -1, bwidth, 2); left_align_field(bf, x); mask.first_focus(101); KEY key = mask.run(); _mask = NULL; return key == K_QUIT ? -2 : 0; } /////////////////////////////////////////////////////////// // Main program /////////////////////////////////////////////////////////// int main(int argc, char** argv) { TApplication::check_parameters(argc, argv); if (user().blank()) { TConfig prawin(CONFIG_INSTALL, "Main"); user() = prawin.get("User"); } TFilename menu = (argc < 2) ? "baprassi.men" : argv[1]; TString ext = menu.ext(); ext.lower(); if (ext == "men" && !menu.exist()) ext.cut(0); if (ext != "men") { if (ext.empty()) menu.ext("mnu"); TFilename newmenu(menu); newmenu.ext("men"); if (newmenu == "prassi.men") newmenu == "baprassi.men"; if (menu.exist() && !newmenu.exist()) convert(menu); menu = newmenu; } if (!menu.exist()) { error_box("Non esiste il menu %s", (const char*)menu); exit(1); } TMenu_application* ma = new TMenu_application(menu); ma->run(argc, argv, "Menu Principale"); delete ma; exit(0); return TRUE; }