#include #include #include #include #include #include #include #include #include #include "velib.h" #include "vepriv.h" #include "verig.h" #include "ve0100.h" #include "ve0100b1.h" #include "ve0100o.h" #include "veuml.h" #include "veuml1.h" #include "veini.h" #include "sconti.h" #include "doc.h" #include "rdoc.h" TDocumento_mask::TDocumento_mask(const char* td) : TVariable_mask(), _progs_page(-1), _last_prog(-1), _condv(NULL) { CHECK(strlen(td) <= 4, "TDocumento_mask(TipoDocumento) not (MaskName)"); { TMagazzini m; _ges_mag = m.gestmag(); _ges_dep = m.gestdep(); _std_mag = m.standardmag(); _std_dep = m.standarddep(); } _doc.set_tipo(td); const TString mname = _doc.tipo().mask_name(); read_mask(mname, 0, MAX_PAGES); int pos = id2pos(BASE_PIEDE + 1); if (pos >= 0) { _progs_page = find_parent_page(fld(pos)); _last_prog = 0; while (id2pos(BASE_PIEDE + _last_prog + 1) >= 0) _last_prog++; } _sheet = &sfield(F_SHEET); _sheet->set_handler( ss_handler ); _sheet->set_notify( ss_notify ); _sheet->set_append(FALSE); TList_field& listbox = ( TList_field& )field( F_LBTIPORIGA ); TTipo_documento& tdoc = (TTipo_documento&)_doc.tipo(); TToken_string& keys = (TToken_string&) tdoc.keys_descrs()[0]; TToken_string& descrs = (TToken_string&) tdoc.keys_descrs()[1]; listbox.replace_items(keys, descrs); configura_sheet(*_sheet); ((TVariable_sheet_field*)_sheet)->set_getmask( ss_getmask ); if (_doc.tipo().clifo_optional()) { field(F_CODCF).check_type(CHECK_NORMAL); field(F_RAGSOC).check_type(CHECK_NORMAL); } set_handler( F_OCCASEDIT, occas_handler ); set_handler( F_CODCF, clifo_handler ); set_handler( F_CODPAG, condpag_hndl ); set_handler( F_DATAINSC, condpag_hndl ); set_handler( F_CODNOTE, note_hndl ); set_handler( F_DATADOC, data_hndl ); set_handler( F_CODLIST, codlist_handler ); set_handler( F_CODLIST1, codlist_handler ); set_handler( F_CODCONT, codcont_handler ); set_handler( F_CODCONT1, codcont_handler ); set_handler( F_CODCAMP, codcamp_handler ); set_handler( F_CODVAL, codval_handler ); set_handler( F_CODVAL1, codval_handler ); set_handler( F_NUMDOCRIF, datadocrif_handler); set_handler( F_DATADOCRIF, datadocrif_handler); set_handler( DLG_ELABORA, elabora_handler ); set_handler( DLG_PRINT, print_handler ); const TString_array& handlers = tdoc.handlers(); int numhandler = handlers.items(); for (int i = 0; i < numhandler; i ++ ) { TToken_string& riga = (TToken_string&) handlers[i]; user_set_handler( riga.get_int( 0 ), riga.get_int( 1 ) ); } _livelli_giac = new TCodgiac_livelli; for (i = 4; i > 0; i--) { const short pos = _sheet->cid2index(FR_LIV1 + i -1); if (_livelli_giac->enabled(i)) { const TString & header = _livelli_giac->name(i); const int len = header.len() + 1; const int f_len = _livelli_giac->code_length(i); _sheet->set_column_header(pos, header); _sheet->set_column_width(pos, (len > f_len ? len : f_len) * 8); } else { _sheet->sheet_mask().hide(FR_LIV1 + i -1); _sheet->delete_column(pos); } } // configurazione campi TConfig cfg(CONFIG_DITTA, "ve"); const bool gesval = cfg.get_bool("GESVAL"); const bool gescambi = cfg.get_bool("GESVALAC"); if (gesval) { const bool enable_controeuro = cfg.get_bool("CONTROEURO"); enable(F_CONTROEURO, enable_controeuro); show(F_CODVAL, !gescambi); show(F_DATACAMBIO, !gescambi); show(F_NOMEVAL, !gescambi); show(F_CODVAL1, gescambi); show(F_DATACAMBIO1, gescambi); show(F_NOMEVAL1, gescambi); show(F_CAMBIO); } else { disable(F_CODVAL); disable(F_DATACAMBIO); disable(F_CONTROEURO); disable(F_NOMEVAL); hide(F_CODVAL1); hide(F_DATACAMBIO1); hide(F_NOMEVAL1); disable(F_CAMBIO); } const bool geslin = cfg.get_bool("GESLIN"); enable(F_CODLIN, geslin); enable(F_DESLIN, geslin); const bool geslis = cfg.get_bool("GES", NULL, 1); const bool gesliscatven = cfg.get_bool("GESLISCV"); if (geslis) { show(F_CODLIST, !gesliscatven); show(F_CODLIST1, gesliscatven); } else { disable(F_CODLIST); hide(F_CODLIST1); } const bool gescontr = cfg.get_bool("GES", "ve", 2); const bool gescontrcli = cfg.get_bool("GESCONCC"); if (gescontr) { show(F_CODCONT1, gescontrcli); show(F_CODCONT, !gescontrcli); } else { disable(F_CODCONT); hide(F_CODCONT1); } const bool gesoff = cfg.get_bool("GES", "ve", 3); enable(F_CODCAMP, gesoff); const bool gessco = cfg.get_char("GESSCO") != 'N'; enable(F_SCONTOPERC, gessco); const bool gesage = cfg.get_bool("GESAGE"); enable(F_CODAG, gesage); enable(F_DESAG, gesage); enable(F_CODAGVIS, gesage); enable(F_DESAGVIS, gesage); const bool has_movmag = dongle().active(MGAUT) && _doc.tipo().mov_mag(); pos = id2pos(F_CAUSMAG); if (pos >= 0) fld(pos).show(has_movmag); pos = id2pos(F_DESCRMAG); if (pos >= 0) fld(pos).show(has_movmag); pos = id2pos(F_CAUSMAGC); if (pos >= 0) fld(pos).show(has_movmag); pos = id2pos(F_DESCRMAGC); if (pos >= 0) fld(pos).show(has_movmag); pos = id2pos(F_CURGIAC); if (pos >= 0) fld(pos).show(has_movmag); pos = id2pos(F_CURDISP); if (pos >= 0) fld(pos).show(has_movmag); } TDocumento_mask::~TDocumento_mask() { if (_condv) delete _condv; if (_livelli_giac) delete _livelli_giac; } void TDocumento_mask::configura_sheet(TSheet_field& sheet) { TBit_array to_delete(MAX_COLUMNS); to_delete.set(); TTipo_documento& tdoc = (TTipo_documento&) _doc.tipo(); const TString_array& sheet_columns = tdoc.sheet_columns(); int ncols = sheet_columns.items(); TToken_string colonne; colonne = "0"; for (int i = 0; i < ncols; i ++ ) { TToken_string& sheet_col = (TToken_string&) sheet_columns[i]; const int field_id = sheet_col.get_int(0); const int coltomove = sheet.cid2index(field_id); to_delete.reset(coltomove); const TString80 descr(sheet_col.get(1)); if (descr.not_empty() ) sheet.set_column_header( field_id, descr); const int size = sheet_col.get_int(2) * 8; // XI_FU_MULTIPLE if (size != 0) sheet.set_column_width( field_id, size); if (field_id != FR_LORDO || tdoc.calcolo_lordo()) colonne.add(field_id); } if (tdoc.calcolo_lordo()) to_delete.reset(0L); else to_delete.set(0L); to_delete.reset(1); if (!to_delete[sheet.cid2index(FR_CODDEP)]) sheet.enable_column(FR_CODDEP, _ges_dep && _ges_mag); if (!to_delete[sheet.cid2index(FR_CODMAG)]) sheet.enable_column(FR_CODMAG, _ges_mag); if (!to_delete[sheet.cid2index(FR_CODDEPC)]) sheet.enable_column(FR_CODDEPC, _ges_dep && _ges_mag); if (!to_delete[sheet.cid2index(FR_CODMAGC)]) sheet.enable_column(FR_CODMAGC, _ges_mag); to_delete.set(sheet.cid2index(FR_CODARTMAG)); to_delete.set(sheet.cid2index(FR_CHECKED)); /* const int sconto_col = sheet.cid2index(FR_SCONTO); if (to_delete[sconto_col] == FALSE) { const bool del = tdoc.sconto_riga() == "N"; to_delete.set(sconto_col, del); } */ for ( i = MAX_COLUMNS - 1; i >= 0; i-- ) if( to_delete[i] ) { sheet.enable_column( i + FIRST_FIELD, FALSE); sheet.delete_column( i + FIRST_FIELD); } if (!sheet.user_saved_columns_order()) sheet.set_columns_order(&colonne); } TCond_vendita& TDocumento_mask::condv() const { if (_condv == NULL) { TDocumento_mask* myself = (TDocumento_mask*)this; myself->_condv = new TCond_vendita(myself, NULL); } return *_condv; } void TDocumento_mask::update_progs() { TWait_cursor hourglass; for (int f = id2pos(BASE_PIEDE + 1)-1; f >= 0; f--) { const TMask_field& mf = fld(f); const TFieldref* fr = mf.field(); if (fr) _doc.put(fr->name(), mf.get()); } _doc.set_riga_esenzione(); for (int i = _last_prog; i > 0; i--) { const short id = BASE_PIEDE + i; const TString& name = field(id).field()->name(); const TString& val = _doc.get(name); set(id, val, TRUE); } } void TDocumento_mask::next_page(int p) { const bool was_normal_page = curr_page() < _progs_page; TMask::next_page(p); const bool is_calculated_page = curr_page() >= _progs_page; if (was_normal_page && is_calculated_page) update_progs(); } bool TDocumento_mask::stop_run(KEY key) { if (key != K_ESC && key != K_QUIT) update_progs(); return TVariable_mask::stop_run(key); } bool TDocumento_mask::on_key(KEY key) { if (key == K_SHIFT + K_F12) { TRelation r(LF_DOC); r.curr()=doc(); if (!doc().bloccato() && ::user_can_write(&r)) { TMask_field& stato = field(F_STATO); stato.enable(); enable(DLG_SAVEREC); enable(DLG_DELREC); } else warning_box("L'utente %s non puo' modificare questo documento", (const char*)user()); return TRUE; } return TVariable_mask::on_key(key); } void TDocumento_mask::occ2mask() { const TOccasionale& o = doc().occas(); reset(F_COFI); reset(F_PAIVA); set(F_OCFPI, o.get(OCC_CFPI)); const TString & ragsoc = o.get(OCC_RAGSOC); set(F_RAGSOC, ragsoc); set(F_RAGSOCSP, ragsoc); const TString & indir = o.get(OCC_INDIR); set(F_INDCF, indir); set(F_INDSP, indir); const TString & civ = o.get(OCC_CIV); set(F_CIVCF, civ); set(F_CIVSP, civ); const TString & cap = o.get(OCC_CAP); set(F_CAPCF, cap); set(F_CAPSP, cap); const TString & com = o.get(OCC_COM); set(F_COMCF, com); set( F_COMSP, com); const TString & stato = o.get(OCC_STATO); set(F_STATOCF, stato); set( F_STATOSP, stato); if (id2pos(F_CODINDSP) >= 0) reset(F_CODINDSP); // Sugli occasionali non c'è la località const TString & localita = o.get(OCC_LOCALITA); set(F_LOCALITACF, localita); set(F_LOCALITASP, localita); check_field(F_COMSP); check_field(F_STATOSP); } void TDocumento_mask::cli2mask() { TCli_for & c = doc().clifor(); TOccasionale & o = doc().occas(); const bool onload = !is_running(); // Setta i campi che appartengono al file LF_CLIFO const bool occas = c.occasionale(); show(F_OCCASEDIT, occas); if (!occas) reset(F_OCFPI); show(F_OCFPI, occas); // In forse per l'Occasionale, sicuri per il Normale show(F_COFI, !occas); show(F_STATOPAIVA, !occas); show(F_PAIVA, !occas); set(F_RAGSOC, c.get(CLI_RAGSOC)); enable(F_RAGSOC, !occas); const TRectype & ven_rec = c.vendite(); if(!onload) { short pos = id2pos(F_CODVAL); const TString & codval = c.get(CLI_CODVAL); if (pos >= 0) set(F_CODVAL, codval, TRUE); pos = id2pos(F_CODVAL1); if (pos >= 0) set(F_CODVAL1, codval, TRUE); pos = id2pos(F_CODLIN); if (pos >= 0 && fld(pos).active()) fld(pos).set(c.get(CLI_CODLIN)); set(F_CODPAG, c.get(CLI_CODPAG)); set(F_CODABIA, c.get(CLI_CODABI)); set(F_CODCABA, c.get(CLI_CODCAB)); // Setta i campi che appartengono al file LF_CFVEN set(F_CODABIP, ven_rec.get(CFV_CODABIPR)); set(F_CODCABP, ven_rec.get(CFV_CODCABPR)); set(F_RAGGR, ven_rec.get(CFV_RAGGDOC)); set(F_RAGGREFF, ven_rec.get(CFV_RAGGEFF)); set(F_CODINDSP, ven_rec.get(CFV_CODINDSP)); set(F_CODAG, ven_rec.get(CFV_CODAG)); set(F_CODSPMEZZO, ven_rec.get(CFV_CODSPMEZZO)); set(F_CODPORTO, ven_rec.get(CFV_CODPORTO)); set(F_CODNOTESP1, ven_rec.get(CFV_CODNOTESP1)); set(F_CODNOTESP2, ven_rec.get(CFV_CODNOTESP2)); set(F_CODNOTE, ven_rec.get(CFV_CODNOTE)); set(F_CODVETT1, ven_rec.get(CFV_CODVETT1)); set(F_CODVETT2, ven_rec.get(CFV_CODVETT2)); set(F_CODVETT3, ven_rec.get(CFV_CODVETT3)); set(F_SPESEINC, ven_rec.get(CFV_PERCSPINC)); set(F_ADDBOLLI, ven_rec.get(CFV_ADDBOLLI)); set(F_CATVEN, ven_rec.get(CFV_CATVEN)); pos = id2pos(F_CODLIST); const TString & codlist = ven_rec.get(CFV_CODLIST); if (pos >= 0 && fld(pos).active()) { TEdit_field & f = (TEdit_field&) fld(pos); f.set(codlist); f.check(); f.on_hit(); } pos = id2pos(F_CODLIST1); if (pos >= 0 && fld(pos).active()) { TEdit_field & f = (TEdit_field&) fld(pos); f.set(codlist); f.check(); f.on_hit(); } pos = id2pos(F_CODAG); if (pos >= 0 && fld(pos).active()) fld(pos).set(ven_rec.get(CFV_CODAG)); set(F_CODZON, ven_rec.get(CFV_CODZONA)); set(F_RAGGR, ven_rec.get(CFV_RAGGDOC)); sconto_testa2mask(); spese2mask(); } enable( F_CODINDSP , !occas); if (occas) occ2mask(); else { set(F_COFI, c.get(CLI_COFI)); set(F_INDCF, c.get(CLI_INDCF)); set(F_CIVCF, c.get(CLI_CIVCF)); set(F_STATOPAIVA, c.get(CLI_STATOPAIV)); set(F_PAIVA, c.get(CLI_PAIV)); set(F_LOCALITACF, c.get(CLI_LOCCF)); set(F_CAPCF, c.get(CLI_CAPCF)); set(F_COMCF, c.get(CLI_COMCF)); set(F_STATOCF, c.get(CLI_STATOCF)); check_field( F_CODINDSP ); } const TString16 newcodval(get(F_CODVAL)); short pos = id2pos(F_CAMBIO); if ((pos >= 0) && newcodval.empty()) fld(pos).reset(); pos = id2pos(F_CODVAL); if (pos >= 0 && fld(pos).active()) fld(pos).check(STARTING_CHECK); pos = id2pos(F_CODVAL1); if (pos >= 0 && fld(pos).active()) fld(pos).check(STARTING_CHECK); check_field(F_COMCF); check_field(F_STATOCF); check_field( F_CODPAG ); pos = id2pos(F_CODLIN); if (pos >= 0 && fld(pos).active()) fld(pos).check(); check_field( F_CODCABA ); pos = id2pos(F_CODLIST); if (pos >= 0 && fld(pos).active()) fld(pos).check(); pos = id2pos(F_CODLIST1); if (pos >= 0 && fld(pos).active()) fld(pos).check(); check_field( F_CODCABP ); pos = id2pos(F_CODAG); if (pos >= 0 && fld(pos).active()) fld(pos).check(); check_field( F_CODSPMEZZO ); check_field( F_CODPORTO ); check_field( F_CODNOTESP1 ); check_field( F_CODNOTESP2 ); check_field( F_CODNOTE ); check_field( F_CODVETT1 ); check_field( F_CODVETT2 ); check_field( F_CODVETT3 ); check_field( F_CATVEN ); check_field( F_CODZON ); const bool contr_enabled = ven_rec.get_bool(CFV_GESTCONTR); bool gescontr = FALSE; if (contr_enabled) { TConfig ditta(CONFIG_DITTA, "ve"); gescontr = ditta.get_bool("GES", "ve", 2); } enable(F_CODCONT1, contr_enabled && gescontr); enable(F_CODCONT, contr_enabled && gescontr); } void TDocumento_mask::sconto_testa2mask() { TCli_for & c = doc().clifor(); TConfig ditta(CONFIG_DITTA, "ve"); const char tipogestione = ditta.get("GESSCO", "ve")[ 0 ]; switch( tipogestione ) { case 'N': // Sconti non gestiti: pussa via! break; case 'P': // Percentuale su anagrafica cliente set( F_SCONTOPERC, c.vendite().get(CFV_SCONTO)); break; case 'T': // Gestione tabella sconti { const TString16 codsconto(c.vendite().get(CFV_CODSCC)); if (codsconto.not_empty()) { TTable sconti("%SCC"); sconti.setkey(1); sconti.zero(); sconti.put("CODTAB", codsconto); if (sconti.read( ) == NOERR) set(F_SCONTOPERC, sconti.get("S1")); } } break; case 'A': // Gestione archivio sconti { TString16 cod; const TRectype & ven_rec = c.vendite(); TLocalisamfile sconti(LF_SCONTI ); sconti.setkey(1); sconti.zero(); sconti.put("TIPO", "I"); if(ditta.get_bool("SCOKEY", "ve", 1)) sconti.put("CODCAT", ven_rec.get(CFV_CATVEN)); if(ditta.get_bool("SCOKEY", "ve", 2)) cod.format("%-2s", (const char *)ven_rec.get(CFV_CODSCC)); else cod = " "; if( ditta.get_bool("SCOKEY", "ve", 3)) { TString8 cz; cz.format("%-2s", (const char*)ven_rec.get(CFV_CODZONA)); cod << cz; } else cod << " "; if( ditta.get_bool("SCOKEY", "ve", 4)) cod << c.get(CLI_CODPAG); sconti.put("CODART", cod); if(sconti.read() == NOERR) set(F_SCONTOPERC, sconti.get( "SCONTO")); } break; default: break; } return; } void TDocumento_mask::spese2mask() { TSheet_field & sh = (TSheet_field &) field(F_SHEET); TCli_for & c = doc().clifor(); TString16 name("CODSP0"); TString_array spese; TRectype & ven_rec = c.vendite(); for (int i = 1; i <= 4; i++) { name.rtrim(1); name << i; const TString16 s(ven_rec.get(name)); if (s.not_empty()) spese.add(s); } // autosave(*_rel); doc().put("SPESEUPD", FALSE); doc().put(DOC_CODVAL, get(F_CODVAL)); doc().put(DOC_CAMBIO, get(F_CAMBIO)); doc().put(DOC_CONTROEURO, get(F_CONTROEURO)); doc().update_spese_aut(spese, FALSE, &sh); sh.force_update(); } void TDocumento_mask::reset_masks(const TString& tipo_doc) { static TString16 last_tipo_doc; if (tipo_doc != last_tipo_doc) { FOR_EACH_ASSOC_OBJECT(_maskriga, h, k, o) { TMask* m = (TMask*)o; m->enable_default(); if (!_sheet->exist_column(FR_PREZZO)) m->hide(FR_PREZZO); } last_tipo_doc = tipo_doc; } } void TDocumento_mask::doc2mask(bool reload_clifo) { for (int p = id2pos(BASE_PIEDE + 1)-1; p >= 0; p--) { TMask_field& f = fld(p); const TFieldref* fr = f.field(); if (fr) f.set(fr->read(doc())); } if (reload_clifo) cli2mask(); TSheet_field& s = sfield(F_SHEET); s.destroy( ); const int righe = doc().physical_rows(); for (int i = 0; i < righe; i++) { s.insert(-1, FALSE); TToken_string& r = s.row(i); doc()[i+1].autoload(s); s.check_row(i, 0x2); } reset_masks(get(F_TIPODOC)); s.force_update(); } void TDocumento_mask::mask2doc() { for (int p = fields()-1; p >= 0; p--) { TMask_field& f = fld(p); const TFieldref* fr = f.field(); if (fr) fr->write(f.get(), doc()); } } TVariable_mask* TDocumento_mask::riga_mask(int numriga) { const TRiga_documento& riga = doc()[numriga + 1]; const TTipo_riga_documento& tiporiga = riga.tipo(); TString16 name; tiporiga.mask_name(name); TVariable_mask* m = (TVariable_mask*)_maskriga.objptr(name); if (m == NULL) { m = new TVariable_mask(name); _maskriga.add(name, m); TFilename proname; tiporiga.profile_name(proname); TConfig pro( proname, "HANDLERS" ); const int numhandler = pro.get_int( "NHANDLER", "HANDLERS" ); for(int i = 1; i <= numhandler; i++) { TString8 chiave; chiave.format("%d", i ); TToken_string riga = pro.get( chiave, "HANDLERS" ); row_set_handler( *m, riga.get_int( 0 ), riga.get_int( 1 ) ); } m->set_handler( FR_QTA, qta_handler ); m->set_handler( FR_UMQTA, um_handler ); const int pos = m->id2pos(FR_CODART); if (pos >= 0) { const TMask_field & f = m->field(FR_CODART); if (f.is_edit()) { TBrowse * browse = ((TEdit_field &) f).browse(); const char tipo_r = tiporiga.tipo(); if (browse ) { const TCursor * cur = browse->cursor(); if (cur) { const int num = cur->file().num(); if (num == LF_ANAMAG || num == LF_CODCORR) { m->set_handler( FR_CODMAG, codmag_handler ); m->set_handler( FR_CODMAGC, codmag_coll_handler ); m->set_handler( FR_CODART, codart_handler ); m->set_handler( FR_LIV1, liv_handler ); m->set_handler( FR_LIV2, liv_handler ); m->set_handler( FR_LIV3, liv_handler ); m->set_handler( FR_LIV4, liv_handler ); m->set_handler( FR_UMQTA, umart_handler ); m->set_handler( FR_CODARTMAG, codartmag_handler ); m->set_handler( FR_DESCR, descr_handler ); m->set_handler( FR_QTA, qtaart_handler ); if (livelli().autoinsert(1)) m->field(FR_LIV1).check_type(CHECK_NONE); if (livelli().autoinsert(2)) m->field(FR_LIV2).check_type(CHECK_NONE); if (livelli().autoinsert(3)) m->field(FR_LIV3).check_type(CHECK_NONE); if (livelli().autoinsert(4)) m->field(FR_LIV4).check_type(CHECK_NONE); } else if (tipo_r == RIGA_SPESEDOC || tipo_r == RIGA_PRESTAZIONI) m->set_handler( FR_CODART, sppr_handler ); } } } } m->set_handler(FR_QTAEVASA, qta_evasa_handler); m->set_handler(FR_CAUS, causmag_handler); if (m->id2pos(FR_CODIVA) >= 0) { m->set_handler(FR_CODIVA, iva_handler); const TString& tipiva = doc().tipo().tipi_iva_validi(); if (tipiva.not_empty()) { TBrowse& browse = *(m->efield(FR_CODIVA)).browse(); TString filter = browse.get_filter(); bool close_filter = FALSE; if (filter.not_empty()) { filter.insert("("); filter << ")&&("; close_filter = TRUE; } bool firstor = TRUE; for (int i = tipiva.len()-1; i >= 0; i--) if (tipiva[i] != ' ') { if (firstor) firstor = FALSE; else filter << "||"; filter << "(S1==\""; switch(i) { case 1: filter << "VE"; break; case 2: filter << "ES"; break; case 3: filter << "NI"; break; case 4: filter << "NS"; break; default: break; } filter << "\")"; } if (close_filter) filter << ')'; browse.set_filter(filter); } m->set_handler(DLG_USER, link_handler); } } m->set_sheet((TSheet_field *)&(field(F_SHEET))); int pos = m->id2pos(FR_PREZZO); if (pos >= 0) { TEditable_field & f =((TEditable_field &) m->fld(pos)); f.reset_driver(F_CODVAL); f.add_driver(-F_CODVAL); } pos = m->id2pos(FR_IMPFISSO); if (pos >= 0) { TEditable_field & f =((TEditable_field &) m->fld(pos)); f.reset_driver(); f.add_driver(-F_CODVAL); } return m; } void TDocumento_mask::update_giacenza() { if (id2pos(F_CURGIAC)<0) return; TSheet_field& sf = sfield(F_SHEET); TToken_string& row = sf.row(sf.selected()); const TString codart = row.get(sf.cid2index(FR_CODARTMAG)); real giac, disp; if (!codart.blank()) { TString16 codmag = row.get(sf.cid2index(FR_CODMAG)); const TString16 coddep = row.get(sf.cid2index(FR_CODDEP)); if (!coddep.blank()) codmag << coddep; TString16 livello; for (int i = 0; i < 4; i++) { const char* liv = row.get(sf.cid2index(FR_LIV1+i)); if (*liv > ' ') livello << liv; else break; } const TString8 annoes = get(F_ANNO); TArticolo_giacenza art(codart); giac = art.disponibilita(annoes, codmag, livello, TRUE); disp = art.disponibilita(annoes, codmag, livello, FALSE); TLocalisamfile umart(LF_UMART); umart.setkey(2); umart.put(UMART_CODART, codart); umart.put(UMART_UM, row.get(sf.cid2index(FR_UMQTA))); if (umart.read() == NOERR) { real curr_fc = umart.get_real(UMART_FC); if (curr_fc > ZERO) { giac /= curr_fc; disp /= curr_fc; } } } set(F_CURGIAC, giac.string()); set(F_CURDISP, disp.string()); } /////////////////////////////////////////////////////////// // Handlers and notifiers /////////////////////////////////////////////////////////// bool TDocumento_mask::ss_handler(TMask_field& f, KEY key) { bool ok = TRUE; if (key == K_ENTER && f.mask().insert_mode()) { TSheet_field& ss = (TSheet_field&)f; if (!app().is_transaction() && ss.items() == 0) ok = yesno_box("Il documento e' privo di righe:\n" "Si desidera continuare ugualmente?"); } return ok; } bool TDocumento_mask::ss_notify( TSheet_field& ss, int r, KEY key ) { TDocumento_mask& m = (TDocumento_mask&)ss.mask(); TDocumento& doc = m.doc(); if ( key == K_ENTER ) // modifica { TRiga_documento & riga = doc[r + 1]; riga.autosave(ss); } else if ( key == K_DEL ) // Cancellazione { doc.destroy_row(r + 1, TRUE); if (r < doc.rows()) { TRiga_documento & riga = doc[r + 1]; if (riga.is_omaggio() && riga.is_generata()) { ss.destroy(r + 1); doc.destroy_row(r + 1, TRUE); } } } else if (key == K_INS) // Inserimento { if (r < doc.rows()) { TRiga_documento & riga = doc[r + 1]; if (riga.is_omaggio() && riga.is_generata()) return FALSE; } doc.insert_row(r + 1, m.get( F_LBTIPORIGA )); } else if (key == K_CTRL + K_INS) { TRiga_documento & riga = doc[r + 1]; TRectype & ven_rec = doc.clifor().vendite(); TString16 s(ven_rec.get(CFV_CODMAG)); if (s.not_empty()) { s.left_just(3); s << ven_rec.get(CFV_CODDEP); } else { s = m.get(F_CAUSMAG); if (!s.blank()) { const TRectype & c=cache().get("%CAU", s); if (!c.empty() && !c.get("S10").blank()) s = c.get("S10"); else { s = m._std_mag; s.left_just(3); s << m._std_dep; } } } riga.put("CODMAG", s); riga.autoload(ss); ss.check_row(r); // ss.select(r, 1); // Ma serve a qualcosa? } else if ( key == K_TAB ) // ingresso nella riga { TMask & sm = ss.sheet_mask(); set_curr_um(sm); m.update_giacenza(); const bool on = doc[r + 1].get(RDOC_DACODNUM).not_empty(); sm.enable(DLG_USER, on); } return TRUE; } // Funzione che dato il profilo di riga ottiene la maschera // Serve per ottenere una maschera diversa per ogni riga TMask* TDocumento_mask::ss_getmask(int numriga, TMask& fullmask) { TSheet_field* sf = fullmask.get_sheet(); TDocumento_mask& m = (TDocumento_mask&)sf->mask(); const TDocumento& doc = m.doc(); if (numriga < doc.physical_rows()) return m.riga_mask(numriga); else return &fullmask; } bool TDocumento_mask::occas_code_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.focusdirty()) { const char* code = f.get(); if (*code) { TRelation occas(LF_OCCAS); occas.lfile().put("CFPI", code); if (occas.read(_isequal) == NOERR) { TMask& m = f.mask(); m.autoload(occas); m.send_key(K_TAB, O_COMUNE); // Forza decodifica comuni m.send_key(K_TAB, O_COMUNENAS); } } } return TRUE; } bool TDocumento_mask::occas_handler( TMask_field& f, KEY key ) { TDocumento_mask & m = (TDocumento_mask &)f.mask(); if ( key == K_SPACE && m.is_running( ) ) { TDocumento& doc = m.doc(); TOccasionale& occ = doc.occas(); TMask occas_mask("ve0100o"); occas_mask.set_handler( O_CODICE, occas_code_handler ); for (int i = occas_mask.fields() - 1; i >= 0; i--) { TMask_field & f = occas_mask.fld(i); const TFieldref * c = f.field(); if (c) f.set(c->read(occ)); } if (occas_mask.run() != K_ESC) { const TString ocfpi(occas_mask.get(O_CODICE)); doc.put("OCFPI", ocfpi); m.set(F_OCFPI, ocfpi); for (int i = occas_mask.fields() - 1; i >= 0; i--) { const TMask_field& f = occas_mask.fld(i); const TFieldref* c = f.field(); if (c) { const char* val = f.get(); c->write(val, occ); } } m.occ2mask(); } f.set_focus( ); } return TRUE; } bool TDocumento_mask::clifo_handler( TMask_field& f, KEY key ) { if (key != K_ENTER && f.to_check(key, TRUE)) { TDocumento_mask & m = (TDocumento_mask &) f.mask(); TDocumento & d = m.doc(); const TString & val = f.get(); TTipo_documento& tdoc = (TTipo_documento&) d.tipo(); d.put("TIPOCF", tdoc.tipocf()); d.put("CODCF", atol(val)); TCli_for & cli_for = d.clifor(); cli_for.put(CLI_CODCF, ""); // force reload if ( cli_for.get_bool("SOSPESO") ) return f.error_box( "Il codice '%ld' e' sospeso e non puo' essere utilizzato", atol(val) ); m.cli2mask(); if (cli_for.occasionale()) { TOccasionale & occas = d.occas(); if(m.id2pos(F_OCCASEDIT) > 0 && f.to_check(key) && *(occas.codice()) == '\0') m.send_key( K_SPACE, F_OCCASEDIT ); // Lancia maschera occasionali } else d.zero("OCFPI"); } return TRUE; } void TDocumento_mask::highlight(COLOR high_back_color, COLOR high_color) { TSheet_field & sf = sfield(F_SHEET); const int items = sf.items(); for (int i = 0 ; i < items; i++) { const bool on = doc()[i + 1].linked(); COLOR back = on ? high_back_color : NORMAL_BACK_COLOR; COLOR fore = on ? high_color : NORMAL_COLOR; sf.set_back_and_fore_color(back, fore, i); sf.force_update(i); } } /////////////////////////////////////////////////////////// // TLista_elaborazioni /////////////////////////////////////////////////////////// void TLista_elaborazioni::read() { if (_elab == NULL) { _elab = new TAssoc_array(); TTable eld("%ELD"); for (int err = eld.first(); err == NOERR; err = eld.next()) { TElaborazione * el = NULL; switch (eld.curr().get_int("I0")) { case _esterna : el = new TElaborazione_esterna(eld.curr()); break; case _consegna_ordini: el = new TConsegna_ordini(eld.curr()); break; case _fatturazione_bolle : el = new TFatturazione_bolle(eld.curr()); break; case _contabilizzazione : el = new TContabilizzazione(eld.curr()); break; case _copia_documento : el = new TCopia_documento(eld.curr()); break; case _generazione_effetti : el = new TGenerazione_effetti(eld.curr()); break; default : break; } _elab->add(el->codice(), el); } } } int TLista_elaborazioni::select(TString_array & result, const char * tipo_iniziale, const char * stato_iniziale, const char * tipo_finale, const char * stato_finale) { read(); _elab->restart(); result.destroy(); for (TElaborazione * el = (TElaborazione *)_elab->get(); el ; el = (TElaborazione *) _elab->get()) { bool ok = FALSE; TString ti; if ((tipo_iniziale && *tipo_iniziale) && (stato_iniziale && *stato_iniziale)) for (int i = 0; !ok && i < TElaborazione::_max_tipi_doc_elab; i++) { ti = el->tipo_iniziale(i); const char si = el->stato_iniziale(i); ok |= ti == tipo_iniziale && si == *stato_iniziale; } else ok = TRUE; if ((tipo_finale && *tipo_finale) && (stato_finale && *stato_finale)) ok &= el->tipo_finale() == tipo_finale && el->stato_finale() == stato_finale; if (ok) result.add(el->codice()); } return result.items(); } TElaborazione & TLista_elaborazioni::operator [](const char * key) const { ((TLista_elaborazioni *)this)->read(); return (TElaborazione &) (*_elab)[key]; } void TLista_elaborazioni::update() { delete _elab; _elab = NULL; read(); } TLista_elaborazioni::~TLista_elaborazioni() { if (_elab) delete _elab; } /////////////////////////////////////////////////////////// // TDocument_tree /////////////////////////////////////////////////////////// class TDocument_tree : public TBidirectional_tree { TRelation* _relation; TCursor* _cursor; TToken_string _curnode; protected: virtual void node2id(const TObject* node, TString& id) const; bool on_head() const; bool on_row() const; void format_field(const TRectype& rec, const TString& field, TString& str) const; void append_custom_fields(const TTipo_documento& tipo, const TRectype& rec, TString& str) const; public: virtual bool goto_root(); virtual bool goto_firstson(); virtual bool goto_rbrother(); virtual bool goto_node(const TString &id); virtual bool has_son() const; virtual bool has_rbrother() const; virtual bool has_father() const; virtual bool has_lbrother() const; virtual bool goto_father(); virtual bool goto_lbrother(); virtual TObject* curr_node() const { return &(TToken_string&)_curnode; } virtual bool get_description(TString& str) const; virtual TImage* image(bool selected) const; const TRectype& testata() const; const TRectype& riga() const; const TRectype& record() const; void set_cursor(char tipocf, long codcf, int anno, const char* filter, FILTERFUNCTION ff = NULL); TCursor* get_cursor() { return _cursor; } TDocument_tree(); ~TDocument_tree(); }; const TRectype& TDocument_tree::testata() const { TDocument_tree& me = (TDocument_tree&)*this; const TRecnotype pos = me._curnode.get_long(0); if (_cursor->pos() != pos || _relation->curr(LF_RIGHEDOC).empty()) *me._cursor = pos; return _relation->curr(); } const TRectype& TDocument_tree::riga() const { TDocument_tree& me = (TDocument_tree&)*this; const TRectype& rec = _relation->curr(LF_RIGHEDOC); const TRecnotype pos = me._curnode.get_long(0); const int nriga = me._curnode.get_int(1); if (_cursor->pos() != pos || rec.get_int(RDOC_NRIGA) > nriga) *me._cursor = pos; for (int i = rec.get_int(RDOC_NRIGA); i < nriga; i++) _relation->next_match(LF_RIGHEDOC); return rec; } const TRectype& TDocument_tree::record() const { return on_row() ? riga() : testata(); } void TDocument_tree::node2id(const TObject* node, TString& id) const { id = *(TString*)node; } bool TDocument_tree::on_head() const { TDocument_tree& me = (TDocument_tree&)*this; return me._curnode.get_int(1) == 0; } bool TDocument_tree::on_row() const { TDocument_tree& me = (TDocument_tree&)*this; return me._curnode.get_int(1) > 0; } bool TDocument_tree::goto_root() { const bool ok = _cursor != NULL && _cursor->items()>0; _curnode = ok ? "0" : ""; *_cursor = 0; return ok; } bool TDocument_tree::goto_firstson() { bool ok = has_son(); if (ok) _curnode.add(1,1); return ok; } bool TDocument_tree::goto_rbrother() { bool ok = has_rbrother(); if (ok) { if (on_head()) { const long pos = _curnode.get_long(0); _curnode.add(pos+1, 0); } else { const int nriga = _curnode.get_int(1); _curnode.add(nriga+1, 1); } } return ok; } bool TDocument_tree::goto_node(const TString &id) { _curnode = id; return TRUE; } bool TDocument_tree::has_son() const { bool ok = on_head(); if (ok) { testata(); const TRectype& rec = _relation->curr(LF_RIGHEDOC); ok = rec.get_int(RDOC_NRIGA) > 0; } return ok; } bool TDocument_tree::has_rbrother() const { bool ok = FALSE; if (on_head()) { TDocument_tree& me = (TDocument_tree&)*this; const long pos = me._curnode.get_long(0); ok = pos < _cursor->items()-1; } else { riga(); // Posizionati sulla riga corrente ok = _relation->next_match(LF_RIGHEDOC); } return ok; } bool TDocument_tree::has_father() const { return on_row(); } bool TDocument_tree::has_lbrother() const { bool ok = FALSE; TDocument_tree& me = (TDocument_tree&)*this; if (on_head()) { const long pos = me._curnode.get_long(0); ok = pos > 0L; } else { const int nriga = me._curnode.get_int(1); ok = nriga > 1; } return ok; } bool TDocument_tree::goto_father() { bool ok = on_row(); if (ok) _curnode.add(0, 1); return ok; } bool TDocument_tree::goto_lbrother() { bool ok = has_lbrother(); if (ok) { if (on_head()) { const long pos = _curnode.get_long(0); _curnode.add(pos-1, 0); } else { const int nriga = _curnode.get_int(1); _curnode.add(nriga-1, 1); } } return ok; } void TDocument_tree::format_field(const TRectype& rec, const TString& field, TString& str) const { const TFieldref fld(field, rec.num()); const TString& value = fld.read(rec); const TFieldtypes ft = rec.type(fld.name()); if (ft == _realfld) { const int len = rec.length(fld.name()); const int ndec = rec.ndec(fld.name()); TString8 pic; pic.format(".%d", ndec); const real r = value; str = r.string(pic); str.right_just(len); } else str = value; } void TDocument_tree::append_custom_fields(const TTipo_documento& tipo, const TRectype& rec, TString& str) const { const TString& format = rec.num() == LF_DOC ? tipo.stringa_descrizione_documento() : tipo.stringa_descrizione_riga(); if (format.not_empty()) { str << ' '; int ch = -1; TString tmp; for (int ap = format.find('{'); ap >= 0; ap = format.find('{', ch+1)) { str << format.sub(ch+1, ap); ch = format.find('}', ap); const TString16 field = format.sub(ap+1, ch); format_field(rec, field, tmp); str << tmp; } str << format.mid(ch+1); } } TImage* TDocument_tree::image(bool selected) const { if (on_row()) { const TRectype& rec = riga(); if (rec.get_bool(RDOC_RIGAEVASA)) return get_res_image(BMP_STOP); } return TTree::image(selected); } bool TDocument_tree::get_description(TString& str) const { if (on_head()) { const TRectype& rec = testata(); str = rec.get(DOC_ANNO); str << ' ' << rec.get(DOC_CODNUM); TString16 tmp; tmp.format("%6ld", rec.get_long(DOC_NDOC)); str << ' ' << tmp << ' ' << rec.get(DOC_DATADOC); const char tipocf = rec.get_char(DOC_TIPOCF); const long codcf = rec.get_long(DOC_CODCF); tmp.format(" %c%6ld ", tipocf, codcf); str << tmp; tmp.format("%c|%6ld", tipocf, codcf); str << cache().get(LF_CLIFO, tmp, CLI_RAGSOC); str.left_just(63); const TString& tipodoc = rec.get(DOC_TIPODOC); const TTipo_documento& tipo = TDocumento::tipo(tipodoc); append_custom_fields(tipo, rec, str); } else { const TRectype& rec = riga(); const TRectype& testata = _relation->curr(); const TString80 codart = rec.get(RDOC_CODART); str = codart; str.left_just(21); str << rec.get(RDOC_DESCR).left(30); str.left_just(52); const TString& tipodoc = testata.get(DOC_TIPODOC); const TTipo_documento& tipo = TDocumento::tipo(tipodoc); if (codart.not_empty()) { const real qta = rec.get(tipo.field_qta()); str << qta.string("###.###.##@,@@@"); if (tipo.is_ordine()) { const real qta_evasa = rec.get(tipo.field_qtaevasa()); const real residuo = qta_evasa < qta ? (qta-qta_evasa) : ZERO; str << residuo.string("###.###.##@,@@@"); } append_custom_fields(tipo, rec, str); } } return TRUE; } void TDocument_tree::set_cursor(char tipocf, long codcf, int anno, const char* filter, FILTERFUNCTION ff) { if (_relation == NULL) { _relation = new TRelation(LF_DOC); _relation->add(LF_RIGHEDOC, "PROVV==PROVV|ANNO==ANNO|CODNUM==CODNUM|NDOC==NDOC"); } if (_cursor == NULL) { _cursor = new TCursor(_relation, "", 2); } TRectype& rec = _relation->curr(); rec.zero(); rec.put(DOC_TIPOCF, tipocf); rec.put(DOC_CODCF, codcf); rec.put(DOC_PROVV, "D"); rec.put(DOC_ANNO, anno); _cursor->freeze(FALSE); _cursor->setfilter(""); // Force cursor rebuild _cursor->setfilter(filter); _cursor->setregion(rec, rec); const long items = _cursor->items(); _cursor->freeze(TRUE); goto_root(); if (items <= 3) expand_all(); } TDocument_tree::TDocument_tree() : _relation(NULL), _cursor(NULL) { } TDocument_tree::~TDocument_tree() { if (_cursor) delete _cursor; if (_relation) delete _relation; } /////////////////////////////////////////////////////////// // TElabora_mask /////////////////////////////////////////////////////////// class TElabora_mask : public TAutomask { TDocumento_mask* _main; TLista_elaborazioni _elab; TDocument_tree _tree; TElaborazione* _last_elab; // @access Protected Member protected: TString _art_filter, _liv_filter; static TElabora_mask* _myself; static bool article_filter(const TRelation* rel); void add_valuta_filter(TString& filter) const; void docrif_search(); int update_list(); void update_ndoc_filter(bool is_tipo_elaborazione = FALSE); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); // @access Public Member public: bool elabora(); TElaborazione* curr_elab(); // @cmember Costruttore (crea la maschera leggendo la descrizione dal file .msk) TElabora_mask(TDocumento_mask& main_mask); // @cmember Distruttore virtual ~TElabora_mask() {} }; TElabora_mask* TElabora_mask::_myself = NULL; bool TElabora_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) { switch (o.dlg()) { case F_CODART: case F_CODNUM_ELAB: if (e == fe_modify) update_ndoc_filter(); break; case F_TYPE: if (e == fe_init || e == fe_modify) { int ne = update_list(); if (e == fe_init && ne == 0) // Riprova a cambiare flag e ricostruire la lista { set(F_TYPE, "X"); ne = update_list(); if (ne == 0) set(F_TYPE, ""); } update_ndoc_filter(TRUE); const bool is_search = o.get().empty() || field(F_CODCF_ELAB).empty(); o.mask().field(F_NDOC_ELAB).check_type(is_search ? CHECK_SEARCH : CHECK_REQUIRED); } break; case F_STATODOC_ELAB: case F_TIPODOC_ELAB: if (e == fe_modify) { update_list(); update_ndoc_filter(); } break; case F_ELAB: if (e == fe_modify) update_ndoc_filter(TRUE); break; case F_ANNO_ELAB: if (e == fe_modify) update_ndoc_filter(); break; case F_NUMDOCRIF_ELAB: if (e == fe_button) docrif_search(); break; case F_NDOC_ELAB: if ((e == fe_modify || e == fe_close) && o.check_type() == CHECK_SEARCH && !o.empty()) { /* Metodo inaffidabile in assenza di codice clifo o.check_type(CHECK_REQUIRED); const bool ok = o.on_key (K_ENTER); o.check_type(CHECK_SEARCH); return ok; */ TToken_string key; key.add("D"); key.add(get(F_ANNO_ELAB)); key.add(get(F_CODNUM_ELAB)); key.add(o.get()); const TRectype& rec = cache().get(LF_DOC, key); bool ok = !rec.empty(); // Verifica esistenza documento if (ok) { TCursor* c = _tree.get_cursor(); c->curr() = rec; ok = c->test(_isequal) == NOERR; // Verifica compatibilità documento } if (!ok) return error_box(((TEdit_field&)o).get_warning()); } break; case F_ROWS: if (e == fe_modify && is_running()) { TCursor* c = _tree.get_cursor(); if (c != NULL && c->items() > 0) { const TRectype& head = _tree.testata(); set(F_DATADOC_ELAB, head.get(DOC_DATADOC)); // Anch'essa nella chiave 2! set(F_ANNO_ELAB, head.get(DOC_ANNO)); set(F_CODNUM_ELAB, head.get(DOC_CODNUM)); field(F_CODNUM_ELAB).check(); set(F_NDOC_ELAB, head.get(DOC_NDOC)); } } break; default: break; } return TRUE; } int TElabora_mask::update_list() { TString_array elabs; const TString16 tipo(_main->get(F_TIPODOC)); const TString16 stato(_main->get(F_STATO)); const TString16 tipo_elab(get(F_TIPODOC_ELAB)); const TString16 stato_elab(get(F_STATODOC_ELAB)); const bool from_elab = !get_bool(F_TYPE); int items = 0; bool agg_test = FALSE; if (from_elab) items = _elab.select(elabs, tipo, stato,"",""/*tipo_elab, stato_elab*/) ; else { items = _elab.select(elabs, tipo_elab, stato_elab, tipo, stato); agg_test = _main->sfield(F_SHEET).items() == 0; } set(F_UPDATE_HEADER, agg_test ? "X" : ""); const bool ok = items > 0; enable(DLG_OK, ok); enable(F_ELAB, ok); TList_field & f = (TList_field &) field(F_ELAB); TToken_string codes; TToken_string descrs; for (int i = 0; i < items; i++) { const TElaborazione& e = _elab[elabs.row(i)]; codes.add(e.codice()); descrs.add(e.descrizione()); } if (codes != f.get_codes()) f.replace_items(codes, descrs); const TElaborazione * e = curr_elab(); if (e && e->tipo() == _consegna_ordini) show(-GRP_ART); else { reset(-GRP_ART); hide(-GRP_ART); } return items; } bool TElabora_mask::elabora() { bool update_mask = FALSE; TLista_documenti in; TLista_documenti out; TDocumento& app_doc = ((TDocumento_mask *)_main)->doc(); const long numdoc = field(F_NDOC_ELAB).active() ? get_long(F_NDOC_ELAB) : app_doc.get_long(DOC_NDOC); const bool update_header = get_bool(F_UPDATE_HEADER); TDocumento* newdoc = new TDocumento(get(F_PROVV_ELAB)[0], get_int(F_ANNO_ELAB), get(F_CODNUM_ELAB), numdoc); TDocumento& d = *newdoc; if (numdoc <= 0) { TDocumento::copy_data(d.head(), app_doc.head()); d.put(DOC_TIPODOC, get(F_TIPODOC_ELAB)); d.put(DOC_STATO, get(F_STATODOC_ELAB)); const TDate datadoc = d.get_date(DOC_DATADOC); const TDate datainsc = d.get_date(DOC_DATAINSC); const bool equal = !datainsc.ok() || datadoc == datainsc; d.put(DOC_DATADOC, get(F_DATADOC_ELAB)); if (equal) d.zero(DOC_DATAINSC); const TTipo_documento & t = d.tipo(); if (t.mov_mag()) d.put(DOC_CAUSMAG, t.caus_mov()); else d.zero(DOC_CAUSMAG); } if (update_header) { const TString16 tipo_doc(app_doc.get(DOC_TIPODOC)); const TString16 caus_mag(app_doc.get(DOC_CAUSMAG)); const long movmag = app_doc.get_long(DOC_MOVMAG); const TDate datadoc = app_doc.get_date(DOC_DATADOC); const TDate datainsc = app_doc.get_date(DOC_DATAINSC); const char stato = app_doc.stato(); TDocumento::copy_data(app_doc.head(), d.head()); app_doc.put(DOC_TIPODOC, tipo_doc); app_doc.put(DOC_CAUSMAG, caus_mag); app_doc.put(DOC_MOVMAG, movmag); app_doc.put(DOC_DATADOC, datadoc); app_doc.put(DOC_DATAINSC, datainsc); app_doc.put(DOC_STATO, stato); } const bool from_elab = !get_bool(F_TYPE); TElaborazione * e = curr_elab(); if (e == NULL) return FALSE; if (e->tipo() == _consegna_ordini) { TParametri_elaborazione& p = e->params(); p.set("ARTICOLO", get(F_CODART)); p.set("UM", get(F_UMQTA)); p.set("QUANTITA", get(F_QTA)); } if (from_elab) { in.add(app_doc); out.add(d); if (e->elabora(in, out, TDate(TODAY), TRUE)) { if (out[0] != d) out.rewrite(); if (app_doc != in[0]) { in.rewrite(); app_doc = in[0]; update_mask = TRUE; } } } else { out.add(app_doc); in.add(d); if (e->elabora(in, out, TDate(TODAY), TRUE)) { if (out[0] != app_doc) { out.rewrite(); app_doc = out[0]; update_mask = TRUE; } if (d != in[0]) in.rewrite(); } const TString8 num_in = e->codice_numerazione_iniziale(); set(F_CODNUM_ELAB, num_in); set(F_NDOC_ELAB, ""); set(F_NUMDOCRIF_ELAB, ""); } if (e->tipo() == _consegna_ordini) { TParametri_elaborazione& p = e->params(); if (p.get("ARTICOLO").not_empty()) { real qta = get_real(F_QTA); if (qta > ZERO) { const real qta_evasa = p.get_real("QUANTITA"); qta -= qta_evasa; set(F_QTA, qta); } } } delete newdoc; // Azzera l'anno in caso di ordini if (in.items() > 0 && in[0].is_ordine()) { reset(F_ANNO_ELAB); update_mask = TRUE; } if (update_mask) update_ndoc_filter(); return update_mask; } TElaborazione * TElabora_mask::curr_elab() { const TString16 cod_elab(get(F_ELAB)); return cod_elab.not_empty() ? &_elab[cod_elab] : NULL; } bool TElabora_mask::article_filter(const TRelation* rel) { bool yes = FALSE; TElabora_mask& m = *_myself; TLocalisamfile rdoc(LF_RIGHEDOC); rdoc.put(RDOC_CODNUM, rel->curr().get(DOC_CODNUM)); rdoc.put(RDOC_ANNO, rel->curr().get(DOC_ANNO)); rdoc.put(RDOC_PROVV, rel->curr().get(DOC_PROVV)); rdoc.put(RDOC_NDOC, rel->curr().get(DOC_NDOC)); rdoc.put(RDOC_NRIGA, 1); int next_riga = 1; for (int err = rdoc.read(); err == NOERR; err = rdoc.next()) { const int nriga = rdoc.get_int(RDOC_NRIGA); if (nriga != next_riga) break; next_riga++; const bool evasa= rdoc.get_bool(RDOC_RIGAEVASA); const TString& codart = rdoc.get(RDOC_CODART); if (!evasa && codart == m._art_filter) { yes = TRUE; break; } } return yes; } void TElabora_mask::add_valuta_filter(TString& filter) const { TString16 valuta = get(F_CODVAL_ELAB); if (::is_firm_value(valuta)) { filter << "((CODVAL==\"" << valuta << "\")"; if (valuta.empty()) valuta = TCurrency::get_firm_val(); else valuta.cut(0); filter << "||(CODVAL==\"" << valuta << "\"))"; } else filter << "(CODVAL==\"" << valuta << "\")"; } void TElabora_mask::update_ndoc_filter(bool is_tipo_elaborazione) { TString filter; add_valuta_filter(filter); TElaborazione * e = curr_elab(); const bool elab_changed = e != _last_elab; _last_elab = e; const bool aggiungi_doc_att = get_bool(F_TYPE); enable(-1, aggiungi_doc_att); if (!aggiungi_doc_att && is_tipo_elaborazione ) reset(-1); const bool enable_group_doc = e != NULL && e->tipo() != _generazione_effetti && e->tipo() != _contabilizzazione; show(-GRP_DOC, enable_group_doc); if (e != NULL) { if (aggiungi_doc_att) { const TString8 num_in = e->codice_numerazione_iniziale(); if (elab_changed) { const TString16 tipo_in(e->tipo_iniziale(0)); const char stato_in = e->stato_iniziale(0); set(F_CODNUM_ELAB, num_in); field(F_CODNUM_ELAB).check(); set(F_TIPODOC_ELAB , tipo_in); field(F_TIPODOC_ELAB).check(); TString8 si; si << stato_in; set(F_STATODOC_ELAB, si); field(F_STATODOC_ELAB).check(); // Azzero anno di elaaborazione quando ho a che fare con degli ordini const TTipo_documento& tipodocin = _main->doc().tipo(tipo_in); if (tipodocin.is_ordine()) reset(F_ANNO_ELAB); } if (!field(F_TIPODOC_ELAB).empty()) { const TString16 tipo(get(F_TIPODOC_ELAB)); TString80 td; td.format("&&(TIPODOC==\"%s\")", (const char *)tipo); filter << td; const TString& stato = get(F_STATODOC_ELAB); if (stato.not_empty()) { filter << "&&(STATO==\"" << stato << "\")"; } else { bool almost_one = FALSE; for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++) { const TString16 tipo_in(e->tipo_iniziale(i)); const char stato_in = e->stato_iniziale(i); if (tipo == tipo_in && stato_in > '0') { if (almost_one) filter << "||"; else filter << "&&("; almost_one = TRUE; filter << "(STATO==\"" << stato_in << "\")"; } } if (almost_one) filter << ')'; } } else { bool almost_one = FALSE; for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++) { const TString16 tipo_in(e->tipo_iniziale(i)); if (tipo_in.not_empty()) { if (almost_one) filter << "||"; else filter << "&&("; almost_one = TRUE; filter << "((TIPODOC==\"" << tipo_in << "\")"; const char stato_in[2] = { e->stato_iniziale(i), '\0' }; if (stato_in[0] > '0') filter << "&&(STATO==\"" << stato_in << "\")"; filter << ')'; } } if (almost_one) filter << ')'; } } else { const TString4 tipo_fin(e->tipo_finale()); const TString4 stato_fin(e->stato_finale()); filter << "&&"; if (stato_fin != "0") filter << '('; filter << "(TIPODOC==\"" << tipo_fin << "\")"; if (stato_fin != "0") filter << "&&(STATO==\"" << stato_fin << "\"))"; if (is_tipo_elaborazione) { const TString16 num_fin(e->codice_numerazione_finale()); set(F_CODNUM_ELAB, num_fin); field(F_CODNUM_ELAB).check(); set(F_TIPODOC_ELAB, tipo_fin); field(F_TIPODOC_ELAB).check(); set(F_STATODOC_ELAB, stato_fin); field(F_STATODOC_ELAB).check(); } } } if (!field(F_CODNUM_ELAB).empty()) { TString80 cn; cn.format("&&(CODNUM==\"%s\")", (const char*)get(F_CODNUM_ELAB)); filter << cn; } TBrowse& brew = *efield(F_NDOC_ELAB).browse(); brew.set_filter(filter); _art_filter = get(F_CODART); TCursor* cursor = brew.cursor(); if (_art_filter.not_empty() && aggiungi_doc_att) cursor->set_filterfunction(article_filter); else cursor->set_filterfunction(NULL); TTree_field& tf = tfield(F_ROWS); if (!field(F_TIPODOC_ELAB).empty() && e != NULL) { tf.set_tree(&_tree); TToken_string header(256, '\n'); header.add("Anno Num. N. Data Cli/For Ragione Sociale"); header.add(" Codice Articolo Descrizione Riga "); if (aggiungi_doc_att && e->tipo() == _consegna_ordini) header << "Da Evadere Residuo"; else header << " Quantità"; tf.set_header(header); if (aggiungi_doc_att && _art_filter.not_empty()) _tree.set_cursor(get(F_TIPOCF_ELAB)[0], get_long(F_CODCF_ELAB), get_int(F_ANNO_ELAB), filter, article_filter); else _tree.set_cursor(get(F_TIPOCF_ELAB)[0], get_long(F_CODCF_ELAB), get_int(F_ANNO_ELAB), filter); if (aggiungi_doc_att) // GF20059 { TCursor& cur = *_tree.get_cursor(); if (cur.items() == 1) // Propone l'unico documento possibile { cur = 0L; const TRectype& curr = cur.curr(); set(F_ANNO_ELAB, curr.get(DOC_ANNO)); set(F_NDOC_ELAB, curr.get(DOC_NDOC)); set(F_DATADOC_ELAB, curr.get(DOC_DATADOC)); } } } else tf.set_tree(NULL); tf.win().force_update(); } void TElabora_mask::docrif_search() { TRectype filtrec(LF_DOC); filtrec.put(DOC_TIPOCF, get(F_TIPOCF_ELAB)); filtrec.put(DOC_CODCF, get(F_CODCF_ELAB)); filtrec.put(DOC_PROVV, get(F_PROVV_ELAB)); filtrec.put(DOC_ANNO, get(F_ANNO_ELAB)); TRelation rel(LF_DOC); rel.add(LF_CLIFO, "TIPOCF==TIPOCF|CODCF==CODCF"); TSorted_cursor cur(&rel, "TIPOCF|CODCF|PROVV|ANNO|CODNUM|NUMDOCRIF", "", 2, &filtrec, &filtrec); TString flt(256); if (!field(F_CODNUM_ELAB).empty()) flt << "(CODNUM==\"" << get(F_CODNUM_ELAB) << "\")&&"; if (!field(F_TIPODOC_ELAB).empty()) flt << "(TIPODOC==\"" << get(F_TIPODOC_ELAB) << "\")&&"; if (!field(F_STATODOC_ELAB).empty()) flt << "(STATO==\"" << get(F_STATODOC_ELAB) << "\")&&"; add_valuta_filter(flt); flt << "&&"; TEdit_field& f = efield(F_NUMDOCRIF_ELAB); if (!f.empty()) flt << "(NUMDOCRIF==\"" << f.get() << "\")&&"; flt.rtrim(2); // Togli gli ultimi && cur.setfilter(flt); TToken_string fields = "ANNO|CODNUM|TIPODOC|NUMDOCRIF|STATO|DATADOCRIF|DOC1|DOC2|DOC3|NDOC|20->RAGSOC"; TCursor_sheet sheet(&cur, fields, "Documento di riferimento", "Anno|Num.|Tipo|Docum.Rif.|Stato|Data@10|Docum.Rif.1|Docum.Rif.2|Docum.Rif.3|Documento|Ragione Sociale@50", 0, 1); if (sheet.run() == K_ENTER) { const int nrifpos = fields.get_pos("NUMDOCRIF"); const TString16 nrif = sheet.row(-1).get(nrifpos); f.set(nrif); const int ndocpos = fields.get_pos("NDOC"); const TString16 ndoc = sheet.row(-1).get(ndocpos); set(F_NDOC_ELAB, ndoc); const int codnumpos = fields.get_pos("CODNUM"); const TString16 codnum = sheet.row(-1).get(codnumpos); set(F_CODNUM_ELAB, codnum, TRUE); } } TElabora_mask::TElabora_mask(TDocumento_mask& main_mask) : TAutomask("ve0100b"), _main(&main_mask), _last_elab(NULL) { _myself = this; set(F_ANNO_ELAB, _main->get(F_ANNO)); set(F_TIPOCF_ELAB, _main->get(F_TIPOCF)); set(F_CODCF_ELAB, _main->get(F_CODCF)); set(F_CODVAL_ELAB, _main->get(F_CODVAL)); } bool TDocumento_mask::elabora_handler( TMask_field& f, KEY key ) { if (key == K_SPACE) { TDocumento_mask& m = (TDocumento_mask&)f.mask(); m.update_progs(); if (m.check_fields()) // Check values { TElabora_mask* selection = new TElabora_mask(m); // No woman no stack bool update_mask = FALSE; const char stato_iniziale = m.doc().stato(); while (selection->run() == K_ENTER) { m.mask2doc(); update_mask |= selection->elabora(); if (m.doc().stato() != stato_iniziale) break; if (update_mask) { m.doc2mask(FALSE); TSheet_field& ss = m.sfield(F_SHEET); for (int i = 0; i < ss.items(); i++) { m.ss_notify(ss,i,K_TAB); m.ss_notify(ss,i,K_SPACE); m.ss_notify(ss,i,K_ENTER); } } } if (update_mask) { m.doc2mask(FALSE); // Provoca decodifiche necessarie const int last = m.id2pos(BASE_PIEDE + 1); for (int p = 0; p < last; p++) { TMask_field& f = m.fld(p); f.check(STARTING_CHECK); } } delete selection; } } return TRUE; } /////////////////////////////////////////////////////////// // TDocumento_mask /////////////////////////////////////////////////////////// bool TDocumento_mask::print_handler( TMask_field& f, KEY key ) { if (key == K_SPACE) main_app().print(); return TRUE; } void TDocumento_mask::user_set_handler(int fieldid, int index) { switch( index ) { case 1: set_handler( fieldid, ora_hndl ); break; case 2: set_handler( fieldid, totdoc_hndl ); break; case 3: set_handler( fieldid, numdocrif_hndl ); break; case 4: set_handler( fieldid, dummy_hndl ); break; default: CHECK( FALSE, "Tentativo di installare un handler non definito" ); break; } } bool TDocumento_mask::anno_handler( TMask_field& f, KEY key) { if (key == K_TAB && f.to_check(key, TRUE)) app().update_navigation_bar(); return true; } bool TDocumento_mask::num_handler( TMask_field& f, KEY key) { if (key == K_TAB && f.to_check(key, TRUE)) { // Ottengo la maschera TMask& m = f.mask(); TTable & tabnum = ((TTable &) ((TEdit_field &)f).browse()->cursor()->file()); if ( tabnum.good()) { TCodice_numerazione cod_num(tabnum.curr()); m.set( F_DESNUM, cod_num.descrizione()); // Propone il primo tipo di documento come default if (m.field(F_TIPODOC).empty() || f.focusdirty()) { m.set( F_TIPODOC, cod_num.tipo_doc(0)); m.send_key( K_TAB, F_TIPODOC ); } // Se per questa numerazione e' abilitata le numerazione provvisoria if (cod_num.num_provv()) { // Setta di default la numerazione provvisoria m.set( F_PROVV, "P" ); // Abilita il campo per la selezione della numerazione m.enable( F_PROVV ); } else // Altrimenti ... { // Setta la numerazione a definitiva m.set( F_PROVV, "D" ); // Disabilita il campo per la selezione della numerazione m.disable( F_PROVV ); } } else { m.set( F_DESNUM, "" ); m.set( F_TIPODOC, "" ); } app().update_navigation_bar(); } return TRUE; } bool TDocumento_mask::tip_handler( TMask_field& f, KEY key ) { TDocumento_mask& m = (TDocumento_mask&)f.mask( ); if ( key == K_TAB && m.is_running() && m.get(F_TIPODOC).not_empty()) { TCodice_numerazione cod_num(m.get(F_CODNUM)); const TString& tipo = f.get(); int last = cod_num.ntipi_doc(); for (int i = 0; i < last; i++ ) { const TString16 curtipo(cod_num.tipo_doc(i)); if (curtipo == tipo) return TRUE; } return f.error_box( "Tipo non valido per la numerazione selezionata!" ); } return TRUE; } bool TDocumento_mask::codlist_handler( TMask_field& f, KEY key ) { if (key == K_TAB && f.focusdirty()) { TLocalisamfile & list = ((TEdit_field &) f).browse()->cursor()->file(); const TDate datadoc(f.mask().get(F_DATADOC)); const TDate datascad(list.get_date("VALFIN")); if (datascad.ok() && datadoc > datascad) { const TString16 codsucc(list.get("CODLISSUCC")); if (codsucc.empty()) return error_box("Listino scaduto il %s", datascad.string()); else { f.set(codsucc); f.set_focusdirty(); ((TEdit_field &)f).check(); } } } return TRUE; } bool TDocumento_mask::codcont_handler( TMask_field& f, KEY key ) { if (key == K_TAB && f.focusdirty()) { TLocalisamfile & cont = ((TEdit_field &) f).browse()->cursor()->file(); const TDate datadoc(f.mask().get(F_DATADOC)); const TDate datascad(cont.get_date("VALFIN")); if (datascad.ok() && datadoc > datascad) return error_box("Contratto scaduto il %s", datascad.string()); } return TRUE; } bool TDocumento_mask::codcamp_handler( TMask_field& f, KEY key ) { if (key == K_TAB && f.focusdirty()) { TLocalisamfile & camp = ((TEdit_field &) f).browse()->cursor()->file(); const TDate datadoc(f.mask().get(F_DATADOC)); const TDate datascad(camp.get_date("VALFIN")); if (datascad.ok() && datadoc > datascad) return error_box("Offerta scaduta il %s", datascad.string()); } return TRUE; } /* bool TDocumento_mask::controeuro_handler( TMask_field& f, KEY key ) { TMask & m = f.mask(); if (m.is_running() && key == K_SPACE) { const real cambio_euro = TCurrency::get_euro_change(); const real val = cambio_euro / m.get_real(F_CAMBIO); m.set(F_CAMBIO, val); } return TRUE; } */ bool TDocumento_mask::datacambio_handler( TMask_field& f, KEY key ) { TMask& m = f.mask(); if (key == K_TAB && m.field(F_CAMBIO).empty()) { const TRectype& rec = cache().get("%VAL", m.get(F_CODVAL1)); m.set(F_CAMBIO, rec.get("S4")); } return TRUE; } bool TDocumento_mask::codval_handler( TMask_field& f, KEY key ) { if (key == K_TAB && f.focusdirty() && !f.empty()) { TMask& m = f.mask(); // Cerco un cambio per la data specificata, se non lo trovo lo invento TDate datacam = m.get(F_DATACAMBIO); if (!datacam.ok()) { datacam = m.get_date(F_DATADOC); m.set(F_DATACAMBIO, datacam); m.set(F_DATACAMBIO1, datacam); } TExchange exc(f.get()); exchange_type et; real cambio = exc.get_change(et); // Determino il cambio standard ed il "Contro-Euro" TString16 key; key.format("%-3s%s", (const char*)f.get(), (const char*)datacam.string(ANSI)); const real giornaliero = cache().get("CAM", key, "S4"); if (!giornaliero.is_zero()) cambio = giornaliero; // Ho trovato un cambio per il giorno! m.set(F_CAMBIO, cambio); m.set(F_CONTROEURO, et == _exchange_contro ? "X" : ""); m.sfield(F_SHEET).force_update(); // Aggiorna punti decimali degli importi } return TRUE; }