Schade, dass du Windows Forms benutzt. In WPF wäre das sehr einfach selbst zu realisieren gewesen und ich hätte dir auch eine fertige Komponente geben können.

Dann musst du dir mal angucken, wie das Script funktioniert und dir daraus ein Greasemonkey Script bastlen. Greasemonkey ist eine FireFox Erweiterung.

Hat ja nun nur bedingt was mit C# zu tun. Aber sei's drum... normalerweise funktionieren solche Seiten, indem die eigentliche Zielseite als Query-Parameter in der Adresse mitgegeben wird. Du brauchst also ein Script, das dir die eigentliche Ziel-URL aus der Query der Linkadresse rausholt und den Link damit ersetzt.

Pack mal diesen Code:

javascript:(function(){var%20k,x,t,i,j,p;%20for(k=0;x=document.links[k];k++){t=x.href.replace(/[%]3A/ig,':').replace(/[%]2f/ig,'/');i=t.lastIndexOf('http');if(i>0){%20t=t.substring(i);%20j=t.indexOf('&');%20if(j>0)t=t.substring(0,j);%20p=/https?\:\/\/[^\s]*[^.,;'%22>\s\)\]]/.exec(unescape(t));%20if(p)%20x.href=p[0];%20}%20else%20if%20(x.onmouseover&&x.onmouseout){x.onmouseover();%20if%20(window.status%20&&%20window.status.indexOf('://')!=-1)x.href=window.status;%20x.onmouseout();%20}%20x.onmouseover=null;%20x.onmouseout=null;%20}})();

... als Bookmark in deine Lesezeichensymbolleiste. Damit sollte das gehen. Du musst vorher also einmal auf den Button drücken, bevor du so einen umgeleiteten Link aufmachst. Funktioniert nicht immer 100%, aber in den meisten Fällen recht zuverlässig.

Allerdings sei dir gesagt, dass solche Zwischenseiten durchaus ihre Daseinsberechtigung haben.

@Shizora: leider nein. Neuinstallation versucht?

@Topic: yeah! Hab's installiert. Wenn mal VS 2010 auch so schnell und flüssig liefe. My dear Mr singing club! Ich hoffe, das bleibt so flott. 😃

Jo. Und der kostet anscheinend richtig viel. Ich stelle fest, dass das Programm seitdem gefühlt um Faktor 10 schneller geworden ist.

Jetzt hab ich nur noch 'n Problem mit einigen ObservableCollections, das ich lösen muss...

Zur Info: ich hab's jetzt mit UserControls und Triggers gelöst. Funktioniert soweit.

Danke!

Ja, der Profiler sagte mir, dass Dispatcher.Invoke in der Tat die meiste Zeit gefressen hat. Nun hab ich den Kram auf INotifyPropertyChanged umgebaut und auch wenn's kompliziert war, so ist es jetzt wahrlich 'ne ganze Ecke flotter.

Wenn ich gewusst hätte, dass Dispatcher.Invoke so sehr an der Performance rumknabbert, hätte ich das gleich mit INotifyPropertyChanged aufgezogen. Gut, man lernt nie aus. Das nächste Mal bin ich schlauer.

Danke!

Hi Leute,

in einem Projekt erzeuge ich aus einem großen Haufen Daten in Textform einen großen Haufen DependencyObjects (bzw. Instanzen einiger davon erbender Klassen). Da diese auf der GUI darstellbar sein sollen, muss ich sie im GUI Thread erzeugen. Dazu nutze ich, wie vorgesehen, an den erforderlichen Stellen den Dispatcher.

Leider ist das wirklich seeeehr langsam und es stand auch irgendwo geschrieben, dass man den Dispatcher nicht so inflationär verwenden soll. Wie aber sonst schaffe ich es, performant und flüssig die Objekte zu erzeugen?

Oder ist es grundsätzlich ein Fehler, DependencyObject als Basis für eine Klasse zu verwenden, deren viele Instanzen aus Daten aus einer Text-Datei zur Laufzeit generiert werden?

Danke!

Grüße,
Hendrik

Also die Definition der DependencyProperty samt einer zugreifenden Methode sieht so aus. Mehr ist da nicht drin.

Das Binding wird in der vererbten Klasse nicht überschrieben. Es gibt keine anderen Stellen, an denen ich die Property verwende. Sie markiert nur, ob an dem im DataContext liegenden Objekt Änderungen vorgenommen wurden und soll über einen DataTrigger diesen Umstand optisch darstellen.

using System.Windows;

namespace HAW_Tool.HAW.Depending
{
    public abstract class DirtyableUIElement : UIElement
    {
        public bool IsDirty
        {
            get { return (bool)GetValue(IsDirtyProperty); }
            set { SetValue(IsDirtyProperty, value); }
        }

        // Using a DependencyProperty as the backing store for IsDirty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IsDirtyProperty =
            DependencyProperty.Register("IsDirty", typeof(bool), typeof(Freezable), new UIPropertyMetadata(false));

        // public abstract bool IsDirty { get; set; }

        public void Clean()
        {
            IsDirty = false;
        }

        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
        {
            if(e.Property.Name != "IsDirty" && 
                e.Property.Name != "IsSelected" &&
                e.Property.Name != "Row") 
                IsDirty = true;
            base.OnPropertyChanged(e);
        }
    }
}

Verlege ich die IsDirty-Property 1:1 in die Kindklasse und packe lediglich eine abstrakte Definition in der Elternklasse an, funktioniert es.

Hi Leute,

ich beobachte gerade ein seltsames Verhalten einer meiner Anwendungen. Vielleicht gehört das ja so, aber ich sehe den Sinn dahinter nicht. Folgendes:

In einem UserControl nutze ich einerseits einen DataTrigger auf eine DependencyProperty des DataContext Objektes. Diese DependencyProperty ist von einer übergeordneten Klasse geerbt, welche direkt von UIElement erbt.

UIElement
|- Elternklasse mit besagter DependencyProperty
|-- Kindklasse, auf deren Instanz DataContext des UserControls verweist

Der Trigger sieht so aus:

                <DataTrigger Binding="{Binding IsDirty}" Value="True">
                    <Setter Property="EventBorderBrush" Value="#22FFFF00" />
                    <Setter Property="EventBorderBackground" Value="#22FFFF00" />
                </DataTrigger>

Soviel zur Theorie.

Das seltsame Verhalten äußert sich nun so, dass alle DependencyProperties wie gefordert ihre Refresh-Events feuern lassen, sodass alle Trigger ausgelöst und alle Bindungs aktualisiert werden, sobald sich in den Properties was ändert... bis auf die geerbte DependencyProperty.

Ich habe dieses Verhalten verifiziert, indem ich die geerbte Property einfach direkt in die Kindklasse verschoben habe. Dort löst sie wie gewünscht den Trigger aus, sobald sich ihr Wert entsprechend ändert. In der Elternklasse nicht.

Kann mir dieses Verhalten jemand erklären? Ist das so gewünscht? Wie kann ich das umgehen, bzw. aktiv dafür sorgen, dass die Trigger auch bei geerbten Properties ausgelöst werden?

Danke!

Viele Grüße,
Hendrik

// Update: ich hatte hier ein ähnliches Problem auch mit einer Attached Property; der Fehler lag aber woanders. Daher hab ich den Teil nun aus meiner Frage gestrichen. Es geht jetzt nur noch um die geerbte DependencyProperty.

Stellenweise unterscheiden sich die Templates lediglich in optischen Dingen, beispielsweise Hintergrundfarbe oder Randdicke. Manche aber auch bezüglich über das Interface hinausgehenden Properties, die die eine Klasse zur Verfügung stellt, die andere jedoch nicht. Ersteres dürfte noch über Trigger zu lösen sein; beim zweiten Beispiel sehe ich da allerdings (noch) keine Lösung. Ihr eventuell?

Hallo Leute,

stellt euch vor, ihr habt mehrere sehr ähnliche Klassen, die ihr mit WPF grafisch darstellen wollt. Die Klassen erben alle vom selben Interface. Sie sollen auf der GUI in marginal unterschiedlicher Weise dargestellt werden. Jetzt wäre der naheliegendste Weg, für jede Klasse ein eigenes Template zu schreiben. Diese Templates unterscheiden sich aber auch nur marginal; aber sie unterscheiden sich, sollen sich auch unterscheiden, weil die grafische Präsentation eben geringfügig unterschiedlich sein soll.

Wie geht man also vor, wenn man nicht 99% des Templates zwei- oder mehrfach in seinen Resources haben will? Bleibt einem überhaupt eine Wahl? Oder muss man im genannten Fall, dass die einzige Gemeinsamkeit der darzustellenden Klassen das Interface ist, tatsächlich für jede Klasse ein Template verfassen, das mit dem der anderen zu 99% (aber eben nicht zu 100%) übereinstimmt?

Was hat man da für Möglichkeiten?

Danke!

Viele Grüße und ein frohes neues Jahr noch von mir,
Hendrik

Hmm... nur so ein Gedanke. Mal probiert, den Aufruf über die IP zu machen, statt über die Domain? Vielleicht ist es der DNS Server, der so lange für die Namensauflösung braucht. Just my two cents...

Ah, ja... schon gelöst. Auf jene Weise, die du mir vorschlägst. Danke trotzdem! 🙂

Guter Link, FZelle. Demnach führt Silverlight kein Nischendasein, sondern viel mehr eine unbemerkter Unterwanderung. Es scheint sich seine Daseinsberechtigung in Bereichen zu etablieren, die weit langlebiger sind, als alles was Adobe mit Flash bisher hat erreichen können. (Ich mein, kennt jemand echte, in Unternehmen eingesetzte Businessanwendungen, die in Flash geschrieben sind? Ich nicht...

Was genau in den Köpfen eines PRlers vorgeht, kann ich auch nicht sagen. Aber bisher hat solche "Werbung" bei Microsoft keinerlei Schaden angerichtet.

Microsoft könnte ja "einfach" alle Gerüchte verstummen lassen.

Warum sollten sie das tun? Es gibt weder gute noch schlechte PR. Es gibt nur PR. Sie bleiben im Gerede. Warum diese Art der kostenlosen Werbung abwürgen?

Hallo Leute,

wie kann ich in einem Lightswitch Screen folgende Datenstruktur darstellen:

Schicht
|-- Fahrzeug
    |-- Fahrt

Eine Schicht muss ein oder mehrere Fahrzeuge haben, ein Fahrzeug kann ein oder mehrere Fahrten haben.

Bisher habe ich es nur geschafft, die zu einer Schicht gehörenden Fahrzeuge als Data Grid anzuzeigen, mithilfe einer entsprechenden Query. Ich habe auch für jedes Fahrzeug eine Query für die zugeordneten Fahrten, doch wird mir auf dem Screen unter Fahrzeug_SelectedItem kein weiteres Data Grid für die zugehörigen Fahrten angeboten.

Kann man nur zwei Ebenen pro Screen anzeigen lassen? Oder wie füge ich eine dritte hinzu?

Danke.

Viele Grüße,
Hendrik

Hallo Leute,

hab ja mal vor einiger Zeit erzählt, dass ich an so'nem Tool für meine Hochschule bastel, mit dem man sich die Vorlesungspläne übersichtlicher anzeigen lassen kann... ist ja auch wurscht. Es ist im Grunde nix weiter als ein Schedule, dessen Datenquelle halt die Vorlesungspläne der Hochschule sind.

Genau da liegt gerade bei mir ein kleines Denkproblem. Ich habe dafür zwar schon eine funktionierende Lösung, aber die finde ich alles andere als schön, da sie die Grenzen zwischen Datenschicht und GUI verschwimmen lässt. Es wird innerhalb des Datenobjekts (Ereignis, Termin, Vorlesung) gespeichert, in welcher Zeile des Schedules der Termin angezeigt werden soll. Unschön. Ich hätte das lieber im Schedule selbst gemacht.

Aber von vorn: mein Schedule ist ein ItemsControl. Das stellt mittels eines DataTemplate die in seiner ItemsSource hinterlegten Termine dar. Das funktioniert auch sauber, solange es keine Termine sind, die sich zeitlich überlappen (bspw. mehrere Vorlesungen gleichzeitig, die nach Studierendengruppen getrennt sind, oder Wahlmodule, die zeitgleich stattfinden). Diese überlappenden Termine möchte ich gern quasi übereinander gestapelt (Achtung! Schedule ist horizontal angeordnet!) darstellen. Diese Darstellung soll der Schedule übernehmen, nicht die Events, wie es jetzt der Fall ist.

Aktuell funktioniert das so, dass bei einer Änderung an der Collection, die hinter der ItemsSource des Schedule liegt, eine Methode durch sämtliche Events läuft und überlappenden Events sagt: du bist jetzt nicht mehr in Zeile 0, sondern eine höher. Und das so lange, bis alle Überlappungen entsprechend übereinander dargestellt werden. Dazu halte ich besagte Zeile aber im Termin selbst. Das ist es, was ich unschön finde. Das muss auch anders gehen. Und, wichtig: es muss alles Data Binding kompatibel/konform sein.

Wie realisiert man sowas am besten? Gibt's da Patterns? Einen Königsweg eventuell? Am liebsten wär's mir, wenn das mit Bordmitteln von WPF zu bewerkstelligen wäre.

Danke euch!

Beste Grüße,
Hendrik

Müsste es nicht theoretisch möglich sein, aus einem Teil des Bytecodes der Binary ein private/public key Paar zu erstellen, mithilfe dessen die gesamte Kommunikation verschlüsselt wird? Das Paar müsste dann für jede neue Version neu erzeugt werden. Eine Bruteforce Attacke übersteht das natürlich auch nicht, wenn jemand weiß, dass ein Teil des Bytecodes als Grundlage für das Keypair steht. Aber das ließe sich zumindest serverseitig mit IP bans erschweren.

Nun ja... wie gesagt, eigentlich ist Aufwand/Nutzen dafür einfach zu groß. Ich denke mal, ein einfaches cookie/session based Benutzersystem langt da völlig aus. Ich muss mich nur noch schlau machen, wie man das mit RESTful Services und WCF realisiert. Dafür mach ich dann aber zu gegebener Zeit einfach noch einen Thread auf. 😃 Es sei denn, es hat jemand auf die Schnelle die zündende Idee.

Info dazu, nochmal kurz: der RESTful Service läuft auf einem LAMP. Clientseitig geht das ganze wunderbarst über DataContracts und WebGet/WebInvoke. Das ist damit so dermaßen einfach, dass es schon weh tut. 😃 Man muss sich um so gut wie nix mehr selbst kümmern. Nur kurz den Endpoint in der config beschreiben, den Client und die DataContracts aufziehen und fertig ist die Laube.

Hmm, ja, das klingt plausibel. Leider. Ich dachte schon daran, das über SSL zu realisieren. Aber ich glaub, dafür lohnt der Aufwand nicht. Naja, mach ich das halt über Benutzeraccounts...

Danke dir dennoch!

Hi Leute,

hab mal eine Frage bezüglich Sicherheitssysteme: ich habe eine Anwendung, die auf einen RESTful Webservice zugreifen soll. Dieser Service läuft mit PHP/MySQL auf einem Apache2 Webserver. Nun möchte ich irgendwie bewerkstelligen, dass auf diesen Service wirklich NUR und ausschließlich die Anwendung zugreift.

Sie soll auf dem Wege auch Schreibrechte bekommen, also Datensätze anlegen dürfen. Daher der Sicherheitsgedanke. Es soll nicht möglich sein, mit einem Bot-Programm oder ähnlichem Datensätze anzulegen.

Allerdings wird die Anwendung einer zwar überschaubaren, aber mir dennoch weitgehend unbekannten Nutzerbasis zur Verfügung stehen. Sie ist also öffentlich verfügbar. Ich mache mir daher natürlich Gedanken darüber, dass (nicht nur) unter den Nutzern auch solche sein könnten, die den Server auf dem Wege zu kompromittieren versuchen könnten.

Das suche ich zu verhindern.

Ich danke für jedwede Form der Unterstützung.

Viele Grüße,
Hendrik

Hi Leute,

hab noch ein Problem, diesesmal allerdings tatsächlich mal technischer Natur: in einem TreeView zeige ich mir über mehrere Ebenen hierarchisch angeordnete Objkete an. Jedes Objekt hat Unterobjekte, die ich über die ItemsSource Eigenschaft des HierarchicalDataTemplates darstellen kann. Das funktioniert auch sauber.

Nun möchte ich diese Unterknoten nach einer bestimmten Eigenschaft der dargestellten Objekte sortieren. Das soll angeblich über einen IValueConverter funktionieren, der mir ein ListCollectionView liefert, mit entsprechender SortDescription. Mag sein, dass es das tut, kann ich nicht beurteilen, da die Objekte anfänglich sowieso sortiert sind.

Das Problem ist nun aber folgendes: Quelle der in den Convertern generierten ListCollectionViews sind ObservableCollections. Diese sollen natürlich, darum observable, auch bei Änderungen aktuell bleiben (hinzufügen/entfernen). Leider aktualisieren sich aber die druch den Converter generierten ListCollectionViews anscheinend nicht, wenn ich was hinzufüge oder entferne.

Wie also kann ich in einem TreeView

a) gebunden
b) sortiert
c) immer aktuell/synchron mit den entsprechenden Collections

Objekte hierarchisch darstellen?

Danke!

Grüße,
Hendrik

PS: hier ist der Converter:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Data;
using System.Collections.ObjectModel;
using System.ComponentModel;

namespace InsectJoint
{
    class OrderByConverter : ConverterMarkupExtension, IValueConverter
    {
        public OrderByConverter()
        {
        }

        public string Property
        {
            get;
            set; 
        }

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            System.Collections.IList coll = value as System.Collections.IList;
            ListCollectionView view = new ListCollectionView(coll);
            SortDescription sort = new SortDescription(Property, ListSortDirection.Ascending);
            view.SortDescriptions.Add(sort);
            return view;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}

Was stört dich denn an if/else?
Du könntest auch mit dem
> arbeiten oder die Min/Max-Methoden verwenden. Läuft aber alles wiederum auf Fallunterscheidungen hinaus... Von daher: Was ist daran "unsauber"?

Ach, ich dachte einfach, das gibt da 'ne mathematisch universelle Lösung ohne Fallunterscheidung. Wenn's diese nicht gibt und ich nicht um die Fallunterscheidung herumkomme, dann wird das wohl das Maß der Dinge sein und bleibt so. if/else ist mir einfach zu sehr "zufuß gegangen". Ich bin jemand, der gerne möglichst wenig Code für solche Probleme schreibt. Sei's drum. Das bleibt nun (erstmal) so.

Was genau machst du anders, je nachdem, in welchem Quadrant der Winkel liegt? Sieht man die Kante, wenn sie hinter der Rolle liegt?

Ja, die Kante sieht man, wenn sie hinter der Rolle liegt. Die Rolle ist unsichtbar. Man sieht die Kante allerdings nicht, wenn sie noch hinter dem Etikett liegt. Daher arbeite ich an der Stelle nun auch mit Math.Min und Math.Max.

Guckst du immer orthogonal auf die Rolle? Denn dann dürfte die Höhe der Kanten doch durch den Sinus vom Winkel dargestellt werden. Und ob die Kante vorn oder hinten liegt, bekommst du ja über den Quadranten des Winkels raus.

Ja, gucke ich. Und genau das habe ich jetzt auch gemacht: anhand des Quadranten eine Fallunterscheidung für beide Winkel durchgeführt. Find ich persönlich ziemlich unschön, funktioniert aber. Eleganter fällt mir nichts ein...

Guck mal in die
>

Hmm... ja, für Tortendiagramme sicher 'ne top Lösung. Ich werd sie mir beizeiten auch mal für mein Problem anschauen. Für den für morgen Abend vorgesehenen Meilenstein reicht mir erstmal die Fallunterscheidung. Eventuell finde ich ja in der Tortenkomponente noch was brauchbares nach Morgen. Heute fehlt dafür die Zeit. Ich danke dir natürlich trotzdem ganz herzlich für den Hinweis.

Hi Leute,

hab nochmal einen zum Insektenprogramm... Ich brauch noch 'ne Art "Seitenansicht" meines Kreisdiagramms. Dazu muss ich aus dem Start- und Endwinkel des Teilkreises die zwei horizontalen Kanten eines Rechtecks berechnen. Es soll also so aussehen, als schaute man von der Seite auf eine durchsichtige Rolle, auf der der von vorn als Teilkreis sichtbare Muskel als Rechteck zu sehen ist.

Stellt euch einfach vor, ihr schaut von vorn auf besagte Rolle (rein orthogonal, also ohne perspektivische oder parallaktische Verzerrungen). Auf der Seite der Rolle klebt ein Rechteckiges Etikett. Dieses Etikett sieht in der Frontansicht wie ein Teilkreis aus. In der Seitenansicht sieht dieses Etikett natürlich (immer noch rein orthogonal), unter Einflussnahme seines Abstands vom linken Rand der Rolle und seiner Breite, wie ein Rechteck aus. Nun stellt euch vor, ihr dreht die Rolle langsam. Das Etikett beginnt nach oben zu wandern und wird immer flacher, je weiter es sich dem oberen Rand der Rolle nähert.

Nun gibt es verschiedene Fallstricke:

1. Es kommt natürlich dazu, dass das Etikett über den höchsten Punkt hinaus wandert, seine Oberkante also aus Sicht des Betrachters hinter der Rolle wieder nach unten wandert. Die Rechteckige Abbildung des Etiketts wirkt aber immer noch so, als läge sie an der Oberkante der Rolle an, bist auch die zweite, die untere Kante des Etiketts den höchten Punkt überschritten hat. Was hinter der Rolle liegt, sieht man nicht, solange es sich auch hinter dem vor der Rolle liegenden Teil des Etiketts befindet. Und damit kommen wir zu Fallstrick Nummer...

2. Dreht man die Rolle weiter, kommt es irgendwann unweigerlich dazu, dass die hinter der Rolle liegende Kante des Etiketts mehr Abstand zur oberen Kante der Rolle hat als die noch vor der Rolle liegende Kante des Etiketts. Damit hört die untere Kante des Rechtecks sofort auf, mit der Drehung der Rolle nach oben zu wandern, sondern tritt wieder ihre Reise nach unten an, da sie nun die hinter der Rolle liegende Kante des Etiketts darstellt.

Das gleiche passiert natürlich auch, wenn das Etikett bei der Drehung der Rolle unten wieder auf die zum Betrachter gewandte Seite wandert.

Meine Frage(n) dazu ist nun: wie berechne ich aus dem gegebenen Anfangs- und Endwinkel des besagten Teilkreises Ober- und Unterkante des Rechtecks in der Seitenansicht? Komme ich um eine Fallunterscheidung herum? Gibt es dafür evtl. schon fertige Funktionen? Oder muss ich auf Sinus zurückgreifen?

Ich danke euch im Voraus für eure zahlreichen Antworten! 😃

Beste Grüße,
Hendrik

**//update: ** Hab das Problem jetzt über 'ne stumpfe Fallunterscheidung mit if-/else-if-Blöcken erschlagen.

Ach, in DEM XAML hab ich das gerade wieder rausgenommen, schulligung. Gar nicht drauf geachtet. Aber es clippt auch, wenn ich ClipToBounds=False drin hab. Außerdem geben mir Tools wie Snoop aus, dass ClipToBounds bei allen Elementen auch standardmäßig auf False ist.

Das mit der Viewbox ist mir bekannt. Die hat nur den Nachteil, dass sich ALLES verkleinert. Auch Text und Strichdicken. Das wollte ich vermeiden.

Was brauchst du denn vom XAML? Alles? Ich denke mal, nur den relevanten Zweig, oder?

Der Hintergrund wird vom Fluent Ribbon Window gezeichnet.

Also hier ist einmal das Resource Dictionary, das die Darstellung der Kreise und Teilkreise aus den jeweiligen Daten erzeugt:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:local="clr-namespace:InsectJoint"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Style TargetType="ItemsControl" x:Key="GridList">
        <Setter Property="ItemsPanel">
            <Setter.Value>
                <ItemsPanelTemplate>
                    <Grid />
                </ItemsPanelTemplate>
            </Setter.Value>
        </Setter>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate>
                    <Grid>
                        <ItemsPresenter />
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

    <DataTemplate DataType="{x:Type local:Muscle}">
        <local:Arc Placement="{Binding Path='Part.MusclePlacement'}" StrokeEndLineCap="Round" StrokeStartLineCap="Round" Stroke="{Binding Color}" StrokeThickness="{Binding Thickness}" StartAngle="{Binding Start}" EndAngle="{Binding End}" />
    </DataTemplate>

    <DataTemplate DataType="{x:Type local:Part}">
        <Grid VerticalAlignment="Center" HorizontalAlignment="Center" Tag="Part">
            <Grid.Width>
                <MultiBinding Converter="{local:ScaleMultiConverter}">
                    <Binding Path="ActualWidth" RelativeSource="{RelativeSource AncestorLevel=1, AncestorType=FrameworkElement}" />
                    <Binding Path="Percent" />
                </MultiBinding>
            </Grid.Width>
            <Grid.Height>
                <MultiBinding Converter="{local:ScaleMultiConverter}">
                    <Binding Path="ActualHeight" RelativeSource="{RelativeSource AncestorLevel=1, AncestorType=FrameworkElement}" />
                    <Binding Path="Percent" />
                </MultiBinding>
            </Grid.Height>
            <ItemsControl Panel.ZIndex="10" Style="{StaticResource GridList}" ItemsSource="{Binding}" />
            <Ellipse Panel.ZIndex="5" MaxHeight="{Binding ActualHeight, RelativeSource={RelativeSource AncestorLevel=2, AncestorType=FrameworkElement}}" Stroke="Red" StrokeThickness="2">
            </Ellipse>
        </Grid>
    </DataTemplate>

    <DataTemplate DataType="{x:Type local:Joint}">
        <ItemsControl VerticalContentAlignment="Stretch" HorizontalContentAlignment="Stretch" Style="{StaticResource GridList}" ItemsSource="{Binding}" />
    </DataTemplate>
</ResourceDictionary>

Hi Leute,

nochmal mein Insektenprogramm. Ich hab das mit dem Teilkreis jetzt so hin, wie ich das gerne hätte. Allerdings stellt sich da ein Phänomen ein, das ich mir nicht erklären kann.

Ich hab den Teilkreis als eigene Shape implementiert. Diese Shape kann auch durchaus mal über den Rand ihres Elternelements hinausgehen. Ich möchte aber nicht, dass sie dort am Rand abgeschnitten, sondern auch dort weitergezeichnet wird.

Eigentlich hab ich das so verstanden, dass für dieses Verhalten genau die Eigenschaft ClipToBounds da ist. Diese ist aber False. Sowohl bei der Shape, als auch bei den übergeordneten Elementen.

Kann mir da jemand etwas zu sagen, wieso die Shape dennoch am Rande des übergeordneten Elementes abgeschnitten wird? (im Bild der schwarze Bogen; der orangefarbene Bogen ist korrekt)

Danke

Grüße,
Hendrik

So. Das Zeichnen des Teilkreises funktioniert jetzt:

Ich habe mir eine Custom Shape erzeugt, die über den Winkelbereich in 1° Schritten BezierSegments anlegt. Performance ist da erstmal Nebensache.

Nächstes Problem: ((gelöst)

//update: Problem gelöst. Nun folgende Variante tut ihren Dienst exakt so, wie ich es gerne hätte. Verbesserungsvorschläge werden natürlich trotzdem gerne angenommen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Media;
using System.Windows.Shapes;
using System.Windows;
using System.Windows.Data;
using System.Windows.Controls.Primitives;

namespace InsectJoint
{
    public class Arc : Shape
    {
        public double StartAngle
        {
            get { return (double)GetValue(StartAngleProperty); }
            set { SetValue(StartAngleProperty, value); }
        }

        // Using a DependencyProperty as the backing store for StartAngle.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StartAngleProperty =
            DependencyProperty.Register("StartAngle", typeof(double), typeof(Arc), new UIPropertyMetadata(0.0D));



        public double EndAngle
        {
            get { return (double)GetValue(EndAngleProperty); }
            set { SetValue(EndAngleProperty, value); }
        }

        // Using a DependencyProperty as the backing store for EndAngle.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty EndAngleProperty =
            DependencyProperty.Register("EndAngle", typeof(double), typeof(Arc), new UIPropertyMetadata(0.0D));

        public bool AngleInDegrees
        {
            get { return (bool)GetValue(AngleInDegreesProperty); }
            set { SetValue(AngleInDegreesProperty, value); }
        }

        // Using a DependencyProperty as the backing store for AngleInDegrees.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty AngleInDegreesProperty =
            DependencyProperty.Register("AngleInDegrees", typeof(bool), typeof(Arc), new UIPropertyMetadata(true));


        PathGeometry _geo = new PathGeometry();
        PathFigure _fig = new PathFigure();

        public Arc()
        {
            _fig.IsClosed = false;
            _geo.Figures.Add(_fig);
        }

        protected override Geometry DefiningGeometry
        {
            get
            {
                _fig.Segments.Clear();

                double start = StartAngle, end = EndAngle;
                if (AngleInDegrees)
                {
                    start *= (Math.PI / 180.0D);
                    end *= (Math.PI / 180.0D);
                }

                double step = 2.0D * (Math.PI / 180);
                
                _fig.StartPoint = calcPoint(start);

                for (double i = start + step; i <= end; i += (step * 3))
                {
                    Point p1 = calcPoint(i - step * 2);
                    Point p2 = calcPoint(i - step);
                    Point p3 = calcPoint(i);

                    BezierSegment seg = new BezierSegment();
                    seg.Point1 = p1;
                    seg.Point2 = p2;
                    seg.Point3 = p3;

                    _fig.Segments.Add(seg);
                }

                return _geo;
            }
        }

        private Point calcPoint(double angle)
        {
            Rect r = LayoutInformation.GetLayoutSlot(this);
            double offX = (r.Width / 2.0D);
            double offY = (r.Height / 2.0D);
            double radX = (r.Width / 2.0D);
            double radY = (r.Height / 2.0D);

            Point p = new Point();
            p.X = radX * Math.Cos(angle) + offX;
            p.Y = radY * -Math.Sin(angle) + offY;
            return p;
        }
    }
}

Das könnte in der Tat funktionieren. Jedoch muss ich mir noch Gedanken machen, wie ich am besten die Verschneidung mit dem Dreieck realisiere, da es auch Kreisbögen geben kann, die mehr als 90° abdecken. Manche möglicherweise mehr als 180°. Da wird das dann mit dem Dreieck nix. Da müssten mehrere her... huah! Das wird ein Spaß... Da werde ich mit XAML alleine wohl nicht weit kommen, was?!

Ein Insektensimulator. 😄 Fast.

Einstellbar sein sollen "nur" Anfangs- und Endwinkel in einem polaren Koordinatensystem nach mathematischem Standard (pos. X als Cosinus des Winkels, pos. Y als Sinus des Winkels), dessen Ursprung im Mittelpunkt der Vollkreise liegt. Eventuell noch so Sachen wie Farbe und Breite des Strichs.

//edit 1
achso: der Radius des Kreises (bzw. beide Radien) ergibt sich aus dem zugeordneten Glied. Das ist also auch quasi eine einstellbare Größe. Ich zieh das als hierarchische Struktur auf: Körperteil -> Teilglied -> Kontaktpunkt, wobei jedes Körperteil mehrere Teilglieder und jedes Teilglied mehrere Kontaktpunkte haben kann.
//edit 1 ende

Die Winkel sollen veränderbar sein (möglichst genau). Am besten per Drag&Drop mit Thumbs an beiden Enden, wenn der jeweilige Kontaktpunkt ausgewählt ist. Auch einer der Gründe, wieso ich das alles mit den vorhandenen Komponenten aufzuziehen versuche und es nicht selber per OnRender zeichne. Die bieten schon einige dafür notwendige Funktionen.

CombinedGeometry... kann ich die auch so verwenden, dass das ein offener Pfad wird? Ich hab's schon versucht, die Teilkreise als Exclude zu erzeugen, indem ich ein "Rechteck" ausschneide, dem eine den Anfangs- und Endwinkeln entsprechende Ecke fehlt. Schwer zu erklären... jedenfalls hätte ich damit zwar einen passenden Kreisbogen bekommen; jedoch wäre dieser Teil eines geschlossenen Tortenstücks gewesen. Ich brauch aber wirklich NUR den Kreisbogen als offenen Pfad.

Is datt kompliziert...

Also der Sinn des ganzen ist folgender:

ich hab einem Freund zugesagt, ihm ein Programm zu schreiben, mit dem er schematisch die Muskulatur an Gliedmaßen von Insekten darstellen kann. Er hätte es gerne so, dass zwei oder mehr Elemente beispielsweise eines Wespenbeins in Vorderansicht als Kreise dargestellt werden. Als ob man direkt von vorn auf das ausgestreckte Bein schaut (grob, sehr schematisch halt). Der größere Kreis ist das aus der Perspektive hintere Glied des Beines, der jeweils kleinere Kreis das jeweils eine Ebene weiter vorne liegende Glied. Das sind die Vollkreise.

Die Teilkreise sollen nun Kontaktpunkte darstellen, an denen die Muskeln am Bein angewachsen sind. Es gehören also immer zwei Teilkreise zusammen. Einer auf einem weiter außen liegenden Vollkreis und einer auf einem weiter innen liegenden Vollkreis.

Und diese (schulligung, VERFLUCHTEN) Teilkreise zu zeichnen, bereitet mir gerade arge Kopfschmerzen.

Der Freund hat einfach keine Lust, für zig Proben immer und immer wieder die selben Bilder malen zu müssen. Da soll 'ne einfache Eingabemaske her, die ihm die Darstellung aus vorhandenen Daten erzeugt, bzw. wo er einfach klicken kann.

Und da ich das ganze nun so haben möchte, dass alle Elemente der Darstellung auswähl- und änderbare Objekte sind, versuche ich das so weit es eben geht in WPF und XAML zu programmieren. Grafische Darstellung und Daten sollen eben so weit es geht von einander getrennt bleiben.

Ja, den hab ich schon überflogen, werde da aber nicht so recht schlau draus.

Ich brech mir hier echt einen ab. Es kann doch nicht so schwer sein, nur einen Teil einer Ellipse unter Angabe eines Mittelpunktes (X, Y), zweier Radien (X, Y) und zweier Winkel (Anfang, Ende) zu zeichnen. Das ist doch kein besonderes Anliegen, oder?

Huh, dann grabe ich diesen Thread mal wieder aus. Kannst du dich mal dazu äußern WIE du das ganze gelöst hast? Mathematisch, codetechnisch...

Danke!

Hi Leute,

ich möchte gern über eine vorhandene Ellipse (Shape) eine weitere zeichnen, die die gleichen Eigenschaften bezüglich Geometrie besitzt, außer dass sie nur einen bestimmtes Bogenmaß abdeckt. Es soll also sowas wie ein ArcSegment werden.

Allerdings ist mir ArcSegment viel zu kompliziert umgesetzt, als dass ich damit in diesem speziellen Fall irgendwas produktives in brauchbarer Zeit umgesetzt bekäme.

Die (ich nenn's mal) "Teilellipse" sollte möglichst rein in XAML umgesetz sein, mit Binding an ein Objekt das einfach Anfangs und Endwinkel vorgibt.

Hat jemand eine Idee, wie man das realisieren könnte? "Einfach nur" eine Teilellipse zeichnen?

Danke

Grüße,
Hendrik

Wir hatten bei unserem Roboterprojekt ein ähnliches Problem. Gegenstelle des seriellen Ports war ein Arduino Uno. Das Problem löste sich, nachdem wir die Baud-Rate bis Anschlag aufgedreht hatten.

Eine nach Kind gecastete Referenz wirst du auf die Basis-Instanz wohl nicht kriegen. Bau dir einen Copy-Constructor in der Kind-Klasse, der ein Basis-Objekt übernimmt, die entsprechenden Basis-Properties kopiert und die erweiterten Kind-Properties auf default-Werte setzt. Oder einen entsprechenden impliziten Cast-Operator.

Aber damit bekommst du nur eine Kopie von basis.

Ich meinte sowas wie Where(a => predicateExpression(a) && ...).){gray}

Exakt das meinte ich auch.

Dass Expression<Func<>> in einer Query nicht (immer) geht, ist genau einer meiner persönlichen Aufreger bei EF.

Hi Leute,

kurze Frage: kennt einer ein WPF Grid, das "splitten" erleichtert? Ich finde das bei dem mitgelieferten Grid etwas lästig, dass ich da immer einen GridSplitter manuell einbauen muss. Ich hätte gern ein Grid, das das automatisch anhand der Column- und RowDefinitions mitliefert.

Gibt's sowas schon? Tät mich freuen, wenn da jemand was kennt und mir mitteilte.

Danke euch!

Grüße,
Hendrik

Danke, herbivore. Genau das habe ich gemeint, mich aber offenbar falsch ausgedrückt. Ich meinte halt auch so Dinge wie Mole 2010 oder den Reflector und dergleichen.

Hi Leute,

mich würde mal brennend interessieren, was ihr so alles an Debugging Tools kennt, an denen man als .NET/C#/WPF/VS2010 Entwickler nicht vorbei kommt, die man einfach haben MUSS. Schreibt einfach den Titel hin, was es macht und welche Vor- und Nachteile ihr seht.

Ich geb mal vorschlaghalber ein Beispiel, wie das aussehen könnte:

Titel: Mein Debugging Tool
Was macht es: es debuggt (gern auch detaillierter)
Vor-/Nachteile:

• es ist ganz toll
• es kann ganz viel

• es ist sehr groß

Danke

Grüße,
Hendrik

In Ermangelung eines erschwinglichen oder gar freien Schedule-Controls baue ich mir so ein Teil gerade selber. Geht um die visuelle Darstellung von Stunden-/Vorlesungsplänen. Die Startzeit eines Eintrags wird in Column umgerechnet, die Dauer in ColumnSpan.

Ich hatte schon einmal solch ein Control gebaut, in dem ich ein Canvas als Panel verwendet habe. Aus irgendeinem Grunde missfiel mir diese Lösung allerdings. Da ich jedoch nicht genug geschlafen habe, letzte Nacht, fällt mir dieser Grund gerade leider nicht ein.

Andererseits, Canvas wäre wahrscheinlich performanter... Na mal sehen...

Ich weiß nicht, ob's auch mit UniformGrid funktioniert hätte... Jedenfalls hab ich's jetzt über ein von Grid abgeleitetes Control realisiert, das eine Eigenschaft Columns bekommen hat und die Anzahl uniformer ColumnDefinitions danach erzeugt. Ist akzeptabel. 👍

Hi Leute,

ich versuche gerade, in einem Custom Control, das von ItemsControl abgeleitet ist, das ItemsPanel zu finden, weil ich's programmatisch verändern will (ca. 250 ColumnDefinitions im XAML gehen mir ein wenig zu sehr gegen Don't Repeat Yourself).

Wie bekomme ich im Programm also Zugriff auf das Grid, das da im ItemsPanel steckt?

        <Setter Property="ItemsPanel">
            <Setter.Value>
                <ItemsPanelTemplate>
                    <Grid x:Name="PART_ItemsTemplateGrid" />
                </ItemsPanelTemplate>
            </Setter.Value>
        </Setter>

Geht das überhaupt?

Danke!

Grüße,
Hendrik

Das habe ich schon probiert. Leider ist CanFilter = False. Ebenso wie CanCustomFilter. Gerade darum bau ich mir ja die ViewModels. Beim direkten Binden der CollectionViewSource an mein WPF Window kann ich nicht filtern. Weshalb, die Frage konnte ich mir noch nicht beantworten.

//edit: Wenn ich die LINQ Query nicht direkt auf der Entity mache, sondern auf einer daraus generierten List, funktioniert das. Ich frage mich nur, ob das auch Änderungen in der Datenbank hinter der Entity berücksichtigt...

//edit 2: Hmm... Das ist 'ne Quick'n'Dirty Lösung. Schön finde ich das nicht. Oder ist das tatsächlich die ultimative Lösung dafür, dass LINQ to Entities kein Invoke kann?

return from p in Model.Buecher.ToArray()
        where Filter(p)
        select p;

verwendetes Datenbanksystem: LINQ to Entity Framework

Hi Leute,

ich versuche immernoch, in meiner nach MVVM umgestrickten Anwendung im ViewModel eine Möglichkeit einzubauen, Datensätze zu filtern.

Dazu hab ich in meiner Basisklasse ViewModelBase eine Property "Filter" vom Typ Predicate<T> implementiert, welche ich im entsprechenden ViewModel in einer LINQ Query dann aufrufen will, sofern gesetzt.

Die LINQ Query sieht dann ungefähr so aus:

return from p in Model.Buecher
        where Filter(p)
        select p;

Leider sagt mir die Laufzeit dort, dass LINQ to Entities den Knotentyp Invoke nicht unterstützt.

Jemand 'ne Idee, wie man das Problem am besten umschifft?

Danke

Grüße,
Hendrik

Ja, das Problem ist halt, dass ich das Ding schon nahezu fertig habe und eine Umstellung auf ein neues Konzept wohl dazu führen würde, dass ich das Teil komplett neu schreiben kann. Gut, ich meine, der Aufwand wäre jetzt nicht so groß.

Aber allein zu verstehen, wie man mit MEF und WAF umgeht, kostet 'ne Weile. Bisher blicke ich da noch nicht so ganz durch.