1369 lines
34 KiB
C++
Executable File
1369 lines
34 KiB
C++
Executable File
#define STRICT
|
||
#define WIN32_EXTRA_LEAN
|
||
#define XVT_INCL_NATIVE
|
||
|
||
#include <config.h>
|
||
#include <controls.h>
|
||
#include <diction.h>
|
||
#include <golem.h>
|
||
#include <image.h>
|
||
#include <msksheet.h>
|
||
#include <prefix.h>
|
||
#include <relation.h>
|
||
#include <statbar.h>
|
||
#include <treectrl.h>
|
||
#include <urldefid.h>
|
||
#include <utility.h>
|
||
|
||
#include <bagn006.h>
|
||
|
||
#ifdef WIN32
|
||
#include <mapi.h>
|
||
#include <shellapi.h>
|
||
#endif
|
||
|
||
#include "bagn006.h"
|
||
|
||
HIDDEN unsigned int mail2icon()
|
||
{
|
||
unsigned int icon = xvt_sys_load_icon(".eml");
|
||
if (icon == 0)
|
||
icon = xvt_sys_load_icon(".msg");
|
||
if (icon == 0)
|
||
icon = xvt_sys_load_icon(".mmf");
|
||
return icon;
|
||
}
|
||
|
||
bool goto_url(const char* url)
|
||
{
|
||
TFilename app(url);
|
||
app.lower();
|
||
const TString ext(app.ext());
|
||
|
||
TConfig link(CONFIG_USER, "Link");
|
||
app = link.get(ext);
|
||
if (app.full())
|
||
{
|
||
app << " \"" << url << '"';
|
||
long error = xvt_sys_execute(app, false, false); //verificare
|
||
if (error > 32)
|
||
return true;
|
||
else
|
||
link.set(ext, "");
|
||
}
|
||
|
||
return xvt_sys_goto_url(url, "open") != 0;
|
||
}
|
||
|
||
bool edit_url(const char* url)
|
||
{
|
||
bool ok = xvt_sys_goto_url(url, "edit") != 0;
|
||
if (!ok)
|
||
ok = goto_url(url);
|
||
if (ok)
|
||
do_events();
|
||
return ok;
|
||
}
|
||
|
||
bool print_url(const char* url)
|
||
{
|
||
bool ok = xvt_sys_goto_url(url, "print") != 0;
|
||
if (!ok)
|
||
ok = goto_url(url);
|
||
return ok;
|
||
}
|
||
|
||
const TString & get_golem_path(long ditta)
|
||
{
|
||
TFilename golem_path;
|
||
if (ditta < 0)
|
||
ditta = prefix().get_codditta();
|
||
golem_path = firm2dir(ditta);
|
||
golem_path.add("golem");
|
||
if (!dexist(golem_path))
|
||
make_dir(golem_path);
|
||
return get_tmp_string() = golem_path;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Maschera GOLEM
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TGolem_mask : public TMask
|
||
{
|
||
bool _archive;
|
||
|
||
protected:
|
||
static bool file_handler(TMask_field& f, KEY k);
|
||
static bool link_handler(TMask_field& f, KEY k);
|
||
static bool main_link_handler(TMask_field& f, KEY k);
|
||
static bool ole_handler(TMask_field& f, KEY k);
|
||
static bool sheet_notify(TSheet_field& s, int r, KEY k);
|
||
|
||
public:
|
||
TGolem_mask(bool archive = false, const char * catdoc = "");
|
||
};
|
||
|
||
bool TGolem_mask::file_handler(TMask_field& f, KEY k)
|
||
{
|
||
TMask& m = f.mask();
|
||
|
||
if (k == K_F9)
|
||
{
|
||
FILE_SPEC fs;
|
||
TFilename n = f.get();
|
||
if (n.empty())
|
||
n = "*.*";
|
||
xvt_fsys_convert_str_to_fspec(n, &fs);
|
||
|
||
DIRECTORY dir; xvt_fsys_get_curr_dir(&dir);
|
||
FL_STATUS ok = xvt_dm_post_file_open(&fs, TR("Selezionare il file..."));
|
||
xvt_fsys_set_dir(&dir);
|
||
|
||
if (ok == FL_OK)
|
||
{
|
||
xvt_fsys_convert_fspec_to_str(&fs, n.get_buffer(), n.size());
|
||
m.set(S_FILE, n);
|
||
k = K_TAB;
|
||
}
|
||
f.set_focus();
|
||
}
|
||
|
||
if (k == K_TAB && f.focusdirty())
|
||
{
|
||
TFilename file = m.get(S_FILE);
|
||
if (file.exist())
|
||
{
|
||
char ext[_MAX_EXT];
|
||
char name[_MAX_FNAME];
|
||
xvt_fsys_parse_pathname(file, NULL, NULL, name, ext, NULL); //verificare
|
||
file = name; file.ext(ext);
|
||
m.enable(S_LINK);
|
||
m.disable(F_NEWREC);
|
||
m.enable(F_LINK);
|
||
m.enable(F_PRINT);
|
||
}
|
||
else
|
||
{
|
||
const bool full = file.not_empty();
|
||
m.set(S_LINK, full ? "X" : "");
|
||
m.disable(S_LINK);
|
||
m.enable(F_NEWREC, full);
|
||
m.enable(F_LINK, full);
|
||
m.disable(F_PRINT);
|
||
file.cut(0);
|
||
}
|
||
m.set(S_ALIAS, file);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool TGolem_mask::link_handler(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TMask& m = f.mask();
|
||
TFilename url = m.get(S_FILE);
|
||
short id = f.dlg();
|
||
if (id == F_NEWREC && url.not_empty())
|
||
{
|
||
if (!url.exist())
|
||
{
|
||
TFilename name;
|
||
char ext[_MAX_EXT];
|
||
xvt_fsys_parse_pathname(url, NULL, NULL, name.get_buffer(), ext, NULL);
|
||
if (name.not_empty() && *ext)
|
||
{
|
||
name.ext(ext);
|
||
url.tempdir();
|
||
url.add(name);
|
||
ofstream out(url); // Crea un file vuoto
|
||
}
|
||
else
|
||
url.cut(0);
|
||
m.set(S_FILE, url, true); // ... memorizza il suo nome ...
|
||
m.reset(S_LINK); // Non puo' essere un collegamento
|
||
}
|
||
else
|
||
id = F_LINK;
|
||
}
|
||
|
||
if (url.not_empty())
|
||
{
|
||
bool open = true;
|
||
if (id == DLG_PRINT)
|
||
open = !print_url(url);
|
||
if (open)
|
||
goto_url(url);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TGolem_mask::main_link_handler(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TSheet_field& sheet = f.mask().sfield(F_SHEET);
|
||
if (sheet.items() > 0)
|
||
{
|
||
sheet.check_row(sheet.selected());
|
||
TMask& sm = sheet.sheet_mask();
|
||
TMask_field& link = sm.field(f.dlg());
|
||
link_handler(link, K_SPACE);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TGolem_mask::sheet_notify(TSheet_field& s, int r, KEY k)
|
||
{
|
||
if (k == K_DEL)
|
||
{
|
||
TToken_string row = s.row(r);
|
||
|
||
if (row.get_char(2)<=' ')
|
||
xvt_fsys_remove_file(row.get(0));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TGolem_mask::ole_handler(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TSheet_field& sheet = f.mask().sfield(F_SHEET);
|
||
TMask& sm = sheet.sheet_mask();
|
||
|
||
int selected = sheet.selected();
|
||
if (sheet.items() == 0 || !sm.field(S_FILE).empty())
|
||
{
|
||
sheet.row(-1);
|
||
selected = sheet.items()-1;
|
||
}
|
||
sheet.check_row(selected);
|
||
|
||
TString16 ext = f.prompt();
|
||
if (ext == "mailto")
|
||
{
|
||
TMail_message msg("");
|
||
msg.send();
|
||
}
|
||
else
|
||
{
|
||
TFilename file;
|
||
file.temp(NULL, ext);
|
||
sm.set(S_FILE, file);
|
||
ofstream out(file);
|
||
out.close();
|
||
sheet.row(selected) = file;
|
||
sheet.force_update();
|
||
edit_url(file);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
TGolem_mask::TGolem_mask(bool archive, const char * catdoc)
|
||
: TMask(archive ? "bagn011" : "bagn006"), _archive(archive)
|
||
{
|
||
TSheet_field& sheet = sfield(F_SHEET);
|
||
|
||
sheet.set_notify(sheet_notify);
|
||
set_handler(F_NEWREC, main_link_handler);
|
||
set_handler(F_LINK, main_link_handler);
|
||
set_handler(F_PRINT, main_link_handler);
|
||
|
||
TMask& sm = sheet.sheet_mask();
|
||
|
||
sm.set_handler(S_FILE, file_handler);
|
||
sm.set_handler(F_NEWREC, link_handler);
|
||
sm.set_handler(F_LINK, link_handler);
|
||
sm.set_handler(F_PRINT, link_handler);
|
||
|
||
TConfig ini(CONFIG_GUI, "Link");
|
||
TString_array list;
|
||
ini.list_variables(list);
|
||
|
||
// Elimina la posta se c'e'
|
||
// Ordina alfabeticamente
|
||
list.sort();
|
||
|
||
const int ITEMS_PER_ROW = 15;
|
||
const int MAX_ITEMS = ITEMS_PER_ROW * 2;
|
||
|
||
// Aggiungi la posta se attiva
|
||
int i = 0;
|
||
FOR_EACH_ARRAY_ROW(list, r, row)
|
||
{
|
||
TString16 ext = *row;
|
||
unsigned int icon = 0;
|
||
|
||
if (ext[0] != '.')
|
||
ext.insert(".", 0);
|
||
icon = xvt_sys_load_icon(ext);
|
||
if (icon)
|
||
{
|
||
const int x = (i < ITEMS_PER_ROW ? i*5 : (i-ITEMS_PER_ROW)*5) + 1;
|
||
const int y = i < ITEMS_PER_ROW ? 0 : 2;
|
||
TButton_field& btn = add_button(301+i, 0, "", x, y, 3, 2);
|
||
btn.set_prompt(ext);
|
||
btn.set_handler(ole_handler);
|
||
btn.set_central_icon(icon);
|
||
i++;
|
||
if (i > MAX_ITEMS)
|
||
break;
|
||
}
|
||
}
|
||
if (archive && catdoc && *catdoc)
|
||
{
|
||
int idx = 0;
|
||
TList_field & l = sm.lfield(S_CLASSE);
|
||
TToken_string codes(" ");
|
||
TToken_string values("Cartaceo");
|
||
|
||
while (true)
|
||
{
|
||
TToken_string appo(ini_get_string(CONFIG_DITTA, "F9", "ANNCAT", "", idx++));
|
||
const TString cat = appo.get(0);
|
||
|
||
if (cat == catdoc)
|
||
{
|
||
codes.add(appo.get(1));
|
||
values.add(appo.get(2));
|
||
}
|
||
else
|
||
if (appo == "STOP" || appo.empty()) /* STOP: Riga terminatrice */
|
||
break;
|
||
}
|
||
l.replace_items(codes, values);
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Campi GOLEM
|
||
///////////////////////////////////////////////////////////
|
||
|
||
TString& TGolem_field::get_window_data()
|
||
{
|
||
return _str;
|
||
}
|
||
|
||
void TGolem_field::set_window_data(const char* data)
|
||
{
|
||
if (_tool) // non si capisce perch<63> non disegni la nuova bitmap
|
||
update_tool();
|
||
else
|
||
{
|
||
unsigned int icon = 0;
|
||
char* pipe = (char*)strchr(data, '|'); //antica porcata
|
||
|
||
if (pipe)
|
||
{
|
||
*pipe = '\0'; // Poor man TToken_string
|
||
icon = xvt_sys_load_icon(data);
|
||
*pipe = '|';
|
||
}
|
||
|
||
TPushbutton_control* btn = (TPushbutton_control*)_ctl;
|
||
|
||
if (icon)
|
||
btn->set_icon(icon);
|
||
else
|
||
btn->set_bmp(_bmp, 0);
|
||
|
||
RCT rct; btn->get_rect(rct);
|
||
|
||
xvt_dwin_invalidate_rect(btn->parent(), &rct);
|
||
}
|
||
}
|
||
|
||
bool TGolem_field::is_editable() const
|
||
{ return false; }
|
||
|
||
short TGolem_field::dlg() const
|
||
{
|
||
return _dlg;
|
||
}
|
||
|
||
void TGolem_field::parse_head(TScanner& scanner)
|
||
{
|
||
_ctl_data._width = scanner.integer();
|
||
if (_ctl_data._width <= 0) _ctl_data._width = 10;
|
||
_ctl_data._height = scanner.integer(); // Height
|
||
if (_ctl_data._height <= 0) _ctl_data._height = 1;
|
||
}
|
||
|
||
bool TGolem_field::parse_item(TScanner& scanner)
|
||
{
|
||
if (scanner.key() == "PI")
|
||
{
|
||
const short bmp = (short)scanner.integer();
|
||
if (_bmp == 0)
|
||
_bmp = bmp;
|
||
return bmp > 0;
|
||
}
|
||
return TEditable_field::parse_item(scanner);
|
||
}
|
||
|
||
void TGolem_field::create(WINDOW parent)
|
||
{
|
||
|
||
if (_tool)
|
||
{
|
||
if (_ctl_data._dlg == DLG_OGGETTI)
|
||
{
|
||
if (_ctl_data._prompt.blank())
|
||
_ctl_data._prompt = TR("Oggetti");
|
||
if (_bmp <= 0)
|
||
_ctl_data._bmp_up = _bmp = TOOL_OLE;
|
||
}
|
||
else
|
||
if (_ctl_data._dlg == DLG_CARTACEI)
|
||
{
|
||
if (_ctl_data._prompt.blank())
|
||
_ctl_data._prompt = TR("Cartacei");
|
||
if (_ctl_data._bmp_up <= 0)
|
||
_ctl_data._bmp_up = _bmp = TOOL_ARCHIVE;
|
||
}
|
||
xvt_toolbar_add_control(_toolbar = parent, _dlg = _ctl_data._dlg, TOOL_TOGLBUTN, _ctl_data._prompt, _ctl_data._bmp_up, _ctl_data._width, -1);
|
||
}
|
||
else
|
||
{
|
||
if (_bmp == 0)
|
||
_bmp = BMP_OLE;
|
||
_ctl_data._bmp_up = _bmp;
|
||
_ctl = new TPushbutton_control(parent, _dlg = _ctl_data._dlg,
|
||
_ctl_data._x, _ctl_data._y,
|
||
_ctl_data._width+2, _ctl_data._height,
|
||
_ctl_data._flags, _ctl_data._prompt,
|
||
_ctl_data._bmp_up, _ctl_data._bmp_dn);
|
||
}
|
||
}
|
||
|
||
bool TGolem_field::autoload(const TRelation& r)
|
||
{
|
||
const bool ok = TEditable_field::autoload(r);
|
||
if (ok)
|
||
_old_value = get();
|
||
else
|
||
_old_value.cut(0);
|
||
return ok;
|
||
}
|
||
|
||
bool TGolem_field::autosave(TRelation& r)
|
||
{
|
||
if (field() != NULL)
|
||
{
|
||
TToken_string new_value(get(), '\n');
|
||
|
||
if (new_value != _old_value)
|
||
{
|
||
TDir dir;
|
||
const int logicnum = r.lfile().num();
|
||
dir.get(logicnum, _nolock, _nordir, _sysdirop);
|
||
const long ditta = dir.is_com() ? 0 : prefix().get_codditta();
|
||
const TFilename golem_path = get_golem_path(ditta);
|
||
|
||
const int old_items = _old_value.items();
|
||
const int new_items = new_value.items();
|
||
const int items = new_items > old_items ? new_items : old_items;
|
||
|
||
TToken_string old_row, new_row;
|
||
TFilename old_file, new_file;
|
||
for (int i = 0; i < items; i++)
|
||
{
|
||
old_row = _old_value.get(i); // Devo usare l'indice ogni volta ...
|
||
new_row = new_value.get(i); // ... perche' le TToken_string cambiano!
|
||
|
||
old_file = old_row.get(0);
|
||
new_file = new_row.get(0);
|
||
|
||
if (old_file != new_file)
|
||
{
|
||
const bool was_stored = old_row.get_char(2) <= ' ' && old_file.starts_with(golem_path, true);
|
||
const bool tobe_stored = new_row.get_char(2) <= ' ';
|
||
if (was_stored && fexist(old_file))
|
||
old_file.fremove();
|
||
if (tobe_stored && new_file.full())
|
||
{
|
||
char ext[_MAX_EXT];
|
||
char fname[_MAX_FNAME];
|
||
|
||
xvt_fsys_parse_pathname(new_file, NULL, NULL, fname, ext, NULL);
|
||
old_file = golem_path;
|
||
old_file.add(fname);
|
||
old_file.ext(ext);
|
||
if (fexist(old_file))
|
||
{
|
||
int i = 0;
|
||
|
||
old_file.ext("");
|
||
old_file << '_' << today.string(ANSI) << "_000";
|
||
old_file.ext(ext);
|
||
|
||
while (fexist(old_file))
|
||
{
|
||
old_file.ext("");
|
||
old_file.rtrim(1);
|
||
old_file << ++i;
|
||
old_file.ext(ext);
|
||
}
|
||
}
|
||
|
||
fcopy(new_file, old_file);
|
||
if (old_file.starts_with(golem_path))
|
||
old_file = old_file.mid(golem_path.len());
|
||
new_row.add(old_file, 0);
|
||
new_value.add(new_row, i);
|
||
|
||
// Cancella il file originale se temporaneo
|
||
TFilename tmp; tmp.tempdir();
|
||
if (new_file.starts_with(tmp, true))
|
||
new_file.fremove();
|
||
}
|
||
}
|
||
}
|
||
set(_old_value = new_value);
|
||
}
|
||
}
|
||
return TEditable_field::autosave(r);
|
||
}
|
||
|
||
bool TGolem_field::on_key(KEY key)
|
||
{
|
||
bool ok = true;
|
||
if (key == K_SPACE)
|
||
{
|
||
TMask* msk = new TGolem_mask(_archive, _catdoc);
|
||
TSheet_field& sheet = msk->sfield(F_SHEET);
|
||
|
||
TToken_string tmp(get(), '\n');
|
||
if (roman())
|
||
{
|
||
FOR_EACH_TOKEN(tmp, row)
|
||
{
|
||
if (*row > ' ')
|
||
sheet.row(-1) = row;
|
||
}
|
||
|
||
short key = msk->run();
|
||
|
||
if (key == K_ENTER)
|
||
{
|
||
tmp.cut(0);
|
||
FOR_EACH_SHEET_ROW(sheet, r, row)
|
||
{
|
||
if ((*row)[0] > ' ')
|
||
tmp.add(*row);
|
||
}
|
||
set(tmp);
|
||
_selected = sheet.selected();
|
||
do_message(0);
|
||
}
|
||
else
|
||
if (key == K_ESC)
|
||
update_tool();
|
||
}
|
||
else
|
||
{
|
||
tmp.separator('|');
|
||
TMask& sm = sheet.sheet_mask();
|
||
for (int i = 0; i < 3; i++)
|
||
sm.set(S_FILE+i, tmp.get());
|
||
|
||
if (sm.run() == K_ENTER)
|
||
{
|
||
tmp.cut(0);
|
||
for (int i = 0; i < 3; i++)
|
||
tmp.add(sm.get(S_FILE+i));
|
||
set(tmp);
|
||
do_message(0);
|
||
}
|
||
}
|
||
safe_delete(msk);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
void TGolem_field::update_tool()
|
||
{
|
||
const TString & val = get_window_data();
|
||
|
||
xvt_toolbar_toggle_control(toolbar(), _dlg, val.full());
|
||
};
|
||
|
||
TGolem_field::TGolem_field(TMask* m, bool tool, bool archive)
|
||
: TEditable_field(m), _old_value(80, '\n'), _selected(0), _bmp(0), _tool(tool), _dlg(-1),
|
||
_archive(archive)
|
||
{ }
|
||
|
||
TGolem_field::~TGolem_field()
|
||
{ }
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TGolem_client_field
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TGolem_window : public TField_window
|
||
{
|
||
TFilename _last_file;
|
||
unsigned long _last_handle;
|
||
|
||
protected:
|
||
virtual bool on_key(KEY k);
|
||
virtual void update();
|
||
virtual long handler(WINDOW win, EVENT* ep);
|
||
|
||
public:
|
||
|
||
TGolem_field* driver() const { return ((TGolem_client_field&)owner()).driver(); }
|
||
const TFilename& get_current_file(TFilename& fn) const;
|
||
|
||
TGolem_window(int x, int y, int dx, int dy, WINDOW parent, TGolem_client_field* owner);
|
||
virtual ~TGolem_window();
|
||
};
|
||
|
||
const TFilename& TGolem_window::get_current_file(TFilename& fn) const
|
||
{
|
||
TGolem_field* gf = driver();
|
||
if (gf != NULL)
|
||
{
|
||
TToken_string list(gf->get(), '\n');
|
||
TToken_string tok = list.get(gf->selected());
|
||
fn = tok.get();
|
||
}
|
||
else
|
||
fn.cut(0);
|
||
return fn;
|
||
}
|
||
|
||
void TGolem_window::update()
|
||
{
|
||
bool drawn = false;
|
||
|
||
TField_window::update();
|
||
|
||
TFilename file; get_current_file(file);
|
||
if (file.not_empty() && file.exist())
|
||
{
|
||
const TString16 ext = file.ext();
|
||
if (ext.compare("bmp", -1, true) == 0)
|
||
{
|
||
TImage img(file);
|
||
if (img.ok())
|
||
{
|
||
RCT cli; xvt_vobj_get_client_rect(win(), &cli);
|
||
if (owner().automagic())
|
||
{
|
||
const double ratiox = double(cli.right-cli.left) / img.width();
|
||
const double ratioy = double(cli.bottom-cli.top) / img.height();
|
||
const double ratio = min(ratiox, ratioy);
|
||
const int maxx = int(ratio * img.width());
|
||
const int maxy = int(ratio * img.height());
|
||
RCT dst; xvt_rect_set(&dst, 0, 0, maxx, maxy);
|
||
img.draw(win(), dst);
|
||
}
|
||
else
|
||
{
|
||
long sx = img.width() - (cli.right-cli.left); if (sx < 0) sx = 0;
|
||
long sy = img.height() - (cli.bottom-cli.top); if (sy < 0) sy = 0;
|
||
set_scroll_max(sx, sy); // Setta le scroll bar
|
||
const TPoint orig = origin();
|
||
img.draw(win(), -int(orig.x), -int(orig.y));
|
||
}
|
||
drawn = true;
|
||
}
|
||
}
|
||
}
|
||
if (!drawn)
|
||
{
|
||
set_scroll_max(0, 0); // Toglie le scroll bar
|
||
RCT cli; xvt_vobj_get_client_rect(win(), &cli);
|
||
set_pen(COLOR_RED, 5);
|
||
line(cli.right/4, cli.bottom/4, 3*cli.right/4, 3*cli.bottom/4);
|
||
line(cli.right/4, 3*cli.bottom/4, 3*cli.right/4, cli.bottom/4);
|
||
}
|
||
}
|
||
|
||
bool TGolem_window::on_key(KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TFilename file; get_current_file(file);
|
||
if (file != _last_file)
|
||
{
|
||
#ifdef WIN32 // verificare
|
||
if (_last_handle)
|
||
{
|
||
if (IsWindow(HWND(_last_handle)))
|
||
::SendMessage(HWND(_last_handle), WM_CLOSE, 0, 0);
|
||
_last_handle = NULL;
|
||
}
|
||
#endif
|
||
_last_file = file;
|
||
|
||
if (!file.blank() && file.exist())
|
||
{
|
||
TString16 ext = file.ext(); ext.upper();
|
||
if (ext != "BMP")
|
||
{
|
||
TFilename cmd;
|
||
const char* good_ext[] = { "BAT", "COM", "DLL", "DOC", "EXE", "INI", "TXT", "WRI", "XLS", NULL };
|
||
for (int i = 0; good_ext[i]; i++)
|
||
{
|
||
if (ext == good_ext[i])
|
||
{
|
||
#ifdef WIN32 // verificare
|
||
::GetSystemDirectory(cmd.get_buffer(), cmd.size());
|
||
cmd.add("viewers");
|
||
cmd.add("quikview.exe");
|
||
#endif
|
||
break;
|
||
}
|
||
}
|
||
if (cmd.blank() || !cmd.exist())
|
||
xvt_sys_find_editor(file, cmd.get_buffer());
|
||
if (cmd.full())
|
||
{
|
||
cmd << ' ' << file;
|
||
_last_handle = xvt_sys_execute_in_window(cmd, win());
|
||
}
|
||
}
|
||
}
|
||
force_update();
|
||
}
|
||
}
|
||
|
||
return TField_window::on_key(k);
|
||
}
|
||
|
||
long TGolem_window::handler(WINDOW win, EVENT* ep)
|
||
{
|
||
switch (ep->type)
|
||
{
|
||
case E_USER:
|
||
switch (ep->v.user.id)
|
||
{
|
||
case E_DROP_FILES:
|
||
if (driver())
|
||
{
|
||
#ifdef WIN32 // verificare
|
||
HDROP hdrop = (HDROP)(DWORD)ep->v.user.ptr;
|
||
const int num_files = ::DragQueryFile(hdrop, -1, NULL, 0); // Numero totale di files
|
||
|
||
TToken_string file_list(driver()->get(), '\n');
|
||
TFilename fname; // File corrente
|
||
for (int i = 0; i < num_files; i++)
|
||
{
|
||
::DragQueryFile(hdrop, i, fname.get_buffer(), fname.size());
|
||
fname << '|' << fname.name() << "|X";
|
||
if (driver()->roman())
|
||
{
|
||
file_list.add(fname);
|
||
}
|
||
else
|
||
{
|
||
file_list = fname;
|
||
break;
|
||
}
|
||
}
|
||
::DragFinish(hdrop);
|
||
driver()->set(file_list);
|
||
#endif
|
||
on_key(K_SPACE);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
case E_MOUSE_DBL:
|
||
on_key(K_SPACE);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return TField_window::handler(win, ep);
|
||
}
|
||
|
||
TGolem_window::TGolem_window(int x, int y, int dx, int dy, WINDOW parent, TGolem_client_field* owner)
|
||
: TField_window(x, y, dx, dy, parent, owner), _last_handle(0)
|
||
{
|
||
_pixmap = true;
|
||
|
||
#ifdef WIN32 // verificare
|
||
HWND nat = (HWND)xvt_vobj_get_attr(win(), ATTR_NATIVE_WINDOW);
|
||
::DragAcceptFiles(nat, true);
|
||
#endif
|
||
}
|
||
|
||
TGolem_window::~TGolem_window()
|
||
{
|
||
#ifdef WIN32 // verificare
|
||
if (_last_handle)
|
||
::PostMessage(HWND(_last_handle), WM_CLOSE, 0, 0);
|
||
HWND nat = (HWND)xvt_vobj_get_attr(win(), ATTR_NATIVE_WINDOW);
|
||
::DragAcceptFiles(nat, false);
|
||
#endif
|
||
}
|
||
|
||
word TGolem_client_field::class_id() const
|
||
{ return CLASS_GOLEM_CLIENT_FIELD; }
|
||
|
||
bool TGolem_client_field::is_kind_of(word cid) const
|
||
{ return cid == CLASS_GOLEM_CLIENT_FIELD || TWindowed_field::is_kind_of(cid); }
|
||
|
||
TField_window* TGolem_client_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
|
||
{ return new TGolem_window(x, y, dx, dy, parent, this); }
|
||
|
||
bool TGolem_client_field::parse_item(TScanner& scan)
|
||
{
|
||
if (scan.key() == "DR")
|
||
{
|
||
TMask& m = mask();
|
||
const short driver = atodlg(scan.pop());
|
||
const int pos = m.id2pos(driver);
|
||
if (pos >= 0)
|
||
{
|
||
_driver = (TGolem_field*)&m.fld(pos);
|
||
TString16 msg;
|
||
msg.format("PUSH,%d", dlg());
|
||
_driver->message(0, true)->add(msg);
|
||
}
|
||
else
|
||
yesnofatal_box("Non esiste il campo driver %d", driver);
|
||
return true;
|
||
}
|
||
return TWindowed_field::parse_item(scan);
|
||
}
|
||
|
||
bool TGolem_client_field::on_hit()
|
||
{
|
||
dispatch_e_char(win().win(), K_SPACE);
|
||
return TWindowed_field::on_hit();
|
||
}
|
||
|
||
TGolem_client_field::TGolem_client_field(TMask* m)
|
||
: TWindowed_field(m), _driver(NULL)
|
||
{ }
|
||
|
||
TGolem_client_field::~TGolem_client_field()
|
||
{ }
|
||
|
||
#ifdef WIN32 // verificare
|
||
///////////////////////////////////////////////////////////
|
||
// MAPI session
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TMAPI_session : public TObject
|
||
{
|
||
HINSTANCE _hlibMAPI;
|
||
LHANDLE _hSession;
|
||
LONG _hWnd;
|
||
|
||
TFilename m_strBaseDir; // Directory iniziale
|
||
|
||
protected:
|
||
bool load_mapi();
|
||
void unload_mapi();
|
||
|
||
public:
|
||
operator LHANDLE() const { return _hSession; }
|
||
LONG hWnd() const { return _hWnd; }
|
||
|
||
bool open();
|
||
|
||
bool send(MapiMessage& msg, FLAGS flags = MAPI_DIALOG);
|
||
bool remove(const TString& id);
|
||
|
||
void close();
|
||
|
||
virtual bool ok() const
|
||
{ return _hlibMAPI != NULL && _hSession != NULL; }
|
||
|
||
TMAPI_session();
|
||
virtual ~TMAPI_session();
|
||
};
|
||
|
||
const char* const szMAPIDLL = "MAPI32.DLL";
|
||
const int MAPI_USE_DEFAULT = 0;
|
||
|
||
LPMAPILOGON lpfnMAPILogon = NULL;
|
||
LPMAPILOGOFF lpfnMAPILogoff = NULL;
|
||
LPMAPISENDMAIL lpfnMAPISendMail = NULL;
|
||
LPMAPISENDDOCUMENTS lpfnMAPISendDocuments = NULL;
|
||
LPMAPIFINDNEXT lpfnMAPIFindNext = NULL;
|
||
LPMAPIREADMAIL lpfnMAPIReadMail = NULL;
|
||
LPMAPISAVEMAIL lpfnMAPISaveMail = NULL;
|
||
LPMAPIDELETEMAIL lpfnMAPIDeleteMail = NULL;
|
||
LPMAPIFREEBUFFER lpfnMAPIFreeBuffer = NULL;
|
||
LPMAPIADDRESS lpfnMAPIAddress = NULL;
|
||
LPMAPIDETAILS lpfnMAPIDetails = NULL;
|
||
LPMAPIRESOLVENAME lpfnMAPIResolveName = NULL;
|
||
|
||
bool TMAPI_session::load_mapi()
|
||
{
|
||
if (_hlibMAPI) // Check in already loaded
|
||
return true;
|
||
|
||
// Check if MAPI is installed on the system
|
||
BOOL MAPI_installed = ::GetProfileInt("Mail", "MAPI", 0);
|
||
if(!MAPI_installed)
|
||
return error_box("MAPI non attivato nel file win.ini");
|
||
|
||
UINT fuError = ::SetErrorMode(SEM_NOOPENFILEERRORBOX);
|
||
_hlibMAPI = ::LoadLibrary(szMAPIDLL);
|
||
::SetErrorMode(fuError);
|
||
|
||
if (_hlibMAPI < (HINSTANCE)HINSTANCE_ERROR)
|
||
{
|
||
DWORD err = *((DWORD*)_hlibMAPI) & 0xFFFF;
|
||
_hlibMAPI = NULL;
|
||
return error_box("Errore di caricamento di %s: %lu", szMAPIDLL, err);
|
||
}
|
||
|
||
if (!(lpfnMAPILogon = (LPMAPILOGON)GetProcAddress (_hlibMAPI, "MAPILogon"))) return false;
|
||
if (!(lpfnMAPILogoff = (LPMAPILOGOFF)GetProcAddress (_hlibMAPI, "MAPILogoff"))) return false;
|
||
if (!(lpfnMAPISendMail = (LPMAPISENDMAIL)GetProcAddress (_hlibMAPI, "MAPISendMail"))) return false;
|
||
if (!(lpfnMAPISendDocuments = (LPMAPISENDDOCUMENTS) GetProcAddress (_hlibMAPI, "MAPISendDocuments"))) return false;
|
||
if (!(lpfnMAPIFindNext = (LPMAPIFINDNEXT)GetProcAddress (_hlibMAPI, "MAPIFindNext"))) return false;
|
||
if (!(lpfnMAPIReadMail = (LPMAPIREADMAIL)GetProcAddress (_hlibMAPI, "MAPIReadMail"))) return false;
|
||
if (!(lpfnMAPISaveMail = (LPMAPISAVEMAIL)GetProcAddress (_hlibMAPI, "MAPISaveMail"))) return false;
|
||
if (!(lpfnMAPIDeleteMail = (LPMAPIDELETEMAIL)GetProcAddress (_hlibMAPI, "MAPIDeleteMail"))) return false;
|
||
if (!(lpfnMAPIFreeBuffer = (LPMAPIFREEBUFFER)GetProcAddress (_hlibMAPI, "MAPIFreeBuffer"))) return false;
|
||
if (!(lpfnMAPIAddress = (LPMAPIADDRESS)GetProcAddress (_hlibMAPI, "MAPIAddress"))) return false;
|
||
if (!(lpfnMAPIDetails = (LPMAPIDETAILS)GetProcAddress (_hlibMAPI, "MAPIDetails"))) return false;
|
||
if (!(lpfnMAPIResolveName = (LPMAPIRESOLVENAME)GetProcAddress (_hlibMAPI, "MAPIResolveName"))) return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
void TMAPI_session::unload_mapi()
|
||
{
|
||
if (_hlibMAPI)
|
||
{
|
||
::FreeLibrary(_hlibMAPI);
|
||
_hlibMAPI = NULL;
|
||
}
|
||
}
|
||
|
||
bool TMAPI_session::open()
|
||
{
|
||
if (_hSession == NULL)
|
||
{
|
||
TWait_cursor hourglass;
|
||
|
||
DIRECTORY dir; xvt_fsys_get_default_dir(&dir); // Salva dir corrente che verra' cambiata da Outlook
|
||
|
||
if (!load_mapi())
|
||
return error_box("Impossibile inizializzare MAPI");
|
||
|
||
FLAGS flags = MAPI_USE_DEFAULT | MAPI_LOGON_UI;
|
||
ULONG err = lpfnMAPILogon(_hWnd, NULL, NULL, flags, 0L, &_hSession);
|
||
|
||
if (err != SUCCESS_SUCCESS)
|
||
return error_box("Impossibile collegarsi a MAPI: %lu", err);
|
||
|
||
_hWnd = xvt_vobj_get_attr(cur_win(), ATTR_NATIVE_WINDOW);
|
||
|
||
xvt_fsys_set_dir(&dir); // Ripristina dir corrente
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void TMAPI_session::close()
|
||
{
|
||
if (_hlibMAPI)
|
||
{
|
||
if (_hSession)
|
||
{
|
||
lpfnMAPILogoff(_hSession, _hWnd, 0L, 0L);
|
||
_hSession = NULL;
|
||
}
|
||
unload_mapi();
|
||
}
|
||
}
|
||
|
||
bool TMAPI_session::send(MapiMessage& msg, FLAGS flags)
|
||
{
|
||
bool ok = false;
|
||
if (open())
|
||
{
|
||
LONG err = lpfnMAPISendMail(_hSession, _hWnd, &msg, flags, 0L);
|
||
if (err == SUCCESS_SUCCESS)
|
||
ok = true;
|
||
else
|
||
ok = error_box("Can't send mail message: %ld", err);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
bool TMAPI_session::remove(const TString& id)
|
||
{
|
||
bool ok = false;
|
||
if (open())
|
||
{
|
||
LONG err = lpfnMAPIDeleteMail(_hSession, _hWnd,
|
||
(char*)(const char*)id, 0L, 0L);
|
||
if (err == SUCCESS_SUCCESS)
|
||
ok = true;
|
||
else
|
||
error_box("Can't delete mail message %s\nError %ld", (const char*)id, err);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
TMAPI_session::TMAPI_session()
|
||
: _hlibMAPI(NULL), _hSession(NULL), _hWnd(NULL)
|
||
{
|
||
// Memorizza directory base
|
||
GetCurrentDirectory(_MAX_PATH, m_strBaseDir.get_buffer(_MAX_PATH));
|
||
}
|
||
|
||
TMAPI_session::~TMAPI_session()
|
||
{
|
||
close();
|
||
|
||
// Ripristina directory base
|
||
SetCurrentDirectory(m_strBaseDir);
|
||
}
|
||
#endif
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TMail_message
|
||
///////////////////////////////////////////////////////////
|
||
|
||
int TMail_message::add_line(const char* s)
|
||
{
|
||
const long len = (s && *s) ? strlen(s) : 0;
|
||
int n = items() - 1;
|
||
|
||
if (n < 0 || (long(row(n).len()) + len) > 30000L)
|
||
n = TString_array::add("");
|
||
|
||
TString & line = row(n);
|
||
line << s;
|
||
if (line.right(1) != "\n")
|
||
line << '\n';
|
||
|
||
return n;
|
||
}
|
||
|
||
bool TMail_message::send(TMAPI_session& lhSession, bool hide_ui)
|
||
{
|
||
#ifdef WIN32
|
||
const int MAX_RECIPIENTS = _recipients.items() + _copy_recipients.items() + 1;
|
||
MapiRecipDesc* msgRecipient = new MapiRecipDesc[MAX_RECIPIENTS];
|
||
memset(msgRecipient, 0, MAX_RECIPIENTS*sizeof(MapiRecipDesc));
|
||
|
||
int nr = 0;
|
||
if (_sender.not_empty())
|
||
{
|
||
msgRecipient[nr].ulRecipClass = MAPI_ORIG;
|
||
msgRecipient[nr++].lpszName = _sender.get_buffer();
|
||
}
|
||
FOR_EACH_ARRAY_ROW(_recipients, rec, recipient)
|
||
{
|
||
msgRecipient[nr].ulRecipClass = MAPI_TO;
|
||
msgRecipient[nr].lpszName = recipient->get_buffer();
|
||
nr++;
|
||
}
|
||
FOR_EACH_ARRAY_ROW(_copy_recipients, cc_rec, cc_recipient)
|
||
{
|
||
msgRecipient[nr].ulRecipClass = MAPI_CC;
|
||
msgRecipient[nr].lpszName = cc_recipient->get_buffer();
|
||
nr++;
|
||
}
|
||
|
||
const int MAX_ATTACHMENTS = _attachments.items() + 1;
|
||
MapiFileDesc* msgAttachment = new MapiFileDesc[MAX_ATTACHMENTS];
|
||
memset(msgAttachment, 0, MAX_ATTACHMENTS*sizeof(MapiFileDesc));
|
||
int na = 0;
|
||
FOR_EACH_ARRAY_ROW(_attachments, att, attachment)
|
||
{
|
||
TString80 tmp; tmp.spaces(32);
|
||
this-> row(0) << tmp;
|
||
msgAttachment[na].nPosition = row(0).len()-1;
|
||
msgAttachment[na].lpszPathName = attachment->get_buffer();
|
||
na++;
|
||
}
|
||
|
||
MapiMessage msgSend;
|
||
memset(&msgSend, 0, sizeof(MapiMessage));
|
||
|
||
long tot = 0;
|
||
int i;
|
||
for (i = 0; i < items(); i++)
|
||
tot += row(i).len();
|
||
char* buffer = new char[tot + 16];
|
||
long b = 0;
|
||
for (i = 0; i < items(); i++)
|
||
{
|
||
strcpy_s(&buffer[b], tot-b+1, row(i));
|
||
b += row(i).len();
|
||
}
|
||
buffer[b] = '\0';
|
||
|
||
msgSend.lpszNoteText = buffer;
|
||
msgSend.lpszSubject = _subject.empty() ? NULL : _subject.get_buffer();
|
||
msgSend.nRecipCount = nr;
|
||
msgSend.lpRecips = nr == 0 ? NULL : msgRecipient;
|
||
msgSend.nFileCount = na;
|
||
msgSend.lpFiles = na == 0 ? NULL : msgAttachment;
|
||
|
||
if (receipt_requested())
|
||
msgSend.flFlags |= MAPI_RECEIPT_REQUESTED;
|
||
|
||
bool ok = lhSession.send(msgSend, hide_ui ? 0 : MAPI_DIALOG);
|
||
|
||
delete buffer;
|
||
delete msgRecipient;
|
||
delete msgAttachment;
|
||
|
||
return ok;
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_message::send(bool hide_ui)
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
TMAPI_session lhSession; // Open MAPI session
|
||
return send(lhSession, hide_ui);
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_message::remove(TMAPI_session& lhSession)
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
bool ok = _id.not_empty() && lhSession.remove(_id);
|
||
return ok;
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_message::remove()
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
TMAPI_session lhSession; // Open MAPI session
|
||
return remove(lhSession);
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_message::add_recipient_ex(const char* recipient, int type)
|
||
{
|
||
TFilename rec(recipient);
|
||
rec.trim();
|
||
bool ok = rec.not_empty();
|
||
if (ok) switch(type)
|
||
{
|
||
case 1:
|
||
_copy_recipients.add(rec);
|
||
break;
|
||
case 2:
|
||
if (rec.is_relative_path())
|
||
rec.make_absolute_path();
|
||
ok = fexist(rec);
|
||
if (ok)
|
||
_attachments.add(rec);
|
||
break;
|
||
default:
|
||
_recipients.add(rec);
|
||
break;
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
// Certified 99%
|
||
void TMail_message::set_date_time(const char* str)
|
||
{
|
||
if (str == NULL)
|
||
str = "";
|
||
|
||
int anno, mese, giorno;
|
||
int ora = 12, minuto = 0, secondo = 0;
|
||
const int num = sscanf_s(str, "%d/%d/%d %d:%d:%d",
|
||
&anno, &mese, &giorno, &ora, &minuto, &secondo);
|
||
if (num >= 3)
|
||
{
|
||
_date = TDate(giorno, mese, anno);
|
||
_hms = ora*10000L + minuto*100L + secondo;
|
||
}
|
||
else
|
||
{
|
||
_date = TODAY;
|
||
_hms = 0;
|
||
}
|
||
}
|
||
|
||
void TMail_message::set_date_time(const TDate& date, long hhmmss)
|
||
{
|
||
_date = date;
|
||
_hms = hhmmss;
|
||
}
|
||
|
||
// Certified 100%
|
||
const TString& TMail_message::recipient(int n) const
|
||
{
|
||
if (n >= 0 && n < recipients())
|
||
return _recipients.row(n);
|
||
return EMPTY_STRING;
|
||
}
|
||
|
||
TMail_message::TMail_message(const char* recipient, const char* subject,
|
||
const char* text, const char* sender)
|
||
: _subject(subject), _sender(sender), _hms(0), _query_receipt(false)
|
||
{
|
||
add_recipient(recipient);
|
||
if (text && *text)
|
||
{
|
||
const TFixed_string s(text);
|
||
if (s.find("=3D") > 0)
|
||
{
|
||
TString str(text);
|
||
for (int pos = str.find("=3D"); pos > 0; pos = str.find("=3D", pos+1))
|
||
{
|
||
char *buf = str.get_buffer();
|
||
strcpy_s(buf + pos + 1, str.size()-pos, buf + pos + 3);
|
||
}
|
||
add(str);
|
||
}
|
||
else
|
||
add(text);
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TMail_messages
|
||
///////////////////////////////////////////////////////////
|
||
|
||
TMail_messages::TMail_messages()
|
||
{ }
|
||
|
||
int TMail_messages::get(const char* senderFilter,
|
||
const char* subjectFilter,
|
||
const char* bodyFilter,
|
||
bool attach, bool mark)
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
TMAPI_session lhSession;
|
||
destroy();
|
||
if (!lhSession.open())
|
||
return 0;
|
||
|
||
TString str_msg_id(512); // Accept MAPI_LONG_MSGID
|
||
char* msg_id = str_msg_id.get_buffer();
|
||
|
||
TString str_msg_next(512); // Next MAPI message
|
||
|
||
LONG err = lpfnMAPIFindNext(lhSession, lhSession.hWnd(), NULL, NULL,
|
||
MAPI_GUARANTEE_FIFO | MAPI_LONG_MSGID,
|
||
0, msg_id);
|
||
|
||
FLAGS flags = 0;
|
||
if (!mark) flags |= MAPI_PEEK;
|
||
if (!attach) flags |= MAPI_SUPPRESS_ATTACH;
|
||
|
||
while (err == SUCCESS_SUCCESS)
|
||
{
|
||
MapiMessage FAR* pMessage = NULL;
|
||
err = lpfnMAPIReadMail(lhSession, lhSession.hWnd(), msg_id,
|
||
flags, 0, &pMessage);
|
||
|
||
if (err == SUCCESS_SUCCESS)
|
||
{
|
||
const char* id = NULL;
|
||
const char* sender = NULL;
|
||
const char* subject = NULL;
|
||
const char* body = NULL;
|
||
const char* recipient = NULL;
|
||
|
||
bool should_add = true;
|
||
if (should_add)
|
||
{
|
||
const MapiRecipDesc* pSender = pMessage->lpOriginator;
|
||
sender = pSender->lpszName;
|
||
if (senderFilter && *senderFilter)
|
||
should_add = xvt_str_compare_ignoring_case(senderFilter, sender) == 0;
|
||
}
|
||
|
||
if (should_add)
|
||
{
|
||
subject = pMessage->lpszSubject;
|
||
if (subjectFilter && *subjectFilter)
|
||
{
|
||
const unsigned lenFilter = strlen(subjectFilter);
|
||
should_add = strncmp(subject, subjectFilter, lenFilter) == 0;
|
||
}
|
||
}
|
||
|
||
if (should_add)
|
||
{
|
||
body = pMessage->lpszNoteText;
|
||
if (bodyFilter && *bodyFilter)
|
||
should_add = strstr(body, bodyFilter) != NULL;
|
||
|
||
// Toglie eventuale = finale derivante da cattiva traduzione quoted-printable
|
||
char* tail = pMessage->lpszNoteText + strlen(body)-2;
|
||
if (tail[0] == '\n' && tail[1] == '=')
|
||
*tail = '\0';
|
||
}
|
||
|
||
if (should_add)
|
||
{
|
||
TMail_message* msg = new TMail_message(recipient, subject, body, sender);
|
||
msg->set_date_time(pMessage->lpszDateReceived);
|
||
msg->set_id(msg_id);
|
||
msg->query_receipt((pMessage->flFlags & MAPI_RECEIPT_REQUESTED) != 0);
|
||
add(msg);
|
||
}
|
||
|
||
lpfnMAPIFreeBuffer(pMessage);
|
||
}
|
||
|
||
err = lpfnMAPIFindNext(lhSession, lhSession.hWnd(), NULL,
|
||
msg_id, MAPI_LONG_MSGID, 0, str_msg_next.get_buffer());
|
||
str_msg_id = str_msg_next;
|
||
}
|
||
|
||
return items();
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_messages::send(bool hide_ui)
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
TMAPI_session lhSession;
|
||
bool ok = true;
|
||
for (int i = 0; i < items(); i++)
|
||
ok &= msg(i).send(lhSession, hide_ui);
|
||
return ok;
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool TMail_messages::remove()
|
||
{
|
||
#ifdef WIN32 //verificare
|
||
TMAPI_session lhSession;
|
||
bool ok = true;
|
||
for (int i = 0; ok && i < items(); i++)
|
||
ok &= msg(i).remove(lhSession);
|
||
return ok;
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|