void provinatore_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
Fotografia foto = (Fotografia)e.UserState;
bool esistevaRisultante = foto.imgRisultante != null;
// Rilascio memoria
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Tutte);
AiutanteFoto.creaProvinoFoto(foto);
// Le due foto grandi le rilascio per non intasare la memoria qualora questo metodo è chiamato più volte
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Originale);
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Risultante);
bool esisteRisultante = foto.imgRisultante != null;
// Siccome è molto probabile che venga idratata l'immagine risultante e siccome sono in un loop,
// non posso tenere in memoria tanta roba, altrimenti esplode
if (esisteRisultante && !esistevaRisultante)
{
// Significa che l'ho idratata io in questo momento
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Risultante);
}
// Avviso tutti che questa foto è cambiata
FotoModificateMsg msg = new FotoModificateMsg(this, foto);
pubblicaMessaggio(msg);
}
public void addLogo(Fotografia fotografia, Logo logo, bool salvare)
{
if (logo == null)
{
// Rimuovo il logo dalle correzioni
// Deserializzo la stringa con le eventuali correzioni attuali
if (fotografia.correzioniXml != null)
{
CorrezioniList correzioni = SerializzaUtil.stringToObject <CorrezioniList>(fotografia.correzioniXml);
foreach (Correzione c in correzioni)
{
if (c is Logo)
{
correzioni.Remove(c);
break;
}
}
// Ora serializzo di nuovo
fotografia.correzioniXml = SerializzaUtil.objectToString(correzioni);
}
}
else
{
// Siccome ho reso il logo sommabile, questa operazione in realtà non aggiunge ma sostituisce.
addCorrezione(fotografia, logo, salvare);
}
// Ricalcolo il provino giusto per poterlo visualizzare
AiutanteFoto.creaProvinoFoto(fotografia);
}
/// <summary>
/// Elimina tutte le Correzioni da una foto e quindi ricrea il provino
/// </summary>
public void tornaOriginale(Fotografia fotografia, bool salvare)
{
fotografia.correzioniXml = null;
// Rimuovo anche eventuale file su disco
string nomeFileRis = PathUtil.nomeCompletoRisultante(fotografia);
if (File.Exists(nomeFileRis))
{
File.Delete(nomeFileRis);
}
// Rilascio memoria
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Tutte);
AiutanteFoto.creaProvinoFoto(fotografia);
// Le due foto grandi le rilascio per non intasare la memoria qualora questo metodo è chiamato più volte
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Originale);
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Risultante);
if (salvare)
{
Fotografia f = fotografia;
fotografieRepositorySrv.update(ref f, true);
fotografieRepositorySrv.saveChanges(); // Persisto nel db le modifiche
// Devo informate tutti che questa foto è cambiata
FotoModificateMsg msg = new FotoModificateMsg(this, fotografia);
pubblicaMessaggio(msg);
}
}
public void tornaOriginale(IEnumerable <Fotografia> fotografie, bool salvare)
{
foreach (Fotografia fotografia in fotografie)
{
fotografia.correzioniXml = null;
// Rimuovo anche eventuale file su disco
string nomeFileRis = PathUtil.nomeCompletoRisultante(fotografia);
if (File.Exists(nomeFileRis))
{
File.Delete(nomeFileRis);
}
// Rilascio memoria
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Tutte);
if (salvare)
{
Fotografia f = fotografia;
fotografieRepositorySrv.update(ref f, true);
fotografieRepositorySrv.saveChanges(); // Persisto nel db le modifiche
}
}
// Rifaccio tutti i provini in background
provinare(fotografie);
}
/// <summary>
/// Rileggo dal db la fotografia. In questo modo, ricopro la proprietà correzioniXml che
/// era stata modificata dall'utente applicando delle correzioni che poi non ha confermato.
/// </summary>
/// <param name="fotografia"></param>
public void undoCorrezioniTransienti(Fotografia fotografia)
{
fotografieRepositorySrv.refresh(fotografia);
fotografia.imgProvino = null; // Questo forza la rilettura del provino da disco
AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Provino);
}
private byte[] getImage(Guid fotografiaId, IdrataTarget quale)
{
byte[] bytes = null;
using (new UnitOfWorkScope()) {
var srv = LumenApplication.Instance.getServizioAvviato <IEntityRepositorySrv <Fotografia> >();
Fotografia fotografia = srv.getById(fotografiaId);
string nomeFileImg;
// Qui faccio una piccola miglioria: Se l'immagine risultante ha delle correzioni non ancora applicate, le applico adesso.
if (quale == IdrataTarget.Risultante)
{
nomeFileImg = AiutanteFoto.idrataImmagineDaStampare(fotografia);
}
else
{
nomeFileImg = AiutanteFoto.idrataImmaginiFoto(fotografia, quale);
}
bytes = File.ReadAllBytes(nomeFileImg);
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Tutte);
}
return(bytes);
}
private static void seIdErratoSpaccati(string id)
{
if (!AiutanteFoto.IsValidFotografoId(id))
{
throw new LumenException("Il codice (ID) fotografo contiene caratteri non validi");
}
}
/// <summary>
/// Uso tutti try-catch perché è importante che io arrivi a fare la dispose del DbContext,
/// altrimenti mi rimangono le entità tracciate.
/// </summary>
public void Dispose()
{
// Se ho delle fotografie caricate, rilascio le immagini
if (carrello != null && carrello.righeCarrello != null)
{
foreach (RigaCarrello riga in carrello.righeCarrello)
{
try {
AiutanteFoto.disposeImmagini(riga.fotografia);
} catch (Exception) {
}
}
}
// Se il carrello è stato modificato nel db o aggiunto al db ma non ancora committato, allora devo "tornare indietro"
if (carrello != null && isCarrelloTransient == false)
{
try {
OrmUtil.rinuncioAlleModifiche(carrello, mioDbContext);
} catch (Exception) {
}
carrello = null;
}
isCarrelloModificato = false;
// Distruggo anche il contesto. In questo modo riparto pulito per il prossimo carrello, ma sopattutto devo rilasciare le entità che sono "tracciate" da questo context
this.mioDbContext.Dispose();
this.mioDbContext = null;
}
public void OnNext(FotoModificateMsg fmMsg)
{
if (slideShow == null)
{
return;
}
foreach (Fotografia modificata in fmMsg.fotos)
{
int pos = slideShow.slides.IndexOf(modificata);
if (pos > 0)
{
AiutanteFoto.disposeImmagini(slideShow.slides[pos], IdrataTarget.Provino);
// Se la foto è stata modificata, allora mi copio le correzioni.
slideShow.slides[pos].correzioniXml = modificata.correzioniXml;
// Se ho a disposizione l'immagine del provino, me la copio, altrimenti me la rileggo da disco.
if (modificata.imgProvino != null)
{
slideShow.slides[pos].imgProvino = (Digiphoto.Lumen.Imaging.IImmagine)modificata.imgProvino;
}
else
{
AiutanteFoto.idrataImmaginiFoto(slideShow.slides[pos], IdrataTarget.Provino, true);
}
}
}
}
protected override void Dispose(bool disposing)
{
try {
// Se il tread di copia è ancora vivo, lo uccido
if (_threadIdrata != null)
{
if (_threadIdrata.IsAlive)
{
_threadIdrata.Abort();
}
else
{
_threadIdrata.Join();
}
}
} finally {
}
try {
if (this.fotografie != null)
{
foreach (Fotografia foto in this.fotografie)
{
AiutanteFoto.disposeImmagini(foto);
}
}
} finally {
}
base.Dispose(disposing);
}
// ------------------
void associareFacciaFotografo()
{
// La foto la prendo da quella selezionata
if (targetMode != TargetMode.Singola)
{
throw new InvalidOperationException("Operazione solo su singola foto");
}
if (selettoreFotografoViewModelFaccia.countElementiSelezionati != 1)
{
throw new InvalidOperationException("Non è stato selezionato un Fotografo");
}
Fotografia fotografia = getListaFotoTarget().Single();
Fotografo fotografo = selettoreFotografoViewModelFaccia.fotografoSelezionato;
AiutanteFoto.setImmagineFotografo(fotografia, fotografo);
string msg = string.Format("Impostata immagine per faccia fotografo {0}\nCon la foto numero {1}", fotografo.cognomeNome, fotografia.numero);
_giornale.Info(msg);
// Spengo la selezione per la prossima volta
selettoreFotografoViewModelFaccia.fotografiCW.deselezionaTutto();
dialogProvider.ShowMessage(msg, "Operazione riuscita");
}
public void creaProvinoANastro()
{
Fotografia f = cercaUnaFotoQuasiasi();
for (int ii = 0; ii < 100; ii++)
{
AiutanteFoto.creaProvinoFoto(f);
}
}
private void uploadNuovaImmagine()
{
string nomeFile = AiutanteUI.scegliFileImmagineDialog(null);
if (nomeFile != null)
{
AiutanteFoto.setImmagineFotografo(nomeFile, entitaCorrente);
caricaImmagineEsistente();
}
}
public void applicaCorrezioneLogo()
{
using (LumenEntities dbContext = new LumenEntities()) {
Random rnd = new Random();
ImmagineWic iw;
Fotografia foto;
do
{
int num = rnd.Next(1, 1000);
iw = null;
// Scelgo una foto qualsiasi e prendo l'immagine originale (cosi non rischio di avere già dei loghi)
foto = dbContext.Fotografie.FirstOrDefault(f => f.numero == num);
if (foto != null)
{
AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Originale);
iw = (ImmagineWic)foto.imgOrig;
}
} while(iw == null);
_correttore = new LogoCorrettore();
Logo logo = LogoCorrettore.creaLogoDefault();
/*
* logo.zoom = new Zoom {
* fattore = 3
* };
*
* logo.rotazione = new Ruota( 45 );
*
* logo.traslazione = new Trasla {
* offsetX = 100,
* offsetY = 300,
* rifW = iw.ww,
* rifH = iw.hh
* };
*/
//
logo.posiz = Logo.PosizLogo.NordEst;
vediLogo(foto.imgOrig, logo);
//
logo.posiz = Logo.PosizLogo.NordOvest;
vediLogo(foto.imgOrig, logo);
//
logo.posiz = Logo.PosizLogo.SudEst;
vediLogo(foto.imgOrig, logo);
//
logo.posiz = Logo.PosizLogo.SudOvest;
vediLogo(foto.imgOrig, logo);
}
}
/// <summary>
// azzero la gallery corrente e rilascio la memoria eventualmente utilizzata dalle foto
/// </summary>
private void svuotaGalleryCorrente()
{
if (fotografie != null)
{
foreach (Fotografia f in fotografie)
{
AiutanteFoto.disposeImmagini(f, IdrataTarget.Tutte);
}
FormuleMagiche.rilasciaMemoria();
}
fotografie = null;
}
/// <summary>
/// Se ho delle foto visibili, rilascio la memoria delle foto più pesanti
/// poi svuoto la lista
/// </summary>
void rilasciaEdAzzeraVisibili()
{
if (slidesVisibili != null)
{
// Devo rilasciare la memoria delle immagini pesanti precedenti prima di pulire
foreach (var slideVisibile in slidesVisibili)
{
AiutanteFoto.disposeImmagini(slideVisibile, IdrataTarget.Risultante);
AiutanteFoto.disposeImmagini(slideVisibile, IdrataTarget.Originale);
}
slidesVisibili.Clear();
}
}
private byte [] getImmagineFotografo(Fotografo f)
{
string nomeFile = AiutanteFoto.nomeFileImgFotografo(f);
if (nomeFile != null && File.Exists(nomeFile))
{
IGestoreImmagineSrv g = LumenApplication.Instance.getServizioAvviato <IGestoreImmagineSrv>();
return(g.load(nomeFile).getBytes());
}
else
{
return(null);
}
}
public void DisposeFotografia(Fotografia fotografia)
{
if (_fotografiaCorrente == null)
{
_fotografiaCorrente = fotografia;
}
if (_fotografiaCorrente != null && !_fotografiaCorrente.Equals(fotografia))
{
AiutanteFoto.disposeImmagini(_fotografiaCorrente, IdrataTarget.Risultante);
AiutanteFoto.disposeImmagini(_fotografiaCorrente, IdrataTarget.Originale);
_fotografiaCorrente = fotografia;
}
}
private void caricaImmagineEsistente()
{
string nomeFile = AiutanteFoto.nomeFileImgFotografo(entitaCorrente);
if (nomeFile != null && File.Exists(nomeFile))
{
IGestoreImmagineSrv g = LumenApplication.Instance.getServizioAvviato <IGestoreImmagineSrv>();
immagineFotografo = g.load(nomeFile);
}
else
{
immagineFotografo = null;
}
}
protected override bool cancella(Fotografo entita)
{
bool esito = base.cancella(entita);
if (esito == true)
{
string nomeFileImg = AiutanteFoto.nomeFileImgFotografo(entita);
try {
File.Delete(nomeFileImg);
} catch (Exception) {
_giornale.Warn("Impossibile cancellare il file con l'immagine del fotografo: " + nomeFileImg);
}
}
return(esito);
}
/** Idrato in modo asincrono gli attributi delle immagini che ho caricato */
private void idrataImmaginiFoto()
{
foreach (Fotografia fotografia in fotografie)
{
// Per essere più veloce, idrato solo l'immagine del provino.
AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Provino);
// TODO forse occorre lanciare un evento di foto caricata ???
// essendo la collezione bindabile, forse non ce ne sarà bisogno.....
// vedremo. Per ora risparmio fatica.
}
// Lancio un messaggio che dice che è stata portata a termine una nuova ricerca
LumenApplication.Instance.bus.Publish(new RicercaModificataMessaggio(this));
// Mando anche un messaggio di refresh per i provini che ho liberato
LumenApplication.Instance.bus.Publish(new RefreshMsg(this));
}
/// <summary>
/// Elimino e distruggo le foto sparse indicate
/// </summary>
/// <param name="fotosDaCanc"></param>
public int elimina(IEnumerable <Fotografia> fotosDaCanc)
{
_possoChiudere = false;
int conta = 0;
_giornale.Info("E' stata richiesta la distruzione di " + fotosDaCanc.Count() + " fotografie. Iniizo eliminazione");
LumenEntities lumenEntities = UnitOfWorkScope.currentDbContext;
foreach (Fotografia ff in fotosDaCanc)
{
Fotografia ff2 = ff;
OrmUtil.forseAttacca <Fotografia>(ref ff2);
AiutanteFoto.disposeImmagini(ff2);
// Elimino la foto da disco
seEsisteCancella(PathUtil.nomeCompletoRisultante(ff2));
seEsisteCancella(PathUtil.nomeCompletoProvino(ff2));
seEsisteCancella(PathUtil.nomeCompletoOrig(ff2));
// Poi dal database
lumenEntities.Fotografie.Remove(ff2);
_giornale.Debug("Eliminata Fotogarfia dal db: id=" + ff2.id + " num=" + ff2.numero);
++conta;
}
int test3 = lumenEntities.SaveChanges();
_giornale.Info("Eliminazione foto completata. Tot = " + conta);
_giornale.Debug("la SaveChanges ha ritornato: " + test3);
if (test3 > 0)
{
// Rilancio un messaggio in modo che tutta l'applicazione (e tutti i componenti) vengano notificati
FotoEliminateMsg msg = new FotoEliminateMsg(this as IEliminaFotoVecchieSrv);
msg.listaFotoEliminate = fotosDaCanc;
pubblicaMessaggio(msg);
}
_possoChiudere = true;
return(conta);
}
public void OnNext(FotoEliminateMsg msg)
{
if (slideShow == null)
{
return;
}
foreach (Fotografia fotoEliminata in msg.listaFotoEliminate)
{
// Elimino dalla collezione delle foto quelle che non ci sono più
int pos = slideShow.slides.IndexOf(fotoEliminata);
if (pos > 0)
{
AiutanteFoto.disposeImmagini(slideShow.slides [pos], IdrataTarget.Tutte);
slideShow.slides.Remove(fotoEliminata);
}
}
}
/// <summary>
/// Creo le immagini temporanee per darle da mangiare a gimp.
/// </summary>
/// <param name="fotografie"></param>
/// <returns></returns>
private FileInfo [] creaImmaginiTemporanee()
{
// Creo un vettore uguale a quello di partenza, con i nomi dei files temporanei che vado a creare
FileInfo [] tempFilesInfo = new FileInfo [_fotosDaModificare.Count];
for (int ciclo = 0; ciclo < _fotosDaModificare.Count; ciclo++)
{
Fotografia foto = _fotosDaModificare[ciclo];
string nomeFilePartenza = null;
// Prima verifico se esiste un file con già l'immagine risultante.
// In tal caso scelgo subito questa.
if (nomeFilePartenza == null && AiutanteFoto.esisteFileRisultante(foto))
{
nomeFilePartenza = PathUtil.nomeCompletoRisultante(foto);
}
if (nomeFilePartenza == null && foto.correzioniXml != null)
{
// TODO qui ci sono delle modifiche da apportare che non sono state ancora applicate.
// devo creare la risultante e poi ripartire dall'inizio.
// Per ora salto questo passaggio. Non ho tempo. Rimane da fare per dopo.
}
// Se ancora non ho rimediato niente prendo l'immagine originale
if (nomeFilePartenza == null)
{
nomeFilePartenza = PathUtil.nomeCompletoOrig(foto);
}
// Creo un nome di file temporaneo
string tempFile = PathUtil.dammiTempFileConEstesione(Path.GetExtension(foto.nomeFile));
// copio il file da modificare e tolgo il flag di read-only
File.Copy(nomeFilePartenza, tempFile, true);
File.SetAttributes(tempFile, FileAttributes.Normal);
tempFilesInfo [ciclo] = new FileInfo(tempFile);
Trace.WriteLine("prima len=" + tempFilesInfo [ciclo].Length + " wrtime=" + tempFilesInfo [ciclo].LastWriteTime.ToLongTimeString());
}
return(tempFilesInfo);
}
/// <summary>
/// Lancio GIMP e gli passo l'elenco delle foto indicate
/// </summary>
/// <param name="fotografie"></param>
public Fotografia [] modificaConProgrammaEsterno(Fotografia [] fotografie)
{
LanciatoreEditor lanciatore = new LanciatoreEditor(fotografie);
lanciatore.lancia();
List <Fotografia> modificate = lanciatore.applicaImmaginiModificate();
Gimp correzioneGimp = new Gimp();
foreach (Fotografia foto in modificate)
{
// Ora idrato l'immagine risultante
AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Risultante);
addCorrezione(foto, correzioneGimp, false);
}
return(modificate.ToArray());
}
/// <summary>
/// Quando lavoro con una singola foto, se vado sullo schermo del pubblico,
/// devo fare vedere la foto più bella che ho (cioè quella grande)
/// Il problema è che la foto grande, potrebbe ancora non essere stata calcolata
/// </summary>
/// <param name="fotografia"></param>
///
public void eseguiSnapshotSuFinestraPubblica(Fotografia fotografia, bool forzaAperturaWin)
{
// Se la finestra è chiusa e il flag non mi forza l'apertura non faccio niente
if (!forzaAperturaWin && _snapshotPubblicoWindow == null)
{
return;
}
FotoDisposeUtils.Instance().DisposeFotografia(fotografia);
IdrataTarget quale = AiutanteFoto.qualeImmagineDaStampare(fotografia);
AiutanteFoto.idrataImmagineDaStampare(fotografia);
IImmagine immagine = AiutanteFoto.getImmagineFoto(fotografia, quale);
forseApriSnapshotPubblicoWindow();
snapshotPubblicoViewModel.snapshotImageSource = ((ImmagineWic)immagine).bitmapSource;
}
public void removeCorrezione(Fotografia foto, Type quale)
{
// Se non ho correzioni è impossibile che ne voglio rimuovere una
if (foto.correzioniXml == null)
{
return;
}
// Deserializzo la stringa con le eventuali correzioni attuali
CorrezioniList correzioni = SerializzaUtil.stringToObject <CorrezioniList>(foto.correzioniXml);
bool rimossa = false;
foreach (Correzione cor in correzioni)
{
if (cor.GetType().Equals(quale))
{
correzioni.Remove(cor);
rimossa = true;
break;
}
}
if (!rimossa)
{
return;
}
// Ora serializzo di nuovo in stringa tutte le correzioni
if (correzioni.Count > 0)
{
foto.correzioniXml = SerializzaUtil.objectToString(correzioni);
}
else
{
foto.correzioniXml = null;
}
AiutanteFoto.creaProvinoFoto(foto);
}
/// <summary>
/// Faccio qualche controllo preventivo.
/// </summary>
/// <param name="fotografia"></param>
/// <param name="ruota"></param>
public void autoRuotaSuOriginale(Fotografia fotografia, Ruota ruota)
{
if (fotografia.correzioniXml != null)
{
throw new LumenException("Sulla foto " + fotografia.numero + " esistono correzioni.\nImpossibile ruotare sull'originale.\nRimuovere prima le correzioni (torna originale)");
}
if (!ruota.isAngoloRetto)
{
throw new ArgumentException("La rotazione sull'originale funziona solo con angoli retti");
}
string nomeFileOrig = PathUtil.nomeCompletoOrig(fotografia);
string estensione = Path.GetExtension(nomeFileOrig);
if (fotografia.imgOrig == null)
{
AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Originale);
}
IImmagine imgRuotata = applicaCorrezione(fotografia.imgOrig, ruota);
string nomeFileBackup = Path.ChangeExtension(nomeFileOrig, "BACKUP" + estensione);
if (!File.Exists(nomeFileBackup))
{
// Salvo per sicurezza il file originale
File.Move(nomeFileOrig, nomeFileBackup);
}
fotografia.imgOrig = imgRuotata;
gestoreImmaginiSrv.save(imgRuotata, nomeFileOrig);
AiutanteFoto.creaProvinoFoto(fotografia);
// Libero memoria. Lascio solo il provino
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Originale);
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Risultante);
}
private void viewFotoFullScreen()
{
// Qui devo capire quale foto verrà idratata
IdrataTarget quale = AiutanteFoto.qualeImmagineDaStampare(singolaFotoTarget);
// Qui idrato
AiutanteFoto.idrataImmagineDaStampare(singolaFotoTarget);
// Qui ricavo la foto
IImmagine img = AiutanteFoto.getImmagineFoto(singolaFotoTarget, quale);
var imageSource = ((ImmagineWic)img).bitmapSource as ImageSource;
// Qui passo la foto al viewmodel che la deve visualizzare
PanAndZoomViewModel panZommViewModel = new PanAndZoomViewModel(imageSource);
// TODO anti-pattern : aprire finestre nel WiewModel.
// usare openPopupDialogRequest come già fatto per associazione faccia fotografo
PanAndZoomWindow w = new Digiphoto.Lumen.UI.PanAndZoom.PanAndZoomWindow();
w.DataContext = panZommViewModel;
w.ShowDialog();
}
/// <summary>
///
/// </summary>
/// <param name="values">Un array di oggetti cosi: composto:</br>
/// indice = 0 : un oggetto Fotografia
/// indice = 1 : un viewModel (o una qualsiasi classe) che implementi l'interfaccia IContenitoreGriglia
/// </param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns>una ImageSource</returns>
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
ImageSource imageSource = null;
try {
Fotografia fotografia = (Fotografia)values[0];
IContenitoreGriglia vmContenitoreGriglia = (IContenitoreGriglia)values[1];
IdrataTarget quale;
// Se sto visualizzando una sola foto, oppure due affiancate su di una riga .... scelgo alta qualita
if (vmContenitoreGriglia != null &&
richiedeAltaQualita(vmContenitoreGriglia.numRighe, vmContenitoreGriglia.numColonne))
{
// ALTA QUALITA (più lento)
quale = AiutanteFoto.qualeImmagineDaStampare(fotografia);
AiutanteFoto.idrataImmagineDaStampare(fotografia);
}
else
{
// BASSA QUALITA (più veloce)
quale = IdrataTarget.Provino;
}
IImmagine immagine = AiutanteFoto.getImmagineFoto(fotografia, quale);
if (immagine != null)
{
imageSource = ((ImmagineWic)immagine).bitmapSource as ImageSource;
}
} catch (Exception ee) {
_giornale.Error("estrazione immagine fallita", ee);
// Alcune immagini possono essere rovinate o mancanti. Devo proseguire.
imageSource = null;
}
return(imageSource);
}
