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); }