Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Ayke
Thema: Custom GUI für Mono for Android
Am im Forum: Rund um die Programmierung

Hallo Leute,

könnt ihr mir sagen wie ich eine Benutzerdefinierte Oberfläche mit Mono for Android erzeuge. Ich möchte einen Media Player schreiben. Gibt es da ähnliche möglichkeiten wie in WPF oder muss ich HTML mit Bildern benutzen ? Wenn jaa wie bind ich das ein ??

Thema: Mono for Android: Wie leuft die Installation von der Laufzeitumgebung auf Android.
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Hallo,

ich habe nur eine ganz kurze Frage:
"Wenn ich mit Mono for Android eine Anwendung erstelle, wie wird dan die Laufzeitumgebung auf den Android installiert ? Für eine kleine App ist schon eine seperate Installation ein hindernis für die Benutzer."

Thema: VS: Installation von Setup/Update-Datei: Die Anwendungsdatei "Setup.msi" kann nicht gefunden werden
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

nur mal eine Vermutung...
"Setup[3].msi" != "Setup.msi"

Thema: Assembly nach Typ durchsuchen funktioniert nicht.
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Das Argument ist vill doch aus einen anderen Grund leer. Die Methode AppDomain.Load sollte laut msdn nicht dafür verwendet werden um eine Assembly in eine AppDomain zu laden, die nicht die Ausführende ist.
How to: Load Assemblies into an Application Domain


Ein Alternative ist die Methode "CreateInstanceAndUnwrap".
Plugins mit AppDomains realisieren
Plugin Manager

Thema: Wieviel kann man als (Werks-) Student verlangen?
Am im Forum: Smalltalk

5-10 € kommt vill bei vWorker & co rum. Das ist für mich kein normaler Stundenlohn. Da kann man gleich nach Ghana ziehen oder im Lager arbeiten.

In vielen anderen Berufen wo ein Stundenlohn von 9 - 14 € normal ist hat man höchstens 3 Jahre gelernt und danach ist alles nur Routine. Als Entwickler lernst du dein ganzen Leben. Wer infomiert, verbessert sich leidenschaftlich, damit man finanziell mit Leuten die weniger machen gleichgestellt wird ?

Ich würde das nehmen was man rausbekommt. Ist für dich besser und für den Markt.

Thema: Assembly nach Typ durchsuchen funktioniert nicht.
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Wenn du eine assembly nicht über seinen pfad sondern direkt als byte array lädst, hat die assembly keinen vollständigen Namen (Fully Qualified assembly name). Deshalb ist in der AssemblyResolve methode ResolveEventArgs argument gleich null.

Load(AssemblyName.GetAssemblyName(path))

Im AssemblyResolve Event kanst du dan die Assembly so laden wie du
es bisher machst und diese dan zurückgeben.

Thema: Unterschiedlichen Typen in List<Interface> finden
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

ich würde einefach die liste mit einer schleife interieren und dan

if (listItem is A)
... listItem.DoSomething();

Thema: Teamspeak 3 SDK verwenden
Am im Forum: Rund um die Programmierung

        [DllImport("kernel32.dll")]
        internal static extern IntPtr LoadLibrary(String dllname);

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        internal static extern bool FreeLibrary(IntPtr hModule);

        [DllImport("kernel32.dll")]
        internal static extern IntPtr GetProcAddress(IntPtr hModule, String procname);

        internal delegate int MyFuncDelegate(int myParam);

        static void Main(string[] args)
        {
            //Modul laden
            IntPtr hModule = LoadLibrary("TeamSpeakLibraryPfad");
            //Funktions adresse bekommen
            IntPtr proc = GetProcAddress(hModule, "Funktionname");
            //Funktions addresse in delegate
            MyFuncDelegate meineNativeFunction = (MyFuncDelegate)
                Marshal.GetDelegateForFunctionPointer(proc, typeof(MyFuncDelegate));
            //Funktion aufrufen
            int retVal = meineNativeFunction.Invoke(123);
            //Modul entladen wenn nicht mehr gebraucht wird
            FreeLibrary(hModule);
        }

Thema: Suche Liegestuhl für PC- Arbeit
Am im Forum: Smalltalk

Hallo herbivore,
viele Stühle lassen sich auch Winkel verstellen, das sogar Elektronisch.
Die Tastatur und der Bildschirm müsste an irgendeiner Konstruktion befestigt sein die sich relativ dynamisch verstellen läst. Das mit der Maus wird dann etwas schwierig, da gibt es aber auch Alternativen.

Hallo t2t,
werde auf jeden Fall meine Erfahrungen berichten, wenn ich alles habe.

Hallo Tefnut,
mache Sport der sogar besonders den Rücken beansprucht, 1h gleichen aber nicht den Rest des Tages aus. Und ein Ball ist mir zu unbequem ^^

Thema: Suche Liegestuhl für PC- Arbeit
Am im Forum: Smalltalk

Sieht nett aus. Bin Handwerklich nicht allzu begabt. Werd mich mal beim Saturn & co umschauen. Da gibt diese Massagestühle die teilweise in alle Richtungen verstellbar sind, vielleicht findet man da ja einen passenden.

Thema: Suche Liegestuhl für PC- Arbeit
Am im Forum: Smalltalk

Genial !!! Leider habe ich auch keine 40.000 € übrig :(

Für ein Bruchteil des Geldes könnte man sich was anfertigen lassen oder auch selber bauen. Irgendwas mach bestimmt den ich habe absolut keine Lust mehr auf Bürostühle. Vor-allem diese ergonomischen sind völlig unbequem und ich kann es auch nicht lassen mich nach vorn zu lehnen um 2cm vor den Bildschirm zu hängen.

Thema: Suche Liegestuhl für PC- Arbeit
Am im Forum: Smalltalk

Hallo,

ich bin auf der Suche nach einen Liegestuhl. Müsste gesünder für die Schultern, Rücken sein und bequemer dürfte es dadurch auch werden.
Am besten so einen wie der etwas beleibte in Stirb langsam 4.0 im Keller stehen hat. Leinwand wäre auch schön, dürfte aber die Augen zu stark beanspruchen.

Hab nur den hier "Surf Chair" gefunden ... Gibt es aber nicht zu kaufen.

Hab mir das so vorgestellt das das Keyboard und die Mouse auf einer Oberfläche mit Gelenkarm liegen die beim zurück fahren vor einen sind. Vorne am Stuhl sollte es die Möglichkeit geben den Bildschirm aufzustellen.

Thema: String Split mit TSQL
Am im Forum: Datentechnologien

Hallo,

ich versuche aus einer Spalte, einen String der eine bestimmte Zeichenfolge enhält zu spliten. Die Zeichenfolgen sehen ungefähr so aus.

MeineTabelle.MeineSpalte.Datensatz1
{
abcdef abcdef 12345\r
gijgge grgerg 09482
}

MeineTabelle.MeineSpalte.Datensatz2
{
arercef vvcdef 12345\r
gijbvbe ggterg 09482
}

Jetzt durchsuche ich die Spalte auf einen Wert z.b 12345
Ein View soll dan folgende Spalten zugewiesen bekommen.

Datensatz 1
var1 = abcdef
var2 = abcdef
var3 = 12345

Datensatz 2
var1 = arercef
var2 = vvcdef
var3 = 12345

habe nur sehr oberflächliche Kenntnisse vom SQL Kontext. Ich möchte sehr ungerne wegen dieser Kleinigkeit mich lange mit TSQL befassen (das hat später noch Zeit). Hab mir schon paar links angeschaut. Irrelang !

verwendetes Datenbanksystem: MSSQL 2005

Thema: .NET und ihre "Plattformunabhängigkeit"...
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

danke für eure Antworten,
ich wollte eingleich auf nix genaues hinaus. Wollte einfach nur meine Meinung sagen :) und vill ist ja Mono wirklich eine alternative.

Thema: .NET und ihre "Plattformunabhängigkeit"...
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Hi,
ich bin grade dabei mich mit Unix zu beschäftigen. Was mich an einen kompletten umstieg auf eine Linux- Distribution hindert ist das .NET Framework.

Klar gibt es Mono, aber wenn ich auf Unix mit .NET arbeiten möchte muss ich bestimmt die Namensräume und Klassen von Mono kennenlernen. Außerdem bin ich mit Visual Studio sehr zufrieden und ich bin mir nicht sicher ob es in der Linux- Welt eine bessere oder gleichzusetzende IDE gibt.

Mono ist leider auch nicht auf dem aktuellsten Stand und ich bezweifle mal das es wirklich stabil läuft (Ich möchte keine vorurteile in die Welt setzten, wenn das nicht stimmt könnt ihr mich auch gerne berichtigen). Mono an sich ist einer super Projekt doch könnte mann das nicht einfacher umsetzten ? Microsoft könnte ein wenig dazu beisteuern.

Microsoft könnte auch ihre Quellcodes veröffentlichen, damit das portieren leichter fällt (Nervt auch wenn mann einfach mal reinschauen muss. Reflector zeigt mir auch nicht immer den Quellcode). Es kann doch nur in Microsofts Interesse sein .NET möglichst zugänglich zu machen, damit es irgendwann mal Java ablösen kann.

Thema: Exemplarische Instanzen (ungenaue oder falsche Übersetzungen von englischen Fachbegriffen)
Am im Forum: Smalltalk

Hauptsache jeder weiß was gemeint ist. Und da wir jetzt auch wissen was es mit Exemplar auf sich hat, verstehen wir auch herbivore

Thema: Architektur eines CAD-Systems zur 2D-Darstellung von Fensteranlagen (für Häuser)
Am im Forum: Grafik und Sound

danke gfoidl,
hast das gut auf den Punkt gebracht.

Thema: Architektur eines CAD-Systems zur 2D-Darstellung von Fensteranlagen (für Häuser)
Am im Forum: Grafik und Sound

Hallo gfoidl,

das Ziel ist über einen Dialog verschiedene Infomationen zu Fenstern
einzugeben. Danach soll ein Bild einer Fensteranlage erstellt werden.
Siehe Anhang...

Erstmal nur eckige Fenster, später auch Bogenfenster und weitere Exoten.
Bei den Bild sollen Abmessung automatisch für die ganze Anlage und pro Fenster erstellt werden.

Bei jedem Fenster sollen folgende Angaben zur verfügung stehen.
1. X Postion oder Column
2. Y Postion oder Row
3. Breite
4. Höhe
5. Auf welcher Seiten kann das Fenster geöffnet werden.
6. Auf welcher Seiten ist die Bedienung um das Fenster zu öffnen.
7. Ist überhaupt ein "Beschlag? auf den Rahmen". Ohne Öffnung wäre der nicht nötig.
8. Wie Breit ist der Beschlag (Ich bin mir nicht sicher wie das Ding heißt was auf den Rahmen sitzt.)

Beim zusammenführen der Fenster zu einer Fensteranlage müssen noch kleinigkeiten berücksichtigt werden. z.B Wenn 2 Fenster die selbe Höhe haben und genau nebeneinander sind, wird auf der Seite wo sich diese berühren nicht mit einen Rahmen abgeschlossen sondern durch eine Stelze getrennt.

Das Ziel meines Beitrags soll sein, herauszufinden ob mein Klassendesin sinn macht. Ob es da nicht schönere oder einfachere Umsetzung gibt. Vill findet mann ja Opensource oder jemand von euch hatte schon eine ähnliche Lösung die mir helfen kann. Vielleicht sollte mann eine ganz andere Technologie verwenden. Am besten alles was einen einfällt um mir die Sache zu erleichtern.

Die Lösung wirkt recht Simple, mann stößt aber stendig an irgenwelche Probleme. Damit meine ich die Sache mit den Linien.
Auserdem stört mich das ich mit jeder weiteren Drawing Klasse mehr zu rechnen habe, das weist auf eine Design Schwäche hin oder nicht. Hier mal ein Auschnitt von diesen Wirwar...

drawingContainer.RahmenInside.Coordinates
   = new Points(HaveStelzeLeft ? Context.BreiteStelzen / 2 : drawingContainer.RahmenOutside.Coordinates.X + Context.BreiteRahmen, drawingContainer.RahmenOutside.Coordinates.Y + Context.BreiteRahmen,
                drawingContainer.RahmenOutside.Coordinates.Width - Context.BreiteRahmen * 2 +
                (HaveStelzeLeft ? (Context.BreiteRahmen - Context.BreiteStelzen / 2) : 0) +
                (HaveStelzeRight ? (Context.BreiteRahmen - Context.BreiteStelzen / 2) : 0),
                drawingContainer.RahmenOutside.Coordinates.Height - Context.BreiteRahmen * 2,
                0, 0, drawingContainer.RahmenOutside.Coordinates.Width - Context.BreiteRahmen * 2 +
                (HaveStelzeLeft ? (Context.BreiteRahmen - Context.BreiteStelzen / 2) : 0) +
                (HaveStelzeRight ? (Context.BreiteRahmen - Context.BreiteStelzen / 2) : 0), drawingContainer.RahmenOutside.Coordinates.Height - Context.BreiteRahmen * 2);
drawingContainer.BeschlagOutside.Coordinates
   = new Points(drawingContainer.RahmenInside.Coordinates.X - Context.BreiteBeschlag / 2, drawingContainer.RahmenInside.Coordinates.Y - Context.BreiteBeschlag / 2,
                drawingContainer.RahmenInside.Coordinates.Width + Context.BreiteBeschlag, drawingContainer.RahmenInside.Coordinates.Height + Context.BreiteBeschlag,
                0, 0, drawingContainer.RahmenInside.Coordinates.Width + Context.BreiteBeschlag, drawingContainer.RahmenInside.Coordinates.Height + Context.BreiteBeschlag);
drawingContainer.BeschlagInside.Coordinates
   = new Points(drawingContainer.RahmenInside.Coordinates.X + Context.BreiteBeschlag / 2, drawingContainer.RahmenInside.Coordinates.Y + Context.BreiteBeschlag / 2,
                drawingContainer.RahmenInside.Coordinates.Width - Context.BreiteBeschlag, drawingContainer.RahmenInside.Coordinates.Height - Context.BreiteBeschlag,
                0, 0, drawingContainer.RahmenInside.Coordinates.Width - Context.BreiteBeschlag, drawingContainer.RahmenInside.Coordinates.Height - Context.BreiteBeschlag);
drawingContainer.BedienungLeft.Coordinates
   = new Points(drawingContainer.BeschlagOutside.Coordinates.X + Context.BreiteBeschlag / 2 - BreiteBedienung / 2,
                drawingContainer.BeschlagOutside.Coordinates.Y + drawingContainer.BeschlagOutside.Coordinates.Height / 2 - HöheBedienung / 2 + BedienungLeftVersatz,
                BreiteBedienung, HöheBedienung, 0, 0, BreiteBedienung, HöheBedienung);
drawingContainer.BedienungTop.Coordinates
   = new Points(drawingContainer.BeschlagOutside.Coordinates.X + drawingContainer.BeschlagOutside.Coordinates.Width / 2 - HöheBedienung / 2 + BedienungTopVersatz,
                drawingContainer.BeschlagOutside.Coordinates.Y + BreiteBedienung / 2,
                HöheBedienung, BreiteBedienung, 0, 0, HöheBedienung, BreiteBedienung);
drawingContainer.BedienungRight.Coordinates
   = new Points(drawingContainer.BeschlagOutside.Coordinates.X + drawingContainer.BeschlagOutside.Coordinates.Width - BreiteBedienung / 2 - Context.BreiteBeschlag / 2,
                drawingContainer.BeschlagOutside.Coordinates.Y + drawingContainer.BeschlagOutside.Coordinates.Height / 2 - HöheBedienung / 2 + BedienungRightVersatz,
                BreiteBedienung, HöheBedienung, 0, 0, BreiteBedienung, HöheBedienung);
drawingContainer.BedienungBottom.Coordinates
   = new Points(drawingContainer.BeschlagOutside.Coordinates.X + drawingContainer.BeschlagOutside.Coordinates.Width / 2 - HöheBedienung / 2 + BedienungBottomVersatz,
                drawingContainer.BeschlagOutside.Coordinates.Y + drawingContainer.BeschlagOutside.Coordinates.Height - Context.BreiteBeschlag / 2 - BreiteBedienung / 2,
                HöheBedienung, BreiteBedienung, 0, 0, HöheBedienung, BreiteBedienung);
drawingContainer.KreuzCenter.Coordinates
   = new Points(this.Coordinates.Width / 2 - BreiteKreuz / 2, this.Coordinates.Height / 2 - BreiteKreuz / 2,
                BreiteKreuz, BreiteKreuz,
                0, 0, BreiteKreuz, BreiteKreuz);

Hallo Coder007,
danke für deinen Tip.

Hallo Chilic,
das mit "Pen.Width / 2 Pixel" den mache ich bereits.

            //Int ungerade Pinselgröße
            //Rectangle ist aussen...
            Pen pen1rect = new Pen(Color.FromArgb(100, 34, 117, 76), 5);
            Pen pen1line = new Pen(Color.FromArgb(100, 0, 0, 250), 5);
            e.Graphics.FillRectangle(Brushes.Red, new Rectangle(box1.Location.X, box1.Location.Y, box1.Width, box1.Height));
            e.Graphics.DrawRectangle(pen1rect, new Rectangle(box1.Location.X, box1.Location.Y, box1.Width, box1.Height));
            e.Graphics.DrawLine(pen1line, new Point(box1.Location.X, box1.Location.Y),
                                     new Point(box1.Location.X + box1.Width, box1.Location.Y + box1.Height));

            //Float ungerade Pinselgröße
            //Macht alles komplizierter
            Pen pen2rect = new Pen(Color.FromArgb(100, 34, 117, 76), 5);
            Pen pen2line = new Pen(Color.FromArgb(100, 0, 0, 250), 5);
            e.Graphics.FillRectangle(Brushes.Red, new RectangleF(box3.Location.X + pen2rect.Width / 2, box3.Location.Y + pen2rect.Width / 2, box3.Width - pen2rect.Width / 2, box3.Height - pen2rect.Width / 2));
            e.Graphics.DrawRectangle(pen2rect, (float)box3.Location.X + pen2rect.Width / 2, (float)box3.Location.Y + pen2rect.Width / 2, (float)box3.Width - pen2rect.Width / 2, (float)box3.Height - pen2rect.Width / 2);
            e.Graphics.DrawLine(pen2line, new PointF(box3.Location.X, box3.Location.Y),
                                     new PointF(box3.Location.X + box3.Width, box3.Location.Y + box3.Height));
Über sowas simples will mann sicht doch keine Gedanken machen. Wenn ich sage das ich ein Rectangle von 0 bis 100 Zeichnen will. Nicht von 0 - PenWidth / 2 bis 100 + PenWidth + PenWidth / 2. Das es mit int und 5 als PenWidth unsauber wird verstehe ich ja noch.

Thema: Architektur eines CAD-Systems zur 2D-Darstellung von Fensteranlagen (für Häuser)
Am im Forum: Grafik und Sound

Ich habe die Aufgabe ein Modul zu erstellen, was Fenster CAD Zeichnung erstellen soll. Ich habe bereits 2 Lösungen erstellt die ich verwerfen musste.

[B]1 Versuch [/B]Alles in eine Klasse gestopft und direkt gezeichnet. 

[FRAME]
[B][COLOR]Problem[/COLOR][/B]
Der Code war sehr unübersichtlich. Das Erweitern oder Verändern war kaum möglich. Ich poste hier mal nicht den Quellcode  :D
[/frame]
[B]2 Versuch[/B]

Drawing Klasse => Fenster Klasse => FensterContext Klasse
Fenster Klasse zeichnet mehrere Drawing Objekte.
Fenster Context zeichnet mehrere Fenster Objekte

[FRAME]
[COLOR][B]Klassen Konstruktoren[/B][/COLOR]

Drawing Objekt
[csharp]DrawingRectangle rectangle = new DrawingRectangle(Points coordinates, Painting style);[/csharp]

Fenster Objekt
[csharp]Fenster fenster1 = new Fenster(float x, float y, float width, float height, BedienseitenFlag bedienungsSeiten, OeffnungsSeitenFlag oeffnungsSeiten, float rahmenBreite, float beschlagBreite, float stelzenBreite);[/csharp]

FensterContext Objekt
[csharp]FensterContext context = new FensterContext(Fenster[] fenster);[/csharp]
[COLOR][B]Basisklassen für den Überblick[/B][/COLOR]

Drawing 
[csharp]    public class DrawingBase
    {
        public DrawingBase() { IsVisible = false;}
        public Image _Image { get { return DrawImage(); } }
        public Points Coordinates { get; set; }
        public Painting Style { get; set; }
        public bool IsVisible { get; set; }
        public string Description { get; set; }
        public virtual void OnDraw(Graphics g) {}

        private Image DrawImage()
        {
            Bitmap bitmap = new Bitmap(IsVisible ? (int)Coordinates.Width : 1, IsVisible ? (int)Coordinates.Height : 1);
            if (IsVisible)
            {
                Graphics graphics = Graphics.FromImage(bitmap);
                graphics.FillRectangle(Style.BackgroundBrush, new Rectangle(0, 0, (int)Coordinates.Width, (int)Coordinates.Height));
                OnDraw(graphics);
                graphics.Dispose();
                bitmap.MakeTransparent(Color.Magenta);
            }
            return bitmap;
        }
    }[/csharp]

Fenster
[csharp]    public abstract class FensterBase
    {
        public FensterBase()
        {
            DrawingItems = new List<Drawing>();
        }

        public Image WindowImage { get { return DrawImage(); } }
        public Points Coordinates { get; set; }
        public Painting Style { get; set; }
        public List<Drawing> DrawingItems { get; private set; }
        public virtual void InitializeImage() { }

        public Image DrawImage()
        {
            Bitmap bitmap = new Bitmap((int)Coordinates.Width, (int)Coordinates.Height);
            Graphics graphics = Graphics.FromImage(bitmap);
            foreach (Drawing drawing in DrawingItems)
                if (drawing != null && drawing.IsVisible)
                    graphics.DrawImage(drawing.DrawingImage, new PointF(drawing.Coordinates.X, drawing.Coordinates.Y));
            graphics.Dispose();
            return bitmap;
        }
    }[/csharp]

FensterContext
[csharp]    public abstract class FensterContextBase
    {
        public Image ContextImage { get { return DrawImage(); } }
        public Painting Style { get; set; }
        public List<Fenster> FensterItems { get; set; }
        public int Width { get; private set; }
        public int Height { get; private set; }

        public Image DrawImage()
        {
            float width = 0;
            float height = 0;

            foreach (Fenster fenster in FensterItems)
            {
                float fensterWidth = fenster.Coordinates.X + fenster.Coordinates.Width;
                float fensterHeight = fenster.Coordinates.Y + fenster.Coordinates.Height;
                if (fensterWidth > width)
                    width = fensterWidth;
                if (fensterHeight > height)
                    height = fensterHeight;
            }

            Bitmap bitmap = new Bitmap((int)width, (int)height);
            Graphics graphics = Graphics.FromImage(bitmap);
            foreach (Window window in FensterItems)
                graphics.DrawImage(window.WindowImage, new PointF(window.Coordinates.X, window.Coordinates.Y));
            graphics.Dispose();
            return bitmap;
        }
    }[/csharp]
[COLOR][B]Problem[/B][/COLOR]
Die Linien werden nicht immer gezeichnet oder sie haben einen Schatten.
Ich versuche ich immer die Linien in der Mitte zu zeichnen, weil es für mich keinen Sinn ergibt das sie immer nach unten Rechts gezeichnet werden. Deshalb Zeichne nur über Graphics.DrawLine oder Graphics.DrawPolygon und ziehe Linien Breite / 2 bei Width und Height ab und addiere sie bei X und Y. Das setzt voraus das ich float statt int benutze. Hier liegt wohl das Problem.
[csharp]
graphics.DrawLine(myPen, x + myPen.Width / 2, y + myPen.Width / 2, width - myPen.Width / 2, height - myPen.Width / 2);
[/csharp]

Durch das Zeichnen in der Mitte wird gibt es fälle wo die Zeichenlogik schwer zu durchschauen ist z.B simple Pfeile die nicht Width x Height sind werden völlig krunkelig. Linien nach innen wäre wohl auch eine möglichkeit. Was mach ich aber wenn ich kein Rectangle zeichne sondern eine Diagonale Linie.
[/frame]

Irgendwie hab ich das Gefühl das die 2 Lösung auch nicht das Gelbe vom Ei ist. WPF wäre wohl eine Alternative die sehr vieles erleichtern würde oder ? Sieht auch schöner aus da alles geglättet ist ohne zu verschwimmen.
Habt ihr schon Erfahrungen gemacht die mir weiterhelfen könnte, anderen Aufbau, die Lienen- Sache. unsw.. unsw...

Bin für jede Anregung und Kritik offen.

Thema: einfachstes Binding :: steh auf dem Schlauch
Am im Forum: GUI: WPF und XAML

How to bind to a WPF dependency property when the datacontext of the page is used for other bindings?

Thema: Assembly im AssemblyBuilder abbilden
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Finde Mono.Cecil auch super, hatte auch schon einiges damit gemacht.
Wäre nur schon Reflection zu benutzen, da Cecil noch paar Kanten hat und
ich möchte nicht mit einen Flagschiff immer auf Spatzen schießen.

Thema: Assembly im AssemblyBuilder abbilden
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Ich möchte eine Assembly im AssemblyBuilder abbilden, um sie dort zu manipulieren und wieder zu speichern. Ich denke nicht das dies funktioniert oder ?

Mann könnte doch aber alle Typen eines Moduls durchlaufen und im Modulbuilder erstellen. Das ist sicher aufwendig. Hat sich jemand schon die Mühe gemacht ?

Thema: SplashScreen - Statustext Updaten
Am im Forum: GUI: WPF und XAML

Zitat
Das kann man auch schön erkennen, wenn man z.B. einen Button mit einem langen Prozess auf die GUI legt, bleibt der Button eingedrückt bis die Aktion abgeschlossen ist.


Das wäre wohl anderes auch nicht möglich. Der Button wird aber trotzdem neu gezeichnet, auch wenn er so lange verhaart bis die Aktion abgeschlossen ist.
Das sieht man am besten wenn man den GUI Thread arbeiten schickt und dann mit einen anderen Fenster drüber fährt. Bei Windows Forms hast mann dann ein buntes Fenster. Das wird dann aber wahrscheinlich irgendwo in der Milcore Bibliothek geregelt.

Das verhalten ist irgendwie eigenartig. Habe mal in der Main Methode folgendes versucht. Erst wenn die Application Klasse eine "MessageLoop?" erstellt, werden die Fenster aktualisiert. Das hat wohl eher nix wie in meiner vorherigen Vermutung mit den "Zeichenthread" zu tun.

        [System.STAThreadAttribute()]
        [System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public static void Main() {
            MainWindow window = new MainWindow();
            window.label1.Content = "Me";
            Thread.Sleep(10000);
            //WpfApplication1.App app = new WpfApplication1.App();
            //app.Run();
        }

Thema: SplashScreen - Statustext Updaten
Am im Forum: GUI: WPF und XAML

WPF hat 2 Threads. Einen womit du arbeitest und einen der alles Zeichnet. Damit die Benutzeroberfläche nicht mehr einfriert beim Zeitaufwändigen unterfangen.

Du musst vermutlich die OnStartup Methode von der Application class aufrufen, damit der Zeichenthread startet.

protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
}

Thema: AutoCompleteBox aktuallisiert ein Feld doppelt
Am im Forum: GUI: WPF und XAML

Ich würde mal den vollständigen C# Code posten, zumindest für Fruit.
Der Fehler ist so nicht ersichtlich.

"List" für das TwoWay Binding ist eher ungünstig.
Warum hab ich dir schon in den anderen Post gesagt.
Benutze ObservableCollection.

public ObservableCollection<User> DataCollection { get; }
  public ObservableCollection<Fruit> FruitCollection { get; }

Thema: [erledigt] GridView aktuallisiert sich nicht
Am im Forum: GUI: WPF und XAML

hab "Postcode" übersehen. sollte mal gründlicher lesen :)

Thema: Wie kann man sich selbst zum Programmieren motivieren?
Am im Forum: Smalltalk

Kenne das... Habe auch immer nur Phasen, wo es auch ohne Motivationsblockaden leuft.

Thema: [erledigt] Zusammenhang zwischen DataContext und Binding beim GridView
Am im Forum: GUI: WPF und XAML

DataContext musst du nicht angeben. Der gilt dann für alle Unterelemente der Textbox als Datenquelle, solange nix anderes bei den Unterelementen angegeben ist.

Du kannst Source verwenden um die Datenquelle anzugeben.
In Binding Path ist die Eigenschaft als Name hinterlegt. Bei DataContext und bei Source die Instanz.

Thema: [erledigt] GridView aktuallisiert sich nicht
Am im Forum: GUI: WPF und XAML

INotifyPropertyChanged wird nur gefeuert, wenn sich eine Eigenschaft
innerhalb deines Personen Objekts ändert.

Das passiert aber nicht, wenn du ein neues Objekt einer Collection hinzufügst.
Dafür gibt es INotifyCollectionChanged.

Benutze eine ObservableCollection<Personen> (die implementiert INotifyCollectionChanged) und füge oder ersetzte dort deine Personen Objekte.

Thema: ObservableEntityCollection Entity Framework [2 Way Binding WPF]
Am im Forum: .NET-Komponenten und C#-Snippets

ObservableEntityCollection für das Entity Framework

Nachdem mir aufgefallen ist, das ich mit den ObjectSet von Entity Framework
kein 2 Way Binding zu einen WPF Control machen kann, weil es nicht von ICollectionChanged erbt hab ich folgendes geschrieben.


    public class ObservableEntityCollection<TEntity> : ObservableCollection<TEntity> where TEntity : class
    {
        private ObjectSet<TEntity> _objectSet = null;
        public delegate int SaveChangesMethod();
        private SaveChangesMethod SaveChanges = null;

        public ObservableEntityCollection(ObjectSet<TEntity> entity)
        {
            Init(entity, null);
        }

        public ObservableEntityCollection(ObjectSet<TEntity> entity, SaveChangesMethod SaveChanges)
        {
            Init(entity, SaveChanges);
        }

        private void Init(ObjectSet<TEntity> entity, SaveChangesMethod SaveChanges)
        {
            this._objectSet = entity;
            this.SaveChanges = SaveChanges;

            foreach (var item in _objectSet)
            {
                if (item is INotifyPropertyChanged)
                {
                    INotifyPropertyChanged notifyPropertyChanged = item as INotifyPropertyChanged;
                    notifyPropertyChanged.PropertyChanged += new PropertyChangedEventHandler(notifyPropertyChanged_PropertyChanged);
                }
                base.InsertItem(this.Count, (TEntity)item);
            }
        }

        void notifyPropertyChanged_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            TEntity _objectSetItem = (TEntity)sender;
            SetItem(this.IndexOf(_objectSetItem), _objectSetItem);
        }

        protected override void InsertItem(int index, TEntity item)
        {
            if (_objectSet == null)
                return;

            _objectSet.AddObject(item);

            if (SaveChanges != null)
                SaveChanges();

            base.InsertItem(index, item);
        }

        protected override void SetItem(int index, TEntity item)
        {
            if (_objectSet != null)
                return;

            var _objectSetItem = _objectSet.ElementAt(index);
            if (_objectSetItem != null)
                _objectSetItem = item;

            if (SaveChanges != null)
                SaveChanges();

            base.SetItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            if (_objectSet != null)
                return;

            var _objectSetItem = _objectSet.ElementAt(index);
            if (_objectSetItem != null)
                _objectSet.DeleteObject(_objectSetItem);

            if (SaveChanges != null)
                SaveChanges();

            base.RemoveItem(index);
        }

        protected override void MoveItem(int oldIndex, int newIndex)
        {
            if (_objectSet != null)
                return;

            var _objectSetItemOld = _objectSet.ElementAt(oldIndex);
            if (_objectSetItemOld != null)
            {
                var _objectSetItemNew = _objectSet.ElementAt(newIndex);
                if (_objectSetItemNew != null)
                    _objectSetItemNew = _objectSetItemOld;
                
            }

            if (SaveChanges != null)
                SaveChanges();

            base.MoveItem(oldIndex, newIndex);
        }

        protected override void ClearItems()
        {
            foreach (var item in _objectSet)
            {
                _objectSet.DeleteObject(item);
            }

            if (SaveChanges != null)
                SaveChanges();

            base.ClearItems();
        }
    }

ObservableEntityCollection, ObservableCollection, Entity, Entity Framework, 2 Way Binding, WPF