Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #21
    Membre expert
    Inscrit en
    avril 2008
    Messages
    2 075
    Détails du profil
    Informations personnelles :
    Âge : 59

    Informations forums :
    Inscription : avril 2008
    Messages : 2 075
    Points : 3 592
    Points
    3 592

    Par défaut

    rebonjour

    Tu n'as pas répondu à la question de base ; quel le type de Node (Class1à et Description ( Class2)?
    Le Class1 (donc Node) contient des DP : est -ce un Cust Control ,un Shape ,un Dependency Object..
    On se perd en devinettes ...bref on en est: Un petit cochon pendu au plafond, tirez lui le nez, il donnera du lait. Tirez-lui la queue, il pondra des ...
    Quid de l'ovni Class2...
    On attend donc que tu éclaires notre lanterne...

  2. #22
    Membre régulier
    Inscrit en
    septembre 2006
    Messages
    229
    Détails du profil
    Informations forums :
    Inscription : septembre 2006
    Messages : 229
    Points : 94
    Points
    94

    Par défaut

    en suivant le cosneil de MABROUKI j'ai fait :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
     <local:CanvaNetwork.Resources>
                                <Style TargetType="{x:Type local:CanvaNetwork}">
                                    <Style.Triggers>
                                        <Trigger Property="IsMouseOver" Value="True">
                                            <Setter Property="NewMouseOver" Value="True"/>
                                            <Setter Property="Cursor"  Value="Cross"/>
                                        </Trigger>
                                        <!--<Trigger Property="IsMouseOver" Value="False">
                                            <Setter Property="NewMouseOver" Value="False"/>
                                            <Setter Property="Cursor"  Value="Arrow"/>
                                        </Trigger>-->
                                    </Style.Triggers>
                                </Style>
                            </local:CanvaNetwork.Resources>
    la souri prend la forme de la croix mais pas de réaction au niveau du changement d'état de ma DP au niveau de ma Methode :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
     private static void On_MyMouseOver(DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                Node nd = (Node) d;
                nd.AN.Visibility = nd.MyMouseOver == true ? Visibility.Visible : Visibility.Hidden;
     
            }
    j'ai mis un point d'arret su ma Méthode mais c'est comme si "MyMouseOver " ne change pas et ne devient pas "True"

  3. #23
    Membre éprouvé
    Homme Profil pro
    edi
    Inscrit en
    juin 2007
    Messages
    579
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : edi

    Informations forums :
    Inscription : juin 2007
    Messages : 579
    Points : 1 134
    Points
    1 134

    Par défaut

    Comme promis, ci-joint le code que j'ai écrit pour capter le survol de la souris sur le Canvas.

    Le fichier Window.xaml :

    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    <Window x:Class="WpfCanvasSample.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfCanvasSample"
            mc:Ignorable="d"
            Title="MainWindow" Height="450" Width="800">
        <ContentControl>
            <ContentControl.Resources>
                <DataTemplate DataType="{x:Type local:MainViewModel}">
                    <Canvas Width="{Binding Width, RelativeSource={RelativeSource FindAncestor, AncestorType=Window}}" 
                        Height="{Binding Height, RelativeSource={RelativeSource FindAncestor, AncestorType=Window}}" 
                        Background="Green" MouseEnter="Canvas_MouseBorderCrossed" MouseLeave="Canvas_MouseBorderCrossed">
                    </Canvas>
                </DataTemplate>
            </ContentControl.Resources>
            <ContentControl.Template>
                <ControlTemplate>
                    <ContentPresenter Content="{TemplateBinding ContentControl.DataContext}"/>
                </ControlTemplate>
            </ContentControl.Template>
        </ContentControl>
    </Window>

    Le fichier C# avec le code behind :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    namespace WpfCanvasSample
    {
        /// <summary>
        /// Logique d'interaction pour MainWindow.xaml
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
                DataContextChanged += OnDataContextChanged;
                DataContext = new MainViewModel();
            }
     
            private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
            {
                if (e.OldValue is MainViewModel oldMvm) oldMvm.PropertyChanged -= OnMvmPropertyChanged;
                if (e.NewValue is MainViewModel newMvm) newMvm.PropertyChanged += OnMvmPropertyChanged;
            }
     
            private void OnMvmPropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                var message = $"{e.PropertyName} => {sender?.GetType()?.GetProperty(e.PropertyName)?.GetValue(sender)}";
                Console.WriteLine(message);
            }
     
            private void Canvas_MouseBorderCrossed(object sender, MouseEventArgs e)
            {
                if (sender is Canvas canvas && canvas.DataContext is MainViewModel model)
                    model.MouseOver = canvas.IsMouseOver;
            }
        }
     
        public class MainViewModel : INotifyPropertyChanged
        {
            public event PropertyChangedEventHandler PropertyChanged;
     
            protected void OnPropertyChanged([CallerMemberName]string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
     
            private bool _mouseOver;
            public bool MouseOver
            {
                get => _mouseOver;
                set { if (_mouseOver == value) return; _mouseOver = value; OnPropertyChanged(); }
            }
        }
    }
    Il y a pas mal de "bruit" par rapport au signal, car j'ai voulu garder le DataTemplate. La partie significative c'est le handler Canvas_MouseBorderCrossed, inséré dans les événement MouseEnter et MouseLeave du Canvas ; le reste sert surtout de démo pour vérifier qu'on a bien le comportement attendu.

    Mais comme je l'ai dit c'est du bricolage, destiné à avoir une réponse rapide. Et je pense comme d'autres que tu nous parles plus de ta solution que du problème que tu cherches à résoudre. Par exemple le Canvas sert-il à afficher un seul Node ou bien est-ce-le composant qui les contient ? Un ItemsControl avec un ItemsPanel spécifique ne répondrait-il pas à ton besoin ? Est-ce-qu'il ne serait pas possible d'utiliser la couche d'enjoliveurs (AdornerLayer) pour afficher les éléments optionnels ?

  4. #24
    Membre régulier
    Inscrit en
    septembre 2006
    Messages
    229
    Détails du profil
    Informations forums :
    Inscription : septembre 2006
    Messages : 229
    Points : 94
    Points
    94

    Par défaut

    Citation Envoyé par Noxen Voir le message
    Mais comme je l'ai dit c'est du bricolage, destiné à avoir une réponse rapide. Et je pense comme d'autres que tu nous parles plus de ta solution que du problème que tu cherches à résoudre. Par exemple le Canvas sert-il à afficher un seul Node ou bien est-ce-le composant qui les contient ? Un ItemsControl avec un ItemsPanel spécifique ne répondrait-il pas à ton besoin ? Est-ce-qu'il ne serait pas possible d'utiliser la couche d'enjoliveurs (AdornerLayer) pour afficher les éléments optionnels ?
    je cherche à afficher des objets dans un Canvas, pour cela j'ai suivi le conseil de plusieurs devellopeurs en choisissant la ListBox comme controle principal.

    j'ai aussi choisi de conciderer chaque objet comme élement de la listBox, exmple :
    1-les Node : collection : NodeColl
    2-les Links : collection : LinkColl
    3-Label ou description ou Annotation : AnnotationColl
    ....
    Je combine le tout dans une CombinedCollection qui est la source de ma ListBox.

    Les Nodes peuvent avoir différent Form, j'ai une propriété "Geometryform" de type PathGeometry ainsi je n'ai pas a creer d'autre type.

    En créant un "Node" un objet "Annotation" est cré mais qui restera "Hidden" sauf si MouOver est frai.


    Maintenant ma DP ne semble pas basculer de False à True.

  5. #25
    Membre expert
    Inscrit en
    avril 2008
    Messages
    2 075
    Détails du profil
    Informations personnelles :
    Âge : 59

    Informations forums :
    Inscription : avril 2008
    Messages : 2 075
    Points : 3 592
    Points
    3 592

    Par défaut

    rebonjour

    Il y a un problème sérieux de conception comme déjà dit et en attendant de connaitre les types de Node et Annotation ,il faut observer que le IsMouseOver sur le Canvas échouera lamentablement .
    Car si le Label affichant l'Annotaion du Node possède un Background NON Transparent il empêchera la détection IsMouseOver sur Canvas....

    3 voies possibles :

    1/ mettre le Trigger du Canvas.Style comme déjà dit et setter la DP Label.Background =Transparent
    ou
    2/ mettre le Trigger du Canvas.Style comme déjà dit et le setter la DP Label.IsHitTestVisible=false sur le Label
    setter la DP
    Mais un minimum de jugeote montre que c'est une voie détournée et débile et qu'il suffit de mettre le trigger sur le Label.Style et de setter la DP Opacity du Label à 0.0 plutôt que sa DP Visibility = false....

    je ne donne pas le code tant que plus ample information soit donnée sur les types les types de Node et Annotation...

    Bon code...

  6. #26
    Membre régulier
    Inscrit en
    septembre 2006
    Messages
    229
    Détails du profil
    Informations forums :
    Inscription : septembre 2006
    Messages : 229
    Points : 94
    Points
    94

    Par défaut

    Citation Envoyé par MABROUKI Voir le message
    ...

    je ne donne pas le code tant que plus ample information soit donnée sur les types les types de Node et Annotation...

    Bon code...
    voici mon code : trois classes pour la représentation de trois objets : les Nodes, les Links et les Annotations
    en plus il y a une classe NetWork
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
     
    public  class  Node : DependencyObject,INotifyPropertyChanged
     
    {
     
     
    //code......
     
     
              public NetWork MyNetWork;
     
    public static readonly DependencyProperty MyMouseOverProperty = DependencyProperty.Register
                                                                            ("MyMouseOver", typeof(bool), typeof(Node), 
                                                                              new PropertyMetadata(false,new PropertyChangedCallback(On_MyMouseOver)));
     
            private static void On_MyMouseOver(DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                Node nd = (Node) d;
     
                nd.AN.Visibility = nd.MyMouseOver == true ? Visibility.Visible : Visibility.Hidden;
     
            }
     
            public bool MyMouseOver
            {
                get { return (bool)GetValue(MyMouseOverProperty); }
                set { SetValue(MyMouseOverProperty, value); }
            }
     
     
     
            private Annotation _an;
            public Annotation AN
            {
                get { return this._an; }
                set
                {
                    if (value != this._an)
                    {
                        this._an = value;
                        OnPropertyChanged(nameof(this.AN));
                    }
                }
            }
     
     
     
     
    	private double _barycenterX;
            public double BarycenterX
            {
                get { return this._barycenterX; }
     
                set
                {
                    if (value != this._barycenterX)
                    {
                        this._barycenterX = value;
     
                        OnPropertyChanged(nameof(this.BarycenterX));
                    }
                }
            }
     
            private double _barycenterY;
            public double BarycenterY
            {
                get { return this._barycenterY; }
     
                set
                {
                    if (value != this._barycenterY)
                    {
                        this._barycenterY = value;
     
                        OnPropertyChanged(nameof(this.BarycenterY));
                    }
                }
            }
     
     
    		 private double _OffsetX;
     
            public double OffsetX
            {
                get { return this._OffsetX; }
     
                set
                {
                    if (value != this._OffsetX)
                    {
                        this._OffsetX = value;
     
                        OnPropertyChanged(nameof(this.OffsetX));
                    }
                }
            }
     
            private double _OffsetY;
     
            public double OffsetY
            {
                get { return this._OffsetY; }
     
                set
                {
                    if (value != this._OffsetY)
                    {
                        this._OffsetY = value;
     
                        OnPropertyChanged(nameof(this.OffsetY));
                    }
                }
            }
     
     
            private Visibility _visibility; //for the geoform
            public Visibility Visibility 
            {
                get { return this._visibility; }
     
                set
                {
                    if (value != this._visibility)
                    {
                        this._visibility = value;
                        OnPropertyChanged(nameof(this.Visibility));
                    }
                }
            }
     
     
    	private NodeForm _nodeForm;
            public NodeForm NodeForm
            {
                get { return this._nodeForm; }
                set
                {
                    if (value != this._nodeForm)
                    {
                        this._nodeForm = value;
                        OnPropertyChanged(nameof(this.NodeForm));
                    }
                }
            }
     
     
     
     
            private PathGeometry _geometryform;
            public PathGeometry Geometryform
            {
                get { return this._geometryform; }
     
                set
                {
                    if (value != this._geometryform)
                    {
                        this._geometryform = value;
                        OnPropertyChanged(nameof(this.Geometryform));
                    }
                }
            }
     
     
     
    	public  void CreatGeometry(NodeForm NDF)
            {
                Geometryform = new PathGeometry();
     
                switch (NDF)
                {
                    case NodeForm.RECTANGLE:
                        Geometryform.AddGeometry(Geometry.Parse("M 0,0 L 0,50 L 100,50 100,0 Z "));
     
                        break;
     
                    case NodeForm.ELIPSE:
                        //Geometryform.AddGeometry(Geometry.Parse("C 0,0 R 50"));  comment décrir une ELIPSE
                        Geometryform.AddGeometry(new EllipseGeometry
                        {
                            Center = new Point { X = 0, Y = 0 },
                            RadiusX = 10,
                            RadiusY = 10
                        });
                        break;
     
                    case NodeForm.TRIANGLE:
                        Geometryform.AddGeometry(Geometry.Parse("M 0,0 L 0,50  50,50 Z "));
                        break;
     
    				default:
                        break;
                }
            }
     
     
     
     
     
     
     
     
     
    }


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
     
    public  class  Link : DependencyObject,INotifyPropertyChanged
     
    {
     
     
    //code......
     
     
    		public NetWork MyNetWork;
     
    public static readonly DependencyProperty MyMouseOverProperty = DependencyProperty.Register
                                                                            ("MyMouseOver", typeof(bool), typeof(Node), 
                                                                              new PropertyMetadata(false,new PropertyChangedCallback(On_MyMouseOver)));
     
            private static void On_MyMouseOver(DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                Node nd = (Node) d;
     
                nd.AN.Visibility = nd.MyMouseOver == true ? Visibility.Visible : Visibility.Hidden;
     
            }
     
            public bool MyMouseOver
            {
                get { return (bool)GetValue(MyMouseOverProperty); }
                set { SetValue(MyMouseOverProperty, value); }
            }
     
     
     
            private Annotation _an;
            public Annotation AN
            {
                get { return this._an; }
                set
                {
                    if (value != this._an)
                    {
                        this._an = value;
                        OnPropertyChanged(nameof(this.AN));
                    }
                }
            }
     
     
     
     
            private Point _FirstConPoint;
            private Point _LastConPoint;
     
            public Point FirstConPoint
            {
                get { return _FirstConPoint; }
                set
                {
                    if (value != _FirstConPoint)
                        _FirstConPoint = value;
                    //FirstConnPointStruct.ConPoint = _FirstConPoint;
                    OnPropertyChanged(nameof(FirstConPoint));
                }
            }
            public Point LastConPoint
            {
                get { return _LastConPoint; }
                set
                {
                    if (value != _LastConPoint)
                        _LastConPoint = value;
                    //LastConnPointStruct.ConPoint = _LastConPoint;
                    OnPropertyChanged(nameof(LastConPoint));
                }
            }
     
     
     
     
    	private double _barycenterX;
            public double BarycenterX
            {
                get { return this._barycenterX; }
     
                set
                {
                    if (value != this._barycenterX)
                    {
                        this._barycenterX = value;
     
                        OnPropertyChanged(nameof(this.BarycenterX));
                    }
                }
            }
     
            private double _barycenterY;
            public double BarycenterY
            {
                get { return this._barycenterY; }
     
                set
                {
                    if (value != this._barycenterY)
                    {
                        this._barycenterY = value;
     
                        OnPropertyChanged(nameof(this.BarycenterY));
                    }
                }
            }
     
     
    	private double _OffsetX;
     
            public double OffsetX
            {
                get { return this._OffsetX; }
     
                set
                {
                    if (value != this._OffsetX)
                    {
                        this._OffsetX = value;
     
                        OnPropertyChanged(nameof(this.OffsetX));
                    }
                }
            }
     
            private double _OffsetY;
     
            public double OffsetY
            {
                get { return this._OffsetY; }
     
                set
                {
                    if (value != this._OffsetY)
                    {
                        this._OffsetY = value;
     
                        OnPropertyChanged(nameof(this.OffsetY));
                    }
                }
            }
     
     
            private Visibility _visibility; 
            public Visibility Visibility 
            {
                get { return this._visibility; }
     
                set
                {
                    if (value != this._visibility)
                    {
                        this._visibility = value;
                        OnPropertyChanged(nameof(this.Visibility));
                    }
                }
            }
     
     
     
     
    }
    Annotation
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
     
     
    public  class  Annotation : INotifyPropertyChanged
     
    {
     
     
    //code......
     
     
    		public NetWork MyNetWork;
    		public Node MyNode;
    		public Link MyLink;
     
    		//du code ..
     
     
    		private double _labelX;
            public double LabelX
            {
                get { return this._labelX; }
                set
                {
                    if (value != this._labelX)
                    {
                        this._labelX = value;
                        OnPropertyChanged(nameof(this.LabelX));
                    }
                }
            }
     
     
            private double _labelY;
            public double LabelY
            {
                get { return this._labelY; }
                set
                {
                    if (value != this._labelY)
                    {
                        this._labelY = value;
                        OnPropertyChanged(nameof(this.LabelY));
                    }
                }
            }
     
    		 private string _labelText;
            public string LabelText
            {
                get { return this._labelText; }
                set
                {
                    if (value != this._labelText)
                    {
                        this._labelText = value;
                        OnPropertyChanged(nameof(this.LabelText));
                    }
                }
            }
     
     
     
    		 private Visibility _visibility; 
            public Visibility Visibility
            {
                get { return this._visibility; }
     
                set
                {
                    if (value != this._visibility)
                    {
                        this._visibility = value;
                        OnPropertyChanged(nameof(this.Visibility));
                    }
                }
            }
     
     
    		private double _barycenterX;
            public double BarycenterX
            {
                get { return this._barycenterX; }
     
                set
                {
                    if (value != this._barycenterX)
                    {
                        this._barycenterX = value;
     
                        OnPropertyChanged(nameof(this.BarycenterX));
                    }
                }
            }
     
            private double _barycenterY;
            public double BarycenterY
            {
                get { return this._barycenterY; }
     
                set
                {
                    if (value != this._barycenterY)
                    {
                        this._barycenterY = value;
     
                        OnPropertyChanged(nameof(this.BarycenterY));
                    }
                }
            }
     
     
     
     
     
     
    		 private double _OffsetX;
     
            public double OffsetX
            {
                get { return this._OffsetX; }
     
                set
                {
                    if (value != this._OffsetX)
                    {
                        this._OffsetX = value;
     
                        OnPropertyChanged(nameof(this.OffsetX));
                    }
                }
            }
     
            private double _OffsetY;
     
            public double OffsetY
            {
                get { return this._OffsetY; }
     
                set
                {
                    if (value != this._OffsetY)
                    {
                        this._OffsetY = value;
     
                        OnPropertyChanged(nameof(this.OffsetY));
                    }
                }
            }
    NetWork :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
     
     
    public class NetWork : INotifyPropertyChanged
        {
     
            readonly MainWindow myMW; // ref to external world
     
     
     
    		 private ObservableCollection<Node> _nodeColl;
            public ObservableCollection<Node> NodeColl
            {
                get => _nodeColl;
     
                set
     
                {
                    if (value != _nodeColl)
                    {
                        _nodeColl = value;
                        IsCollectionChanged = true;
                    }
                }
     
            }
     
            private ObservableCollection<Link> _linkColl;
            public ObservableCollection<Link> LinkColl
            {
                get => _linkColl;
                set
                {
                    if (value!=_linkColl)
                    {
                        _linkColl = value;
                        IsCollectionChanged = true;
                    }
                }
            }
     
    		private ObservableCollection<Annotation> _annotationColl;
            public ObservableCollection<Annotation> AnnotationColl
            {
                get => _annotationColl;
                set
                {
                    if (value!=_annotationColl)
                    {
                        _annotationColl = value;
                        IsCollectionChanged = true;
                    }
                }
            }
     
    }
    Pour mon XAML j'ai déjà publié voici pour Le DataTemplate de Link
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
                    <DataTemplate DataType="{x:Type local:Link}">
     
                        <Canvas Name="ItemCanvas_Link" Background="Transparent">
     
                            <Path x:Name="Path_Link"
                                  Stroke="Red"
                                  StrokeThickness="2">
                                <Path.Data>
                                    <LineGeometry
                                        StartPoint = "{Binding Path=FirstConPoint}"
                                        EndPoint = "{Binding Path=LastConPoint}" />
                                </Path.Data>
     
                                <Path.RenderTransform>
                                    <TransformGroup>
     
                                        <TranslateTransform
                                           X="{Binding Path=OffsetX ,Mode=TwoWay}"
                                           Y="{Binding Path=OffsetY ,Mode=TwoWay}" />
     
                                    </TransformGroup>
                                </Path.RenderTransform>
                            </Path>
     
     
                        </Canvas>
     
     
                    </DataTemplate>


    j'ai mis un point d’arrêt au niveau de la Méthode :"On_MyMouseOver" mais c'est comme si ma DP "MyMouseOver" ne change pas, pourtant "Cursor" réagit:
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <local:CanvaNetwork.Resources>
                                <Style TargetType="{x:Type local:CanvaNetwork}">
                                    <Style.Triggers>
                                        <Trigger Property="IsMouseOver" Value="True">
                                            <Setter Property="NewMouseOver" Value="True"/>
                                            <Setter Property="Cursor"  Value="Cross"/>
                                        </Trigger>
                                       
                                    </Style.Triggers>
                                </Style>
                            </local:CanvaNetwork.Resources>

  7. #27
    Membre expert
    Inscrit en
    avril 2008
    Messages
    2 075
    Détails du profil
    Informations personnelles :
    Âge : 59

    Informations forums :
    Inscription : avril 2008
    Messages : 2 075
    Points : 3 592
    Points
    3 592

    Par défaut

    Rebonjour
    je cites un 1er post :
    En créant un "Node" un objet "Annotation" est créé mais qui restera "Hidden" sauf si MouOver est frai.
    je cites un 2e post:
    Pour une raison la description ne doit apparaître que si la souri et sur le "Node"
    Si les mots ont un sens j'ai compris que les Annotations des "nodes" ne doivent être visibles que si tu survoles un "node"...

    2 exemples de code sont donnés ci-après(ce post et le post suivant pour ne pas alourdir la lecture):
    1/ le 1er utilise 3 Class CLR implementant INotifyPropertyChanged Node,Link,Annotation...
    Le prop GeometryForm a été viré car elle doit faire partie normalement de l'UI conformement à l'ortodoxie WPF
    Plus 2 Class:
    -NetworkGraph gerant le Graph (liaisons entre Node et Link) et implementant INotifyPropertyChanged
    -Provider chargé de "populer" le graph. C'est un fournisseur de données ou magasin de donnéés(une BD par exemple ou un fichier XML)

    Cote UI :
    - un simpliste UserControl denommé ControlGraph et un Form

    code behind .cs du 1er exemple(Node,Link et Annotaion):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    public class Node : INotifyPropertyChanged 
        {
            public Node()
            {
     
            }
            public Node(string pkey,Point pposition,Annotation pannotation,bool pisvisible)
            {
                m_key = pkey;
                m_position = pposition;
                m_an = pannotation;
                m_isVisible = pisvisible;
            }
            private string m_key;
            public string Key
            {
                get { return this.m_key; }
                set
                {
                    if (value != m_key)
                    {
                        m_key = value;
                        OnPropertyChanged("Key");
                    }
                }
            }
            private Point m_position;
            public Point Position
            {
                get { return m_position; }
                set { 
                    m_position=value;
                    OnPropertyChanged("Position");
                }
            }
     
            private Annotation m_an;
            public Annotation AN
            {
                get { return m_an; }
                set { 
                    if (value != m_an)
                    {
                        m_an = value;
                        OnPropertyChanged("AN");
                    } 
                }
            }
     
            private bool m_isVisible;
            public bool IsVisible
            {
                get { return m_isVisible; }
     
                set
                {
                    if (value != m_isVisible)
                    {
                        this.m_isVisible = value;
                        OnPropertyChanged("IsVisible");
                    }
                }
            }
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string n)
            {
                PropertyChangedEventHandler h = PropertyChanged;
                if (h != null)
                    h(this, new PropertyChangedEventArgs(n));
     
            }
        }
        public class NodeCollection : ObservableCollection<Node>
        {
            public NodeCollection()
            {
     
            }
        }
     
     public class Link : INotifyPropertyChanged 
        {
            public Link()
            { }
            public Link(
                Node pfromnode, Node ptonode,
                bool pisvisible)
                : this()
            {
                m_fromNode = pfromnode;
                m_toNode = ptonode;
                m_isVisible = pisvisible;
     
            }
            public Link(Annotation pannotion,
                Node pfromnode,Node ptonode,
                bool pisvisible):this(pfromnode, ptonode,pisvisible)
            {
                m_an = pannotion;
                m_fromNode = pfromnode;
                m_toNode = ptonode;
                m_isVisible = pisvisible;
     
            }
            private Node m_fromNode;
            public Node FromNode
            {
                get { return m_fromNode; }
                set {
     
                    if (value != m_fromNode)
                    {
                        m_fromNode = value;
                        OnPropertyChanged("FromNode");
                    }
                }
            }
            private Node m_toNode;
            public Node ToNode
            {
                get { return m_toNode; }
                set
                {
                    if (value != m_toNode)
                    {
                        m_toNode = value;
                        OnPropertyChanged("ToNode");
                    }
                }
            }
            public Point Position
            {
                get
                {
                    return new Point(
                        (this.FromNode.Position.X + this.ToNode.Position.X) / 2,
                        (this.FromNode.Position.Y + this.ToNode.Position.Y) / 2);
                }
            }
            private Annotation m_an;
     
            public Annotation AN
            {
                get { return m_an; }
                set
                {
                    if (value != m_an)
                    {
                        m_an = value;
                        OnPropertyChanged("AN");
                    }
                }
            }
            private bool m_isVisible;
            public bool IsVisible
            {
                get { return m_isVisible; }
     
                set
                {
                    if (value != m_isVisible)
                    {
                        m_isVisible = value;
                        OnPropertyChanged("IsVisible");
                    }
                }
            }
     
     
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string n)
            {
                PropertyChangedEventHandler h = PropertyChanged;
                if (h != null)
                    h(this, new PropertyChangedEventArgs(n));
     
            }
        }
        public class LinkCollection : ObservableCollection<Link>
        {
            public LinkCollection()
            {
     
            }
        }
     
    public class Annotation :INotifyPropertyChanged  
        {
            public Annotation()
            { }
            public Annotation(string plibelle,bool  pisvisible):this()
            {
                m_libelle = plibelle;
                m_isVisible = pisvisible; 
            }
            public Annotation(string plibelle, Point pposition, bool pisvisible)
                : this(plibelle ,pisvisible )
            {
                m_libelle = plibelle;
                m_position = pposition;
                m_isVisible = pisvisible;
            }
     
     
     
     
     
            private String m_libelle;
            public String Libelle
            {
                get { return m_libelle ; }
                set {
                    if (value != m_libelle)
                    {
                        m_libelle = value;
                        OnPropertyChanged("Libelle");
                    }
                }
            }
            private Point m_position;
            public Point Position
            {
                get { return m_position; }
                set
                {
                    if (value != m_position)
                    {
                        this.m_position = value;
                        OnPropertyChanged("Position");
                    }
                }
            }
     
     
     
            private bool m_isVisible;
            public bool IsVisible
            {
                get { return m_isVisible; }
     
                set
                {
                    if (value != m_isVisible)
                    {
                        this.m_isVisible = value;
                        OnPropertyChanged("IsVisible");
                    }
                }
            }
     
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string n)
            {
                PropertyChangedEventHandler h = PropertyChanged;
                if (h != null)
                    h(this, new PropertyChangedEventArgs(n));
     
            }
     
        }
        public class AnnotationCollection : ObservableCollection<Annotation>
        {
            public AnnotationCollection()
            {
     
            }
        }
    suite code behind .cs du 1er exemple(NetworkGraph et Provider):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
     
     public class NetworkGraph : INotifyPropertyChanged
        {
     
            private Provider provider = new Provider();
            private Dictionary <string,Node> tableNodes;
            public NetworkGraph()
            {
                tableNodes = new Dictionary<string, Node>();
                m_nodes = new NodeCollection();
                m_links = new LinkCollection();
     
                InitGraph();
     
                this.AddLinks(provider.Links);
            }
            private void InitGraph()
            {
                m_rootkey = "Root";
                m_rootPosition= new Point(100, 100);
                m_rootNode = new Node() {
                        Key = m_rootkey, 
                        Position = m_rootPosition,
                        IsVisible = true ,
                        AN  = new Annotation( )
                        {
                            Libelle = "Root",
                            IsVisible = true
                        }
                    };
     
                //prebuilt node
     
                tableNodes.Add(m_rootkey, m_rootNode);
                Nodes.Add( m_rootNode);
     
            }
            // Ajout des Links
            public void AddLinks(List<Link> listLinks)
            {
                foreach (var item in listLinks)
                {
                  this.AddLink(item);  
                }
            }
            private void AddLink(Link lnk)
            {
                 this.AddLink(lnk.FromNode, lnk.ToNode);
            }
     
     
            // methode de base
            private void AddLink(Node nd1, Node nd2)
            {
                if (!FoundNode(nd1) && !FoundNode(nd1))
                    return ;     // link non connecte
     
                if (FoundNode(nd1) && FoundNode(nd2)) 
                { 
                    //add link
                    nd1 = tableNodes[nd1.Key];
                    nd2 = tableNodes[nd2.Key];
     
                    Link lnk = new Link(nd1,  nd2, true);
                    this.Links.Add(lnk);
                }
                if (FoundNode(nd1) && !FoundNode(nd2))
               { 
                    //add  nd2
                    tableNodes.Add(nd2.Key, nd2);
                    Nodes.Add(nd2);
     
                    //add link
                    nd1 = tableNodes[nd1.Key];
                    Link lnk = new Link(nd1,  nd2, true);
                    this.Links.Add(lnk);
                }
     
                if (!FoundNode(nd1) && FoundNode(nd2))
     
                { 
                    //add  nd1
                    tableNodes.Add(nd1.Key, nd1);
                    Nodes.Add(nd1);
                    //new link
     
                    //exchange nd1 & nd2
                    nd2 =  tableNodes[nd2.Key];
                    Link lnk = new Link(nd2, nd1,  true);
                    this.Links.Add(lnk);
                }
     
            }
     
            private bool FoundNode(Node node)
            {
                if (tableNodes.ContainsKey(node.Key))
                    return true;
                else
                    return false;
            }
     
     
     
     
     
            private Point m_rootPosition;
            public Point  RootPosition 
            {
                get { return m_rootPosition;}
     
                set
                {
                    if (value != m_rootPosition)
                    { 
                        m_rootPosition = value;
                        OnPropertyChanged("RootPos");
                    }
                }
            }
            private string m_rootkey;
     
            public string RootKey
            {
                get { return m_rootkey; }
                set
                {
                    if (value != m_rootkey)
                    {
                        m_rootkey = value;
                        OnPropertyChanged("RootKey");
                    }
                }
            }  
            private Node m_rootNode;
     
            public Node RootNode
            {
                get { return m_rootNode; }
                set
                {
                    if (value != m_rootNode)
                    {
                        m_rootNode = value;
                        OnPropertyChanged("RootNode");
                    }
                }
            }  
     
            private NodeCollection m_nodes;
            public NodeCollection Nodes
            {
                get { return m_nodes ; }
                set
                { 
                    if(value !=m_nodes)
                    {
                        m_nodes = value;
                        OnPropertyChanged("Nodes");
                    }
                }
            }
            private LinkCollection m_links;
            public LinkCollection Links
            {
                 get { return m_links ; }
                set
                { 
                    if(value !=m_links)
                    {
                        m_links = value;
                        OnPropertyChanged("Links");
                    }
                }
            }
     
            private LinkCollection m_invalidlinks;
            public LinkCollection InvalidLinks
            {
                get { return m_invalidlinks ; }
                set 
                { 
                    if(value !=m_invalidlinks)
                    {
                        m_invalidlinks = value;
                        OnPropertyChanged("InvalidLinks");
                    }
                }
            }
     
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string n)
            {
                PropertyChangedEventHandler h = PropertyChanged;
                if (h != null)
                    h(this, new PropertyChangedEventArgs(n));
     
            } 
        }
    code xaml du UserControl :
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    <UserControl x:Class="WpfNetwork.ControlGraph"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:local="clr-namespace:WpfNetwork" 
                 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">
        <UserControl.Resources>
            <DataTemplate 
                x:Key="nodeTemplate"
                DataType="{x:Type local:Node}">
                <Canvas
                    x:Name="canvasNode"
                    Background="Transparent"
                    MouseLeftButtonDown="canvasNode_MouseLeftButtonDown"
                    MouseMove="canvasNode_MouseMove"
                    MouseRightButtonUp="canvasNode_MouseRightButtonUp">
                    <Path 
                        StrokeThickness="2" 
                        Stroke="LimeGreen" 
                        >
                        <Path.Data>
                            <EllipseGeometry
                                x:Name="EllipseNode"
                                Center="{Binding  Path=Position,Mode=TwoWay}" 
                                RadiusX="50" 
                                RadiusY="25"
                            />
                        </Path.Data>
                        <Path.Style>
                            <Style >
                                <Setter Property="Path.Fill" Value="Red"/>
                                <Setter Property="Path.Stroke" Value="DarkBlue"/>
                                <Style.Triggers>
                                    <Trigger  
                                        Property="Path.IsMouseOver" Value="True">
                                        <Setter 
                                            Property="Path.ToolTip"
                                            Value="{Binding Path=AN.Libelle}"/>
                                        <Setter
                                            Property="Path.Fill" Value="Yellow"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Path.Style>
                    </Path>
                    <Label 
                        FontSize="14" FontFamily="Times New Roman" 
                        FontWeight="Bold"
                        Foreground="Black" Background="Beige" 
                        BorderBrush="Brown" BorderThickness="2"
                        Content="{Binding Path=AN.Libelle}"
                        Canvas.Left="{Binding Path=Position.X}"
                        Canvas.Top="{Binding Path=Position.Y}">
                        <Label.Style>
                            <Style  >
                                <Setter Property="Label.Opacity"  Value="0.0"/>
                                <Style.Triggers>
                                    <Trigger  
                                        Property="Label.IsMouseOver" Value="true">
                                        <Setter
                                            Property="Label.Opacity"  Value="1.0"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Label.Style>
                    </Label>
                </Canvas>
     
            </DataTemplate>
            <DataTemplate 
                x:Key="linkTemplate"
                DataType="{x:Type local:Link}">
                <Canvas
                    x:Name="canvasLink"
                    Background="Transparent" >
                    <Path 
                          StrokeThickness="3.0" 
                        >
                        <Path.Data>
                            <LineGeometry
                                x:Name="lineLink" 
                                StartPoint="{Binding  Path=FromNode.Position,Mode=TwoWay}"
                                EndPoint="{Binding Path=ToNode.Position,Mode=TwoWay}"
                                >
                            </LineGeometry>
                        </Path.Data>
                        <Path.Style>
                            <Style >
                                <Setter Property="Path.Stroke" Value="RoyalBlue"/>
                                <Style.Triggers>
                                    <Trigger  
                                        Property="Path.IsMouseOver" Value="True">
                                        <Setter
                                            Property="Path.Stroke"  Value="LimeGreen"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Path.Style>
                    </Path>
                </Canvas>
     
            </DataTemplate>
            <ControlTemplate x:Key="graphTemplate">
                <Canvas 
                    IsItemsHost="True"
                    Background="Transparent">
                </Canvas>
            </ControlTemplate>
        </UserControl.Resources>
        <Grid>
            <Canvas
                Background="Transparent" >
                <!--links en arriere plan-->
                <ItemsControl 
                    ItemsSource="{Binding Path=Links}"
    			    ItemTemplate="{StaticResource linkTemplate}"
    			    Template="{StaticResource graphTemplate}" />
                <!--nodes en premier plan-->
                <ItemsControl 
     
                    ItemsSource="{Binding Path=Nodes}"
    			    ItemTemplate="{StaticResource nodeTemplate}"
    			    Template="{StaticResource graphTemplate}" />
     
            </Canvas>
     
        </Grid>
    </UserControl>

    et son code behind .cs (pour "dragger" les nodes et les fameux annotations qui "fretillent" comme voulu au survol souris:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
     
     
     public partial class ControlGraph : UserControl
        {
            public ControlGraph()
            {
                InitializeComponent();
            }
     
            private Point pt;
            private bool _isDown;
            private Path _selectedPath = null;
            private EllipseGeometry _selectedEllipse = null;
            private void canvasNode_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                FrameworkElement elem = e.OriginalSource as FrameworkElement;
                if (elem.GetType() == typeof(Path))
                {
                    _selectedPath = elem as Path;
                    pt = e.GetPosition(cnv);
                    Geometry geom  = _selectedPath.Data as Geometry;
                    if( geom.GetType() == typeof(EllipseGeometry) )
                    {  
                        _selectedEllipse = _selectedPath.Data as EllipseGeometry;
                        if( _selectedEllipse.Bounds.Contains(pt))
                        {
                            _isDown = true;
                        }
                    }
                }
     
            }
     
            private void canvasNode_MouseMove(object sender, MouseEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                if (_isDown)
                {
                    _selectedEllipse.Center = e.GetPosition(cnv);
                }
            }
     
           private void canvasNode_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                pt = e.GetPosition(cnv);
                if (_isDown)
                {
                    _selectedEllipse.Center = pt;
                    _isDown = false;
                    _selectedEllipse = null;
                    _selectedPath = null;
                    pt = new Point();
                }
     
            }
     
     
     
     
     
     
        }
    et le Form User :
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <Window x:Class="WpfNetwork.TestControlGraph"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:local="clr-namespace:WpfNetwork" 
            Title="TestControlGraph" Height="300" Width="300">
        <Window.Resources>
            <local:NetworkGraph x:Key="net" 
                         />
        </Window.Resources>
        <Grid>
     
            <local:ControlGraph 
                DataContext="{StaticResource net}"/>
     
        </Grid>
    </Window>
    voir le post suivant pour le 2eme exemple ...

  8. #28
    Membre expert
    Inscrit en
    avril 2008
    Messages
    2 075
    Détails du profil
    Informations personnelles :
    Âge : 59

    Informations forums :
    Inscription : avril 2008
    Messages : 2 075
    Points : 3 592
    Points
    3 592

    Par défaut

    rebonjour

    Suite du post précédent :
    2/ le 2eme utilise les mêmes 3 Class héritant de DependencyObject(nul besoin d’implémenter INotifyPropertyChanged ,car DependencyObject suffit)...
    Le prop GeometryForm a été viré la aussi
    -idem pour NetworkGraph & Provider

    Cote UI :
    - un simpliste UserControl denommé ControlNetwork et un Form

    code behind .cs du 1er exemple(Node,Link et Annotaion):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
     
    public class Node:DependencyObject
        {
            public Node()
            {}
            public Node(string pkey, Point pposition, Annotation pannotation, bool pisvisible)
            {
                Key = pkey;
                Position = pposition;
                AN = pannotation;
                IsVisible = pisvisible;
            }
     
     
            public string Key
            {
                get { return (string)GetValue(KeyProperty); }
                set { SetValue(KeyProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for Key.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty KeyProperty =
                DependencyProperty.Register("Key",
                typeof(string), 
                typeof(Node), 
                new UIPropertyMetadata(null));
     
     
     
            public Point Position
            {
                get { return (Point)GetValue(PositionProperty); }
                set { SetValue(PositionProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for Position.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty PositionProperty =
                DependencyProperty.Register("Position",
                typeof(Point),
                typeof(Node),
                new UIPropertyMetadata(new Point()));
     
     
     
     
            public Annotation AN
            {
                get { return (Annotation)GetValue(ANProperty); }
                set { SetValue(ANProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for AN.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty ANProperty =
                DependencyProperty.Register("AN",
                typeof(Annotation),
                 typeof(Node),
                new UIPropertyMetadata(null));
     
     
     
     
            public bool IsVisible
            {
                get { return (bool)GetValue(IsVisibleProperty); }
                set { SetValue(IsVisibleProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for IsVisible.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty IsVisibleProperty =
                DependencyProperty.Register("IsVisible",
                typeof(bool), 
                typeof(Node ), 
                new UIPropertyMetadata(true));
        }
        public class NodeCollection : ObservableCollection<Node>
        {
            public NodeCollection()
            {
     
            }
        }
     
    public class Link:DependencyObject 
        {
            public Link()
            { }
     
            public Link(
                     Node pfromnode, Node ptonode,
                     bool pisvisible)
                : this()
            {
                FromNode = pfromnode;
                ToNode = ptonode;
                IsVisible = pisvisible;
     
            }
            public Link(Annotation pannotion,
                    Node pfromnode, Node ptonode,
                    bool pisvisible)
                : this(pfromnode, ptonode, pisvisible)
            {
                AN = pannotion;
                FromNode = pfromnode;
                ToNode = ptonode;
                IsVisible = pisvisible;
     
            }
     
     
     
            public Node  FromNode
            {
                get { return (Node )GetValue(FromNodeProperty); }
                set { SetValue(FromNodeProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for FromNode.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty FromNodeProperty =
                DependencyProperty.Register("FromNode", 
                typeof(Node ), 
                typeof(Link ), 
                new UIPropertyMetadata(null));
     
     
     
     
            public Node ToNode
            {
                get { return (Node)GetValue(ToNodeProperty); }
                set { SetValue(ToNodeProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for ToNode.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty ToNodeProperty =
                DependencyProperty.Register("ToNode",
                typeof(Node),
                typeof(Link ), 
                new UIPropertyMetadata(null));
     
     
     
            public Point Position
            {
                get { return (Point)GetValue(PositionProperty); }
                set { SetValue(PositionProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for Position.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty PositionProperty =
                DependencyProperty.Register("Position", 
                typeof(Point), 
                typeof(Link), 
                new UIPropertyMetadata(new Point()));
     
     
     
            public Annotation  AN
            {
                get { return (Annotation )GetValue(ANProperty); }
                set { SetValue(ANProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for AN.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty ANProperty =
                DependencyProperty.Register("AN", 
                typeof(Annotation ),
                typeof(Link ), 
                new UIPropertyMetadata(null));
     
     
     
            public bool  IsVisible
            {
                get { return (bool )GetValue(IsVisibleProperty); }
                set { SetValue(IsVisibleProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for IsVisible.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty IsVisibleProperty =
                DependencyProperty.Register("IsVisible",
                typeof(bool ), 
                typeof(Link ), 
                new UIPropertyMetadata(true));
     
        }
     
        public class LinkCollection : ObservableCollection<Link>
        {
            public LinkCollection()
            {
     
            }
        }
    public class Annotation:DependencyObject 
        {
     
            public Annotation()
            { }
            public Annotation(string plibelle, bool pisvisible)
                : this()
            {
                Libelle = plibelle;
                IsVisible = pisvisible;
            }
            public Annotation(string plibelle, Point pposition, bool pisvisible)
                : this(plibelle, pisvisible)
            {
                Libelle = plibelle;
                Position = pposition;
                IsVisible = pisvisible;
            }
            public string Libelle
            {
                get { return (string)GetValue(LibelleProperty); }
                set { SetValue(LibelleProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for Libelle.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty LibelleProperty =
                DependencyProperty.Register("Libelle", typeof(string),
                typeof(Annotation),
                new UIPropertyMetadata("node"));
     
     
            public Point Position
            {
                get { return (Point)GetValue(PositionProperty); }
                set { SetValue(PositionProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for Position.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty PositionProperty =
                DependencyProperty.Register("Position",
                typeof(Point),
                typeof(Annotation),
                new UIPropertyMetadata(new Point()));
     
     
            public bool IsVisible
            {
                get { return (bool)GetValue(IsVisibleProperty); }
                set { SetValue(IsVisibleProperty, value); }
            }
     
            // Using a DependencyProperty as the backing store for IsVisible.  This enables animation, styling, binding, etc...
            public static readonly DependencyProperty IsVisibleProperty =
                DependencyProperty.Register("IsVisible", 
                typeof(bool),
                typeof(Annotation), 
                new UIPropertyMetadata(true));
     
     
     
        }
        public class AnnotationCollection : ObservableCollection<Annotation>
        {
            public AnnotationCollection()
            {
     
            }
        }
    suite code behind .cs du 2 ieme exemple(NetworkGraph et Provider):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
     
     public class NetworkGraph : INotifyPropertyChanged
        {
            private Provider provider = new Provider();
            private Dictionary<string, Node> tableNodes;
            public NetworkGraph()
            {
                tableNodes = new Dictionary<string, Node>();
                m_nodes = new NodeCollection();
                m_links = new LinkCollection();
     
                InitGraph();
     
                this.AddLinks(provider.Links);
            }
     
            private void InitGraph()
            {
                m_rootkey = "Root";
                m_rootPosition = new Point(100, 100);
                m_rootNode = new Node()
                {
                    Key = m_rootkey,
                    Position = m_rootPosition,
                    IsVisible = true,
                    AN = new Annotation()
                    {
                        Libelle = "Root",
                        IsVisible = true
                    }
                };
     
                //prebuilt node
     
                tableNodes.Add(m_rootkey, m_rootNode);
                Nodes.Add(m_rootNode);
     
            }
            // Ajout des Links
            public void AddLinks(List<Link> listLinks)
            {
                foreach (var item in listLinks)
                {
                    this.AddLink(item);
                }
            }
            private void AddLink(Link lnk)
            {
                this.AddLink(lnk.FromNode, lnk.ToNode);
            }
            // methode de base
            private void AddLink(Node nd1, Node nd2)
            {
                if (!FoundNode(nd1) && !FoundNode(nd1))
                    return;     // link non connecte
     
                if (FoundNode(nd1) && FoundNode(nd2))
                {
                    //add link
                    nd1 = tableNodes[nd1.Key];
                    nd2 = tableNodes[nd2.Key];
     
                    Link lnk = new Link(nd1, nd2, true);
                    this.Links.Add(lnk);
                }
                if (FoundNode(nd1) && !FoundNode(nd2))
                {
                    //add  nd2
                    tableNodes.Add(nd2.Key, nd2);
                    Nodes.Add(nd2);
     
                    //add link
                    nd1 = tableNodes[nd1.Key];
                    Link lnk = new Link(nd1, nd2, true);
                    this.Links.Add(lnk);
                }
     
                if (!FoundNode(nd1) && FoundNode(nd2))
                {
                    //add  nd1
                    tableNodes.Add(nd1.Key, nd1);
                    Nodes.Add(nd1);
                    //new link
     
                    //exchange nd1 & nd2
                    nd2 = tableNodes[nd2.Key];
                    Link lnk = new Link(nd2, nd1, true);
                    this.Links.Add(lnk);
                }
     
            }
     
            private bool FoundNode(Node node)
            {
                if (tableNodes.ContainsKey(node.Key))
                    return true;
                else
                    return false;
            }
            private Point m_rootPosition;
            public Point RootPosition
            {
                get { return m_rootPosition; }
     
                set
                {
                    if (value != m_rootPosition)
                    {
                        m_rootPosition = value;
                        OnPropertyChanged("RootPos");
                    }
                }
            }
            private string m_rootkey;
     
            public string RootKey
            {
                get { return m_rootkey; }
                set
                {
                    if (value != m_rootkey)
                    {
                        m_rootkey = value;
                        OnPropertyChanged("RootKey");
                    }
                }
            }
            private Node m_rootNode;
     
            public Node RootNode
            {
                get { return m_rootNode; }
                set
                {
                    if (value != m_rootNode)
                    {
                        m_rootNode = value;
                        OnPropertyChanged("RootNode");
                    }
                }
            }
            private NodeCollection m_nodes;
            public NodeCollection Nodes
            {
                get { return m_nodes; }
                set
                {
                    if (value != m_nodes)
                    {
                        m_nodes = value;
                        OnPropertyChanged("Nodes");
                    }
                }
            }
            private LinkCollection m_links;
            public LinkCollection Links
            {
                get { return m_links; }
                set
                {
                    if (value != m_links)
                    {
                        m_links = value;
                        OnPropertyChanged("Links");
                    }
                }
            }
     
            private LinkCollection m_invalidlinks;
            public LinkCollection InvalidLinks
            {
                get { return m_invalidlinks; }
                set
                {
                    if (value != m_invalidlinks)
                    {
                        m_invalidlinks = value;
                        OnPropertyChanged("InvalidLinks");
                    }
                }
            }
            public event PropertyChangedEventHandler PropertyChanged;
            private void OnPropertyChanged(string n)
            {
                PropertyChangedEventHandler h = PropertyChanged;
                if (h != null)
                    h(this, new PropertyChangedEventArgs(n));
     
            }
        }
     
     public class Provider
        {
            private Random rndPos = new Random ();
            private  List<RouteCity> tableRoute;
     
            public Provider()
            {
                Links = new List<Link>();
                tableRoute = GetRoute();
     
                foreach( RouteCity route in tableRoute)
                {
                    Point  pt1 = new Point( rndPos.Next(50, 600), rndPos.Next(50, 600));
                    Annotation an1 = new Annotation(route.CityName1, pt1,true );
                    Node nd1 = new Node(route.CityName1, pt1, an1, true);
     
                    Point pt2 = new Point( rndPos.Next(50, 600), rndPos.Next(50, 600));
                    Annotation an2 = new Annotation(route.CityName2, pt2,true );
                    Node nd2 = new Node(route.CityName2, pt2, an2, true);
     
     
                    Link thelink = new Link(nd1, nd2, true);
                    this.Links.Add(thelink);
                 };
                }
                public List<Link> Links { get; set; }
     
                private List <RouteCity> GetRoute() 
                {
                    List<RouteCity> routes = new List<RouteCity> 
                    {
                        new RouteCity(1,"Root", "Contantine"),
                        new RouteCity(2,"Contantine", "Annaba"),
                        new RouteCity(3,"Contantine", "Batna"),
                        new RouteCity(4,"Contantine", "Setif"),
                        new RouteCity(5,"Setif", "Batna"),
                        new RouteCity(6,"Setif", "Msila"),
                        new RouteCity(7,"Setif", "BBA"),
                        new RouteCity(8,"Contantine", "Tebessa"),
                        new RouteCity(9,"Guelma", "SoukAhras")
                    };
     
                return routes;
            }
        }
        public class RouteCity
        {
            public RouteCity ()
    	    {}
            public RouteCity(int  pid,string  pcity1 ,string pcity2)
            {
                ID = pid; 
                CityName1 = pcity1;
                CityName2 = pcity2;
            }
     
            public int ID { get; set; }
            public string CityName1 { get; set; }
            public string CityName2 {get ;set;}
        }
    code xaml du UserControl :
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
     
    <UserControl x:Class="WpfNetworkVersusCollections.ControlNetwork"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:local="clr-namespace:WpfNetworkVersusCollections"
                 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"
                >
        <UserControl.Resources>
            <local:NetworkGraph x:Key="net"/>
            <DataTemplate DataType="{x:Type local:Node}" >
                <Canvas 
            x:Name="canvas_Node"  
            Background="Transparent"
            MouseLeftButtonDown="canvas_Node_MouseLeftButtonDown"
            MouseMove="canvas_Node_MouseMove"
            MouseRightButtonUp="canvas_Node_MouseRightButtonUp">
                    <Path 
            StrokeThickness="2" 
            Stroke="LimeGreen" 
            >
                    <Path.Data>
                        <EllipseGeometry
            x:Name="EllipseNode"
            Center="{Binding  Path=Position,Mode=TwoWay}" 
            RadiusX="50" 
            RadiusY="25"
                        />
                    </Path.Data>
                        <Path.Style>
                            <Style >
                                <Setter Property="Path.Fill" Value="Red"/>
                                <Setter Property="Path.Stroke" Value="DarkBlue"/>
                                <Style.Triggers>
                                    <Trigger  
                                        Property="Path.IsMouseOver" Value="True">
                                        <Setter 
                                            Property="Path.ToolTip"
                                            Value="{Binding Path=AN.Libelle}"/>
                                        <Setter
                                            Property="Path.Fill" Value="Yellow"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Path.Style>
                    </Path>
     
                    <Label 
            x:Name="label_Node"
            FontSize="14" FontFamily="Times New Roman"
            FontWeight="Bold"
            Foreground="Black" Background="Beige" 
            BorderBrush="Brown" BorderThickness="2"
            Content="{Binding Path=AN.Libelle}"
            Canvas.Left="{Binding Path=Position.X}"
            Canvas.Top="{Binding Path=Position.Y}">
                        <Label.Style>
                            <Style >
                                <Setter Property="Label.Opacity" Value="0.0"/>
                                <Style.Triggers>
                                    <Trigger Property="Label.IsMouseOver" Value="true">
                                    <Setter  Property="Label.Opacity" Value="1.0"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Label.Style>
                    </Label>
                </Canvas>
            </DataTemplate>
     
     
            <DataTemplate DataType="{x:Type local:Link}">
                <Canvas 
            x:Name="canvas_Link"
            Background="Transparent"
            >
                    <Path 
            StrokeThickness="3.0" 
            >
                    <Path.Data>
                        <LineGeometry
            x:Name="lineLink" 
            StartPoint="{Binding  Path=FromNode.Position,Mode=TwoWay}"
            EndPoint="{Binding Path=ToNode.Position,Mode=TwoWay}"
            >
                        </LineGeometry>
                    </Path.Data>
                        <Path.Style>
                            <Style >
                                <Setter Property="Path.Stroke" Value="RoyalBlue"/>
                                <Style.Triggers>
                                    <Trigger  
                                        Property="Path.IsMouseOver" Value="True">
                                        <Setter
                                            Property="Path.Stroke"  Value="LimeGreen"/>
                                    </Trigger>
                                </Style.Triggers>
                            </Style>
                        </Path.Style>
                    </Path>
                </Canvas>
            </DataTemplate>
            <ControlTemplate x:Key="graphTemplate">
                <Canvas 
                    IsItemsHost="True"
                    IsHitTestVisible="True" >
     
     
                </Canvas>
            </ControlTemplate>
        </UserControl.Resources> 
        <Grid>
            <ListBox 
                Name="listbox" 
                Template="{StaticResource graphTemplate}">
                <ListBox.ItemsSource>
                    <CompositeCollection >
                        <CollectionContainer  Collection="{Binding Source={StaticResource net},Path=Links}"  />
                        <CollectionContainer Collection="{Binding Source={StaticResource net},   Path=Nodes}"/>
                    </CompositeCollection>
                </ListBox.ItemsSource>
                <ListBox.ItemTemplate>
                    <DataTemplate>
                        <ListBoxItem Content="{Binding .}"/>
                    </DataTemplate>
                </ListBox.ItemTemplate>
            </ListBox>
     
        </Grid>
    </UserControl>

    et son "boiler-plate" code behind .cs (pour "dragger" les nodes et les fameux annotations qui "fretillent" comme voulu au survol souris:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
     
     
    public partial class ControlNetwork : UserControl
        {
            public ControlNetwork()
            {
                InitializeComponent();
            }
     
            private Point pt;
            private bool _isDown;
            private Path _selectedPath = null;
            private EllipseGeometry _selectedEllipse = null;
            private void canvas_Node_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                FrameworkElement elem = e.OriginalSource as FrameworkElement;
                if (elem.GetType() == typeof(Path))
                {
                    _selectedPath = elem as Path;
                    pt = e.GetPosition(cnv);
                    Geometry geom = _selectedPath.Data as Geometry;
                    if (geom.GetType() == typeof(EllipseGeometry))
                    {
                        _selectedEllipse = _selectedPath.Data as EllipseGeometry;
                        if (_selectedEllipse.Bounds.Contains(pt))
                        {
                            _isDown = true;
                        }
                    }
                }
     
            }
     
            private void canvas_Node_MouseMove(object sender, MouseEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                if (_isDown)
                {
                    _selectedEllipse.Center = e.GetPosition(cnv);
                }
            }
     
            private void canvas_Node_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
            {
                Canvas cnv = sender as Canvas;
                pt = e.GetPosition(cnv);
                if (_isDown)
                {
                    _selectedEllipse.Center = pt;
                    _isDown = false;
                    _selectedEllipse = null;
                    _selectedPath = null;
                    pt = new Point();
                }
            }
        }
    code xaml du Form User:
    Code XAML : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    <Window x:Class="WpfNetworkVersusCollections.TestControlNetwork"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:local="clr-namespace:WpfNetworkVersusCollections" 
            Title="TestControlNetwork" Height="350" Width="525"
            >
        <Grid >
            <local:ControlNetwork >
            </local:ControlNetwork>
        </Grid>
    </Window>


    La différence importante entre les 2 exemples est que le DataContext doit être fourni dans le UserControl dans le 2 ieme exemple ,ce qui est gênant et cela à cause de l'utilisation de la "composite collection" ...
    Alors que le 1er exemple utilise 2 itemscontrol superposés("layered ou en couche) dans le Grid...

    Nota-Bene-1: c'est la prop DP Opacity qui est utilisée sur IsMouseOVer du Label charge d'afficher le Lbellé de l'Annotation



    Nota-Bene-2 : le graph est construit de telle sorte que les arcs isolés(composante connexe isolée)du Network sont ignorés ( cas de l' arc "Guelma", "SoukAhras")...
    bon code...

Discussions similaires

  1. Binding sur une propriété
    Par Villard.patrick dans le forum Silverlight
    Réponses: 5
    Dernier message: 09/12/2009, 18h52
  2. binding sur une propriété shared (vb) static (c#) ?
    Par Pol63 dans le forum Windows Presentation Foundation
    Réponses: 3
    Dernier message: 24/06/2009, 16h44
  3. Création tag avec test sur une proprièté d'un bean
    Par Didine981 dans le forum Struts 1
    Réponses: 1
    Dernier message: 04/06/2009, 23h08
  4. Binding sur une propriété avec paramètre
    Par FRED.G dans le forum Windows Presentation Foundation
    Réponses: 1
    Dernier message: 17/11/2008, 19h38
  5. [Databinding] bind sur une propriété d'une collection
    Par herveb dans le forum Général Dotnet
    Réponses: 2
    Dernier message: 11/12/2007, 11h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo