private static ImageSource caricaMascheraDaCorrezioneXml(string correzioneXml)
        {
            ImageSource    imageSource = caricaImmagineDefault();
            CorrezioniList correzioni  = SerializzaUtil.stringToObject <CorrezioniList>((String)correzioneXml);

            ImmagineWic  immagineMaschera = null;
            Mascheratura mascheratura     = null;

            if (correzioni != null && correzioni.Contains(typeof(Mascheratura)))
            {
                mascheratura = (Mascheratura)correzioni.FirstOrDefault(c => c is Mascheratura);
            }
            if (correzioni != null && correzioni.Contains(typeof(MascheraturaOrientabile)))
            {
                MascheraturaOrientabile mo = (MascheraturaOrientabile)correzioni.FirstOrDefault(c => c is MascheraturaOrientabile);
                mascheratura = mo.mascheraturaH ?? mo.mascheraturaV;
            }


            if (mascheratura != null)
            {
                immagineMaschera = new ImmagineWic(Path.Combine(PathUtil.getCartellaMaschera(FiltroMask.MskSingole), mascheratura.nome));
            }

            if (immagineMaschera != null)
            {
                imageSource = ((ImmagineWic)immagineMaschera).bitmapSource as ImageSource;
            }

            return(imageSource);
        }
Example #2
0
        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);
        }
Example #3
0
        public IList <T> converteCorrezioni <T>(Fotografia fotografia)
        {
            if (fotografia.correzioniXml == null)
            {
                return(null);
            }

            CorrezioniList correzioni = SerializzaUtil.stringToObject <CorrezioniList>(fotografia.correzioniXml);

            return(converteCorrezioni <T>(correzioni));
        }
Example #4
0
        private Mascheratura estraiMascheratura(AzioneAuto azioneAuto)
        {
            if (azioneAuto.correzioniXml == null)
            {
                return(null);
            }

            CorrezioniList correzioniList = SerializzaUtil.stringToObject <CorrezioniList>(azioneAuto.correzioniXml);

            if (correzioniList == null || correzioniList.Count < 1)
            {
                return(null);
            }

            return((Mascheratura)correzioniList.FirstOrDefault(c => c is Mascheratura));
        }
        public static bool determinaSeComposizione(string correzioniXml)
        {
            bool composizione = false;

            CorrezioniList          correzioniList          = null;
            MascheraturaOrientabile mascheraturaOrientabile = null;

            // Controllo che l'azione corrente contenga una mascheratura orientabile
            correzioniList = SerializzaUtil.stringToObject <CorrezioniList>(correzioniXml);
            if (correzioniList != null && correzioniList.Count > 0)
            {
                mascheraturaOrientabile = (MascheraturaOrientabile)correzioniList.SingleOrDefault(mo => mo is MascheraturaOrientabile);
                composizione            = (mascheraturaOrientabile != null);
            }

            return(composizione);
        }
Example #6
0
        public void objectToStringTest()
        {
            CorrezioniList lista = new CorrezioniList();

            lista.Add(new Ruota()
            {
                gradi = 35
            });
            lista.Add(new BiancoNero());
            lista.Add(new Ruota()
            {
                gradi = 50
            });

            string ris = SerializzaUtil.objectToString(lista, typeof(CorrezioniList));



            object oo = SerializzaUtil.stringToObject(ris, typeof(CorrezioniList));
        }
Example #7
0
        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);
        }
Example #8
0
        /// <summary>
        /// Se una azione automatica contiene una mascheratura orientabile (quindi doppia)
        /// posso disassociarla e creare una nuova azione
        /// </summary>
        void disassociareMascheratura()
        {
            CorrezioniList correzioniList = null;
            AzioneAuto     azioneAuto     = azioneAutomaticaSelezionata;

            MascheraturaOrientabile mascheraturaOrientabile = null;

            // Controllo che l'azione corrente contenga una mascheratura orientabile
            if (azioneAuto.correzioniXml != null)
            {
                correzioniList = SerializzaUtil.stringToObject <CorrezioniList>(azioneAuto.correzioniXml);
                if (correzioniList != null && correzioniList.Count > 0)
                {
                    mascheraturaOrientabile = (MascheraturaOrientabile)correzioniList.SingleOrDefault(mo => mo is MascheraturaOrientabile);
                }
            }

            if (mascheraturaOrientabile == null)
            {
                dialogProvider.ShowError("L'azione selezionata non contiene una <MascheraturaOrientabile>.\nSolo queste si possono separare!", "Azione non separabile", null);
                return;
            }

            // ok procedo a separare le cornici
            // Sostituisco la correzione nella lista, cercando di mettere quella nuova nella stessa posizione
            Mascheratura masH = mascheraturaOrientabile.mascheraturaH;
            Mascheratura masV = mascheraturaOrientabile.mascheraturaV;

            // Elimino la mascheratura doppia ...
            correzioniList.Remove(mascheraturaOrientabile);
            // aggiungo solo la mascheratura Orizzontale
            correzioniList.Insert(0, masV);

            // Aggiorno l'entità sul db
            OrmUtil.forseAttacca <AzioneAuto>(ref azioneAuto);
            azioneAuto.correzioniXml = SerializzaUtil.objectToString(correzioniList);

            // Ora creo l'altra azione
            CorrezioniList correzioniList2 = new CorrezioniList();

            correzioniList2.Add(masH);
            AzioneAuto azioneV = new AzioneAuto {
                id            = Guid.NewGuid(),
                attivo        = true,
                nome          = "Separata",
                correzioniXml = SerializzaUtil.objectToString(correzioniList2)
            };

            UnitOfWorkScope.currentDbContext.AzioniAutomatiche.Add(azioneV);

            // Ora aggiungo anche alla collezione visiva
            azioniAutomatiche.Add(azioneV);

            deselezionareTutto();

            // Purtroppo non si aggiornano le icone di overlay. devo ricaricare.
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                rileggereAzioniAutomaticheCommand.Execute(null);
            }
                                                          ));
        }
Example #9
0
        void forseAssociareMaschere()
        {
            if (!modalitaAssociazione)
            {
                return;
            }

            // Per poter iniziare l'associazione, ocorre che la riga selezionata, contenga una mascheratura
            Mascheratura mascheratura2 = estraiMascheratura(azioneAutomaticaSelezionata);

            if (mascheratura2 == null)
            {
                dialogProvider.ShowError("L'azione selezionata non contiene Mascheratura", "Azioni non associate", null);
                return;
            }

            // Dalla prima azione, estraggo la mascheratura, perché devo controllare che sia di Orientamento opposto alla prima che ho fissato.
            CorrezioniList correzioni1   = SerializzaUtil.stringToObject <CorrezioniList>(azioneAutoAssociare1.correzioniXml);
            Mascheratura   mascheratura1 = (Mascheratura)correzioni1.ToList <Correzione>().FirstOrDefault(c => c is Mascheratura);

            var ratio1 = mascheratura1.width / mascheratura1.height;
            var ratio2 = mascheratura2.width / mascheratura2.height;

            if ((ratio1 < 1 && ratio2 < 1) || (ratio1 > 1 && ratio2 > 1))
            {
                dialogProvider.ShowError("Le maschere devono ossere di diverso orientamento.\nUna orizzontale ed una verticale!", "Azioni non associate", null);
                return;
            }

            // Ok : adesso posso procedere alla associazione

            MascheraturaOrientabile mo = new MascheraturaOrientabile();

            mo.mascheraturaH = (ratio1 < 1 ? mascheratura2 : mascheratura1);
            mo.mascheraturaV = (ratio1 < 1 ? mascheratura1 : mascheratura2);

            using (new UnitOfWorkScope()) {
                // Sostituisco la correzione nella lista, cercando di mettere quella nuova nella stessa posizione
                int pos = correzioni1.IndexOf(mascheratura1);
                correzioni1.RemoveAt(pos);
                correzioni1.Insert(pos, mo);

                // Rimuovo l'azione2 dalla collezione a video
                AzioneAuto azioneDacanc = azioneAutomaticaSelezionata;
                azioniAutomatiche.Remove(azioneDacanc);

                // Ora vado ad aggiornare l'azione1 con le correzioni nuove
                AzioneAuto azione = azioneAutoAssociare1;
                OrmUtil.forseAttacca <AzioneAuto>(ref azione);
                azioneAutoAssociare1.correzioniXml = SerializzaUtil.objectToString(correzioni1);

                // Elimino dal db la azione2
                OrmUtil.forseAttacca <AzioneAuto>(ref azioneDacanc);

                // Rimuovo l'azione dal database
                UnitOfWorkScope.currentDbContext.AzioniAutomatiche.Remove(azioneDacanc);

                UnitOfWorkScope.currentDbContext.SaveChanges();

                // Torno in modalità normale
                modalitaAssociazione = false;
            }

            // Purtroppo non si aggiornano le icone di overlay. devo ricaricare.
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                rileggereAzioniAutomaticheCommand.Execute(null);
            }
                                                          ));
        }
Example #10
0
        /// <summary>
        /// Aggiungo una correzione a quelle già eventualmente presenti sulla foto.
        /// Se la correzione esiste già, gestisco eventuale somma, oppure rimozione in caso che sia inutile (ininfluente)
        /// </summary>
        /// <param name="fotografia">la foto</param>
        /// <param name="correzione">la correzione da aggiungere</param>
        public void addCorrezione(Fotografia fotografia, Correzione correzioneNuova, bool salvare)
        {
            CorrezioniList correzioni;

            // Deserializzo la stringa con le eventuali correzioni attuali
            if (fotografia.correzioniXml == null)
            {
                correzioni = new CorrezioniList();
            }
            else
            {
                correzioni = SerializzaUtil.stringToObject <CorrezioniList>(fotografia.correzioniXml);
            }


            // Alcune correzioni, non devono andare sempre in aggiunta, ma possono sommarsi l'un l'altra.
            // Per esempio la rotazione. Se ruoto 90° poi altri 90, l'effetto finale è quello di avere una sola da 180°
            Correzione daSost  = null;
            Correzione vecchia = null;

            foreach (Correzione c in correzioni)
            {
                if (c.isSommabile(correzioneNuova))
                {
                    vecchia = c;
                    daSost  = c.somma(correzioneNuova);
                    break;
                }
            }

            if (daSost != null)
            {
                // Sostituisco la correzione con quella ricalcolata
                if (daSost.isInutile)
                {
                    correzioni.Remove(vecchia);
                }
                else
                {
                    correzioni.sostituire(vecchia, daSost);
                }
            }
            else
            {
                // Aggiungo in fondo (se la correzione è inutile, allora non aggiungo nulla)
                if (!correzioneNuova.isInutile)
                {
                    correzioni.Add(correzioneNuova);
                }
            }

            // Ora serializzo di nuovo in stringa tutte le correzioni
            fotografia.correzioniXml = SerializzaUtil.objectToString(correzioni);

            if (salvare)
            {
                fotografieRepositorySrv.saveChanges();                  // Persisto nel db le modifiche

                AiutanteFoto.creaProvinoFoto(fotografia);

                // Devo informare tutti che questa foto è cambiata
                FotoModificateMsg msg = new FotoModificateMsg(this, fotografia);
                pubblicaMessaggio(msg);
            }
        }