private void Update_Ablage_Click(object sender, RoutedEventArgs e)
 {
     if (string.IsNullOrEmpty(txtAblageort.Text) == true)
     {
         MessageBox.Show("Ablageort fehlt!");
     }
     if (string.IsNullOrEmpty(txtBeschreibung.Text) == true)
     {
         MessageBox.Show("Beschreibung fehlt!");
     }
     else
     {
         ablage.Ablageort    = txtAblageort.Text.Trim();
         ablage.Beschreibung = txtBeschreibung.Text.Trim();
         using (SammlungDataClassDataContext conn = new SammlungDataClassDataContext())
         {
             Ablage abl = (from a in conn.Ablage where a.ID == ablage.ID select a).FirstOrDefault();
             abl.Ablageort    = ablage.Ablageort;
             abl.Beschreibung = ablage.Beschreibung;
             conn.SubmitChanges();
             MessageBox.Show(abl.Ablageort + " wurde übenommen.");
             DialogResult = false;
         }
     }
 }
예제 #2
0
 /// <summary>
 /// Erstellt ein neues Einzelergebnis.
 /// </summary>
 /// <param name="ergebnis">Die Informationen aus der Ablage.</param>
 private Einzelergebnis( Ablage.Spielergebnis ergebnis )
 {
     // Übernehmen
     Datum = ergebnis.Endzeitpunkt.ToLocalTime().ToString( "dd.MM HH:mm" );
     Gesamtergebnis = ergebnis.Gesamtergebnis;
     Restenergie = ergebnis.Restenergie;
     Punkte = ergebnis.Punkte;
 }
예제 #3
0
        public ActionResult DeleteConfirmed(int id)
        {
            Ablage ablage = db.Ablages.Find(id);

            db.Ablages.Remove(ablage);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
예제 #4
0
        /// <summary>
        /// Erstellt eine neue Verwaltung.
        /// </summary>
        /// <param name="ergebnisse">Die direkte Verwaltung der Ablagestrukturen.</param>
        internal Ergebnisse( Ablage.Spielergebnisse ergebnisse )
        {
            // Prüfen
            if (ergebnisse == null)
                throw new ArgumentNullException( "ergebnisse" );

            // Merken
            m_ergebnisse = ergebnisse;
        }
예제 #5
0
 public ActionResult Edit([Bind(Include = "Id,Bezeichnung")] Ablage ablage)
 {
     if (ModelState.IsValid)
     {
         db.Entry(ablage).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(ablage));
 }
예제 #6
0
        public ActionResult Create([Bind(Include = "Id,Bezeichnung")] Ablage ablage)
        {
            if (ModelState.IsValid)
            {
                db.Ablages.Add(ablage);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(ablage));
        }
예제 #7
0
        // GET: Ablages/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Ablage ablage = db.Ablages.Find(id);

            if (ablage == null)
            {
                return(HttpNotFound());
            }
            return(View(ablage));
        }
예제 #8
0
        private void Button_Click_Info(object sender, RoutedEventArgs e)
        {
            Ablage selected = DGAblage.SelectedItem as Ablage;

            if (selected == null)
            {
                MessageBox.Show("Bitte einen Ablageort auswählen!");
                return;
            }
            UpdateAblageOrte updateAblage = new UpdateAblageOrte(selected);

            updateAblage.ShowDialog();
            LoadDGAblage();
            //DialogResult = false;
        }
예제 #9
0
        private void Button_Click_Delete(object sender, RoutedEventArgs e)
        {
            Ablage selected = DGAblage.SelectedItem as Ablage;

            if (selected == null)
            {
                MessageBox.Show("Bitte den zu löschenden Ablagort auswählen!");
            }
            else
            {
                if (MessageBoxResult.Yes == MessageBox.Show("Wirklich löschen?", "Ablageort löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning))
                {
                    using (SammlungDataClassDataContext conn = new SammlungDataClassDataContext())
                    {
                        var abl = from a in conn.Ablage where a.ID == selected.ID select a;
                        conn.Ablage.DeleteAllOnSubmit(abl);
                        conn.SubmitChanges();
                    }

                    LoadDGAblage();
                }
            }
        }
예제 #10
0
 private void Add_Ablage_Click(object sender, RoutedEventArgs e)
 {
     if (string.IsNullOrEmpty(txtAblageort.Text) == true)
     {
         MessageBox.Show("Ablageort fehlt!");
     }
     if (string.IsNullOrEmpty(txtBeschreibung.Text) == true)
     {
         MessageBox.Show("Beschreibung fehlt!");
     }
     else
     {
         Ablage abl = new Ablage();
         abl.Ablageort    = txtAblageort.Text.Trim();
         abl.Beschreibung = txtBeschreibung.Text.Trim();
         using (SammlungDataClassDataContext conn = new SammlungDataClassDataContext())
         {
             conn.Ablage.InsertOnSubmit(abl);
             conn.SubmitChanges();
         }
         MessageBox.Show(abl.Ablageort + " wurde hinzugefügt.");
         DialogResult = true;
     }
 }
예제 #11
0
 /// <summary>
 /// Erstellt eine neue Präsentation.
 /// </summary>
 /// <param name="ergebnisse">Die Verwaltung der Spielergebnisse.</param>
 public Ergebnisse( Ablage.Spielergebnisse ergebnisse )
 {
     // Merken
     m_ergebnisse = ergebnisse;
 }
예제 #12
0
 /// <summary>
 /// Erstellt ein neues Einzelergebnis.
 /// </summary>
 /// <param name="ergebnis">Die Informationen aus der Ablage.</param>
 /// <returns>Die Präsentation des Ergebnisses.</returns>
 public static Einzelergebnis Erzeuge( Ablage.Spielergebnis ergebnis )
 {
     // Anlegen
     return new Einzelergebnis( ergebnis );
 }
예제 #13
0
        /// <summary>
        /// Erstellt die Repräsentation eines Spiels.
        /// </summary>
        /// <param name="spielKonfiguration">Die Konfiguration des Spiels.</param>
        /// <param name="spielfigur">Eine bereits vorbereitete Spielfigur.</param>
        /// <returns>Die angeforderte Repräsentation.</returns>
        public static Spiel ErzeugePräsentation( this Ablage.Spiel spielKonfiguration, Ablage.Spielfigur spielfigur )
        {
            // Prüfen
            if (spielKonfiguration == null)
                return null;
            if (spielfigur == null)
                throw new ArgumentNullException( "spielfigur" );

            // Das Spielfeld ist fest mit dem Spiel verbunden
            var spielfeld = spielKonfiguration.Spielfeld;

            // Präsentation der Spielfigur auf dem Spielfeld
            var figur =
                new FigurElement<IVerbinderErzeuger>
                (
                    spielfeld.InitialePosition.X,
                    spielfeld.InitialePosition.Y,
                    spielfigur.ErzeugePräsentation(),
                    () => new SpielerErzeuger<IVerbinderErzeuger>( spielfigur, spielfeld )
                );

            // Erzeugen
            var spiel =
                Spiel.Erzeugen
                (
                    spielKonfiguration.SichtfensterBreite,
                    spielKonfiguration.SichtfensterHoehe,
                    spielfeld.ErzeugePräsentation( figur ),
                    figur,
                    SimulationsVerbinder.SpielumgebungAufsetzen
                );

            // Melden
            return spiel;
        }
예제 #14
0
        /// <summary>
        /// Erstellt eine neue Präsentation für ein Element.
        /// </summary>
        /// <param name="element">Das zu verwendende Element.</param>
        /// <returns>Eine neue Präsentation.</returns>
        public static Element ErzeugePräsentation( Ablage.Element element )
        {
            // Prüfen
            if (element == null)
                throw new ArgumentNullException( "element" );

            // Element mit Bild
            var elementMitBild = element as Ablage.ElementMitBildSequenz;
            if (elementMitBild != null)
                return
                    new BildElement<IVerbinderErzeuger>
                    (
                        elementMitBild.Name,
                        !elementMitBild.AnfänglichUnsichtbar,
                        elementMitBild.HorizontalePosition,
                        elementMitBild.VertikalePosition,
                        elementMitBild.Bilder.ErzeugePräsentation(),
                        elementMitBild.BilderProSekunde,
                        elementMitBild.Ebene,
                        () => new BildElementErzeuger( elementMitBild )
                    );

            // Anlegen
            return
                new Element<IVerbinderErzeuger>
                (
                    element.Name,
                    !element.AnfänglichUnsichtbar,
                    element.HorizontalePosition,
                    element.VertikalePosition,
                    element.Breite,
                    element.Hoehe,
                    -1,
                    () => new ElementErzeuger( element )
                );
        }
 public UpdateAblageOrte(Ablage ablage)
 {
     InitializeComponent();
     this.ablage = ablage;
 }