root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modificato meccanismo richiamo programmi esterni

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@793 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 1994-12-27 14:59:25 +00:00
parent af3b1f3113
commit e8dcb49a76
26 changed files with 3991 additions and 3804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/applicat.cpp
View File

@ -301,6 +301,17 @@ void TApplication::terminate()
if (_create_ok) if (_create_ok)
{ {
destroy(); // Distruzione files e maschere destroy(); // Distruzione files e maschere
#if XVT_OS == XVT_OS_WIN
const word WM_WAKEUP = RegisterWindowMessage("WAKEUP");
const HTASK ht = GetCurrentTask();
SendMessage(HWND_BROADCAST, WM_WAKEUP, ht, 0L);
if (fexist("prassi.hlp"))
{
HWND hwnd = (HWND)get_value(TASK_WIN, ATTR_NATIVE_WINDOW);
WinHelp(hwnd, "prassi.hlp", HELP_QUIT, 0L);
}
#endif
do_events(); do_events();
if (_printer != NULL) // Distruzione dell'eventuale stampante if (_printer != NULL) // Distruzione dell'eventuale stampante
@ -310,13 +321,6 @@ void TApplication::terminate()
delete _printer; delete _printer;
_printer = NULL; _printer = NULL;
} }
#if XVT_OS == XVT_OS_WIN
if (fexist("prassi.hlp"))
{
HWND hwnd = (HWND)get_value(TASK_WIN, ATTR_NATIVE_WINDOW);
WinHelp(hwnd, "prassi.hlp", HELP_QUIT, 0L);
}
#endif
} }
if (use_files()) if (use_files())
@ -392,17 +396,9 @@ void TApplication::check_parameters(int & argc, char* argv[])
#ifdef DBG #ifdef DBG
else _user = "PRASSI"; else _user = "PRASSI";
#endif #endif
long twin_style = WSF_ICONIZABLE | WSF_SIZE | WSF_CLOSE;
if (stricmp(argv[argc-1], "-icon") == 0)
{
twin_style |= WSF_ICONIZED;
argc--;
}
else
twin_style |= WSF_MAXIMIZED;
#if XVT_OS == XVT_OS_WIN #if XVT_OS == XVT_OS_WIN
const long twin_style = WSF_ICONIZABLE | WSF_SIZE | WSF_CLOSE | WSF_MAXIMIZED;
set_value(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE, twin_style); set_value(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE, twin_style);
#endif #endif
} }

220
include/applicat.h
View File

@ -1,107 +1,113 @@
#ifndef __APPLICATION_H #ifndef __APPLICATION_H
#define __APPLICATION_H #define __APPLICATION_H
#ifndef INCL_XVTH #ifndef INCL_XVTH
#include <xvt.h> #include <xvt.h>
#endif #endif
#ifndef __PRINTER_H #ifndef __PRINTER_H
#include <printer.h> #include <printer.h>
#endif #endif
// @C // @C
// Classe TApplication // Classe TApplication
// @END // @END
#define MSG_AI "AI" // message auto_insert (relapp) #define MSG_AI "AI" // message auto_insert (relapp)
#define MSG_FS "FS" // message filtered start (relapp) #define MSG_FS "FS" // message filtered start (relapp)
#define MSG_LN "LN" // message (printapp -> relapp) #define MSG_LN "LN" // message (printapp -> relapp)
#define CHK_ALL -1 // all authorization checks #define CHK_ALL -1 // all authorization checks
#define CHK_DONGLE 0 // dongle authorization checks #define CHK_DONGLE 0 // dongle authorization checks
#define CHK_USER 1 // user authorization checks #define CHK_USER 1 // user authorization checks
class TApplication class TApplication
{ {
// @DPRIV // @DPRIV
int _bar; int _bar;
int __argc; int __argc;
const char** __argv; const char** __argv;
TBit_array _dongle_aut; TBit_array _dongle_aut;
TBit_array _user_aut; TBit_array _user_aut;
TString80 _name, _title; TString80 _name, _title;
TPrinter* _printer; TPrinter* _printer;
long _savefirm; long _savefirm;
bool _create_ok; bool _create_ok;
static TString16 _user; word _waiting;
protected: static TString16 _user;
const char* get_module_name() const;
static long task_eh(WINDOW win, EVENT* ep); protected:
const char* get_module_name() const;
virtual long handler(WINDOW win, EVENT* ep); static long task_eh(WINDOW win, EVENT* ep);
virtual bool extended_firm() const { return FALSE; } // Extended set_firm dialog box
virtual bool use_files() const { return TRUE; } virtual long handler(WINDOW win, EVENT* ep);
virtual bool extended_firm() const { return FALSE; } // Extended set_firm dialog box
virtual bool create(); // Crea la finestra principale virtual bool use_files() const { return TRUE; }
virtual bool menu(MENU_TAG) { return TRUE; } // Controlla il menu
virtual bool build_firm_data(long cod, bool flagcom = FALSE) { return TRUE;} virtual bool create(); // Crea la finestra principale
virtual bool destroy(); // Rimuove l'applicazione virtual bool menu(MENU_TAG) { return TRUE; } // Controlla il menu
virtual void print(); virtual bool build_firm_data(long cod, bool flagcom = FALSE) { return TRUE;}
virtual bool destroy(); // Rimuove l'applicazione
virtual void on_config_change(); virtual void print();
virtual void on_firm_change();
virtual void on_config_change();
void set_user(const char * user) { _user = user; } virtual void on_firm_change();
void set_perms();
void set_user(const char * user) { _user = user; }
void terminate(); void set_perms();
bool config();
void about() const; void terminate();
bool config();
public: void about() const;
// @FPUB
public:
void setbar(int menubar) { _bar = menubar;} // Modifica la menu-bar // @FPUB
void run(int argc, char* argv[], const char* name);
void setbar(int menubar) { _bar = menubar;} // Modifica la menu-bar
// @DES Queste funzioni possono essere ridefinite da ogni applicazione void run(int argc, char* argv[], const char* name);
// @FPUB
virtual word class_id() const { return CLASS_APPLICATION; } // @DES Queste funzioni possono essere ridefinite da ogni applicazione
void stop_run(); // Forza chiusura applicazione // @FPUB
virtual word class_id() const { return CLASS_APPLICATION; }
void check_menu_item(MENU_TAG item); // Check menu void stop_run(); // Forza chiusura applicazione
void uncheck_menu_item(MENU_TAG item); // Uncheck
void enable_menu_item(MENU_TAG item, bool on = TRUE); void check_menu_item(MENU_TAG item); // Check menu
void disable_menu_item(MENU_TAG item) { enable_menu_item(item, FALSE); } void uncheck_menu_item(MENU_TAG item); // Uncheck
void dispatch_e_menu(MENU_TAG item); void enable_menu_item(MENU_TAG item, bool on = TRUE);
void disable_menu_item(MENU_TAG item) { enable_menu_item(item, FALSE); }
const TString& name() const { return _name; } void dispatch_e_menu(MENU_TAG item);
const char** argv() const { return __argv; }
const char* argv(int i) const { return __argv[i]; } const TString& name() const { return _name; }
int argc() const { return __argc; } const char** argv() const { return __argv; }
const char* argv(int i) const { return __argv[i]; }
void set_title(const char* t) { _title = t; } int argc() const { return __argc; }
const TString& title() const { return _title; }
void set_title(const char* t) { _title = t; }
TPrinter* set_printer(TPrinter* p); const TString& title() const { return _title; }
TPrinter& printer();
TPrinter* set_printer(TPrinter* p);
static void check_parameters(int & argc, char *argv[]); TPrinter& printer();
const TString& user() const { return _user; } static void check_parameters(int & argc, char *argv[]);
bool has_module(int module, int checktype = CHK_ALL) const;
bool set_firm(long cod = -1); const TString& user() const { return _user; }
long get_firm() const; bool has_module(int module, int checktype = CHK_ALL) const;
const char* get_firm_dir() const; bool set_firm(long cod = -1);
long get_firm() const;
TApplication(); const char* get_firm_dir() const;
virtual ~TApplication();
}; void wait_for(word taskid) { _waiting = taskid; }
void wake_up() { _waiting = 0; }
bool xvt_running(); // xvt is running? word waiting() const { return _waiting; }
TApplication* MainApp(); // main application (old fashioned: will be removed soon
TApplication& main_app(); TApplication();
virtual ~TApplication();
#endif // __APPLICATION_H };
bool xvt_running(); // xvt is running?
TApplication* MainApp(); // main application (old fashioned: will be removed soon
TApplication& main_app();
#endif // __APPLICATION_H

14
include/checks.cpp
View File

@ -146,7 +146,6 @@ int yesnofatal_box(const char* fmt, ...)
} }
int yesnocancel_box(const char* fmt, ...) int yesnocancel_box(const char* fmt, ...)
{ {
buildmsg(); buildmsg();
@ -170,6 +169,19 @@ int yesnocancel_box(const char* fmt, ...)
#endif #endif
} }
int __trace(const char* fmt, ...)
{
buildmsg();
FILE* f = fopen("trace.log", "a");
if (f != NULL)
{
fprintf(f, "%s\n", msg);
fclose(f);
}
return f != NULL;
}
#endif // XVT_OS #endif // XVT_OS

117
include/checks.h
View File

@ -1,58 +1,59 @@
#ifndef __CHECKS_H #ifndef __CHECKS_H
#define __CHECKS_H #define __CHECKS_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* @FPUB */ /* @FPUB */
int message_box(const char* fmt, ...); int message_box(const char* fmt, ...);
int warning_box(const char* fmt, ...); int warning_box(const char* fmt, ...);
int sorry_box(const char* fmt, ...); int sorry_box(const char* fmt, ...);
int error_box(const char* fmt, ...); int error_box(const char* fmt, ...);
int fatal_box(const char* fmt, ...); int fatal_box(const char* fmt, ...);
int yesno_box(const char* fmt, ...); int yesno_box(const char* fmt, ...);
int yesnocancel_box(const char* fmt, ...); int yesnocancel_box(const char* fmt, ...);
int yesnofatal_box(const char* fmt, ...); int yesnofatal_box(const char* fmt, ...);
int __trace(const char* fmt, ...);
/* @END */
#ifdef __cplusplus /* @END */
} #ifdef __cplusplus
#endif }
#endif
/* @M
Utilizzate in fase di debug (definire il simbolo DBG in compilazione) /* @M
*/ Utilizzate in fase di debug (definire il simbolo DBG in compilazione)
#ifdef DBG */
#define CHECK(p, m) ( (p) ? (void)0 : (void) fatal_box( \ #ifdef DBG
"Check failed in %s, line %d:\n\r%s", \ #define CHECK(p, m) ( (p) ? (void)0 : (void) fatal_box( \
__FILE__, __LINE__, m) ) "Check failed in %s, line %d:\n\r%s", \
__FILE__, __LINE__, m) )
#define CHECKS(p, m, s0) ( (p) ? (void)0 : (void) fatal_box( \
"Check failed in %s, line %d:\n\r%s%s", \ #define CHECKS(p, m, s0) ( (p) ? (void)0 : (void) fatal_box( \
__FILE__, __LINE__, m, s0) ) "Check failed in %s, line %d:\n\r%s%s", \
__FILE__, __LINE__, m, s0) )
#define CHECKD(p, m, d0) ( (p) ? (void)0 : (void) fatal_box( \
"Check failed in %s, line %d:\n\r%s%d", \ #define CHECKD(p, m, d0) ( (p) ? (void)0 : (void) fatal_box( \
__FILE__, __LINE__, m, d0) ) "Check failed in %s, line %d:\n\r%s%d", \
#else __FILE__, __LINE__, m, d0) )
#else
#define CHECK(p, m)
#define CHECKS(p, m, s) #define CHECK(p, m)
#define CHECKD(p, m, d) #define CHECKS(p, m, s)
#define CHECKD(p, m, d)
#endif
/* @END */ #endif
/* @END */
/* @M
Utilizzata in fase di debug (definire il simbolo TRC in compilazione) /* @M
*/ Utilizzata in fase di debug (definire il simbolo TRC in compilazione)
#ifdef TRC */
#define TRACE(m) warning_box(m) #ifdef TRC
#else #define TRACE __trace
#define TRACE(m) ((void) 0) #else
#endif #define TRACE 1 ? 0 : __trace
/* @END */ #endif
/* @END */
#endif // __CHECKS_H
#endif // __CHECKS_H

3378
include/cisam.c
View File

File diff suppressed because it is too large Load Diff

27
include/controls.cpp
View File

@ -505,6 +505,7 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
{ {
switch(id) switch(id)
{ {
case DLG_OK: case DLG_OK:
if (strcmp("Conferma", caption()) == 0) if (strcmp("Conferma", caption()) == 0)
capt = format("#%d", BMP_OK); capt = format("#%d", BMP_OK);
@ -526,21 +527,23 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
if (strcmp("Nuovo", caption()) == 0) // Puo' essere Gestione if (strcmp("Nuovo", caption()) == 0) // Puo' essere Gestione
capt = format("#%d#%d", BMP_NEWREC, BMP_NEWRECDN); capt = format("#%d#%d", BMP_NEWREC, BMP_NEWRECDN);
break; break;
case DLG_FIRSTREC:
capt = format("#%d", BMP_FIRSTREC);
break;
case DLG_PREVREC:
capt = format("#%d", BMP_PREVREC);
break;
case DLG_STOPREC: case DLG_STOPREC:
capt = format("#%d", BMP_STOPREC); capt = format("#%d", BMP_STOPREC);
break; break;
case DLG_NEXTREC: /*
capt = format("#%d", BMP_NEXTREC); case DLG_FIRSTREC:
break; capt = format("#%d", BMP_FIRSTREC);
case DLG_LASTREC: break;
capt = format("#%d", BMP_LASTREC); case DLG_PREVREC:
break; capt = format("#%d", BMP_PREVREC);
break;
case DLG_NEXTREC:
capt = format("#%d", BMP_NEXTREC);
break;
case DLG_LASTREC:
capt = format("#%d", BMP_LASTREC);
break;
*/
case DLG_SAVEREC: case DLG_SAVEREC:
capt = format("#%d#%d", BMP_SAVEREC, BMP_SAVERECDN); capt = format("#%d#%d", BMP_SAVEREC, BMP_SAVERECDN);
break; break;

36
include/execp.cpp
View File

@ -30,15 +30,12 @@ bool TExternal_app::can_run() const
} }
int TExternal_app::run(bool async, bool iconized) int TExternal_app::run(bool async, bool user)
{ {
TString256 path(_path); TString256 path(_path);
if (!async) if (user)
{
if (iconized) path << " -icon";
path << " -u" << main_app().user(); path << " -u" << main_app().user();
}
_error = 0; _error = 0;
_exitcode = 0; _exitcode = 0;
@ -59,34 +56,32 @@ int TExternal_app::run(bool async, bool iconized)
CURSOR oldcur = get_cursor(TASK_WIN); CURSOR oldcur = get_cursor(TASK_WIN);
set_cursor(TASK_WIN, CURSOR_WAIT); set_cursor(TASK_WIN, CURSOR_WAIT);
const UINT sh = iconized ? SW_SHOWMINIMIZED : SW_SHOW; _exitcode = WinExec((char*)(const char*)path, SW_SHOW);
_exitcode = WinExec((char*)(const char*)path, sh);
if (_exitcode >= 32) if (_exitcode >= 32)
{ {
if (!async) if (!async)
{ {
if (!iconized) TTemp_window tw(TASK_WIN);
{ tw.iconize();
TTemp_window tw(TASK_WIN);
tw.iconize();
}
HTASK child = NULL; HTASK child = NULL;
TASKENTRY te; te.dwSize = sizeof(TASKENTRY); TASKENTRY te; te.dwSize = sizeof(TASKENTRY);
for (bool ok = TaskFirst(&te); ok; ok = TaskNext(&te)) for (bool ok = TaskFirst(&te); ok; ok = TaskNext(&te))
if (te.hInst == (HINSTANCE)_exitcode) child = te.hTask; if (te.hInst == (HINSTANCE)_exitcode) child = te.hTask;
CHECK(child, "Can't find child task"); CHECK(child, "Can't find child task");
while(TaskFindHandle(&te, child))
process_events();
if (!iconized) main_app().wait_for(child);
for (byte i = 0; main_app().waiting(); i++)
{ {
TTemp_window tw(TASK_WIN); if (i == 0 && TaskFindHandle(&te, child) == FALSE)
tw.maximize(); break;
xvt_statbar_refresh(); process_events();
} }
tw.maximize();
} }
xvt_statbar_refresh();
_exitcode = 0; _exitcode = 0;
} }
else else
@ -96,7 +91,6 @@ int TExternal_app::run(bool async, bool iconized)
else else
error_box("Impossibile eseguire '%s':\nErrore %d", (const char*)_path, _exitcode); error_box("Impossibile eseguire '%s':\nErrore %d", (const char*)_path, _exitcode);
} }
set_cursor(TASK_WIN, oldcur); set_cursor(TASK_WIN, oldcur);
} }
#else #else

68
include/execp.h
View File

@ -1,34 +1,34 @@
// execp.h; trattasi di -*-c++-*- // execp.h; trattasi di -*-c++-*-
// fv 6/10/93 // fv 6/10/93
#ifndef __EXECP_H #ifndef __EXECP_H
#define __EXECP_H #define __EXECP_H
#ifndef __OBJECT_H #ifndef __OBJECT_H
#include <object.h> #include <object.h>
#endif #endif
// Class for external object execution with optional background // Class for external object execution with optional background
// exec under UNIX and swap on EMS under DOS // exec under UNIX and swap on EMS under DOS
// Manages restoring the XVT status // Manages restoring the XVT status
// No command line is implemented; user is supposed to use the // No command line is implemented; user is supposed to use the
// mailbox for this // mailbox for this
class TExternal_app : public TObject class TExternal_app : public TObject
{ {
const char* _path; // app name (must be allocated by user) const char* _path; // app name (must be allocated by user)
int _error; // last error (errno code) int _error; // last error (errno code)
int _exitcode; // last exit code int _exitcode; // last exit code
int _count; // count of calls int _count; // count of calls
public: public:
bool can_run() const; bool can_run() const;
int run(bool async = FALSE, bool iconized = FALSE); int run(bool async = FALSE, bool user = TRUE);
int error() { return _error;}; int error() { return _error;};
int exitcode() { return _exitcode;}; int exitcode() { return _exitcode;};
int count() { return _count; }; int count() { return _count; };
TExternal_app(const char* p); TExternal_app(const char* p);
}; };
#endif #endif

221
include/form.cpp
View File

@ -2,13 +2,13 @@
#include <stdlib.h> #include <stdlib.h>
#include <applicat.h> #include <applicat.h>
#include <msksheet.h>
#include <form.h> #include <form.h>
#include <msksheet.h>
#include <relation.h> #include <relation.h>
#include <sheet.h> #include <sheet.h>
#include <utility.h> #include <utility.h>
#include <bagn003.h> #include "..\ba\ba2100.h"
static TForm* _form = NULL; static TForm* _form = NULL;
@ -71,7 +71,8 @@ void TForm_flags::print_on(ostream& out) const
if (!enabled) s << "D"; if (!enabled) s << "D";
if (!shown) s << "H"; if (!shown) s << "H";
if (s.not_empty()) out << " FLAGS \"" << s << '"' << endl; if (s.not_empty())
out << " FLAGS \"" << s << '"' << endl;
} }
@ -143,7 +144,7 @@ public:
bool in_group(byte g) const { return g == 0 || _group[g]; } bool in_group(byte g) const { return g == 0 || _group[g]; }
const TString& key() const { return _desc; } const TString& key() const { return _desc; }
void to_row(TToken_string& row) const; void print_on(TToken_string& row) const;
void show(bool on = TRUE) { _flag.shown = on; } void show(bool on = TRUE) { _flag.shown = on; }
void hide() { show(FALSE); } void hide() { show(FALSE); }
@ -375,11 +376,15 @@ bool TForm_item::update()
return TRUE; return TRUE;
} }
void TForm_item::to_row(TToken_string& row) const void TForm_item::print_on(TToken_string& row) const
{ {
row = class_name(); row = class_name();
row.add(_y); row.add(_y);
row.add(_x); row.add(_x);
const long fu = _group.first_one();
if (fu > 0) row.add(fu);
else row.add(" ");
row.add(key()); row.add(key());
} }
@ -788,10 +793,27 @@ bool TForm_list::update()
// TPrint_section // TPrint_section
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
TPrint_section::TPrint_section(TForm* f) TMask* TPrint_section::_msk = NULL;
: _height(0), _form(f)
TPrint_section::TPrint_section(TForm* f) : _height(0), _form(f)
{} {}
TPrint_section::~TPrint_section()
{
if (_msk)
{
delete _msk;
_msk = NULL;
}
}
const TPrint_section& TPrint_section::copy(const TPrint_section& ps)
{
_item = ps._item;
_height = ps._height;
return ps;
}
TPrintrow& TPrint_section::row(int num) TPrintrow& TPrint_section::row(int num)
{ {
TPrintrow* pr = (TPrintrow*)objptr(num); TPrintrow* pr = (TPrintrow*)objptr(num);
@ -815,7 +837,7 @@ TForm_item* TPrint_section::parse_item(const TString& s)
if (s == "LI") if (s == "LI")
return new TForm_list(this); return new TForm_list(this);
CHECKS(NULL, "Elemento di stampa sconosciuto: ", (const char*)s); CHECKS(NULL, "Campo di stampa sconosciuto: ", (const char*)s);
return NULL; return NULL;
} }
@ -868,51 +890,63 @@ bool TPrint_section::update()
} }
bool TPrint_section::edit() bool TPrint_section::edit(const char* title)
{ {
TMask m("bagn003"); TMask m("ba2100s");
m.set_caption(title);
m.set(F_HEIGHT, _height);
if (m.run() == K_ESC)
return FALSE;
TString80 title("Campi della sezione"); bool dirty = m.dirty() != 0;
TArray_sheet a(-1, -1, 0, 0, title, "Tipo@8|Riga|Col.|Descrizione@80", 0xE); if (dirty)
_height = m.get_int(F_HEIGHT);
TArray_sheet a(-1, -1, 0, 0, title, "Tipo@8|Riga|Col.|Gr.|Descrizione@40", 0xE);
for (word i = 0; i < fields(); i++) for (word i = 0; i < fields(); i++)
{ {
TToken_string* s = new TToken_string(128); TToken_string* s = new TToken_string(128);
field(i).to_row(*s); field(i).print_on(*s);
a.add(s); a.add(s);
} }
bool dirty = FALSE;
KEY k; KEY k;
do do
{ {
k = a.run(); k = a.run();
i = (word)a.selected(); i = (word)a.selected();
if (k == K_ENTER || k == K_INS && _msk == NULL)
_msk = new TMask("ba2100f");
switch(k) switch(k)
{ {
case K_ENTER: case K_ENTER:
m.set_mode(MODE_MOD); _msk->set_mode(MODE_MOD);
if (field(i).edit(m)) if (field(i).edit(*_msk))
{ {
field(i).print_on(a.row(i));
dirty = TRUE; dirty = TRUE;
field(i).to_row(a.row(i));
} }
break; break;
case K_INS: case K_INS:
{ {
m.set_mode(MODE_INS); _msk->set_mode(MODE_INS);
TForm_string dummy(this); TForm_string dummy(this);
if (dummy.edit(m)) if (dummy.edit(*_msk))
{ {
const TString& c = m.get(F_CLASS).left(2); const TString& c = _msk->get(F_CLASS).left(2);
TForm_item* item = parse_item(c); TForm_item* item = parse_item(c);
item->read_from(m); item->read_from(*_msk);
_item.insert(item, i); _item.insert(item, i);
TToken_string s(128); item->to_row(s); TToken_string s(128); item->print_on(s);
a.insert(s, i); a.insert(s, i);
dirty = TRUE;
} }
} }
break; break;
@ -921,19 +955,20 @@ bool TPrint_section::edit()
{ {
_item.destroy(i, TRUE); _item.destroy(i, TRUE);
a.destroy(i); a.destroy(i);
dirty = TRUE;
} }
break; break;
default: default:
break; break;
} }
} while (k != K_ESC); } while (k != K_ESC);
return dirty; return dirty;
} }
void TPrint_section::print_on(ostream& out) const void TPrint_section::print_on(ostream& out) const
{ {
out << _height << endl; out << ' ' << _height << endl;
for(word i = 0; i < fields(); i++) for(word i = 0; i < fields(); i++)
out << field(i); out << field(i);
} }
@ -952,23 +987,14 @@ bool TForm::parse_use(TScanner& scanner)
else else
{ {
tab = scanner.pop(); tab = scanner.pop();
if (strlen(tab) > 4)
return error_box("'%s' non e' una tabella valida: %d", tab);
_relation = new TRelation(tab); _relation = new TRelation(tab);
} }
int key = 1; int key = 1;
if (scanner.popkey() == "KE") if (scanner.popkey() == "KE")
{
key = scanner.integer(); key = scanner.integer();
if (key < 1) else
{ scanner.push();
error_box("Chiave non valida '%s': uso 1",
(const char*)scanner.token());
key = 1;
}
}
else scanner.push();
_cursor = new TCursor(_relation, "", key); _cursor = new TCursor(_relation, "", key);
return TRUE; return TRUE;
@ -977,7 +1003,7 @@ bool TForm::parse_use(TScanner& scanner)
bool TForm::parse_join(TScanner& scanner) bool TForm::parse_join(TScanner& scanner)
{ {
TString j(scanner.pop()); // File or table TString16 j(scanner.pop()); // File or table
int to = 0; int to = 0;
if (scanner.popkey() == "TO") // TO keyword if (scanner.popkey() == "TO") // TO keyword
@ -1020,13 +1046,16 @@ bool TForm::parse_join(TScanner& scanner)
} }
TPrint_section& TForm::page2pos(const TArray& s, word p) const TPrint_section& TForm::section(char s, word p)
{ {
pagetype pos = odd_page; pagetype pos = odd_page;
if (p == 0 && s.objptr(last_page)) pos = last_page; if (p == 0 && exist(s, last_page)) pos = last_page;
if (p == 1 && s.objptr(first_page)) pos = first_page; if (p == 1 && exist(s, first_page)) pos = first_page;
if (pos == 0 && (p & 0x1) == 0 && s.objptr(even_page)) pos = even_page; if (pos == 0 && (p & 0x1) == 0 && exist(s, even_page)) pos = even_page;
return (TPrint_section&)s[pos];
TPrint_section* sec = exist(s, pos);
CHECKD(sec, "Can't find section for page ", p);
return *sec;
} }
word TForm::set_header(word p, bool u) word TForm::set_header(word p, bool u)
@ -1034,10 +1063,14 @@ word TForm::set_header(word p, bool u)
TPrinter& printer = main_app().printer(); TPrinter& printer = main_app().printer();
printer.resetheader(); printer.resetheader();
TPrint_section& head = page2pos(_head, p); TPrint_section& head = section('H', p);
if (u) head.update(); if (u) head.update();
else head.reset(); else
{
head.reset();
printer.headerlen(head.height());
}
for (word j = 0; j < head.height(); j++) for (word j = 0; j < head.height(); j++)
printer.setheaderline(j, head.row(j)); printer.setheaderline(j, head.row(j));
@ -1047,7 +1080,7 @@ word TForm::set_header(word p, bool u)
word TForm::set_body(word p, bool u) word TForm::set_body(word p, bool u)
{ {
TPrint_section& body = page2pos(_body, p); TPrint_section& body = section('B', p);
if (u) body.update(); if (u) body.update();
else body.reset(); else body.reset();
@ -1067,10 +1100,14 @@ word TForm::set_footer(word p, bool u)
TPrinter& printer = main_app().printer(); TPrinter& printer = main_app().printer();
printer.resetfooter(); printer.resetfooter();
TPrint_section& foot = page2pos(_foot, p); TPrint_section& foot = section('F', p);
if (u) foot.update(); if (u) foot.update();
else foot.reset(); else
{
foot.reset();
printer.footerlen(foot.height());
}
for (word j = 0; j < foot.height(); j++) for (word j = 0; j < foot.height(); j++)
printer.setfooterline(j, foot.row(j)); printer.setfooterline(j, foot.row(j));
@ -1110,13 +1147,13 @@ long TForm::records() const
bool TForm::print(long from, long to) bool TForm::print(long from, long to)
{ {
CHECK(form == NULL, "Can't print two forms"); _form = this; // setta il form corrente
_form = this;
_lastpage = FALSE; _lastpage = FALSE;
TPrinter& printer = main_app().printer(); TPrinter& printer = main_app().printer();
printer.setheaderhandler(header_handler); printer.setheaderhandler(header_handler);
printer.setfooterhandler(footer_handler); printer.setfooterhandler(footer_handler);
printer.formlen(height());
const bool was_open = printer.isopen(); const bool was_open = printer.isopen();
@ -1141,7 +1178,7 @@ bool TForm::print(long from, long to)
if (i > records()) if (i > records())
{ {
if (_head.objptr(last_page) || _body.objptr(last_page) || _foot.objptr(last_page)) if (exist('H', last_page) || exist('B', last_page) || exist('F', last_page))
{ {
_lastpage = TRUE; _lastpage = TRUE;
set_header(0, TRUE); set_header(0, TRUE);
@ -1153,17 +1190,22 @@ bool TForm::print(long from, long to)
if (!was_open) if (!was_open)
printer.close(); printer.close();
_form = NULL; _form = NULL; // resetta form
return ok; return ok;
} }
void TForm::print_section(ostream& out, const TArray& s, const char* name) const void TForm::print_section(ostream& out, char s) const
{ {
for (pagetype t = odd_page; t <= last_page; t = pagetype(t+1)) if (s.objptr(t)) for (pagetype t = odd_page; t <= last_page; t = pagetype(t+1))
{ {
out << "SECTION " << name << ' ' << int(t); const TPrint_section* sec = ((TForm*)this)->exist(s, t);
out << s[t]; if (sec)
out << "END\n" << endl; {
const char* name = s == 'H' ? "HEADER" : (s == 'F' ? "FOOTER" : "BODY");
out << "SECTION " << name << ' ' << int(t);
out << *sec;
out << "END\n" << endl;
}
} }
} }
@ -1172,14 +1214,15 @@ void TForm::print_on(ostream& out) const
if (relation()) if (relation())
out << *relation() << endl; out << *relation() << endl;
print_section(out, _head, "HEADER"); print_section(out, 'H');
print_section(out, _body, "BODY"); print_section(out, 'B');
print_section(out, _foot, "FOOTER"); print_section(out, 'F');
out << "END" << endl; out << "END" << endl;
} }
TPrint_section& TForm::section(char s, pagetype t)
TPrint_section* TForm::exist(char s, pagetype t, bool create)
{ {
TArray* a = NULL; TArray* a = NULL;
switch (s) switch (s)
@ -1193,33 +1236,29 @@ TPrint_section& TForm::section(char s, pagetype t)
} }
TPrint_section* sec = (TPrint_section*)a->objptr(t); TPrint_section* sec = (TPrint_section*)a->objptr(t);
if (sec == NULL) a->add(sec = new TPrint_section(this)); if (sec == NULL && create)
return (TPrint_section&)*sec;
}
bool TForm::edit(char s, pagetype t)
{
bool dirty = FALSE;
section(s, t).edit();
if (dirty && yesno_box("Salvare le modifiche?"))
{ {
set_cursor(TASK_WIN, CURSOR_WAIT); sec = new TPrint_section(this);
TFilename bak(_name); bak.ext("bak"); a->add(sec, t);
rename(_name, bak); }
ofstream out(_name);
print_on(out); return sec;
set_cursor(TASK_WIN, CURSOR_ARROW); }
}
return dirty; word TForm::height()
{
word h = 0;
if (_head.items())
h += section('H', 1).height();
if (_body.items())
h += section('B', 1).height();
if (_foot.items())
h += section('F', 1).height();
return h;
} }
TForm::TForm(const char* name) TForm::TForm(const char* name) : _name(name), _relation(NULL), _cursor(NULL)
: _name(name), _relation(NULL), _cursor(NULL)
{ {
const CURSOR oldcur = get_cursor(TASK_WIN); const CURSOR oldcur = get_cursor(TASK_WIN);
set_cursor(TASK_WIN, CURSOR_WAIT); set_cursor(TASK_WIN, CURSOR_WAIT);
@ -1234,14 +1273,16 @@ TForm::TForm(const char* name)
while (ok && scanner.popkey() == "JO") while (ok && scanner.popkey() == "JO")
ok = parse_join(scanner); ok = parse_join(scanner);
} }
scanner.push();
while (scanner.popkey() != "" && ok) while (ok)
{ {
const char sec = scanner.key()[0]; scanner.popkey();
const char sec = toupper(scanner.key()[0]);
if (sec <= ' ' || sec == 'E')
break;
const pagetype p = (pagetype)scanner.integer(); const pagetype p = (pagetype)scanner.integer();
TPrint_section& ps = section(sec, p); TPrint_section* ps = exist(sec, p, TRUE);
ok = ps.parse(scanner); ok = ps->parse(scanner);
} }
set_cursor(TASK_WIN, oldcur); set_cursor(TASK_WIN, oldcur);

213
include/form.h
View File

@ -1,99 +1,114 @@
#ifndef __FORM_H #ifndef __FORM_H
#define __FORM_H #define __FORM_H
#ifndef __PRINTER_H #ifndef __PRINTER_H
#include <printer.h> #include <printer.h>
#endif #endif
#ifndef __SCANNER_H #ifndef __SCANNER_H
#include <scanner.h> #include <scanner.h>
#endif #endif
#ifndef __RELATION_H #ifndef __MASK_H
class TRelation; class TMask;
class TCursor; #endif
#endif
#ifndef __RELATION_H
enum pagetype { odd_page, even_page, first_page, last_page }; class TRelation;
class TCursor;
class TForm; #endif
class TForm_item;
enum pagetype { odd_page, even_page, first_page, last_page };
class TPrint_section : public TArray
{ class TForm;
word _height; // Altezza della sezione class TForm_item;
TForm* _form; // Form cui appartiene alla sezione class TPrint_section : public TArray
TArray _item; // Lista dei campi da stampare {
static TMask* _msk;
protected:
virtual void print_on(ostream& out) const; word _height; // Altezza della sezione
TForm_item* parse_item(const TString& key);
TForm_item* parse_item(TScanner& scanner); TForm* _form; // Form cui appartiene alla sezione
TArray _item; // Lista dei campi da stampare
public:
TPrintrow& row(int num); const TPrint_section& copy(const TPrint_section& ps);
TForm* form() const { return _form; }
protected:
TForm_item& field(int n) const { return (TForm_item&)_item[n]; } virtual void print_on(ostream& out) const;
word fields() const { return _item.items(); } TForm_item* parse_item(const TString& key);
word height() const { return _height; } TForm_item* parse_item(TScanner& scanner);
void reset(); public:
bool update(); TPrintrow& row(int num);
bool parse(TScanner& scanner); TForm* form() const { return _form; }
bool edit(); TForm_item& field(int n) const { return (TForm_item&)_item[n]; }
word fields() const { return _item.items(); }
TPrint_section(TForm* parent); word height() const { return _height; }
virtual ~TPrint_section() {}
}; void reset();
bool update();
bool parse(TScanner& scanner);
class TForm : public TObject
{ bool edit(const char* title);
TFilename _name; // Profile name
const TPrint_section& operator=(const TPrint_section& ps) { return copy(ps); }
TRelation* _relation; // Can be NULL TPrint_section(TForm* parent);
TCursor* _cursor; // Can be NULL TPrint_section(const TPrint_section& ps) { copy(ps); }
virtual ~TPrint_section();
TArray _head; // Headers };
TArray _body; // Bodies
TArray _foot; // Footers
class TForm : public TObject
bool _lastpage; {
friend class TForm_editor;
TPrint_section& page2pos(const TArray& a, word p) const;
TFilename _name; // Profile name
static void header_handler(TPrinter& p);
static void footer_handler(TPrinter& p); TRelation* _relation; // Can be NULL
TCursor* _cursor; // Can be NULL
protected:
TPrint_section& section(char s, pagetype t); // H = Header, B = Body, F = Footer TArray _head; // Headers
TArray _body; // Bodies
void print_section(ostream& out, const TArray& s, const char* name) const; TArray _foot; // Footers
virtual void print_on(ostream& out) const;
bool _lastpage; // I am about to print the last page
bool parse_use(TScanner&);
bool parse_join(TScanner&); TPrint_section* exist(char s, pagetype t, bool create = FALSE); // Can be NULL
word page(const TPrinter& p) const; static void header_handler(TPrinter& p);
static void footer_handler(TPrinter& p);
virtual long records() const;
virtual word set_header(word p, bool u); protected:
virtual word set_body(word p, bool u); // H = Header, B = Body, F = Footer, R = Relation
virtual word set_footer(word p, bool u); TPrint_section& section(char s = 'B', word page = 1);
word height(); // Height of first page
public:
bool print(long from = 0L, long to = -1L); void print_section(ostream& out, char s) const;
virtual void print_on(ostream& out) const;
TRelation* relation() const { return _relation; } bool edit_relation();
TCursor* cursor() const { return _cursor; }
bool parse_use(TScanner&);
bool edit(char section, pagetype t); bool parse_join(TScanner&);
TForm(const char* form); word page(const TPrinter& p) const;
~TForm();
}; virtual long records() const;
virtual word set_header(word p, bool u);
#endif virtual word set_body(word p, bool u);
virtual word set_footer(word p, bool u);
public:
bool print(long from = 0L, long to = -1L);
const TFilename& name() const { return _name; }
TRelation* relation() const { return _relation; }
TCursor* cursor() const { return _cursor; }
TForm(const char* form);
virtual ~TForm();
};
#endif

17
include/isam.cpp
View File

@ -28,7 +28,7 @@
#endif #endif
#define NOT_LINKED(i,f) CHECKS(i != NULL, "Record senza tracciato: impossibile eseguire ", f) #define NOT_LINKED(i,f) CHECKS(i != NULL, "Record senza tracciato: impossibile eseguire ", f)
#define NOT_OPEN(f) CHECKS(_isamfile != NULL, "File chiuso, impossibile eseguire ", f) #define NOT_OPEN(f) CHECKS(_isamfile != NULL, "File chiuso: ", f)
HIDDEN void UNKNOWN_FIELD(int num, const char* name) HIDDEN void UNKNOWN_FIELD(int num, const char* name)
{ yesnofatal_box("Il campo '%s' non appartiene al file %d", name, num); } { yesnofatal_box("Il campo '%s' non appartiene al file %d", name, num); }
@ -38,7 +38,6 @@ HIDDEN void UNKNOWN_FIELD(int num, const char* name)
HIDDEN bool __autoload = TRUE; HIDDEN bool __autoload = TRUE;
void set_autoload_new_files(bool on) void set_autoload_new_files(bool on)
{ {
__autoload = on; __autoload = on;
} }
@ -193,13 +192,23 @@ const char* TBaseisamfile::name() const
const char* TBaseisamfile::filename() const const char* TBaseisamfile::filename() const
{ {
NOT_OPEN(name()); if (_isamfile == NULL)
{
TDir d;
d.get(num());
return strcpy(__tmp_string, d.name());
}
return _isamfile->d->SysName; return _isamfile->d->SysName;
} }
const char* TBaseisamfile::description() const const char* TBaseisamfile::description() const
{ {
NOT_OPEN(name()); if (_isamfile == NULL)
{
TDir d;
d.get(num());
return strcpy(__tmp_string, d.des());
}
return _isamfile->d->Des; return _isamfile->d->Des;
} }

990
include/isam.h
View File

@ -1,497 +1,493 @@
#ifndef __ISAM_H #ifndef __ISAM_H
#define __ISAM_H #define __ISAM_H
#ifndef __ARRAY_H #ifndef __SYSFLD_H
#include <array.h> #include <sysfld.h>
#endif #endif
#ifndef __SYSFLD_H #ifndef FOXPRO
#include <sysfld.h>
#endif #ifndef __REAL_H
#include <real.h>
#ifndef FOXPRO #endif
#ifndef __REAL_H #endif
#include <real.h>
#endif #ifndef __DATE_H
#include <date.h>
#endif #endif
#ifndef __DATE_H #ifndef __STRINGS_H
#include <date.h> #include <strings.h>
#endif #endif
#ifndef __STRINGS_H #ifndef __FILES_H
#include <strings.h> #include <files.h>
#endif #endif
#ifndef __FILES_H #ifndef __LFFILES_H
#include <files.h> #include <lffiles.h>
#endif #endif
#ifndef __LFFILES_H
#include <lffiles.h> // @M
#endif #define FIELDERR -1
const int MAX_KEYS = 8;
// @M // @END
#define FIELDERR -1
// @C
const int MAX_KEYS = 8; // Classe TRectype : public TObject
// @END //
// Tipo record
// @C //
// Classe TRectype : public TObject // @END
//
// Tipo record class TRectype : public TSortable
// {
// @END friend class TExtrectype;
friend class TRecfield;
class TRectype : public TSortable friend class TBaseisamfile;
{ friend class TLocalisamfile;
friend class TExtrectype; friend class TIsamtempfile;
friend class TRecfield;
friend class TBaseisamfile; // DPRIV
friend class TLocalisamfile; char* _rec; // Puntatore a inizio record
friend class TIsamtempfile; int _logicnum; // Numero logico
int _length; // Lunghezza
// DPRIV isdef* _i; // Puntatore al file isam
char* _rec; // Puntatore a inizio record bool _isempty; // Se il record e' vuoto
int _logicnum; // Numero logico char _tab[5]; // identificatore della tabella
int _length; // Lunghezza TRecfield * _cod; // campo "COD" della tabella
isdef* _i; // Puntatore al file isam // @END
bool _isempty; // Se il record e' vuoto
char _tab[5]; // identificatore della tabella protected:
TRecfield * _cod; // campo "COD" della tabella // FPROT
// @END const char* start(int nf) const;
void setempty(bool val) { _isempty = val;} // Rende vero is_empty
protected: virtual TObject* dup() const; // Duplica record
// FPROT virtual int compare(const TSortable& s) const;
const char* start(int nf) const; // @END
void setempty(bool val) { _isempty = val;} // Rende vero is_empty
virtual TObject* dup() const; // Duplica record public:
virtual int compare(const TSortable& s) const; // FPUB
// @END int items() const;
void setdirty() { setempty(FALSE); }
public: void settab(const char *tab);
// FPUB char* string() const { return _rec;} // Ritorna il puntatore all'inizio. NON dovrebbe essere usata!
int items() const;
void setdirty() { setempty(FALSE); } void discard() { *_rec = char(_deleted);} // Setta il flag di cancellazione
void settab(const char *tab); void recall() { *_rec = char(_valid);} // Ripristina il flag di cancellazione
char* string() const { return _rec;} // Ritorna il puntatore all'inizio. NON dovrebbe essere usata! bool isdeleted() const { return *_rec == _deleted;} // Chiede se e' cancellato
int len() const { return _length;} // Ritorna la lunghezza
void discard() { *_rec = char(_deleted);} // Setta il flag di cancellazione TFieldtypes type(const char* fieldname) const; // Ritorna il tipo del campo
void recall() { *_rec = char(_valid);} // Ripristina il flag di cancellazione int length(const char* fieldname) const; // Ritorna lunghezza campo
bool isdeleted() const { return *_rec == _deleted;} // Chiede se e' cancellato int ndec(const char* fieldname) const; // Ritorna numero di decimali
int len() const { return _length;} // Ritorna la lunghezza bool exist(const char* fieldname) const; // Ritorna l'esistenza del campo
TFieldtypes type(const char* fieldname) const; // Ritorna il tipo del campo const char* fieldname(int i) const; // Ritorna il nome del campo i
int length(const char* fieldname) const; // Ritorna lunghezza campo
int ndec(const char* fieldname) const; // Ritorna numero di decimali // @DES Get tipizzata. Ritorna il contenuto del campo nei vari tipi
bool exist(const char* fieldname) const; // Ritorna l'esistenza del campo // @FPUB
const char* fieldname(int i) const; // Ritorna il nome del campo i #ifndef FOXPRO
int get_int(const char* fieldname) const ;
// @DES Get tipizzata. Ritorna il contenuto del campo nei vari tipi long get_long(const char* fieldname) const ;
// @FPUB word get_word(const char* fieldname) const ;
#ifndef FOXPRO char get_char(const char* fieldname) const ;
int get_int(const char* fieldname) const ; bool get_bool(const char* fieldname) const ;
long get_long(const char* fieldname) const ; real get_real(const char* fieldname) const ;
word get_word(const char* fieldname) const ; #endif
char get_char(const char* fieldname) const ; TDate get_date(const char* fieldname) const ;
bool get_bool(const char* fieldname) const ;
real get_real(const char* fieldname) const ; // @DES Get non tipizzata. Il campo e' ritornato come TString&
#endif // @FPUB
TDate get_date(const char* fieldname) const ; const TString& get(const char* fieldname) const ;
// @DES Get non tipizzata. Il campo e' ritornato come TString& // @DES Put tipizzata
// @FPUB // @FPUB
const TString& get(const char* fieldname) const ;
#ifndef FOXPRO
// @DES Put tipizzata void put(const char* fieldname, int val);
// @FPUB void put(const char* fieldname, long val);
void put(const char* fieldname, word val);
#ifndef FOXPRO void put(const char* fieldname, const TDate& val);
void put(const char* fieldname, int val); void put(const char* fieldname, char val);
void put(const char* fieldname, long val); void put(const char* fieldname, bool val);
void put(const char* fieldname, word val); void put(const char* fieldname, const real& val);
void put(const char* fieldname, const TDate& val); #endif
void put(const char* fieldname, char val);
void put(const char* fieldname, bool val); // @DES Put NON tipizzata
void put(const char* fieldname, const real& val); // @FPUB
#endif void put(const char* fieldname, const char* val);
// void put(const char* fieldname, TString& val);
// @DES Put NON tipizzata
// @FPUB void zero(const char * fieldname); // Vuota campo puntato da fieldname
void put(const char* fieldname, const char* val); void zero(); // Vuota tutto il record
// void put(const char* fieldname, TString& val); void zero(char c); // Vuota tutto il record usando il carattere c
void zero(const char * fieldname); // Vuota campo puntato da fieldname TRectype& operator =(const TRectype& rec); // assegnazione tra TRectype
void zero(); // Vuota tutto il record TRectype& operator =(const char* rec); // assegnazione tra TRectype
void zero(char c); // Vuota tutto il record usando il carattere c TRectype& operator =(const TBaseisamfile& f);
TRectype& operator =(const TRectype& rec); // assegnazione tra TRectype const isdef* filehnd() const { return _i; } // Ritorna il file isam associato
TRectype& operator =(const char* rec); // assegnazione tra TRectype int num() const { return _logicnum;} // Ritorna il numero logico
TRectype& operator =(const TBaseisamfile& f); bool empty() const {return _isempty;} // Ritorna se e' vuoto
bool valid() const {return _rec[0] == 0;} // Ritorna se il record non e'cancellato
const isdef* filehnd() const { return _i; } // Ritorna il file isam associato const char* key(int numkey = 1) const; // Ritorna l'espressione della chiave numero numkey
int num() const { return _logicnum;} // Ritorna il numero logico bool ok() const { return _i != NULL;}
bool empty() const {return _isempty;} // Ritorna se e' vuoto
bool valid() const {return _rec[0] == 0;} // Ritorna se il record non e'cancellato TRectype(int logicnum); // Costruisce un record staccato da un file. Bisogna poi chiamare linkfile(). Sarebbe meglio utilizzare una delle altre due
const char* key(int numkey = 1) const; // Ritorna l'espressione della chiave numero numkey TRectype(const TBaseisamfile* i); // Costruisce record e lo associa al file isam i
bool ok() const { return _i != NULL;} TRectype(const TRectype& r); // Costruisce il record a partire da r
TRectype(int logicnum); // Costruisce un record staccato da un file. Bisogna poi chiamare linkfile(). Sarebbe meglio utilizzare una delle altre due virtual ~TRectype();
TRectype(const TBaseisamfile* i); // Costruisce record e lo associa al file isam i };
TRectype(const TRectype& r); // Costruisce il record a partire da r
// @C
virtual ~TRectype(); // Classe TBaseisamfile : public TObject
}; //
// File isam di base
// @C //
// Classe TBaseisamfile : public TObject // @END
//
// File isam di base class TBaseisamfile : public TObject
// {
// @END // @DPRIV
isdef* _isamfile; // Descrittore file isam
class TBaseisamfile : public TObject int _logicnum; // Numero logico del record corrente
{ int _lasterr; // Ultimo errore
// @DPRIV bool _delrec; // Per sapere se rimuovere il record alla fine
isdef* _isamfile; // Descrittore file isam bool _delopenrec; // Per sapere se rimuovere il record alla fine dalla lista interna di record
int _logicnum; // Numero logico del record corrente TRectype* _current; // Puntatore a record corrente
int _lasterr; // Ultimo errore TFile _hf;
bool _delrec; // Per sapere se rimuovere il record alla fine TFile _hfhd;
bool _delopenrec; // Per sapere se rimuovere il record alla fine dalla lista interna di record bool _historicfile; // Vero se il file e' archivio storico
TRectype* _current; // Puntatore a record corrente TRecnotype _lasthf;
TFile _hf; TRecnotype _recno;
TFile _hfhd;
bool _historicfile; // Vero se il file e' archivio storico friend class TRectype;
TRecnotype _lasthf; friend class TLocalisamfile;
TRecnotype _recno; friend class TIsamfile;
friend class TIsamtempfile;
friend class TRectype; friend class TRecfield;
friend class TLocalisamfile; // friend class TCursor;
friend class TIsamfile; // @END
friend class TIsamtempfile; // @FPRIV
friend class TRecfield; // friend TRecnotype __buildcursor(TFilecursor* tic, TRecnotype rp);
// friend class TCursor; // friend TRecnotype __filtercursor(TFilecursor* tic);
// @END // friend bool __evalcondition(TBaseisamfile* i,TString& condition);
// @FPRIV // friend void __readrec(TFilecursor* tic);
// friend TRecnotype __buildcursor(TFilecursor* tic, TRecnotype rp);
// friend TRecnotype __filtercursor(TFilecursor* tic); int gethr(TRectype& rec, TDate& atdate);
// friend bool __evalcondition(TBaseisamfile* i,TString& condition); int addhr(const TRectype& rec, TDate& atdate);
// friend void __readrec(TFilecursor* tic); int rewhr(const TRectype& rec, TDate& atdate);
int delhr(const TRectype& rec, TDate& atdate);
int gethr(TRectype& rec, TDate& atdate);
int addhr(const TRectype& rec, TDate& atdate); protected:
int rewhr(const TRectype& rec, TDate& atdate); // @FPROT
int delhr(const TRectype& rec, TDate& atdate); isdef** ptrfilehnd() const { return (isdef**) &_isamfile;}
void clearfilehnd() { _isamfile = NULL;}
protected:
// @FPROT void recover();
isdef** ptrfilehnd() const { return (isdef**) &_isamfile;} int _open(unsigned int mode = _manulock); // Apre isam file con lock
void clearfilehnd() { _isamfile = NULL;} int _close();
const char* filename() const;
void recover();
int _open(unsigned int mode = _manulock); // Apre isam file con lock public:
int _close(); // @FPUB
const char* filename() const; void setkey(int nkey); // Attiva una chiave
int getkey() const; // Ritorna la chiave
public: void setstatus(int status) { _lasterr = status; } // Setta _lasterr
// @FPUB virtual int first(word lockop = _nolock);
void setkey(int nkey); // Attiva una chiave virtual int last(word lockop = _nolock);
int getkey() const; // Ritorna la chiave virtual int next(word lockop = _nolock);
void setstatus(int status) { _lasterr = status; } // Setta _lasterr virtual int next(TDate& atdate);
virtual int first(word lockop = _nolock); virtual int prev(word lockop = _nolock);
virtual int last(word lockop = _nolock); virtual int prev(TDate& atdate);
virtual int next(word lockop = _nolock); virtual int reread(word lockop = _nolock, TDate& atdate = (TDate&)botime);
virtual int next(TDate& atdate); virtual int reread(TRectype& rec, word lockop = _nolock, TDate& atdate = (TDate&)botime);
virtual int prev(word lockop = _nolock); virtual int skip(TRecnotype nrec, word lockop = _nolock);
virtual int prev(TDate& atdate); virtual int read(word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
virtual int reread(word lockop = _nolock, TDate& atdate = (TDate&)botime); virtual int read(TRectype& rec, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
virtual int reread(TRectype& rec, word lockop = _nolock, TDate& atdate = (TDate&)botime); virtual int readat(TRecnotype nrec, word lockop = _nolock);
virtual int skip(TRecnotype nrec, word lockop = _nolock); virtual int readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock);
virtual int read(word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime); virtual int write(TDate& atdate = (TDate&)botime);
virtual int read(TRectype& rec, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime); virtual int write(const TRectype& rec, TDate& atdate = (TDate&)botime);
virtual int readat(TRecnotype nrec, word lockop = _nolock); virtual int rewrite(TDate& atdate = (TDate&)botime);
virtual int readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock); virtual int rewrite(const TRectype& rec, TDate& atdate = (TDate&)botime);
virtual int write(TDate& atdate = (TDate&)botime); virtual int rewriteat(TRecnotype nrec);
virtual int write(const TRectype& rec, TDate& atdate = (TDate&)botime); virtual int rewriteat(const TRectype& rec, TRecnotype nrec);
virtual int rewrite(TDate& atdate = (TDate&)botime); virtual int remove(TDate& atdate = (TDate&)botime);
virtual int rewrite(const TRectype& rec, TDate& atdate = (TDate&)botime); virtual int remove(const TRectype& rec, TDate& atdate = (TDate&)botime);
virtual int rewriteat(TRecnotype nrec); virtual const char* name() const;
virtual int rewriteat(const TRectype& rec, TRecnotype nrec);
virtual int remove(TDate& atdate = (TDate&)botime); TRecnotype recno() const { return _recno;}
virtual int remove(const TRectype& rec, TDate& atdate = (TDate&)botime); int lock(); // Attiva lock di tutto il file
virtual const char* name() const; int unlock(); // Disattiva lock di tutto il file
void indexon(); // Accende gli indici
TRecnotype recno() const { return _recno;} void indexoff(); // Spegne gli indici
int lock(); // Attiva lock di tutto il file int status() const { return _lasterr; } // Ritorna _lasterr
int unlock(); // Disattiva lock di tutto il file TRectype& curr() const {return *_current;} // Ritorna puntatore a record corrente
void indexon(); // Accende gli indici bool eof() const { return status() == _iseof || status() == _isemptyfile;} // Vero se siamo a fine file
void indexoff(); // Spegne gli indici bool bof() const { return status() == _isbof || status() == _isemptyfile;} // Vero se siamo a inizio file
int status() const { return _lasterr; } // Ritorna _lasterr bool good() const { return status() == NOERR;} // Vero se _lasterr non contiene codici d'errore
TRectype& curr() const {return *_current;} // Ritorna puntatore a record corrente bool bad() const { return status() != NOERR;} // Vero se _lasterr contiene codici d'errore
bool eof() const { return status() == _iseof || status() == _isemptyfile;} // Vero se siamo a fine file bool empty(); // Vero se il file e' vuoto
bool bof() const { return status() == _isbof || status() == _isemptyfile;} // Vero se siamo a inizio file int num() const { return _logicnum;} // Ritorna il numero logico del record corrente
bool good() const { return status() == NOERR;} // Vero se _lasterr non contiene codici d'errore const char* description() const;
bool bad() const { return status() != NOERR;} // Vero se _lasterr contiene codici d'errore TRecnotype eod() const { return filehnd()->d->EOD;}
bool empty(); // Vero se il file e' vuoto
int num() const { return _logicnum;} // Ritorna il numero logico del record corrente isdef* filehnd() const { return (isdef*) _isamfile;} // Ritorna l'handle del file isam nella tabella
const char* description() const;
TRecnotype eod() const { return filehnd()->d->EOD;} long items() const; // n.o di records nel file
isdef* filehnd() const { return (isdef*) _isamfile;} // Ritorna l'handle del file isam nella tabella // @DES Get tipizzata. Ritorna il contenuto del campo nei vari tipi
// @FPUB
long items() const; // n.o di records nel file #ifndef FOXPRO
int get_int(const char* fieldname) const
// @DES Get tipizzata. Ritorna il contenuto del campo nei vari tipi { return curr().get_int(fieldname);}
// @FPUB long get_long(const char* fieldname) const
#ifndef FOXPRO { return curr().get_long(fieldname);}
int get_int(const char* fieldname) const word get_word(const char* fieldname) const
{ return curr().get_int(fieldname);} { return curr().get_word(fieldname);}
long get_long(const char* fieldname) const char get_char(const char* fieldname) const
{ return curr().get_long(fieldname);} { return curr().get_char(fieldname);}
word get_word(const char* fieldname) const bool get_bool(const char* fieldname) const
{ return curr().get_word(fieldname);} { return curr().get_bool(fieldname);}
char get_char(const char* fieldname) const real get_real(const char* fieldname) const
{ return curr().get_char(fieldname);} { return curr().get_real(fieldname);}
bool get_bool(const char* fieldname) const #endif
{ return curr().get_bool(fieldname);} TDate get_date(const char* fieldname) const
real get_real(const char* fieldname) const { return curr().get_date(fieldname);}
{ return curr().get_real(fieldname);}
#endif // @DES Get non tipizzata. Il campo e' ritornato come TString&
TDate get_date(const char* fieldname) const // @FPUB
{ return curr().get_date(fieldname);} const TString& get(const char* fieldname) const
{ return curr().get(fieldname);}
// @DES Get non tipizzata. Il campo e' ritornato come TString&
// @FPUB // @DES Put NON tipizzata
const TString& get(const char* fieldname) const // @FPUB
{ return curr().get(fieldname);} #ifndef FOXPRO
void put(const char* fieldname, int val)
// @DES Put NON tipizzata { curr().put(fieldname, val);}
// @FPUB void put(const char* fieldname, long val)
#ifndef FOXPRO { curr().put(fieldname, val);}
void put(const char* fieldname, int val) void put(const char* fieldname, word val)
{ curr().put(fieldname, val);} { curr().put(fieldname, val);}
void put(const char* fieldname, long val) void put(const char* fieldname, const TDate& val)
{ curr().put(fieldname, val);} { curr().put(fieldname, val);}
void put(const char* fieldname, word val) void put(const char* fieldname, char val)
{ curr().put(fieldname, val);} { curr().put(fieldname, val);}
void put(const char* fieldname, const TDate& val) void put(const char* fieldname, bool val)
{ curr().put(fieldname, val);} { curr().put(fieldname, val);}
void put(const char* fieldname, char val) void put(const char* fieldname, const real& val)
{ curr().put(fieldname, val);} { curr().put(fieldname, val);}
void put(const char* fieldname, bool val) #endif
{ curr().put(fieldname, val);}
void put(const char* fieldname, const real& val) // @DES Put NON tipizzata
{ curr().put(fieldname, val);} // @FPUB
#endif void put(const char* fieldname, const char* val)
{ curr().put(fieldname, val);}
// @DES Put NON tipizzata
// @FPUB void zero(const char * fieldname) { curr().zero(fieldname);}
void put(const char* fieldname, const char* val) void zero() { curr().zero();}
{ curr().put(fieldname, val);} void zero(char c) { curr().zero(c);}
TRectype& operator =(const TRectype& rec) { return curr() = rec;}
void zero(const char * fieldname) { curr().zero(fieldname);}
void zero() { curr().zero();} TBaseisamfile(int logicnum, bool linkrecinst = TRUE);
void zero(char c) { curr().zero(c);} virtual ~TBaseisamfile();
TRectype& operator =(const TRectype& rec) { return curr() = rec;} };
TBaseisamfile(int logicnum, bool linkrecinst = TRUE); // @C
virtual ~TBaseisamfile(); // Classe TIsamfile : public TBaseisamfile
}; //
// File isam
// @C //
// Classe TIsamfile : public TBaseisamfile // @END
//
// File isam class TIsamfile : public TBaseisamfile
// {
// @END public:
// @FPUB
class TIsamfile : public TBaseisamfile int flags(bool updateeod = FALSE);
{ int open(unsigned int mode = _manulock) { return _open(mode);} // Apre isam file con lock
public: int close() { return _close();}
// @FPUB TIsamfile(int logicnum, bool linkrecinst = TRUE);
int flags(bool updateeod = FALSE); virtual ~TIsamfile();
int open(unsigned int mode = _manulock) { return _open(mode);} // Apre isam file con lock };
int close() { return _close();}
TIsamfile(int logicnum, bool linkrecinst = TRUE); // @C
virtual ~TIsamfile(); // Classe TIsamtempfile : public TBaseisamfile
}; //
// File isam temporaneo
// @C //
// Classe TIsamtempfile : public TBaseisamfile // @END
//
// File isam temporaneo class TIsamtempfile : public TBaseisamfile
// {
// @END public:
// @FPUB
class TIsamtempfile : public TBaseisamfile int open(char* radix, bool create = TRUE, TRecnotype eod = 0,
{ TRecnotype eox = 100); // Apre il file. radix e' la radice del path del file, se create e' falso vuol dire che il file esiste gia', e allora eod dice quanti record ci sono; eox quanti bisogna aggiungerne
public:
// @FPUB int close(bool flagdel = TRUE); // Chiude il file e se e' vero flagdel lo cancella
int open(char* radix, bool create = TRUE, TRecnotype eod = 0,
TRecnotype eox = 100); // Apre il file. radix e' la radice del path del file, se create e' falso vuol dire che il file esiste gia', e allora eod dice quanti record ci sono; eox quanti bisogna aggiungerne TIsamtempfile(int logicnum, bool linkrecinst = FALSE);
virtual ~TIsamtempfile();
int close(bool flagdel = TRUE); // Chiude il file e se e' vero flagdel lo cancella };
TIsamtempfile(int logicnum, bool linkrecinst = FALSE); // @C
virtual ~TIsamtempfile(); // Classe TSystemisamfile : public TBaseisamfile
}; //
// @END
// @C
// Classe TSystemisamfile : public TBaseisamfile class TSystemisamfile : public TIsamfile
// {
// @END TArray _flds;
TArray _exps;
class TSystemisamfile : public TIsamfile
{ bool getlcf(long flev);
TArray _flds; bool exec_convapp(long flev, const bool before);
TArray _exps; void makelc(TRectype& rec);
bool getlcf(long flev); public:
bool exec_convapp(long flev, const bool before); // @FPUB
void makelc(TRectype& rec); int build(TRecnotype eox); // Costruisce un file isam
int extend(TRecnotype eox); // Estende un file preesistente
public: long size(TRecnotype eox); // Calcola lo spazio che il file occuperebbe se venisse esteso a eox
// @FPUB int update(TTrec& newrec, bool vis = TRUE);
int build(TRecnotype eox); // Costruisce un file isam
int extend(TRecnotype eox); // Estende un file preesistente int packfile(bool vis = TRUE); // Rimuove fisicamente i record cancellati
long size(TRecnotype eox); // Calcola lo spazio che il file occuperebbe se venisse esteso a eox int packindex(bool vis = TRUE); // La stessa cosa sugli indici
int update(TTrec& newrec, bool vis = TRUE);
// @DES Importa un file ascii. from e' il nome del file da importare
int packfile(bool vis = TRUE); // Rimuove fisicamente i record cancellati int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool extended = FALSE) ;
int packindex(bool vis = TRUE); // La stessa cosa sugli indici
// @DES Esporta VERSO un file ascii.
// @DES Importa un file ascii. from e' il nome del file da importare int dump(const char* to, int nkey = 1, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool withdeleted = FALSE);
int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool extended = FALSE) ;
TSystemisamfile(int logicnum, bool linkrecinst = TRUE)
// @DES Esporta VERSO un file ascii. : TIsamfile(logicnum, linkrecinst) {}
int dump(const char* to, int nkey = 1, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool withdeleted = FALSE); virtual ~TSystemisamfile() {}
};
TSystemisamfile(int logicnum, bool linkrecinst = TRUE)
: TIsamfile(logicnum, linkrecinst) {} // @C
virtual ~TSystemisamfile() {} // Classe TLocalisamfile : public TBaseisamfile
}; //
// @END
// @C
// Classe TLocalisamfile : public TBaseisamfile class TLocalisamfile : public TBaseisamfile
// {
// @END // @DPRIV
bool _was_open; // Vero se il file e' stato aperto come Localisamfile
class TLocalisamfile : public TBaseisamfile bool _isatab; // Vero se il file e' una tabella
{
// @DPRIV public:
bool _was_open; // Vero se il file e' stato aperto come Localisamfile // @FPUB
bool _isatab; // Vero se il file e' una tabella virtual int operator +=(const TRecnotype npos); // Avanza npos record
virtual int operator -=(const TRecnotype npos); // Sposta indietro di npos
public: virtual int operator ++(); // record successivo
// @FPUB virtual int operator --(); // record precedente
virtual int operator +=(const TRecnotype npos); // Avanza npos record bool tab() const { return _isatab;} // Ritorna vero se tabella
virtual int operator -=(const TRecnotype npos); // Sposta indietro di npos void settab(bool fl = FALSE) { _isatab = fl;} // Setta il flag _isatab
virtual int operator ++(); // record successivo
virtual int operator --(); // record precedente int open(unsigned int mode = _manulock);
bool tab() const { return _isatab;} // Ritorna vero se tabella int close() ;
void settab(bool fl = FALSE) { _isatab = fl;} // Setta il flag _isatab // Costruttore. linkrecinst dice se il file deve utilizzare un area record separata oppure la stessa.
TLocalisamfile(int logicnum, bool linkrecinst = TRUE);
int open(unsigned int mode = _manulock); virtual ~TLocalisamfile();
int close() ; };
// Costruttore. linkrecinst dice se il file deve utilizzare un area record separata oppure la stessa.
TLocalisamfile(int logicnum, bool linkrecinst = TRUE); // @C
virtual ~TLocalisamfile(); // Classe TRec_array : public TArray
}; //
// @END
// @C
// Classe TRec_array : public TArray class TRec_array : public TArray
// {
// @END public:
// @FPUB
class TRec_array : public TArray TRec_array(int dimension, TBaseisamfile& i);
{ };
public:
// @FPUB // @C
TRec_array(int dimension, TBaseisamfile& i); // Classe TRecfield : public TObject
}; //
// @END
// @C
// Classe TRecfield : public TObject class TRecfield : public TObject
// {
// @END // @DPRIV
char _name[12]; // Nome campo
class TRecfield : public TObject TRectype* _rec; // Puntatore a inizio record
{ char* _p; // Puntatore a inizio campo
// @DPRIV byte _len; // Lunghezza campo
char _name[12]; // Nome campo byte _dec; // Numero di decimali
TRectype* _rec; // Puntatore a inizio record byte _type; // Tipo del campo
char* _p; // Puntatore a inizio campo // @END
byte _len; // Lunghezza campo
byte _dec; // Numero di decimali // @FPRIV
byte _type; // Tipo del campo void set(int from, int to);
// @END
public:
// @FPRIV // @FPUB
void set(int from, int to); // @DES Operatore di assegnazione (=) per i vari tipi
// @FPUB
public:
// @FPUB int operator =(int i) ;
// @DES Operatore di assegnazione (=) per i vari tipi long operator =(long l) ;
// @FPUB const TDate& operator =(const TDate& d) ;
const char* operator =(const char* s) ;
int operator =(int i) ; #ifndef FOXPRO
long operator =(long l) ; const real& operator =(const real& r) ;
const TDate& operator =(const TDate& d) ; #endif // FOXPRO
const char* operator =(const char* s) ;
#ifndef FOXPRO // @DES Operatore di estrazione per i vari tipi
const real& operator =(const real& r) ; // @FPUB
#endif // FOXPRO operator int() const ;
operator long() const ;
// @DES Operatore di estrazione per i vari tipi operator const char*() const ;
// @FPUB operator TDate() const ;
operator int() const ; #ifndef FOXPRO
operator long() const ; operator const real() const ;
operator const char*() const ; #endif // FOXPRO
operator TDate() const ;
#ifndef FOXPRO
operator const real() const ; void setptr(TRecnotype r); // Scrive un campo packed. Sarebbe meglio non usare mai campi packed.
#endif // FOXPRO TRecnotype ptr() const; // Legge un campo packed. Sarebbe meglio non usare mai campi packed.
const char* pos() const { return (const char*) _p;} // Ritorna un puntatore all'inizio del campo nel record. Dovrebbe essere protected!
void setptr(TRecnotype r); // Scrive un campo packed. Sarebbe meglio non usare mai campi packed. int len() const { return (int) _len;} // Ritorna la lunghezza
TRecnotype ptr() const; // Legge un campo packed. Sarebbe meglio non usare mai campi packed. int dec() const { return (int) _dec;} // Ritorna il numero di decimali
TFieldtypes type() const { return (TFieldtypes) _type;} // Ritorna il tipo del campo
const char* pos() const { return (const char*) _p;} // Ritorna un puntatore all'inizio del campo nel record. Dovrebbe essere protected! TRectype& record() const { return *_rec;} // Ritorna puntatore a inizio record
int len() const { return (int) _len;} // Ritorna la lunghezza
int dec() const { return (int) _dec;} // Ritorna il numero di decimali TRecfield(TRectype& rec, const char* name, int from = 0, int to = -1);
TFieldtypes type() const { return (TFieldtypes) _type;} // Ritorna il tipo del campo };
TRectype& record() const { return *_rec;} // Ritorna puntatore a inizio record
// @C
TRecfield(TRectype& rec, const char* name, int from = 0, int to = -1); // Classe TTransaction
}; //
// @END
// @C
// Classe TTransaction class TTransaction
// {
// @END public:
// @FPUB
class TTransaction void begin();
{ void end(bool success = TRUE);
public: void abort() { end(FALSE);}
// @FPUB };
void begin();
void end(bool success = TRUE); #ifdef __ISAM_CPP
void abort() { end(FALSE);} #define extern
}; #endif
#ifdef __ISAM_CPP // @DPUB
#define extern extern TTransaction transaction;
#endif extern TRectype** openrec;
// @END
// @DPUB #undef extern
extern TTransaction transaction;
extern TRectype** openrec; void set_autoload_new_files(bool on);
// @END
#undef extern #endif // __ISAM_
void set_autoload_new_files(bool on);
#endif // __ISAM_

65
include/maskfld.cpp
View File

@ -1,4 +1,4 @@
// $Id: maskfld.cpp,v 1.63 1994-12-20 15:11:11 guy Exp $ // $Id: maskfld.cpp,v 1.64 1994-12-27 14:58:54 guy Exp $
#include <xvt.h> #include <xvt.h>
#include <applicat.h> #include <applicat.h>
@ -6,6 +6,7 @@
#include <execp.h> #include <execp.h>
#include <mailbox.h> #include <mailbox.h>
#include <mask.h> #include <mask.h>
#include <prefix.h>
#include <relation.h> #include <relation.h>
#include <sheet.h> #include <sheet.h>
#include <tabutil.h> #include <tabutil.h>
@ -38,6 +39,7 @@ TMask_field::TField_Flags::TField_Flags()
roman = exchange = FALSE; roman = exchange = FALSE;
firm = ghost = FALSE; firm = ghost = FALSE;
password = FALSE; password = FALSE;
trim = TRUE;
} }
// Certified 100% // Certified 100%
@ -47,6 +49,9 @@ char TMask_field::TField_Flags::update(const char* s)
for (; *s; s++) for (; *s; s++)
switch(toupper(*s)) switch(toupper(*s))
{ {
case ' ':
case '_':
trim = FALSE; break;
case '*': case '*':
password = TRUE; break; password = TRUE; break;
case 'A': case 'A':
@ -471,7 +476,8 @@ TString& TMask_field::get() const
else else
gpark = get_field_data(); gpark = get_field_data();
return gpark.trim(); if (_flags.trim) gpark.trim();
return gpark;
} }
@ -575,7 +581,7 @@ bool TMask_field::do_message(int num)
KEY key = 0; KEY key = 0;
msg = m; msg = m;
value = msg.get(); value = msg.get();
value.trim(); // value.trim(); // TBR
const char* dlg = msg.get(); const char* dlg = msg.get();
int cmd = -1; int cmd = -1;
@ -748,8 +754,20 @@ bool TMask_field::on_key(KEY key)
#if XVT_OS == XVT_OS_WIN #if XVT_OS == XVT_OS_WIN
if (fexist("prassi.hlp")) if (fexist("prassi.hlp"))
{ {
struct MULTIGUY
{
UINT mkSize;
BYTE mkKeylist;
char mkKeyphrase[16];
} mk;
TFilename topic(mask().source_file()); topic.ext("");
mk.mkSize = sizeof(MULTIGUY);
mk.mkKeylist = 'M';
strcpy(mk.mkKeyphrase, topic);
HWND hwnd = (HWND)get_value(TASK_WIN, ATTR_NATIVE_WINDOW); HWND hwnd = (HWND)get_value(TASK_WIN, ATTR_NATIVE_WINDOW);
WinHelp(hwnd, "prassi.hlp", HELP_KEY, (DWORD)(const char*)mask().source_file()); WinHelp(hwnd, "prassi.hlp", HELP_MULTIKEY, (DWORD)&mk);
} else } else
#endif #endif
if (_help.not_empty()) if (_help.not_empty())
@ -1435,29 +1453,8 @@ KEY TBrowse::run()
do_input(TRUE); do_input(TRUE);
_cursor->read(_isgteq); _cursor->read(_isgteq);
TString80 caption;
const TLocalisamfile& f = _cursor->file(); const TLocalisamfile& f = _cursor->file();
if (f.tab()) TString80 caption(prefhndl->description(f.name()));
{
TFilename name("batb");
name << _cursor->file().name() << ".msk";
if (fexist(name.lower()))
{
TScanner m(name);
while (m.line().left(2) != "PA"); // Find PAGE
const int apicia = m.token().find('"')+1;
const int apicic = m.token().find('"', apicia);
caption = m.token().sub(apicia, apicic);
}
else
{
caption = name.mid(4);
caption.cut(caption.find('.'));
caption.insert("Tabella ", 0);
}
}
else
caption = f.description();
if (!isalnum(caption[0])) if (!isalnum(caption[0]))
caption = "Selezione"; caption = "Selezione";
@ -1900,7 +1897,7 @@ const char* TEdit_field::get_field_data() const
const char* TEdit_field::format(const char* d) const char* TEdit_field::format(const char* d)
{ {
fpark = d; fpark = d;
fpark.trim(); if (_flags.trim) fpark.trim();
if (fpark.not_empty()) if (fpark.not_empty())
{ {
@ -1944,7 +1941,8 @@ const char* TEdit_field::picture_data(const char* data, bool video)
set_window_data(data); set_window_data(data);
TMask_field::get_window_data(); TMask_field::get_window_data();
fpark.trim();
if (_flags.trim) fpark.trim();
return fpark; return fpark;
} }
@ -2245,6 +2243,12 @@ void TButton_field::parse_head(TScanner& scanner)
bool TButton_field::parse_item(TScanner& scanner) bool TButton_field::parse_item(TScanner& scanner)
{ {
if (scanner.key() == "PI")
{
const int bmp = scanner.integer();
_prompt << '#' << bmp;
return bmp > 0;
}
return TMask_field::parse_item(scanner); return TMask_field::parse_item(scanner);
} }
@ -2267,6 +2271,8 @@ void TButton_field::create(WINDOW parent)
_virtual_key = _exit_key = K_ESC; _virtual_key = _exit_key = K_ESC;
break; break;
case DLG_DELREC: case DLG_DELREC:
if (_prompt.empty())
_prompt = "Elimina";
_virtual_key = 'E'; _virtual_key = 'E';
_exit_key = K_DEL; _exit_key = K_DEL;
break; break;
@ -2301,8 +2307,9 @@ void TButton_field::create(WINDOW parent)
break; break;
} }
#if XWTWS == WMWS #if XWTWS == WMWS
const int diesis = _prompt.find('#');
if (diesis > 0) _prompt.cut(diesis);
_prompt.center_just(_width); _prompt.center_just(_width);
#endif #endif

1135
include/maskfld.h
View File

File diff suppressed because it is too large Load Diff

41
include/msksheet.cpp
View File

@ -20,15 +20,13 @@ extern "C"
// TSpreadsheet // TSpreadsheet
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
#define K_PLUS '+'
class TSpreadsheet : public TWindow class TSpreadsheet : public TWindow
{ {
friend class TSheet_field; friend class TSheet_field;
enum { ITF_CID = 0, LIST_CID = 1 }; enum { ITF_CID = 0, LIST_CID = 1 };
TArray _str; // Array di TToken_strings TString_array _str; // Array di TToken_strings
TBit_array _column_disabled; TBit_array _column_disabled;
TArray _disabled; // Array di TBit_array TArray _disabled; // Array di TBit_array
@ -70,11 +68,12 @@ protected:
public: public:
void update(int row); void update(int row);
TToken_string& row(int n); TToken_string& row(int n) { return _str.row(n); }
TArray& rows_array() const { return (TArray&)_str; } int add(const TToken_string& s) { return _str.add(s); }
int add(TToken_string&); int add(TToken_string* s) { return _str.add(s); }
int insert(int rec); int insert(int rec);
bool destroy(int rec = -1); bool destroy(int rec = -1);
TString_array& rows_array() { return _str; }
void set_focus_cell(int riga, int colonna); void set_focus_cell(int riga, int colonna);
void activate(bool on); void activate(bool on);
@ -381,7 +380,7 @@ int TSpreadsheet::insert(int rec)
const bool ok = notify(rec, K_INS); const bool ok = notify(rec, K_INS);
if (!ok) return -1; if (!ok) return -1;
TToken_string s; // Empty row TToken_string s(80); // Empty row
const int r = _str.insert(s, rec); const int r = _str.insert(s, rec);
_disabled.insert(NULL, rec); _disabled.insert(NULL, rec);
@ -505,7 +504,7 @@ break;
else else
{ {
src = row(rec).get(col); // Set value for cell src = row(rec).get(col); // Set value for cell
if (src && *src && (acqua == CLASS_REAL_FIELD || acqua == CLASS_DATE_FIELD)) if (src && *src && f->is_edit())
{ {
src = f->picture_data(src, FALSE); // Get formatted string src = f->picture_data(src, FALSE); // Get formatted string
} }
@ -525,11 +524,7 @@ break;
if (src) if (src)
{ {
strncpy(dst, src, len); strncpy(dst, src, len);
if (isspace(*dst)) // if (isspace(*dst)) { TFixed_string d(dst); d.ltrim(); } TBR
{
TFixed_string d(dst);
d.ltrim();
}
} }
else else
*dst = '\0'; *dst = '\0';
@ -830,16 +825,6 @@ void TSpreadsheet::activate(bool on)
} }
} }
int TSpreadsheet::add(TToken_string& t)
{
return _str.add(t);
}
TToken_string& TSpreadsheet::row(int n)
{
return (TToken_string&)_str[n];
}
#else #else
#include <sheet.h> #include <sheet.h>
@ -868,8 +853,6 @@ public:
TSpreadsheet(short x, short y, short dx, short dy, const char* maskname, int maskno, TSpreadsheet(short x, short y, short dx, short dy, const char* maskname, int maskno,
const char* head, WINDOW parent, TSheet_field * o); const char* head, WINDOW parent, TSheet_field * o);
TArray& rows_array() const { return data(); }
TMask& sheet_mask() { return _mask; } TMask& sheet_mask() { return _mask; }
TMask& mask() const; TMask& mask() const;
@ -1218,12 +1201,12 @@ bool TSheet_field::parse_item(TScanner& scanner)
void TSheet_field::create(WINDOW parent) void TSheet_field::create(WINDOW parent)
{ {
const TMask& m = mask(); const TMask& m = mask();
_sheet = new TSpreadsheet(_x, _y, _width, _size, m.source_file(), m.sheets(), _sheet = new TSpreadsheet(_x, _y, _width, _size, m.source_file(),
_head, parent, this); m.sheets(), _head, parent, this);
_win = _sheet->win(); _win = _sheet->win();
enable_window(_win, enabled());
show_window(_win, shown()); show_window(_win, shown());
if (!enabled()) disable();
} }
@ -1252,7 +1235,7 @@ TToken_string& TSheet_field::row(int n)
if (n < 0 || n >= max) if (n < 0 || n >= max)
{ {
if (n < 0) n = first_empty(); if (n < 0) n = first_empty();
if (n >= max) n = _sheet->add(TToken_string(80)); if (n >= max) n = _sheet->add(new TToken_string(80));
} }
return _sheet->row(n); return _sheet->row(n);
} }

2
include/prassi.ver
View File

@ -1 +1 @@
#define VERSION 1.1 #define VERSION 1.2

48
include/prefix.cpp
View File

@ -9,8 +9,8 @@
#include <applicat.h> #include <applicat.h>
#endif #endif
#include <array.h>
#include <extcdecl.h> #include <extcdecl.h>
#include <isam.h>
#include <scanner.h> #include <scanner.h>
#include <utility.h> #include <utility.h>
@ -18,7 +18,7 @@
HIDDEN const char* const glockname = "xx"; HIDDEN const char* const glockname = "xx";
TPrefix::TPrefix() TPrefix::TPrefix() : _filelevel(0), _items(0)
{ {
CHECK(prefhndl == NULL, "Can't create two prefix objects"); CHECK(prefhndl == NULL, "Can't create two prefix objects");
@ -177,6 +177,7 @@ void TPrefix::set(const char* name, bool force, TFilelock mode)
CGetFile(LF_DIR, &d, _nolock, NORDIR); CGetFile(LF_DIR, &d, _nolock, NORDIR);
_filelevel = d.Flags; _filelevel = d.Flags;
_items = (int)d.EOD;
openall(FALSE, excl, max, comfiles); openall(FALSE, excl, max, comfiles);
} }
} }
@ -247,6 +248,49 @@ bool TPrefix::set_codditta(long codditta, bool force)
return FALSE; return FALSE;
} }
const char* TPrefix::description(const char* cod) const
{
TString80 n(cod);
if (n[0] == '%')
n.ltrim(1);
const int logicnum = atoi(n);
if (logicnum == 0)
{
TFilename name("batb");
name << n << ".msk";
if (fexist(name.lower()))
{
TScanner m(name);
while (m.line().left(2) != "PA"); // Find PAGE
const int apicia = m.token().find('"')+1;
const int apicic = m.token().find('"', apicia);
n = m.token().sub(apicia, apicic);
}
else n.cut(0);
}
else
{
if (logicnum > 0 && logicnum < items())
{
const TBaseisamfile f(logicnum);
n = f.description();
}
else n.cut(0);
}
return strcpy(__tmp_string, n);
}
const char* TPrefix::description(int cod) const
{
TString16 n; n << cod;
return description(n);
}
// Restituisce il nome di una directory dati // Restituisce il nome di una directory dati
// Certified 90% // Certified 90%
const char* firm2dir(long codditta) const char* firm2dir(long codditta)

136
include/prefix.h
View File

@ -1,65 +1,71 @@
#ifndef __PREFIX_H #ifndef __PREFIX_H
#define __PREFIX_H #define __PREFIX_H
#ifndef __EXTCTYPE_H #ifndef __EXTCTYPE_H
#include <extctype.h> #include <extctype.h>
#endif #endif
#ifndef __FILES_H #ifndef __FILES_H
#include <files.h> #include <files.h>
#endif #endif
#ifndef __STRINGS_H #ifndef __STRINGS_H
#include <strings.h> #include <strings.h>
#endif #endif
// @C // @C
// class TPrefix : public TObject // class TPrefix : public TObject
// @END // @END
class TPrefix : public TObject class TPrefix : public TObject
{ {
// @DPRIV // @DPRIV
TString _prefix; TString _prefix;
int* _dirfl; int* _dirfl;
int* _recfl; int* _recfl;
long _filelevel; long _filelevel;
SecDef* _fdir; int _items;
SecDef* _rdir;
SecDef* _fdir;
bool test(const char* s) const ; SecDef* _rdir;
void put();
bool test(const char* s) const ;
public: void put();
// @FPUB
void set(const char* name = NULL, bool force = FALSE, TFilelock mode = _manulock); public:
bool exist(long codditta) const; // @FPUB
bool test(long codditta) const; void set(const char* name = NULL, bool force = FALSE, TFilelock mode = _manulock);
long get_codditta() const ; bool exist(long codditta) const;
bool set_codditta(long codditta, bool force = FALSE); bool test(long codditta) const;
const char* name() const { return _prefix;} long get_codditta() const ;
long filelevel() const {return _filelevel;} bool set_codditta(long codditta, bool force = FALSE);
const char* name() const { return _prefix;}
TPrefix(); long filelevel() const {return _filelevel;}
virtual ~TPrefix();
}; int items() const { return _items; }
const char* description(const char* cod) const;
const char* description(int cod) const;
const char* firm2dir(long codditta);
TPrefix();
#ifdef __PREFIX_CPP virtual ~TPrefix();
#define extern };
#endif
// @DPUB const char* firm2dir(long codditta);
extern TPrefix* prefhndl
// @END #ifdef __PREFIX_CPP
#ifdef __PREFIX_CPP #define extern
= NULL ; #endif
#undef extern
#else // @DPUB
; extern TPrefix* prefhndl
#endif // @END
#ifdef __PREFIX_CPP
#endif // __PREFIX_H = NULL ;
#undef extern
#else
;
#endif
#endif // __PREFIX_H

9
include/relapp.cpp
View File

@ -1,4 +1,4 @@
// $Id: relapp.cpp,v 1.40 1994-12-16 15:50:08 guy Exp $ // $Id: relapp.cpp,v 1.41 1994-12-27 14:59:08 guy Exp $
#include <mailbox.h> #include <mailbox.h>
#include <sheet.h> #include <sheet.h>
#include <urldefid.h> #include <urldefid.h>
@ -465,9 +465,11 @@ bool TRelation_application::modify_mode()
} }
TMask_field* TRelation_application::get_search_field() const TMask_field* TRelation_application::get_search_field() const
{ {
if (_search_id > 0) return &_mask->field(_search_id); if (_search_id > 0)
return &_mask->field(_search_id);
const TChiave& k = _maskeys->key(1); const TChiave& k = _maskeys->key(1);
for (int i = 0; i < k.items(); i++) for (int i = 0; i < k.items(); i++)
{ {
@ -624,6 +626,7 @@ bool TRelation_application::save(bool check_dirty)
if (mode == MODE_INS) if (mode == MODE_INS)
{ {
bool changed = TRUE; bool changed = TRUE;
while (changed) while (changed)
{ {
get_relation()->zero(); get_relation()->zero();

15
include/relation.cpp
View File

@ -1,4 +1,4 @@
// $Id: relation.cpp,v 1.27 1994-12-20 15:11:20 guy Exp $ // $Id: relation.cpp,v 1.28 1994-12-27 14:59:10 guy Exp $
// relation.cpp // relation.cpp
// fv 12/8/93 // fv 12/8/93
// relation class for isam files // relation class for isam files
@ -9,6 +9,7 @@
#include <config.h> #include <config.h>
#include <expr.h> #include <expr.h>
#include <extcdecl.h> #include <extcdecl.h>
#include <prefix.h>
#include <relation.h> #include <relation.h>
#include <tabutil.h> #include <tabutil.h>
#include <utility.h> #include <utility.h>
@ -149,6 +150,7 @@ void TRelationdef::print_on(TToken_string& out) const
out = ""; out = "";
print_name(out, f); print_name(out, f);
out.add(prefhndl->description(f.name()));
out << '|'; out << '|';
if (_numto > 0) if (_numto > 0)
@ -161,7 +163,8 @@ void TRelationdef::print_on(TToken_string& out) const
const TLocalisamfile& t = _rel->file(_numto); const TLocalisamfile& t = _rel->file(_numto);
print_name(out, t); print_name(out, t);
} }
} } else out << ' ';
out.add(_key); out.add(_key);
out.add(_alias); out.add(_alias);
out << '|'; out << '|';
@ -213,14 +216,16 @@ void TRelation::print_on(TArray& a) const
const TLocalisamfile& f = file(); const TLocalisamfile& f = file();
TToken_string s(128); TToken_string s(128);
print_name(s, f); print_name(s, f);
s.add(prefhndl->description(f.name()));
s.add("");
s.add(f.getkey()); s.add(f.getkey());
s.add(" | ");
a.destroy(); a.destroy();
a.add(s, 0); a.add(s);
for (int i = 0; i < _reldefs.items(); i++) for (int i = 0; i < _reldefs.items(); i++)
{ {
((TRelationdef&)_reldefs[i]).print_on(s); ((TRelationdef&)_reldefs[i]).print_on(s);
a.add(s, i+1); a.add(s);
} }
} }

48
include/sheet.cpp
View File

@ -6,6 +6,10 @@
#include <urldefid.h> #include <urldefid.h>
#include <utility.h> #include <utility.h>
///////////////////////////////////////////////////////////
// TSheet
///////////////////////////////////////////////////////////
TSheet::TSheet(short x, short y, short dx, short dy, TSheet::TSheet(short x, short y, short dx, short dy,
const char* title, const char* head, byte buttons, const char* title, const char* head, byte buttons,
long first, WINDOW parent) long first, WINDOW parent)
@ -146,13 +150,10 @@ void TSheet::set_first(long n)
} }
void TSheet::set_row(const TToken_string& row, byte i) void TSheet::set_row(const TToken_string& r, byte i)
{ {
if (i > 64) i = 0; else i++; if (i > 64) i = 0; else i++;
if (_page.objptr(i) == NULL) _page.add(r, i);
_page.add(row, i);
else
((TToken_string&)_page[i]) = row;
} }
@ -202,7 +203,7 @@ void TSheet::handler(WINDOW win, EVENT* ep)
select(nuo); select(nuo);
if (ep->type == E_MOUSE_DBL) if (ep->type == E_MOUSE_DBL)
dispatch_e_char(win, K_ENTER); dispatch_e_char(win, K_ENTER);
else if (_checkable && _check_enabled && vec == nuo) else if (_checkable && _check_enabled && vec == nuo)
{ {
_checked.not(nuo); _checked.not(nuo);
force_update(); force_update();
@ -270,6 +271,8 @@ bool TSheet::on_key(KEY key)
{ {
case K_ENTER: case K_ENTER:
if (items() < 1) key = K_ESC; if (items() < 1) key = K_ESC;
if (_disabled[selected()])
break;
case K_ESC: case K_ESC:
stop_run(key); stop_run(key);
case K_DEL: case K_DEL:
@ -317,8 +320,11 @@ bool TSheet::on_key(KEY key)
switch(key) switch(key)
{ {
case K_SPACE: case K_SPACE:
_checked.not(selected()); if (!_disabled[selected()])
force = TRUE; {
_checked.not(selected());
force = TRUE;
}
break; break;
case K_F2: case K_F2:
uncheck(-1); uncheck(-1);
@ -337,6 +343,23 @@ bool TSheet::on_key(KEY key)
} }
void TSheet::enable(long n, bool on)
{
if (n >= 0)
_disabled.set(n, !on);
else
{
if (on)
_disabled.reset();
else
{
_disabled.set(items());
_disabled.set();
}
}
}
void TSheet::select(long n) void TSheet::select(long n)
{ {
if (n < 0) n = 0; else if (n < 0) n = 0; else
@ -436,11 +459,15 @@ bool TSheet::update_row(long n)
for (int j = 0; (s = t.get()) != NULL; x += _size[j++]+1) for (int j = 0; (s = t.get()) != NULL; x += _size[j++]+1)
{ {
int x1 = x; int x1 = x;
bool dis = FALSE;
if (n >= 0) if (n >= 0)
{ {
if (_checkable && j == 0) if (_checkable && j == 0)
s = _checked[n] ? "X" : " "; s = _checked[n] ? "X" : " ";
dis = _disabled[n];
if (dis) set_color(COLOR_CYAN, COLOR_GRAY);
switch (_type[j]) switch (_type[j])
{ {
case 'R': case 'R':
@ -457,6 +484,7 @@ bool TSheet::update_row(long n)
x1 += (_size[j]-strlen(s)) >> 1; // Centra le testate x1 += (_size[j]-strlen(s)) >> 1; // Centra le testate
stringat(x1, y, s); stringat(x1, y, s);
if (dis) set_color(COLOR_BLACK, COLOR_GRAY);
} }
return TRUE; return TRUE;
@ -578,7 +606,7 @@ long TArray_sheet::add(const TToken_string& s)
long TArray_sheet::add(TToken_string* s) long TArray_sheet::add(TToken_string* s)
{ {
const long n = _data.add(s, -1); const long n = _data.add(s);
set_scroll_max(-1, n); set_scroll_max(-1, n);
return n; return n;
} }
@ -721,7 +749,7 @@ void TBrowse_sheet::repos_buttons() const
bool TBrowse_sheet::on_key(KEY k) bool TBrowse_sheet::on_key(KEY k)
{ {
const WINDOW ctl = get_ctl_window(win(), 100); const WINDOW ctl = get_ctl_window(win(), 100);
const bool alnum = k >= ' ' && k < 256; const bool alnum = k >= ' ' && k < K_UP;
if (ctl != NULL_WIN && (alnum || k == K_BACKSPACE || k == K_DEL)) if (ctl != NULL_WIN && (alnum || k == K_BACKSPACE || k == K_DEL))
{ {

330
include/sheet.h
View File

@ -1,164 +1,166 @@
#ifndef __SHEET_H #ifndef __SHEET_H
#define __SHEET_H #define __SHEET_H
#ifndef __ARRAY_H #ifndef __STRINGS_H
#include <array.h> #include <strings.h>
#endif #endif
#ifndef __STRINGS_H #ifndef __WINDOW_H
#include <strings.h> #include <window.h>
#endif #endif
#ifndef __WINDOW_H #ifndef __RELATION_H
#include <window.h> class TCursor;
#endif #endif
#ifndef __RELATION_H #ifndef __MASKFLD_H
class TCursor; class TEdit_field;
#endif #endif
#ifndef __MASKFLD_H
class TEdit_field; // @C
#endif // class TSheet : public TScroll_window
// @END
// @C
// class TSheet : public TScroll_window class TSheet : public TScroll_window
// @END {
// @DPRIV
class TSheet : public TScroll_window enum { MAX_BUT = 8, MAX_COL = 128 };
{ TString_array _page;
// @DPRIV
enum { MAX_BUT = 8, MAX_COL = 128 }; byte _columns;
TArray _page; byte _size[MAX_COL], _type[MAX_COL];
long _curr, _last_update;
byte _columns;
byte _size[MAX_COL], _type[MAX_COL]; short _visible_rows;
long _curr, _last_update;
bool _checkable;
short _visible_rows; bool _check_enabled;
TBit_array _checked, _disabled;
bool _checkable;
bool _check_enabled; WINDOW _button[MAX_BUT];
TBit_array _checked; KEY _key[MAX_BUT];
byte _buttonmask;
WINDOW _button[MAX_BUT];
KEY _key[MAX_BUT]; protected:
byte _buttonmask; // @FPROT
bool head_on() const { return _columns > 1; }
protected: bool buttons_on() const { return *_button != NULL_WIN; }
// @FPROT short visible_rows() const { return _visible_rows; }
bool head_on() const { return _columns > 1; } virtual short reserved_rows() const;
bool buttons_on() const { return *_button != NULL_WIN; } void build_page(long first = -1);
short visible_rows() const { return _visible_rows; }
virtual short reserved_rows() const; PNT log2dev(long x, long y) const;
void build_page(long first = -1); virtual void handler(WINDOW win, EVENT* ep);
virtual bool on_key(KEY);
PNT log2dev(long x, long y) const; virtual void update();
virtual void handler(WINDOW win, EVENT* ep); virtual void open();
virtual bool on_key(KEY);
virtual void update(); void set_first(long n);
virtual void open(); bool is_visible(long n) const { return n >= first() && n < first()+visible_rows(); }
void set_first(long n); int width() const;
bool is_visible(long n) const { return n >= first() && n < first()+visible_rows(); } int row_to_page(long n) const;
int row_to_win(long n) const;
int width() const;
int row_to_page(long n) const; long first() const { return origin().y; }
int row_to_win(long n) const; bool update_row(long n);
void invert_row(long n);
long first() const { return origin().y; }
bool update_row(long n); void set_row(const TToken_string& row, byte n);
void invert_row(long n);
virtual void repos_buttons() const;
void set_row(const TToken_string& row, byte n);
virtual void page_build(long first, byte num) pure;
virtual void repos_buttons() const;
void print();
virtual void page_build(long first, byte num) pure; public:
// @FPUB
void print(); TSheet(short x, short y, short dx, short dy,
public: const char* title, const char* head, byte buttons = 0,
// @FPUB long first = 0L, WINDOW parent = NULL_WIN);
TSheet(short x, short y, short dx, short dy, void add_button(short id, const char* caption, KEY key = K_ESC);
const char* title, const char* head, byte buttons = 0,
long first = 0L, WINDOW parent = NULL_WIN); virtual long items() const pure;
void add_button(short id, const char* caption, KEY key = K_ESC); virtual TToken_string& row(long s = -1);
virtual long items() const pure; long selected() const { return _curr; }
virtual TToken_string& row(long s = -1); void select(long n);
long selected() const { return _curr; } bool checked(long n) const { return _checked[n]; }
void select(long n); void check(long n, bool on = TRUE);
void uncheck(long n) { check(n, FALSE); }
bool checked(long n) const { return _checked[n]; } void enable_check(bool yn = TRUE) { _check_enabled = yn; }
void check(long n, bool on = TRUE); void disable_check() { enable_check(FALSE); }
void uncheck(long n) { check(n, FALSE); }
void enable_check(bool yn = TRUE) { _check_enabled = yn; } void enable(long n = -1, bool on = TRUE);
void disable_check() { enable_check(FALSE); } void disable(long n = -1) { enable(n, FALSE); }
bool one_checked() const { return _checked.first_one() != -1; } bool enabled(long n) const { return !_disabled[n]; }
long checked() const { return _checked.ones(); } bool disabled(long n) const { return _disabled[n]; }
};
bool one_checked() const { return _checked.first_one() != -1; }
class TArray_sheet : public TSheet long checked() const { return _checked.ones(); }
{ };
TArray _data;
class TArray_sheet : public TSheet
protected: {
TString_array _data;
virtual void page_build(long first, byte num);
protected:
TArray& data() const { return (TArray&)_data; }
TToken_string& data(long n) const { return (TToken_string&)_data[(int)n]; } virtual void page_build(long first, byte num);
TToken_string& data(long n) { return _data.row((int)n); }
public: TString_array& rows_array() { return _data; }
TArray_sheet(short x, short y, short dx, short dy, const char* caption,
const char* head, byte buttons = 0, WINDOW parent = NULL_WIN); public:
virtual long items() const { return _data.items(); } TArray_sheet(short x, short y, short dx, short dy, const char* caption,
long add(const TToken_string& s); const char* head, byte buttons = 0, WINDOW parent = NULL_WIN);
long add(TToken_string* s); virtual long items() const { return _data.items(); }
long insert(const TToken_string& s, long n); long add(const TToken_string& s);
virtual TToken_string& row(long s = -1) { return (s < 0) ? data(selected()) : data(s); } long add(TToken_string* s);
bool destroy(int i = -1) { uncheck(-1); return _data.destroy(i, TRUE); } long insert(const TToken_string& s, long n);
}; virtual TToken_string& row(long s = -1) { return (s < 0) ? data(selected()) : data(s); }
bool destroy(int i = -1) { uncheck(-1); return _data.destroy(i, TRUE); }
};
class TCursor_sheet : public TSheet
{
TArray _fields; // Array of TRecfield class TCursor_sheet : public TSheet
long _records; {
TArray _fields; // Array of TRecfield
protected: long _records;
TCursor* _cursor;
protected:
virtual void page_build(long first, byte rows); TCursor* _cursor;
public: virtual void page_build(long first, byte rows);
TCursor_sheet(TCursor* cursor, const char* fields,
const char* title, const char* head, byte buttons = 0); public:
virtual ~TCursor_sheet() {} TCursor_sheet(TCursor* cursor, const char* fields,
virtual long items() const { return _records; } const char* title, const char* head, byte buttons = 0);
virtual KEY run(); virtual ~TCursor_sheet() {}
}; virtual long items() const { return _records; }
virtual KEY run();
};
class TBrowse_sheet : public TCursor_sheet
{
TEdit_field* const _field; class TBrowse_sheet : public TCursor_sheet
{
protected: TEdit_field* const _field;
virtual void handler(WINDOW win, EVENT* ep);
virtual short reserved_rows() const; protected:
virtual void repos_buttons() const; virtual void handler(WINDOW win, EVENT* ep);
virtual bool on_key(KEY k); virtual short reserved_rows() const;
TEdit_field& field() { return *_field; } virtual void repos_buttons() const;
virtual bool on_key(KEY k);
public: TEdit_field& field() { return *_field; }
TBrowse_sheet(TCursor* cursor, const char* fields,
const char* title, const char* head, byte buttons, public:
TEdit_field* f, TToken_string* siblings = NULL); TBrowse_sheet(TCursor* cursor, const char* fields,
virtual ~TBrowse_sheet() {} const char* title, const char* head, byte buttons,
virtual KEY run(); TEdit_field* f, TToken_string* siblings = NULL);
}; virtual ~TBrowse_sheet() {}
virtual KEY run();
};
#endif
#endif

21
include/strings.cpp
View File

@ -1012,3 +1012,24 @@ void TParagraph_string::tokenize()
} }
} }
} }
///////////////////////////////////////////////////////////
// TString_array
///////////////////////////////////////////////////////////
int TString_array::add(const char* s, int n)
{
if (objptr(n) == NULL)
n = TArray::add(new TToken_string(s), n);
else row(n) = s;
return n;
}
int TString_array::add(const TToken_string& s, int n)
{
if (objptr(n) == NULL)
n = TArray::add(s);
else
row(n) = s;
return n;
}

596
include/strings.h
View File

@ -1,290 +1,306 @@
#ifndef __STRINGS_H #ifndef __STRINGS_H
#define __STRINGS_H #define __STRINGS_H
#ifndef __STRING_H #ifndef __STRING_H
#include <string.h> #include <string.h>
#endif #endif
#ifndef __OBJECT_H #ifndef __ARRAY_H
#include <object.h> #include <array.h>
#endif #endif
// @C // @C
// Classe TString : public TObject // Classe TString : public TObject
// @END // @END
class TString : public TObject class TString : public TObject
{ {
protected: protected:
// @DPROT // @DPROT
char* _str; // Puntatore alla stringa char* _str; // Puntatore alla stringa
int _size; // Lunghezza int _size; // Lunghezza
// @END // @END
// @FPROT // @FPROT
int make_room(int size); // Cerca spazio per altri size caratteri int make_room(int size); // Cerca spazio per altri size caratteri
TString& set(const char*); // Inizializza con la stringa puntata da char* di lunghezza size TString& set(const char*); // Inizializza con la stringa puntata da char* di lunghezza size
TString(char* str, int size) : _str(str), _size(size) {} TString(char* str, int size) : _str(str), _size(size) {}
public: public:
// @FPUB // @FPUB
virtual void resize(int size, bool cpy); // Ri/alloca la stringa virtual void resize(int size, bool cpy); // Ri/alloca la stringa
TString(); TString();
TString(int size); // Default constructor for a string of given size TString(int size); // Default constructor for a string of given size
TString(const char* s); // Costruttore a partire da una stringa s TString(const char* s); // Costruttore a partire da una stringa s
TString(const TString& s); // Costruttore da un oggetto TString s TString(const TString& s); // Costruttore da un oggetto TString s
virtual ~TString(); // Deallocates the string virtual ~TString(); // Deallocates the string
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @DES Methods derived from TObject // @DES Methods derived from TObject
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @FPUB // @FPUB
virtual const char* class_name() const; // Ritorna il nome della classe virtual const char* class_name() const; // Ritorna il nome della classe
virtual word class_id() const; // Ritorna l'identificatore della classe virtual word class_id() const; // Ritorna l'identificatore della classe
virtual bool ok() const { return _str != NULL; } virtual bool ok() const { return _str != NULL; }
virtual TObject* dup() const; virtual TObject* dup() const;
virtual void print_on(ostream& out) const; virtual void print_on(ostream& out) const;
virtual void read_from(istream& in); virtual void read_from(istream& in);
virtual word hash() const; // Return hash value virtual word hash() const; // Return hash value
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @DES Query methods // @DES Query methods
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @FPUB // @FPUB
operator const char*() const { return (const char*)_str; } // *(TString) -> _str operator const char*() const { return (const char*)_str; } // *(TString) -> _str
char& operator[](int i) // TString[i] -> _str[i] char& operator[](int i) // TString[i] -> _str[i]
{ {
CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i); CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i);
return _str[i]; return _str[i];
} }
char operator[](int i) const // TString[i] -> _str[i] char operator[](int i) const // TString[i] -> _str[i]
{ {
CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i); CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i);
return _str[i]; return _str[i];
} }
int size() const { return _size; } int size() const { return _size; }
int len() const { return strlen(_str); } int len() const { return strlen(_str); }
bool empty() const { return *_str == '\0'; } bool empty() const { return *_str == '\0'; }
bool not_empty() const { return *_str != '\0'; } bool not_empty() const { return *_str != '\0'; }
int find(char, int from = 0) const; // Ritorna la posizione del carattere char nell'oggetto TString int find(char, int from = 0) const; // Ritorna la posizione del carattere char nell'oggetto TString
int find(const char* s, int from = 0) const; // Ritorna la posizione della stringa s nell'oggetto TString int find(const char* s, int from = 0) const; // Ritorna la posizione della stringa s nell'oggetto TString
const TString& left(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da sinistra const TString& left(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da sinistra
const TString& mid(int from, int count = -1) const; // Ritorna l'oggetto TString composto dai count caratteri a partire da from const TString& mid(int from, int count = -1) const; // Ritorna l'oggetto TString composto dai count caratteri a partire da from
const TString& sub(int from, int to = -1) const; // Ritorna la stringa da FROM a TO (escluso) const TString& sub(int from, int to = -1) const; // Ritorna la stringa da FROM a TO (escluso)
const TString& right(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da destra const TString& right(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da destra
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @DES Modifying methods // @DES Modifying methods
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @FPUB // @FPUB
TString& fill(char c, int n = -1); // Riempie con n caratteri c TString& fill(char c, int n = -1); // Riempie con n caratteri c
TString& spaces(int n = -1) { return fill(' ', n); } TString& spaces(int n = -1) { return fill(' ', n); }
TString& overwrite(const char* s, int pos = 0); // Sovrascrive la stringa s dalla posizione pos TString& overwrite(const char* s, int pos = 0); // Sovrascrive la stringa s dalla posizione pos
TString& insert(const char* s, int pos = 0); // Inserisce la stringa s dalla posizione pos TString& insert(const char* s, int pos = 0); // Inserisce la stringa s dalla posizione pos
TString& strip(const char* k); // Elimina tutti i caratteri contenuti in k TString& strip(const char* k); // Elimina tutti i caratteri contenuti in k
TString& strip_spaces(); // Elimina tutti gli spazi non contenuti tra apici singoli o doppi TString& strip_spaces(); // Elimina tutti gli spazi non contenuti tra apici singoli o doppi
TString& ltrim(int n = 0); // Elimina gli spazi da sinistra se n=0 altrimenti elimina i primi n caratteri (da sinistra). TString& ltrim(int n = 0); // Elimina gli spazi da sinistra se n=0 altrimenti elimina i primi n caratteri (da sinistra).
TString& rtrim(int n = 0); // Elimina gli spazi da destra se n=0 altrimenti elimina i primi n caratteri (da destra). TString& rtrim(int n = 0); // Elimina gli spazi da destra se n=0 altrimenti elimina i primi n caratteri (da destra).
TString& trim(); // ltrim e rtrim TString& trim(); // ltrim e rtrim
TString& right_just(int n = -1, char c = ' '); // Giustifica a destra TString& right_just(int n = -1, char c = ' '); // Giustifica a destra
TString& center_just(int n = -1, char c = ' '); // Centra TString& center_just(int n = -1, char c = ' '); // Centra
TString& left_just(int n = -1, char c = ' '); // Giustifica a sinistra TString& left_just(int n = -1, char c = ' '); // Giustifica a sinistra
TString& picture(const char* pic, const char* s); TString& picture(const char* pic, const char* s);
virtual TString& format(const char* fmt, ...); virtual TString& format(const char* fmt, ...);
TString& cut(int n); // Inserisce un '\0' alla posizione n-esima. TString& cut(int n); // Inserisce un '\0' alla posizione n-esima.
TString& upper(); // Mette la stringa in maiuscolo TString& upper(); // Mette la stringa in maiuscolo
TString& lower(); // Mette la stringa in minuscolo TString& lower(); // Mette la stringa in minuscolo
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @DES Standard operators // @DES Standard operators
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @FPUB // @FPUB
const TString& operator =(const TString& s) { return set(s._str); } const TString& operator =(const TString& s) { return set(s._str); }
const TString& operator =(const char* s) { return set(s); } const TString& operator =(const char* s) { return set(s); }
TString& operator <<(const char*); TString& operator <<(const char*);
TString& operator <<(char); TString& operator <<(char);
TString& operator <<(int); TString& operator <<(int);
TString& operator <<(long); TString& operator <<(long);
TString& operator <<(double); TString& operator <<(double);
TString& operator <<(const TObject& obj); TString& operator <<(const TObject& obj);
TString& operator <<(const TString& str); // For efficiency only TString& operator <<(const TString& str); // For efficiency only
bool operator ==(const char* s) const { return strcmp(_str, s) == 0; } bool operator ==(const char* s) const { return strcmp(_str, s) == 0; }
bool operator ==(char* s) const { return strcmp(_str, s) == 0; } bool operator ==(char* s) const { return strcmp(_str, s) == 0; }
bool operator ==(const TString& s) const { return strcmp(_str, s._str) == 0; } bool operator ==(const TString& s) const { return strcmp(_str, s._str) == 0; }
bool operator !=(const char* s) const { return strcmp(_str, s) != 0; } bool operator !=(const char* s) const { return strcmp(_str, s) != 0; }
bool operator !=(char* s) const { return strcmp(_str, s) != 0; } bool operator !=(char* s) const { return strcmp(_str, s) != 0; }
bool operator !=(const TString& s) const { return strcmp(_str, s._str) != 0; } bool operator !=(const TString& s) const { return strcmp(_str, s._str) != 0; }
bool operator <(const char* s) const { return strcmp(_str, s) < 0; } bool operator <(const char* s) const { return strcmp(_str, s) < 0; }
bool operator >(const char* s) const { return strcmp(_str, s) > 0; } bool operator >(const char* s) const { return strcmp(_str, s) > 0; }
bool operator >=(const char* s) const { return strcmp(_str, s) >= 0; } bool operator >=(const char* s) const { return strcmp(_str, s) >= 0; }
bool operator <=(const char* s) const { return strcmp(_str, s) <= 0; } bool operator <=(const char* s) const { return strcmp(_str, s) <= 0; }
bool match(const char* s) const; bool match(const char* s) const;
bool compare(const char* s, int max = -1, bool ignorecase = FALSE) const; bool compare(const char* s, int max = -1, bool ignorecase = FALSE) const;
}; };
// @C // @C
// Classe TFixed_string : public TString // Classe TFixed_string : public TString
// @END // @END
class TFixed_string : public TString class TFixed_string : public TString
{ {
protected: protected:
virtual void resize(int size, bool cpy); // Causa un errore fatale! virtual void resize(int size, bool cpy); // Causa un errore fatale!
public: public:
TFixed_string(const char* str, int size = -1); TFixed_string(const char* str, int size = -1);
virtual ~TFixed_string(); virtual ~TFixed_string();
virtual TString& format(const char* fmt, ...); virtual TString& format(const char* fmt, ...);
const TString& operator =(const TString& s) { return set((const char*)s); } const TString& operator =(const TString& s) { return set((const char*)s); }
const TString& operator=(const char* str) { return set(str); } const TString& operator=(const char* str) { return set(str); }
void strncpy(const char* s, int n); void strncpy(const char* s, int n);
}; };
class TString16 : public TFixed_string class TString16 : public TFixed_string
{ {
char _str16[17]; char _str16[17];
public: public:
TString16(const char* s = "") : TFixed_string(_str16, 17) { set(s); } TString16(const char* s = "") : TFixed_string(_str16, 17) { set(s); }
TString16(const TString& s) : TFixed_string(_str16, 17) { set(s); } TString16(const TString& s) : TFixed_string(_str16, 17) { set(s); }
const TString& operator =(const TString& s) { return set((const char*)s); } const TString& operator =(const TString& s) { return set((const char*)s); }
const TString& operator =(const char* s) { return set(s); } const TString& operator =(const char* s) { return set(s); }
}; };
class TString80 : public TFixed_string class TString80 : public TFixed_string
{ {
char _str80[81]; char _str80[81];
public: public:
TString80(const char* s = "") : TFixed_string(_str80, 81) { set(s); } TString80(const char* s = "") : TFixed_string(_str80, 81) { set(s); }
TString80(const TString& s) : TFixed_string(_str80, 81) { set(s); } TString80(const TString& s) : TFixed_string(_str80, 81) { set(s); }
const TString& operator =(const char* s) { return set(s); } const TString& operator =(const char* s) { return set(s); }
const TString& operator =(const TString& s) { return set((const char*)s); } const TString& operator =(const TString& s) { return set((const char*)s); }
}; };
class TString256 : public TFixed_string class TString256 : public TFixed_string
{ {
char _str256[257]; char _str256[257];
public: public:
TString256(const char* s = "") : TFixed_string(_str256, 257) { set(s); } TString256(const char* s = "") : TFixed_string(_str256, 257) { set(s); }
TString256(const TString& s) : TFixed_string(_str256, 257) { set(s); } TString256(const TString& s) : TFixed_string(_str256, 257) { set(s); }
const TString& operator =(const char* s) { return set(s); } const TString& operator =(const char* s) { return set(s); }
const TString& operator =(const TString& s) { return set((const char*)s); } const TString& operator =(const TString& s) { return set((const char*)s); }
}; };
// @C // @C
// Classe TFilename : public TString80 (256 su Windows'95) // Classe TFilename : public TString80 (256 su Windows'95)
// @END // @END
class TFilename : public TString80 class TFilename : public TString80
{ {
public: public:
// @FPUB // @FPUB
TFilename(const char* n = "") : TString80(n) {} TFilename(const char* n = "") : TString80(n) {}
TFilename(const TString& n) : TString80((const char*)n) {} TFilename(const TString& n) : TString80((const char*)n) {}
TFilename(const TFilename& n) : TString80((const char*)n) {} TFilename(const TFilename& n) : TString80((const char*)n) {}
// assegnazione tra TFile e stringa // assegnazione tra TFile e stringa
const TString& operator =(const char* s) { return set(s); } const TString& operator =(const char* s) { return set(s); }
const TString& operator =(const TString& s) { return set((const char*)s); } const TString& operator =(const TString& s) { return set((const char*)s); }
virtual bool ok() const; // Controlla il formato del nome del file virtual bool ok() const; // Controlla il formato del nome del file
const char* ext() const; // Ritorna l'estensione const char* ext() const; // Ritorna l'estensione
void ext(const char*); // Imposta come estensione la stringa puntata da char* void ext(const char*); // Imposta come estensione la stringa puntata da char*
const char* name() const; // Ritorna il nome del file const char* name() const; // Ritorna il nome del file
const char* path() const; // Ritorna il nome del direttorio const char* path() const; // Ritorna il nome del direttorio
const TFilename& temp(const char* prefix = NULL); // Genera il nome di un file temporaneo const TFilename& temp(const char* prefix = NULL); // Genera il nome di un file temporaneo
const TFilename& tempdir(); // Genera il nome della directory temporanea const TFilename& tempdir(); // Genera il nome della directory temporanea
}; };
// @C // @C
// Classe TToken_string : public TString // Classe TToken_string : public TString
// @END // @END
class TToken_string : public TString class TToken_string : public TString
{ {
// @DPRIV // @DPRIV
char _separator; // Carattere separatore char _separator; // Carattere separatore
int _last; // Puntatore all'ultimo int _last; // Puntatore all'ultimo
protected: protected:
// @FPROT // @FPROT
virtual TObject* dup() const; // Crea un duplicato della token string virtual TObject* dup() const; // Crea un duplicato della token string
bool set_item(const char* v, int n); bool set_item(const char* v, int n);
public: public:
// @FPUB // @FPUB
TToken_string(const char* = "", char separator = '|'); TToken_string(const char* = "", char separator = '|');
TToken_string(int n, char separator = '|'); TToken_string(int n, char separator = '|');
TToken_string(const TToken_string& s); TToken_string(const TToken_string& s);
void separator(char s) { _separator = s; } // Setta il separatore a s void separator(char s) { _separator = s; } // Setta il separatore a s
void restart() { _last = empty() ? -1 : 0; } // Rimette all'inizio il puntatore void restart() { _last = empty() ? -1 : 0; } // Rimette all'inizio il puntatore
const TString& operator =(const char* s) { set(s);restart();return *this; } const TString& operator =(const char* s) { set(s);restart();return *this; }
const TString& operator =(const TString& s) { set(s);restart();return *this; } const TString& operator =(const TString& s) { set(s);restart();return *this; }
void add(const char* s, int n = -1); // Aggiunge una stringa void add(const char* s, int n = -1); // Aggiunge una stringa
void add(char c, int pos = -1); // Aggiunge un char void add(char c, int pos = -1); // Aggiunge un char
void add(long n, int pos = -1); // Aggiunge un intero void add(long n, int pos = -1); // Aggiunge un intero
void add(int n, int pos = -1); // Aggiunge un intero void add(int n, int pos = -1); // Aggiunge un intero
void destroy(int pos); // Toglie la stringa pos void destroy(int pos); // Toglie la stringa pos
const char* get(); // Ritorna il prossimo token const char* get(); // Ritorna il prossimo token
const char* get(int n); // Ritorna un token (-1 = prossimo; -2 = ultimo; n = ennesimo) const char* get(int n); // Ritorna un token (-1 = prossimo; -2 = ultimo; n = ennesimo)
char get_char(int n = -1); // Ritorna un carattere char get_char(int n = -1); // Ritorna un carattere
int get_int(int n = -1); // Ritorna un intero int get_int(int n = -1); // Ritorna un intero
long get_long(int n = -1); // Ritorna un intero esteso long get_long(int n = -1); // Ritorna un intero esteso
int get_pos(const char* s); // Ritorna la posizione dell'item s int get_pos(const char* s); // Ritorna la posizione dell'item s
int items() const; // Ritorna il numero di token presenti int items() const; // Ritorna il numero di token presenti
bool empty_items() const; // Controlla se tutti i token sono nulli bool empty_items() const; // Controlla se tutti i token sono nulli
}; };
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @DES Paragraph // @DES Paragraph
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
class TParagraph_string : public TToken_string class TParagraph_string : public TToken_string
{ {
int _width; int _width;
bool _fixed; bool _fixed;
protected: protected:
void tokenize(); void tokenize();
public: public:
TParagraph_string(const char* s, int width); TParagraph_string(const char* s, int width);
const TString& operator =(const char* s); const TString& operator =(const char* s);
void set_width(int width) { _width = width; } void set_width(int width) { _width = width; }
}; };
#endif ///////////////////////////////////////////////////////////
// @DES TString_array
///////////////////////////////////////////////////////////
class TString_array : public TArray
{
public:
TToken_string& row(int n) { return (TToken_string&)operator[](n); }
int add(TToken_string* s, int n = -1) { return TArray::add(s, n); }
int add(const TToken_string& s, int n = -1);
int add(const char* s, int n = -1);
TString_array(int size = 8) : TArray(size) {}
virtual ~TString_array() {}
};
#endif

2
include/viswin.cpp
View File

@ -1832,7 +1832,7 @@ bool TViswin::call_editor ()
newfilename.insert (" ", 0); newfilename.insert (" ", 0);
newfilename.insert (editor, 0); newfilename.insert (editor, 0);
TExternal_app edit (newfilename); TExternal_app edit (newfilename);
if (edit.run(TRUE)) if (edit.run(TRUE, FALSE))
beep (); beep ();
else else
ok = TRUE; ok = TRUE;

18
include/xvtility.cpp
View File

@ -99,6 +99,8 @@ HIDDEN COLORREF NormalForeColor = COLOR2RGB(NORMAL_COLOR);
HIDDEN COLORREF NormalBackColor = COLOR2RGB(NORMAL_BACK_COLOR); HIDDEN COLORREF NormalBackColor = COLOR2RGB(NORMAL_BACK_COLOR);
HIDDEN HBRUSH NormalBrush = CreateSolidBrush(NormalBackColor); HIDDEN HBRUSH NormalBrush = CreateSolidBrush(NormalBackColor);
const word WM_WAKEUP = RegisterWindowMessage("WAKEUP");
static BOOLEAN event_hook(HWND hwnd, static BOOLEAN event_hook(HWND hwnd,
UINT msg, UINT msg,
UINT wparam, UINT wparam,
@ -200,6 +202,9 @@ static BOOLEAN event_hook(HWND hwnd,
} }
break; break;
default: default:
if (msg == WM_WAKEUP && wparam == main_app().waiting())
main_app().wake_up();
break;
break; break;
} }
@ -393,9 +398,8 @@ KEY e_char_to_key(const EVENT* ep)
KEY key = ep->v.chr.ch; KEY key = ep->v.chr.ch;
if (key < K_INS || key > K_HELP) if (key < K_INS || key > K_HELP)
{ {
// if (ep->v.chr.shift && !isprint(key)) key += K_SHIFT; if (ep->v.chr.shift && (key < ' ' || key >= K_UP)) key += K_SHIFT;
if (ep->v.chr.shift && (key < ' ' || key > 'z')) key += K_SHIFT; if (ep->v.chr.control && key >= ' ') key += K_CTRL;
if (key >= ' ' && ep->v.chr.control) key += K_CTRL;
} }
return key; return key;
} }
@ -543,9 +547,9 @@ void xvt_init_font()
LogFont.lfWidth = (int)font.get_long("Width"); LogFont.lfWidth = (int)font.get_long("Width");
LogFont.lfWeight = FontWeight = (int)font.get_long("Weight"); LogFont.lfWeight = FontWeight = (int)font.get_long("Weight");
LogFont.lfCharSet = (int)font.get_long("CharSet"); LogFont.lfCharSet = (int)font.get_long("CharSet");
LogFont.lfClipPrecision = (int)font.get_long("Clip"); // LogFont.lfClipPrecision = (int)font.get_long("Clip");
LogFont.lfOutPrecision = (int)font.get_long("Precision"); // LogFont.lfOutPrecision = (int)font.get_long("Precision");
LogFont.lfQuality = (int)font.get_long("Quality");; // LogFont.lfQuality = (int)font.get_long("Quality");;
LogFont.lfPitchAndFamily = (int)font.get_long("Pitch"); LogFont.lfPitchAndFamily = (int)font.get_long("Pitch");
strcpy(LogFont.lfFaceName, font.get("Name")); strcpy(LogFont.lfFaceName, font.get("Name"));
} }
@ -581,8 +585,6 @@ void xvt_set_font(WINDOW win, int family, int style, int dim)
#if XVT_OS == XVT_OS_WIN #if XVT_OS == XVT_OS_WIN
if (dim < 1) if (dim < 1)
{ {
// LogFont.lfWidth = CHARX - (style & FS_BOLD) ? 2 : 1;
// LogFont.lfHeight = CHARY - ((style & FS_BOLD) ? 4 : 2);
LogFont.lfWeight = FontWeight + ((style & FS_BOLD) ? 300 : 0); LogFont.lfWeight = FontWeight + ((style & FS_BOLD) ? 300 : 0);
LogFont.lfItalic = (style & FS_ITALIC) ? TRUE : FALSE; LogFont.lfItalic = (style & FS_ITALIC) ? TRUE : FALSE;
set_value(NULL_WIN, ATTR_WIN_PM_LOGFONT, (long)&LogFont); set_value(NULL_WIN, ATTR_WIN_PM_LOGFONT, (long)&LogFont);