Laden...
Avatar #avatar-2293.gif
Ayke myCSharp.de - Member
Grafikdesigner, Programmierer Hamburg Dabei seit 28.06.2006 643 Beiträge
Benutzerbeschreibung

Forenbeiträge von Ayke Ingesamt 643 Beiträge

01.02.2012 - 22:32 Uhr

Hat jemand von euch einen Link oder Buch über OpenGL + gängige OO Modelle dafür.

01.02.2012 - 21:56 Uhr

großes Danke !

01.02.2012 - 20:07 Uhr

Genau das Problem habe ich jetzt auch ^^
Und die Emulatoren laufen grottenschlecht.

01.02.2012 - 13:36 Uhr

Hallo,

gut zu wissen das es machbar ist. Es soll die neuern Geräte unterstüzen. LG Optimus 3D etc... Das Spiel soll ungefähr so aussehen.

Osmos

01.02.2012 - 12:37 Uhr

Hab ich auch im Spiegel gelesen. Ganz interessant und dein Fazit ist auch ganz nachvollziehbar 😃 Naja wenigstens nimmt es ein dann die Arbeit ab vor den PC zu sitzen. Frag mich sowieso wie das noch funktionieren soll nachdem jetzt schon die mehrheit der kurzfristigen Trades automatisiert sind. Wettrennen der automatisierten Handelssysteme wo jeder Normalsterblicher verliert.

01.02.2012 - 11:33 Uhr

Weis jemand wie das mit der Performance von ExEn Spiele für Android aussieht. Lassen sich damit vernüftige 2D spiele ohne Ruckler umsetzten ??
Ich mein alles in einem wirkt dies wie eine Notlösung, da es sonst keine möglichkeit in C# gibt Games für Android zu schreiben oder irre ich mich da ?

ExEn: XNA for iPhone, Silverlight and Android

01.02.2012 - 11:27 Uhr

Hät mich auch gewundert wenn das so einfach funktionieren würde.
Dann jagt mann das Netz über verschiedene Historische Kurse und für alle eine Lizenz zum Geld drucken ^^

20.01.2012 - 14:31 Uhr

Hi, das wird so nix. Mit 51 wahrscheinlichkeit kannst du schon glücklich sein. Vielleicht solltest du dich auch erstmal in diesen bereich
..

20.01.2012 - 12:42 Uhr

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 ??

13.01.2012 - 11:59 Uhr

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."

11.08.2011 - 12:57 Uhr

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

11.08.2011 - 02:41 Uhr

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

10.08.2011 - 12:28 Uhr

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.

10.08.2011 - 11:42 Uhr

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.

10.08.2011 - 10:41 Uhr

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

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

04.08.2011 - 14:58 Uhr
        [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);
        }
22.07.2011 - 11:19 Uhr

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 ^^

22.07.2011 - 08:56 Uhr

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.

21.07.2011 - 00:16 Uhr

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.

20.07.2011 - 22:58 Uhr

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.

15.06.2011 - 15:07 Uhr

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

12.06.2011 - 16:16 Uhr

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.

10.06.2011 - 14:42 Uhr

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.

26.05.2011 - 06:49 Uhr

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

20.05.2011 - 18:10 Uhr

danke gfoidl,
hast das gut auf den Punkt gebracht. 👍

20.05.2011 - 16:58 Uhr

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.

20.05.2011 - 14:01 Uhr

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.

16.05.2011 - 19:07 Uhr

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.

16.05.2011 - 12:36 Uhr

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 ?

04.05.2011 - 12:28 Uhr

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();
        }
04.05.2011 - 06:41 Uhr

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

03.05.2011 - 15:21 Uhr

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; }
03.05.2011 - 08:17 Uhr

hab "Postcode" übersehen. sollte mal gründlicher lesen 😃

03.05.2011 - 05:50 Uhr

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

03.05.2011 - 05:07 Uhr

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.

03.05.2011 - 04:47 Uhr

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.

30.04.2011 - 10:59 Uhr

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

29.04.2011 - 23:42 Uhr

Hi,

komme selber noch nicht so richtig mit WPF klar.
Weiß auch nicht ob Eigenschaft Title in deinen Control liegt.
Wenn nicht musst du vermutlich den Standard Style überschreiben.

DefaultStyleKeyProperty.OverrideMetadata(typeof(FilterView), new FrameworkPropertyMetadata(typeof(FilterView)));

Hier klicken

29.04.2011 - 12:39 Uhr

Hey,

mir ist aufgefallen das beim DataGrid das TwoWay Binding mit AutoGenerateColumns="True" nicht funktioniert. Ich habe deshalb angefangen mir selber etwas zu schreiben. Kennt da jemand eine Lösung die kurzer ist ?

29.04.2011 - 12:31 Uhr

danke talla,
dann muss ich alles neu schreiben 😃

28.04.2011 - 23:44 Uhr

Hallo Talla,

ich mache auch eine Abfrage wegen den Filter bevor ich das an das DataGrid weiterleite.

        public void FilterQuerySource()
        {
            IQueryable tempQuery = null;

            //...................................
            //filter with dynamic Linq...........
            //...................................

            QuerySource = tempQuery;
        }
28.04.2011 - 23:25 Uhr

Hallo,

ich habe eine Klasse Filter. Diese hat ein IQueryable Object das als Datenquelle verwendet wird.

    public class Filter : NotifyPropertyChanged
    {
       
       public Filter(IQueryable querySource)
       {
              this.QuerySource = querySource;
       }       

        private IQueryable _QuerySource;
        public IQueryable QuerySource
        {
            get { return _QuerySource; }
            set
            {
                _QuerySource = value;
                onPropertyChanged(this, "QuerySource");
            }
        }

        public void FilterQuerySource()
        {
            IQueryable tempQuery = null;

            //...................................
            //filter with dynamic Linq...........
            //...................................

            QuerySource = tempQuery;
        }
    }

Dazu habe noch ein Usercontrol erstellt.

    public partial class FilterControl : UserControl
    {
        
        private Filter filter 
        
        public IQueryable QuerySource
        {
            get
            {
                if (filter == null)
                    return null;
                else
                    return filter.QuerySource;
            }

            set
            {
                filter = new Filter(value);
            }
        }
    }

Jetzt habe ich irgendwo ein Gridview. Wie aus den Code zu entnehmen ist, bekommt das Gridview leider von einer Änderung durch den Filter nix mit.

Wie geh ich da am besten vor ?

  1. Ich mache eine Dependeny Property aus der Filter Class QuerySource Property. (Ist IQueryable überhaupt das richtige Object dafür ?)

  2. In der Usercontrol Class mach ich einen Pointer auf die QuerySource der Filter Class.
    (Muss für den Getter und Setter ein delegate machen ?)

3.Das ganze bind ich dann irgendwo wo ich ein DataGrid habe.

        private void Data_ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            FilterControl.ItemSource = Data_Dict_Queries[Data_ComboBox.SelectedItem.ToString()];
            Binding binding = new Binding();
            binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            binding.Source = FilterControl;
            binding.Path = new PropertyPath("QuerySource");
            dataGrid.SetBinding(DataGrid.ItemsSourceProperty, binding);
        }

Würde mich sehr über eure Untersützung freuen.

26.04.2011 - 13:41 Uhr

Ich nochmal...
Möchte einen Button unsichtbar machen wenn HasItems True ist.
Hab schon einige Varianten probiert.

Wenn ich das über Style.Triggers mache funktioniert es. Da kann ich meinen Button aber leider nicht mit einen Event ausstattung.

    <ListBox.Template>
        <ControlTemplate TargetType="ctrl:FilterView">
                   <Border BorderBrush="{TemplateBinding BorderBrush}"
                                BorderThickness="{TemplateBinding BorderThickness}" 
                                Background="{TemplateBinding Background}"
                                CornerRadius="{TemplateBinding Rounding}"
                                SnapsToDevicePixels="True">
                <Grid>
                    <StackPanel IsItemsHost="True"/>
                    <Button Name="buttonCreate"  Content="Filter Table" Width="75" Height="22" HorizontalAlignment="Left" VerticalAlignment="Top" Click="buttonCreate_Click">
                        <Button.Triggers>
                            <Trigger Property="HasItems" Value="False">
                                <Setter Property="Visibility" Value="Hidden" TargetName="buttonCreate"/>
                            </Trigger>
                        </Button.Triggers>
                    </Button>
                </Grid>
            </Border>
        </ControlTemplate>
    </ListBox.Template>

Fehlermeldung:
Bei der Initialisierung von "System.Windows.Controls.Button" wurde eine Ausnahme ausgelöst.

    <ListBox.Template>
        <ControlTemplate TargetType="ctrl:FilterView">            
        <Border BorderBrush="{TemplateBinding BorderBrush}"
                                BorderThickness="{TemplateBinding BorderThickness}" 
                                Background="{TemplateBinding Background}"
                                CornerRadius="{TemplateBinding Rounding}"
                                SnapsToDevicePixels="True">
                <Grid>
                    <StackPanel IsItemsHost="True"/>
                </Grid>
            </Border>
            
        </ControlTemplate>
    </ListBox.Template>
    <ListBox.Triggers>
        <Trigger Property="HasItems" Value="False">
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="ctrl:FilterView">
                        <Border BorderBrush="{TemplateBinding BorderBrush}"
                                        BorderThickness="{TemplateBinding BorderThickness}" 
                                        Background="{TemplateBinding Background}"
                                        CornerRadius="{TemplateBinding Rounding}"
                                        SnapsToDevicePixels="True">
                            <Grid>
                                <Button Name="buttonCreate" Content="Filter Table" Width="75" Height="22" HorizontalAlignment="Left" VerticalAlignment="Top" Click="buttonCreate_Click"/>
                            </Grid>
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Trigger>
    </ListBox.Triggers>

Fehlermeldung:
Member "HasItems" ist nicht gültig, da er nicht über einen qualifizierenden Typnamen verfügt.

26.04.2011 - 10:49 Uhr

Danke mit den statischen constructor funktioniert es. Hab mir heute den teil zu WPF im openbook Visual C# 2010 durchgelesen. Irgenwie ist das ganz schön knapp gehalten. Wieso muss ich einen static constructor erstellen ? Wegen den DepencyProperties ?

26.04.2011 - 05:01 Uhr

Ich möchte ein Control auf Basis der ListBox erstellen.

Im Codebehind lege ich eine Rounding- Eigenschaft fest.

    public partial class FilterView : ListBox
    {
        public static DependencyProperty RoundingProperty = DependencyProperty.Register("Rounding", typeof(CornerRadius), typeof(QueryFilterView), new PropertyMetadata(new CornerRadius(2)));
        public CornerRadius Rounding { get { return (CornerRadius)GetValue(RoundingProperty); } set { SetValue(RoundingProperty, value); } }

        public FilterView()
        {
            InitializeComponent();
        }
    }

Hier möchte ich beim ControlTemplate ein TemplateBinding benutzen um die Eigenschaft Rounding zu verwenden.

<ListBox     x:Class="UI.Controls.FilterView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300">

    <ListBox.Resources>
        <CornerRadius x:Key="CornerRadiusValue" BottomLeft="10"/>
        <Style TargetType="ctrl:FilterView">
            <Setter Property="BorderBrush" Value="Black"/>
            <Setter Property="BorderThickness" Value="1"/>
            <Setter Property="Background" Value="Transparent"/>
            <Setter Property="Rounding" Value="2"/>
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate>
                        <Border BorderBrush="{TemplateBinding BorderBrush}"
                                BorderThickness="{TemplateBinding BorderThickness}" 
                                Background="{TemplateBinding Background}"
                                CornerRadius="{TemplateBinding Rounding}">
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </ListBox.Resources>
</ListBox>

Fehlermeldung:
Der statische Member "RoundingProperty" wurde nicht im Typ "Control" gefunden

Was mache ich falsch ?

21.04.2011 - 10:13 Uhr

Ich möchte das die DataGrid Header sich über den freien Platz strecken.

Also bei jedem DataGridColumnHeader
HorizontalAlignment="Stretch" oder Width = "*"
oder wie bei den guten alten Windows Forms Fill.

Hab schon paar sachen ausprobiert. Haben aber leider kein erfolg gebracht.

        <Style TargetType="DataGridColumnHeader">
            <Setter Property="ContentTemplate">
                <Setter.Value>
                    <DataTemplate>
                    <TextBlock Text="{Binding}" HorizontalAlignment="Stretch"/>
                    </DataTemplate>
                </Setter.Value>
            </Setter>
        </Style>
21.04.2011 - 10:08 Uhr

Danke erstmal.
Bin auf WPF umgestiegen, deswegen nicht getestet ob das Hilft.

20.04.2011 - 13:11 Uhr

Hallo,

kenn jemand eine Möglichkeit das die Zeile umbricht wenn der Text länger als die Zelle ist.

z.B

COLUMN TEXT
Dies ist ein
kurzer
Text

Der Text hat keine umbrüche deshalb scheint mir Wrap=True nix zu nützen.