root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/include/formed.cpp
guy 238527b5ba Patch level : 4.0 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Corretta e migliorata gestione campi read only


git-svn-id: svn://10.65.10.50/trunk@15195 c028cbd2-c16b-5b4b-a496-9718f37d4682
2007-04-06 14:46:40 +00:00

1264 lines
33 KiB
C++
Executable File
Raw Blame History

#include <defmask.h>
#include <form.h>
#include <msksheet.h>
#include <printer.h>
#include "../ba/bafrm.h"
// per lo sheet di edit campi
#define idt_id 101
#define dsc_id 102
#define prn_id 103
#define yps_id 104
#define xps_id 105
#define len_id 106
#define col_id 107
#define int_id 108
#define spc_id 109
#define fnl_id 110
#define fnr_id 111
#define typ_id 112
#define frm_id 113
// Current section (edit, print)
HIDDEN TPrint_section* _cur_sect = NULL;
HIDDEN TMask* _special_mask = NULL;
HIDDEN TPrint_section& section()
{
CHECK(_cur_sect, "Can't print NULL section");
return *_cur_sect;
}
///////////////////////////////////////////////////////////
// Gestione TFieldref su maschera
// ID CAMPO ATTIVO
// xx0 Stringa completa del TFieldref
// xx1 Descrizione file
// xx2 Bottone selezione file X
// xx3 Descrizione campo
// xx4 Bottone selezione campo X
// xx5 Primo carattere campo X
// xx6 Ultimo carattere campo X
///////////////////////////////////////////////////////////
HIDDEN void put_fieldref(const TFieldref& fr, TMask_field& f)
{
TRelation_description& rd = _cur_form->rel_desc();
rd.set_cur_file(fr.file());
TString80 desc; desc << fr;
f.set(desc);
TMask& m = f.mask();
const short id = f.dlg(); // Campo contenente il TFieldref
m.set(id+1, rd.file_desc());
m.set(id+3, rd.get_field_description(fr.name()));
m.set(id+5, (fr.from() > 0 || fr.to() > 0) ? fr.from()+1 : 0);
m.set(id+6, fr.to() > fr.from() ? fr.to() : 0);
}
// Handler of F_BUT_FILE field on mask
HIDDEN bool but_file_handler(TMask_field& f, KEY k)
{
if (k == K_F9)
{
TRelation_description& r = _cur_form->rel_desc();
TEdit_field& e = f.mask().efield(f.dlg()-1);
TFieldref ref; ref = e.get();
if (r.choose_file(ref.file()))
{
ref.set_file(r.file_num());
put_fieldref(ref, e);
}
}
return TRUE;
}
HIDDEN bool but_file_handler_sub(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TRelation_description& r = _cur_form->rel_desc();
TEdit_field& e = f.mask().efield(f.dlg()-2);
TFieldref ref; ref = e.get();
if (r.choose_file(ref.file()))
{
ref.set_file(r.file_num());
f.mask().set(F_FILE1,r.file_desc());
}
}
return TRUE;
}
// Handler of F_BUT_FIELD field on mask
HIDDEN bool but_field_handler(TMask_field& f, KEY k)
{
if (k == K_F9)
{
TRelation_description& r = _cur_form->rel_desc();
TEdit_field& e = f.mask().efield(f.dlg()-3); // TBC
TFieldref ref; ref = e.get();
if (r.choose_field(ref.name()))
{
ref.set_name(r.field_name());
put_fieldref(ref, e);
}
}
return TRUE;
}
// Handler of F_FROM field on mask
HIDDEN bool from_handler(TMask_field& f, KEY k)
{
if (f.to_check(k))
{
TEdit_field& e = f.mask().efield(f.dlg()-5);
TFieldref ref; ref = e.get();
ref.set_from(atoi(f.get()));
put_fieldref(ref, e);
}
return TRUE;
}
// Handler of F_TO field on mask
HIDDEN bool to_handler(TMask_field& f, KEY k)
{
if (f.to_check(k))
{
TEdit_field& e = f.mask().efield(f.dlg()-6);
TFieldref ref; ref = e.get();
ref.set_to(atoi(f.get()));
put_fieldref(ref, e);
}
return TRUE;
}
HIDDEN bool dateformat_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask& m = f.mask();
char fmt[8];
fmt[0] = m.get(F_DFORMAT)[0];
fmt[1] = m.get(F_DDAY)[0];
fmt[2] = m.get(F_DMONTH)[0];
fmt[3] = m.get(F_DYEAR)[0];
fmt[4] = m.get(F_DSEP)[0];
fmt[5] = '\0';
const TDate d(TODAY);
const TFormatted_date ex(d,fmt);
m.set(F_DEXAMPLE, ex.string());
}
return TRUE;
}
HIDDEN bool fmt_handler(TMask_field& f, KEY k)
{
if (k==K_ENTER || k==K_TAB)
{
TMask& m = f.mask();
TPrint_section& s = ::section();
if (s.columnwise())
{
const int fmt_len = m.get(F_PICTURE).len(); // length of picture
m.set(F_LENFMT,fmt_len);
m.set(F_NUMCOL,s.fields());
}
else
m.set(F_NUMCOL,999);
}
return TRUE;
}
HIDDEN bool font_handler(TMask_field& f, KEY key)
{
if (key == K_SPACE)
{
TWait_cursor hourglass;
const char* family = f.get();
const int MAXSIZES = 16;
long sizes[MAXSIZES];
BOOLEAN scalable;
const int num_sizes = (int)xvt_fmap_get_family_sizes(printer().get_printrcd(),
(char*)family, sizes, &scalable, MAXSIZES);
TToken_string pn1(80), pn2(80);
if (scalable)
{
for (int i = 4; i <= 32; i++)
{
pn1.add(i);
pn2.add(i);
}
}
else
{
if (num_sizes > 0)
{
for (int i = 0; i < num_sizes; i++)
pn1.add(sizes[i]);
}
else pn1.add(printer().get_char_size());
pn2 = pn1;
}
TList_field& lst = (TList_field&)f.mask().field(F_SIZE);
lst.replace_items(pn1, pn2);
TString16 str; str.format("%d",printer().get_char_size());
lst.set(str);
}
return TRUE;
}
///////////////////////////////////////////////////////////
// TForm_flags
///////////////////////////////////////////////////////////
// Set mask fields
// Certified 100%
void TForm_flags::print_on(TMask& m)
{
m.set(F_DISABLED, enabled ? " " : "X");
m.set(F_HIDDEN, shown ? " " : "X");
m.set(F_AUTOMAGIC, automagic ? "X" : " ");
m.set(F_FINKL, finkl ? " " : "X");
m.set(F_FINKR, finkr ? " " : "X");
}
// Get mask fields
// Certified 100%
void TForm_flags::read_from(const TMask& m)
{
shown = !m.get_bool(F_HIDDEN);
enabled = !m.get_bool(F_DISABLED);
automagic = m.get_bool(F_AUTOMAGIC);
finkl = !m.get_bool(F_FINKL);
finkr = !m.get_bool(F_FINKR);
}
///////////////////////////////////////////////////////////
// TForm_item
///////////////////////////////////////////////////////////
void TForm_item::print_on_sheet_row(TToken_string& tt) const
{
TString tmp(80);
tt.add(_id, idt_id - 101);
tt.add(_desc, dsc_id - 101);
tt.add(_x, _section->columnwise() ? col_id - 101 : xps_id - 101);
tt.add(_width, len_id - 101);
if (!_section->columnwise())
tt.add(_y, yps_id - 101);
tt.add(class_name(), typ_id - 101);
tt.add(shown() ? " " : "X", prn_id - 101);
tmp = example(); tt.add(tmp, frm_id - 101);
if (_section->columnwise())
{
tt.add(_ofs, spc_id -101);
tt.add(finkl() ? " " : "X", fnl_id -101);
tt.add(finkr() ? " " : "X", fnr_id -101);
tt.add(_col_head, int_id - 101);
}
}
void TForm_item::print_on(TMask& m)
{
m.set(F_CLASS, class_name());
m.set(F_ID, id());
m.set(F_KEY, key());
m.set(F_X, _x);
m.set(F_Y, _y);
m.set(F_PROMPT, _prompt);
m.set(F_WIDTH, _width);
if (_section->columnwise())
m.set(F_INTEST, _col_head);
m.set(F_HEIGHT, _height);
m.set(F_SPACES, _ofs);
_flag.print_on(m);
for (int g = 1; g <= 24; g++)
m.set(F_GROUP+g, _group[g] ? "X" : " ");
}
void TForm_item::read_from(const TMask& m)
{
_desc = m.get(F_KEY);
_x = atoi(m.get(F_X));
_y = atoi(m.get(F_Y));
_prompt = m.get(F_PROMPT);
_width = atoi(m.get(F_WIDTH));
if (_section->columnwise())
_col_head = m.get(F_INTEST);
_height = atoi(m.get(F_HEIGHT));
_id = atoi(m.get(F_ID));
_ofs = atoi(m.get(F_SPACES));
_flag.read_from(m);
_group.reset();
for (int g = 1; g <= 24; g++)
_group.set(g, m.get_bool(F_GROUP+g));
}
void TForm_item::read_from(TToken_string& s)
{
_id = s.get_int(idt_id - 101);
_desc = s.get(dsc_id - 101);
_x = _section->columnwise() ? s.get_int(col_id - 101) : s.get_int(xps_id - 101);
_width = s.get_int(len_id - 101);
if (!_section->columnwise())
_y = s.get_int(yps_id - 101);
_flag.set_shown(s.get(prn_id - 101)[0] != 'X');
if (_section->columnwise())
{
_ofs = s.get_int(spc_id - 101);
_flag.set_finkl(s.get(fnl_id - 101)[0] != 'X');
_flag.set_finkr(s.get(fnr_id - 101)[0] != 'X');
_col_head = s.get(int_id - 101);
}
set_dirty();
}
bool TForm_item::edit(TMask& m)
{
m.enable(F_CLASS, m.insert_mode());
m.reset();
if (m.insert_mode())
{
short id = 0;
for (word i = 0; i < section().fields(); i++)
{
const TForm_item& f = section().field(i);
if (f.id() > id) id = f.id();
}
_id = id+1;
}
print_on(m);
const bool godmode = form().edit_level() > 1;
m.enable_page(1, godmode);
m.enable(-7, godmode);
m.enable(F_ID, godmode);
m.enable(F_KEY,godmode);
m.enable(F_Y,!_section->columnwise());
m.enable(F_INTEST,_section->columnwise());
if (_flag.memo)
{
m.disable(F_PROMPT);
m.hide(F_PROMPT);
m.enable(F_MEMO);
m.show(F_MEMO);
m.enable(F_HEIGHT);
m.show(F_HEIGHT);
}
else
{
m.hide(F_MEMO);
m.disable(F_MEMO);
}
const bool dirty = m.run() == K_ENTER;
if (dirty)
{
read_from(m);
set_dirty();
}
return dirty;
}
///////////////////////////////////////////////////////////
// TForm_string
///////////////////////////////////////////////////////////
bool TForm_string::edit(TMask& m)
{
const bool godmode = form().edit_level() > 1;
m.enable(F_PROMPT, godmode ? TRUE : (_field.items()==0));
return TForm_item::edit(m);
}
void TForm_string::print_body(ostream& out) const
{
TForm_item::print_body(out);
if (_picture.not_empty())
out << " PICTURE \"" << _picture << "\"" << endl;
for (int i = 0; i < _field.items(); i++)
out << " FIELD " << field(i) << endl;
}
bool TForm_string::read_from(const TRectype& prof)
{
bool changed = TForm_item::read_from(prof);
const TString& pict = prof.get("PICT");
if (_picture != pict)
{
_picture = pict;
changed = TRUE;
}
if (has_memo())
{
const TString& m = prof.get("TESTO");
if (_memo != m)
{
_memo = m;
changed = TRUE;
}
}
return changed;
}
void TForm_string::print_on(TToken_string& row)
{
TForm_item::print_on(row);
if (_field.items() && form().edit_level() > 1)
row << '|' << field(0);
}
void TForm_string::print_on(TRectype& prof)
{
TForm_item::print_on(prof);
prof.put("PICT", _picture);
if (has_memo())
{
prof.put("TESTO", _memo);
}
}
void TForm_string::print_on(TMask& m)
{
TForm_item::print_on(m);
for (int i = 0; i < _field.items(); i++)
put_fieldref(field(i), m.field(i == 0 ? F_FIELDREF1 : F_FIELDREF2));
m.set(F_PICTURE, _picture);
m.set(F_MEMO, _memo);
TSheet_field& s = (TSheet_field&)m.field(F_ITEMS);
s.reset();
if (_message.items() > 0)
{
TToken_string& row = s.row(0);
row = " | ";
row.add(message(0));
}
}
void TForm_string::read_from(const TMask& m)
{
TForm_item::read_from(m);
_picture = m.get(F_PICTURE);
_memo = m.get(F_MEMO);
for (int i = 0; i < 2; i++)
{
const TString& f = m.get(i == 0 ? F_FIELDREF1 : F_FIELDREF2);
if (f.not_empty())
{
TFieldref* fr = (TFieldref*)_field.objptr(i);
if (fr == NULL)
{
fr = new TFieldref(f, 0);
_field.add(fr, i);
}
*fr = f;
}
else
_field.destroy(i);
}
TSheet_field& f = (TSheet_field&)m.field(F_ITEMS);
TToken_string& msg = f.row(0);
if (msg.empty_items())
_message.destroy(0);
else
_message.add(msg.get(2), 0);
}
///////////////////////////////////////////////////////////
// TForm_subsection
///////////////////////////////////////////////////////////
bool TForm_subsection::edit(TMask& m)
{
// mask con nome e bottone edit contents / annulla
TMask mu("ba2100u");
mu.set(F_CAPTION, _name);
mu.set(F_WIDTH, _width);
mu.set(F_HEIGHT, _height);
mu.set(F_X, _x);
mu.set(F_Y, _y);
mu.set_handler(F_BUT_FILE1, but_file_handler_sub);
if (_file_id != -1)
{
// set file description
form().rel_desc().set_cur_file(_file_id);
TString80 desc; desc << form().rel_desc().file_desc();
mu.set(F_FILE1, desc);
}
KEY k;
// vedere se e' nuova etc.
// gestire aggiunta / modifica menu
while ((k = mu.run()) != K_ESC)
{
if (mu.field(F_CAPTION).dirty())
_name = mu.get(F_CAPTION);
if (mu.field(F_WIDTH).dirty())
_width = mu.get_int(F_WIDTH);
if (mu.field(F_HEIGHT).dirty())
_height = mu.get_int(F_HEIGHT);
if (mu.field(F_X).dirty())
_x = mu.get_int(F_X);
if (mu.field(F_Y).dirty())
_y = mu.get_int(F_Y);
if (mu.field(F_FILE1).dirty())
{
if (mu.get(F_FILE1).empty())
_file_id = -1;
else
_file_id = form().rel_desc().file_num();
}
if (k == K_INS)
_ssec.edit(_name);
else if (k == K_DEL)
{
// remove myself
}
else if (k == K_ENTER)
break;
}
return k != K_ESC;
}
void TForm_subsection::print_on(ostream& out) const
{
out << "SEZIONE " << _name << ' ' << _width << ' ' << _height
<< ' ' << _x << ' ' << _y;
if (_file_id != -1)
out << " FILE " << _file_id;
out << "\n";
for (word i = 0; i < _ssec.fields(); i++)
out << _ssec.field(i);
out << "\nEND\n";
}
///////////////////////////////////////////////////////////
// TPrint_section
///////////////////////////////////////////////////////////
// @doc EXTERNAL
// @mfunc Legge dal record <p rec> altezza e offset prima colonna della sezione
//
// @rdesc Ritorna se i valori letti hanno modificato quelli attuali
bool TPrint_section::read_from(
const TRectype& prof) // @parm Record dal quela leggere i valori
// @comm Nel caso il record non sia LF_RFORM viene dato un messaggio di <f CHECK>.
{
CHECK(prof.num() == LF_RFORM, "Il record deve essere del file LF_RFORM");
bool changed = FALSE;
const word h = (word)prof.get_int("HGT");
const word l = (word)prof.get_int("LEN");
const word y = (word)prof.get_int("Y");
if (_height != h)
{
_height = h;
changed = TRUE;
}
if (_ofspc != l)
{
_ofspc = l;
changed = TRUE;
}
if (_ofsvr != y)
{
_ofsvr = y;
changed = TRUE;
}
return changed;
}
void TPrint_section::print_on(TRectype& prof)
{
CHECK(prof.num() == LF_RFORM, "Il record deve essere del file LF_RFORM");
prof.put("ID", 0);
prof.put("X", 0);
prof.put("Y", _ofsvr);
prof.put("LEN", _ofspc);
prof.put("HGT", _height);
}
typedef struct
{
TString80 name_1; // Fontname old
TString80 name_2; // Fontname new
int size_1; // size (height) of old font
int size_2; // size (height) of new font
real ratio; // ratio (width_old_font/width_new_font)
} s_data;
BOOLEAN wpr(long data)
{
s_data* st =(s_data*)data;
WINDOW prwin = xvt_print_create_win(printer().get_printrcd(),"");
long width_old,width_new;
TString spc(128, 'm');
xvtil_set_font(prwin,st->name_1, XVT_FS_NONE, st->size_1);
width_old = xvt_dwin_get_text_width(prwin, spc, spc.len());
xvtil_set_font(prwin,st->name_2, XVT_FS_NONE, st->size_2);
width_new = xvt_dwin_get_text_width(prwin,spc, spc.len());
st->ratio = (double)width_old / (double)width_new;
xvt_vobj_destroy(prwin);
return FALSE;
}
bool TPrint_section::special_field_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE && _special_mask != NULL)
_special_mask->run();
return TRUE;
}
bool TPrint_section::repos_fields(const char* name, int size)
{
TPrint_section& ps = ::section();
bool rt = FALSE;
if (ps.form().fontname() != name ||
ps.form().fontsize() != size)
{
if (!ps.form().dirty()) ps.form().set_dirty();
ps.set_dirty();
if (yesno_box("E' stato cambiato il font o la dimensione del carattere.\nSi desidera aggiornare le coordinate dei campi?"))
{
rt = TRUE;
s_data prm;
prm.size_1=ps.form().fontsize();
prm.name_1 = ps.form().fontname();
prm.size_2=size;
prm.name_2 = name;
prm.ratio = 1.0;
// Next 3 lines may be changed
xvt_print_open();
xvt_print_start_thread (wpr, (long)&prm);
xvt_print_close();
if (ps.form().edit_level() > 1)
{
TMask rm("Rapporto tra i caratteri", 1, 30, 4);
rm.add_number(DLG_USER, 0, "Rapporto ", 1, 1, 8, "", 4);
rm.add_button(DLG_OK, 0, "Conferma", -12, -1, 10, 2);
rm.add_button(DLG_CANCEL, 0, "Annulla", -22, -1, 10, 2);
real ratio = prm.ratio;
rm.set(DLG_USER, ratio);
if (rm.run() == K_ENTER)
{
ratio = rm.get_real(DLG_USER);
prm.ratio = ratio;
}
}
const char sechar[4] = { 'B', 'F', 'G', 'H' };
for (int sn = 0; sn < 4 ; sn++)
{
const char sc = sechar[sn];
for (pagetype pt = odd_page; pt <= last_page; pt = pagetype(pt+1))
{
TPrint_section* sec = ps.form().exist(sc, pt);
if (sec != NULL && !sec->columnwise())
{
sec->set_dirty();
for (word i = 0; i < sec->fields() ; i++)
{
TForm_item& fi = sec->field(i);
short value = fi.x();
if (value > 0 && (prm.ratio != 1.0))
{
real x_pos;
x_pos = value * prm.ratio;
x_pos.round();
fi.set_x((short)x_pos.integer());
fi.set_dirty();
}
}
}
}
}
}
ps.form().fontname() = name;
ps.form().fontsize() = size;
// Aggiorna lo spreadsheet
TSheet_field& ms = (TSheet_field&)ps._msk->field(F_FIELDS);
TToken_string tt(128);
const word flds = ps.fields();
for (word i = 0; i < flds; i++)
{
TForm_item& f = ps.field(i);
f.print_on_sheet_row(tt);
ms.row(i) = tt;
}
}
return rt;
}
// handlers for section editing
bool TPrint_section::detail_field_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
const TFixed_string sm(_cur_form->section_mask());
if (_cur_form && sm.left(2) == "ba")
{
TString name(_msk->get(F_FONT));
int size = _msk->get_int(F_SIZE);
repos_fields(name, size);
}
bool consider_sheet_mask = FALSE;
if (f.mask().is_running()) // Se la maschera di editing dello sheet e' running
consider_sheet_mask = TRUE; // allora deve tener conto anche di essa per l'I/O
// to avoid kasinations with recursion
TPrint_section& section = ::section();
TSheet_field& ms = *f.mask().get_sheet();
int field = ms.selected();
TToken_string& tt = ms.row(field);
TToken_string tt_mask(tt);
if (consider_sheet_mask)
{
TMask& msheet = f.mask();
tt_mask.add(msheet.get(idt_id), idt_id - 101);
tt_mask.add(msheet.get(dsc_id), dsc_id - 101);
tt_mask.add(msheet.get(len_id), len_id - 101);
tt_mask.add(msheet.get(prn_id), prn_id - 101);
if (section.columnwise())
{
tt_mask.add(msheet.get(col_id), col_id - 101);
tt_mask.add(msheet.get(spc_id), spc_id -101);
tt_mask.add(msheet.get(int_id), int_id - 101);
tt_mask.add(msheet.get(fnl_id), fnl_id -101);
tt_mask.add(msheet.get(fnr_id), fnr_id -101);
}
else
{
tt_mask.add(msheet.get(xps_id), xps_id - 101);
tt_mask.add(msheet.get(yps_id), yps_id - 101);
}
}
TMask msk("ba2100f");
msk.set_handler(F_DFORMAT, dateformat_handler);
msk.set_handler(F_DYEAR, dateformat_handler);
msk.set_handler(F_DMONTH, dateformat_handler);
msk.set_handler(F_DDAY, dateformat_handler);
msk.set_handler(F_DSEP, dateformat_handler);
msk.set_handler(F_FILE1, but_file_handler);
msk.set_handler(F_FIELD1, but_field_handler);
msk.set_handler(F_FROM1, from_handler);
msk.set_handler(F_TO1, to_handler);
msk.set_handler(F_FILE2, but_file_handler);
msk.set_handler(F_FIELD2, but_field_handler);
msk.set_handler(F_FROM2, from_handler);
msk.set_handler(F_TO2, to_handler);
msk.set_handler(F_PICTURE,fmt_handler);
// TBI set_mode etc, vedi sotto
// gna'
TForm_item& fi = section.field(field);
msk.enable(F_OPTIONS, fi.special_items() > 3);
msk.enable(F_SPACES, section.columnwise());
msk.enable(F_FINKL, section.columnwise());
msk.enable(F_FINKR, section.columnwise());
// build option mask
if (fi.special_items() > 3)
{
msk.set_handler(F_OPTIONS, special_field_handler);
CHECK(fi.special_items() < 18, "Quanti special! Non ho nessuna voglia di "
" farti una maschera a piu' pagine. Ripensaci e riprova");
_special_mask = new TMask("Variabili personalizzate", 1, 78, fi.special_items() + 3);
_special_mask->add_button(DLG_OK, 0, "", -12, -1, 10, 2);
_special_mask->add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
fi.specials().restart();
for (int k = 0; k < fi.special_items(); k++)
{
THash_object* ho = fi.specials().get_hashobj();
TToken_string& tt = (TToken_string&)(ho->obj());
TString type = tt.get(0);
TString val = tt.get(1);
TToken_string des(tt.get(2),'/');
TString prompt(des.get(0));
if (type == "STRINGA")
{
_special_mask->add_string(101+k, 0, prompt, 1, k+1, des.get_int(1),"");
_special_mask->set(101+k, val);
}
else if (type == "NUMERO")
{
_special_mask->add_number(101+k, 0, prompt, 1, k+1, des.get_int(1),"",des.get_int(2));
_special_mask->set(101+k, val);
}
else if (type == "LISTA")
{
TToken_string codes(128);
TToken_string value(128);
for (int jj = 2; jj < des.items(); jj++)
{
CHECK (jj < (des.items() - 1), "AAARGH! 'Sta LISTA special e' fatta male");
TString t1(des.get(jj++));
TString t2(des.get(jj));
codes.add(t1);
value.add(t2);
}
_special_mask->add_list(101+k, 0, prompt, 1, k+1, des.get_int(1), "", codes, value);
_special_mask->set(101+k, val);
}
else if (type == "BOOLEAN")
{
_special_mask->add_boolean(101+k, 0, prompt, 1, k+1);
_special_mask->set(101+k, val);
}
else if (type == "DATA")
{
_special_mask->add_date(101+k, 0, prompt, 1, k+1);
_special_mask->set(101+k, val);
}
}
}
if (consider_sheet_mask)
fi.read_from(tt_mask);
else
fi.read_from(tt);
fi.edit(msk);
// check specials
if (_special_mask != NULL)
{
if (_special_mask->last_key() == K_ENTER)
{
fi.specials().restart();
for (int k = 0; k < fi.special_items(); k++)
{
THash_object* ho = fi.specials().get_hashobj();
TToken_string& tt = (TToken_string&)(ho->obj());
TString val = tt.get(1);
TString nvl = _special_mask->get(k + 101);
if (nvl != val)
{
tt.add(nvl, 1);
if (tt.items() == 3) tt.add("X");
fi.set_dirty();
}
}
}
if (_special_mask != NULL)
{
delete _special_mask;
_special_mask = NULL;
}
}
if (!consider_sheet_mask)
fi.print_on_sheet_row(tt);
else
{
TMask& msheet = f.mask();
fi.print_on_sheet_row(tt_mask);
msheet.set(idt_id, tt_mask.get_int(idt_id - 101));
msheet.set(dsc_id, tt_mask.get(dsc_id - 101));
msheet.set(len_id, tt_mask.get_int(len_id - 101));
msheet.set(prn_id, tt_mask.get(prn_id - 101));
msheet.set(frm_id, fi.example());
if (section.columnwise())
{
msheet.set(spc_id, tt_mask.get_int(spc_id - 101));
msheet.set(col_id, tt_mask.get_int(col_id - 101));
msheet.set(int_id, tt_mask.get(int_id - 101));
msheet.set(fnl_id, tt_mask.get(fnl_id - 101));
msheet.set(fnr_id, tt_mask.get(fnr_id - 101));
}
else
{
msheet.set(xps_id, tt_mask.get_int(xps_id - 101));
msheet.set(yps_id, tt_mask.get_int(yps_id - 101));
}
}
ms.force_update();
_cur_sect = &section;
}
return TRUE;
}
bool TPrint_section::detail_field_notify (TSheet_field& s, int r, KEY k)
{
TPrint_section& sec = ::section();
if (k == K_DEL || k == K_INS)
{
if (sec.form().edit_level() <= 1)
return FALSE;
if (k == K_DEL)
{
// elimina campo
sec.destroy_field(r);
sec.set_dirty();
}
}
else if (k == (K_INS + K_CTRL))
{
// new field: set defaults and create field
TForm_string* f = new TForm_string(&sec);
sec.insert_field(r, f);
TToken_string& tt = s.row(r);
f->print_on_sheet_row(tt);
tt.add("Nuovo campo", sec.columnwise() ? int_id : dsc_id);
if (sec.columnwise()) tt.add(r+1, col_id - 101);
s.force_update();
sec.set_dirty();
}
else if (k == K_ENTER)
{
// modify field
TForm_item* fld = &sec.field(r);
TToken_string& tt = s.row(r);
if (sec.columnwise() && ((word)tt.get_int(col_id - 101) <= 0 ||
(word)tt.get_int(col_id - 101) > sec.fields()))
{
warning_box("Numero di colonna non accettabile (deve essere da 1 a %u)", sec.fields());
return FALSE;
}
// ??? type changed ???
if (strcmp(tt.get(typ_id - 101), fld->class_name()) != 0)
{
// so'ccazzi: crea nuovo campo del tipo dato e
// copia gli special (e il resto)
const TString typ(tt.get(typ_id - 101));
TForm_item* fff = sec.create_item(typ);
// copia SPECIALS
TAssoc_array& aa = fld->specials();
TAssoc_array& bb = fff->specials();
THash_object* oo = NULL;
aa.restart();
for (int i = 0; i < aa.items(); i++)
{
oo = aa.get_hashobj();
bb.add(oo->key(), oo->obj());
}
sec.change_field(r, fld = fff);
fld->set_dirty();
}
// modifica valori
fld->read_from(tt);
}
else
if (k == K_SPACE)
{
if (_cur_form && TString(_cur_form->section_mask()).left(2) == "ba")
{
TString80 name(s.mask().get(F_FONT));
int size = s.mask().get_int(F_SIZE);
if (repos_fields(name,size))
s.force_update();
}
}
return TRUE;
}
// @doc EXTERNAL
// @mfunc Esegue l'edit della sezione di stampa
//
// @rdesc Ritorna TRUE se e' stata modificata effettivamente
bool TPrint_section::edit(
const char* title) // @parm Titolo della maschera di edit
{
const bool is_ba_editor = TString(_form->section_mask()).left(2) == "ba";
bool nstd_dirty = FALSE;
bool font_found = FALSE;
_cur_form = _form;
_cur_sect = this;
if (!_upsection)
{
TMask m(_form->section_mask());
_msk = &m;
m.set_caption(title);
m.set(F_HEIGHT, _height);
m.set(F_OFSPC, _ofspc);
m.set(F_OFSVR, _ofsvr);
if (is_ba_editor)
{
m.set(F_X, form().offset_x());
m.set(F_Y, form().offset_y());
TString16 str; str << form().char_to_pos();
m.set(F_CTP, str);
m.set(F_IPX, form().ipx());
m.set(F_IPY, form().ipy());
m.set(F_FPX, form().fpx());
m.set(F_FLEN, printer().formlen());
}
else
_form->pre_edit_checks(m,_cur_sect);
TSheet_field& ms = (TSheet_field&)m.field(F_FIELDS);
m.hide(F_OFSVR);//Offset verticale, per _columnwise. Non ancora usato.
if (_columnwise)
{
m.disable(F_HEIGHT);
ms.delete_column(xps_id); ms.sheet_mask().hide(xps_id);
ms.delete_column(yps_id); ms.sheet_mask().hide(yps_id);
}
else
{
m.hide(F_OFSPC);
ms.delete_column(int_id); ms.sheet_mask().hide(int_id);
ms.delete_column(col_id); ms.sheet_mask().hide(col_id);
ms.delete_column(spc_id); ms.sheet_mask().hide(spc_id);
ms.delete_column(fnl_id); ms.sheet_mask().hide(fnl_id);
ms.delete_column(fnr_id); ms.sheet_mask().hide(fnr_id);
}
ms.enable_column(frm_id - 101, FALSE);
if (form().edit_level() <= 1)
{
ms.enable_column(idt_id - 101, FALSE);
ms.enable_column(typ_id - 101, FALSE);
}
// handlers
ms.set_notify(detail_field_notify);
ms.sheet_mask().set_handler(100, detail_field_handler);
if (_form->edit_level()<=1) ms.sheet_mask().disable(DLG_DELREC);
TToken_string tt(128);
const word flds = fields();
// fill sheet
for (word i = 0; i < flds; i++)
{
TForm_item& f = field(i);
f.print_on_sheet_row(tt);
// TBI colorare se specials (e vedi se colorare solo se non standard)
ms.row(-1) = tt;
}
if (is_ba_editor)
{
const int MAX_FAMILIES = 128;
char* family[MAX_FAMILIES];
const int num_families = (int)xvt_fmap_get_families(printer().get_printrcd(), family, MAX_FAMILIES);
TToken_string pn1(256), pn2(256);
for (int i = 0; i < num_families; i++)
{
pn1.add(family[i]);
pn2.add(family[i]);
if (!font_found)
if (form().fontname() == family[i]) font_found = TRUE;
xvt_mem_free(family[i]);
}
TList_field& lst = (TList_field&)m.field(F_FONT);
if (!font_found)
{
warning_box("Il font %s non esiste per la stampante di default.",(const char*) form().fontname());
pn1.add(form().fontname());
pn2.add(form().fontname());
}
lst.replace_items(pn1, pn2);
lst.set(form().fontname());
printer().set_char_size(form().fontsize());
m.set_handler(F_FONT,font_handler);
}
if(_columnwise)
{
bool ok = FALSE;
while (m.run() != K_ESC)
{
TSheet_field& ms = (TSheet_field&)m.field(F_FIELDS);
const int items = ms.items();
int i;
for (i=0; i<items && !ok; i++)
{
TToken_string& tt = ms.row(i);
ok = tt.get_char(prn_id - 101)==' ';
}
if (i==items && !ok) error_box("Selezionare almeno una colonna stampabile.");
if (ok) break;
}
_msk = NULL;
if (!ok) return FALSE;
}
else
if (m.run() == K_ESC)
{
// Se premo Annulla ed il form e' nuovo lo devo cancellare.
if (form()._isnew)
{
TLocalisamfile frm(LF_FORM);
frm.zero();
frm.put("TIPOPROF",form().name());
frm.put("CODPROF",form().code());
frm.remove();
}
_msk = NULL;
return FALSE;
}
bool dirty = m.dirty() != 0;
if (dirty)
{
// Controlli da fare sempre a prescindere dal form editor
if (_height != (word)m.get_int(F_HEIGHT) )
{
_height = m.get_int(F_HEIGHT);
_dirty=TRUE;
}
if (_ofspc != (word)m.get_int(F_OFSPC) )
{
_ofspc = m.get_int(F_OFSPC);
_dirty=TRUE;
}
if (_ofsvr != (word)m.get_int(F_OFSVR) )
{
_ofsvr = m.get_int(F_OFSVR);
_dirty=TRUE;
}
if (is_ba_editor)
{ // Controlli solo se il form editor e' quello base
if (m.get_int(F_X) != form().offset_x() || m.get_int(F_Y) != form().offset_y())
{
form().offset_x() = m.get_int(F_X);
form().offset_y() = m.get_int(F_Y);
form().set_dirty();
_dirty = TRUE;
}
if (m.get(F_CTP)[0] != form().char_to_pos() ||
m.get_int(F_IPX) != form().ipx() ||
m.get_int(F_IPY) != form().ipy() ||
m.get_int(F_IPX) != form().fpx())
{
form().char_to_pos() = m.get(F_CTP)[0];
form().ipx() = m.get_int(F_IPX);
form().ipy() = m.get_int(F_IPY);
form().fpx() = m.get_int(F_FPX);
_dirty = TRUE;
}
TString80 name(m.get(F_FONT));
int size = m.get_int(F_SIZE);
repos_fields(name,size);
} else // controlli se l'editor non e' quello base
nstd_dirty = _form->post_edit_checks(m,_cur_sect);
}
_msk = NULL;
}
if (is_ba_editor)
if (form()._isnew || (_dirty && yesno_box("Dati generali modificati. Salvare?")))
{
TLocalisamfile frm(LF_FORM);
frm.zero();
frm.put("TIPOPROF",form().name());
frm.put("CODPROF",form().code());
if (frm.read(_isequal,_lock) == NOERR)
{
frm.put("OFFY",form().offset_y());
frm.put("OFFX",form().offset_x());
frm.put("FONTNAME",form().fontname());
frm.put("FONTSIZE",form().fontsize());
frm.put("CTP",form().char_to_pos());
frm.put("IPX", form().ipx());
frm.put("IPY", form().ipy());
frm.put("FPX", form().fpx());
frm.rewrite();
_dirty = FALSE;
}
}
if (!_dirty)
for (word j = 0; j < fields(); j++)
_dirty |= field(j).dirty();
set_dirty(_dirty);
return (_dirty || nstd_dirty);
}
void TPrint_section::print_on(ostream& out) const
{
out << ' ';
switch (page_type())
{
case even_page:
out << "EVEN"; break;
case first_page:
out << "FIRST"; break;
case last_page:
out << "LAST"; break;
default:
out << "ODD"; break;
}
out << ' ' << _height;
if (_columnwise) out << " COLUMNWISE";
out << endl << endl;
for(word i = 0; i < fields(); i++)
if (!field(i).temp()) out << field(i);
}
Reference in New Issue View Git Blame Copy Permalink