← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/DisplayBindings/ClassDiagram/ClassCanvas/Src/ClassCanvasItem.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/DisplayBindings/ClassDiagram/ClassCanvas/Src/ClassCanvasItem.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
 
 
7
using System.Drawing;
 
8
using System.Drawing.Drawing2D;
 
9
 
 
10
using System.Xml;
 
11
using System.Xml.XPath;
 
12
 
 
13
using ICSharpCode.SharpDevelop;
 
14
using ICSharpCode.SharpDevelop.Dom;
 
15
using ICSharpCode.SharpDevelop.Project;
 
16
 
 
17
using System.Globalization;
 
18
 
 
19
using Tools.Diagrams;
 
20
using Tools.Diagrams.Drawables;
 
21
 
 
22
namespace ClassDiagram
 
23
{
 
24
        public class ClassCanvasItem : CanvasItem, IDisposable
 
25
        {
 
26
                IClass classtype;
 
27
                string typeclass;
 
28
                InteractiveHeaderedItem classItemHeaderedContent;
 
29
                DrawableItemsStack classItemContainer = new DrawableItemsStack();
 
30
 
 
31
                #region Graphics related variables
 
32
                
 
33
                [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
 
34
                public static readonly Font TitleFont = new Font (FontFamily.GenericSansSerif, 11, FontStyle.Bold, GraphicsUnit.Pixel);
 
35
                [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
 
36
                public static readonly Font SubtextFont = new Font (FontFamily.GenericSansSerif, 11, FontStyle.Regular, GraphicsUnit.Pixel);
 
37
                [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
 
38
                public static readonly Font GroupTitleFont = new Font (FontFamily.GenericSansSerif, 11, FontStyle.Regular, GraphicsUnit.Pixel);
 
39
 
 
40
                LinearGradientBrush grad;
 
41
                GraphicsPath shadowpath;
 
42
                DrawableRectangle containingShape;
 
43
                
 
44
                #endregion
 
45
 
 
46
                CollapseExpandShape collapseExpandShape = new CollapseExpandShape();
 
47
 
 
48
                DrawableItemsStack titles = new DrawableItemsStack();
 
49
 
 
50
                DrawableItemsStack titlesCollapsed = new DrawableItemsStack();
 
51
                DrawableItemsStack titlesExpanded = new DrawableItemsStack();
 
52
                
 
53
                DrawableItemsStack<InteractiveHeaderedItem> groups = new DrawableItemsStack<InteractiveHeaderedItem>();
 
54
                Dictionary<InteractiveHeaderedItem, string> groupNames = new Dictionary<InteractiveHeaderedItem, string>(); // TODO - this is really an ugly patch
 
55
                Dictionary<string, InteractiveHeaderedItem> groupsByName = new Dictionary<string, InteractiveHeaderedItem>(); // TODO - this is really an ugly patch
 
56
                
 
57
                DrawableItemsStack<TextSegment> interfaces = new DrawableItemsStack<TextSegment>();
 
58
                
 
59
                DrawableRectangle titlesBackgroundCollapsed;
 
60
                DrawableRectangle titlesBackgroundExpanded;
 
61
                
 
62
                protected override bool AllowHeightModifications()
 
63
                {
 
64
                        return false;
 
65
                }
 
66
                
 
67
                public override float Width
 
68
                {
 
69
                        set
 
70
                        {
 
71
                                base.Width = Math.Max (value, 100.0f);
 
72
                                PrepareFrame();
 
73
                        }
 
74
                }
 
75
                
 
76
                public override float GetAbsoluteContentWidth()
 
77
                {
 
78
                        return classItemHeaderedContent.GetAbsoluteContentWidth();
 
79
                }
 
80
                
 
81
                public override float GetAbsoluteContentHeight()
 
82
                {
 
83
                        return classItemHeaderedContent.GetAbsoluteContentHeight();
 
84
                }
 
85
                
 
86
                public IClass RepresentedClassType
 
87
                {
 
88
                        get { return classtype; }
 
89
                }
 
90
 
 
91
                #region Constructors
 
92
                
 
93
                public ClassCanvasItem (IClass ct)
 
94
                {
 
95
                        classtype = ct;
 
96
        
 
97
                        grad = new LinearGradientBrush(
 
98
                                new PointF(0, 0), new PointF(1, 0),
 
99
                                TitleBackground, Color.White);
 
100
                                        
 
101
                        classItemHeaderedContent = new InteractiveHeaderedItem(titlesCollapsed, titlesExpanded, InitContentContainer(InitContent()));
 
102
 
 
103
                        classItemContainer.Container = this;
 
104
                        classItemContainer.Add(classItemHeaderedContent);
 
105
                        Pen outlinePen = GetClassOutlinePen();
 
106
                        if (RoundedCorners)
 
107
                        {
 
108
                                int radius = CornerRadius;
 
109
                                containingShape = new DrawableRectangle(null, outlinePen, radius, radius, radius, radius);
 
110
                        }
 
111
                        else
 
112
                                containingShape = new DrawableRectangle(null, outlinePen, 0, 0, 0, 0);
 
113
                        
 
114
                        classItemContainer.Add(containingShape);
 
115
                        classItemContainer.OrientationAxis = Axis.Z;
 
116
                        
 
117
                        if (RoundedCorners)
 
118
                        {
 
119
                                int radius = CornerRadius;
 
120
                                titlesBackgroundCollapsed = new DrawableRectangle(grad, null, radius, radius, radius, radius);
 
121
                                titlesBackgroundExpanded = new DrawableRectangle(grad, null, radius, radius, 0, 0);
 
122
                        }
 
123
                        else
 
124
                        {
 
125
                                titlesBackgroundCollapsed = new DrawableRectangle(grad, null, 0, 0, 0, 0);
 
126
                                titlesBackgroundExpanded = new DrawableRectangle(grad, null, 0, 0, 0, 0);
 
127
                        }
 
128
 
 
129
                        titles.Border = 5;
 
130
                        
 
131
                        titlesCollapsed.Add(titlesBackgroundCollapsed);
 
132
                        titlesCollapsed.Add(titles);
 
133
                        titlesCollapsed.OrientationAxis = Axis.Z;
 
134
                        
 
135
                        titlesExpanded.Add(titlesBackgroundExpanded);
 
136
                        titlesExpanded.Add(titles);
 
137
                        titlesExpanded.OrientationAxis = Axis.Z;
 
138
                        
 
139
                        if (classtype != null)
 
140
                        {
 
141
                                typeclass = classtype.Modifiers.ToString();
 
142
                                typeclass += " " + classtype.ClassType.ToString();
 
143
                        }
 
144
                }
 
145
                
 
146
                #endregion
 
147
                
 
148
                private Pen GetClassOutlinePen()
 
149
                {
 
150
                        Pen pen = new Pen(Color.Gray);
 
151
                        
 
152
                        if (classtype.IsAbstract)
 
153
                        {
 
154
                                pen.DashStyle = DashStyle.Dash;
 
155
                        }
 
156
                        
 
157
                        if (classtype.IsSealed)
 
158
                        {
 
159
                                pen.Width = 3;
 
160
                        }
 
161
                        
 
162
                        if (classtype.IsStatic)
 
163
                        {
 
164
                                pen.DashStyle = DashStyle.Dash;
 
165
                                pen.Width = 3;
 
166
                        }
 
167
                        
 
168
                        return pen;
 
169
                }
 
170
                
 
171
                public override bool IsVResizable
 
172
                {
 
173
                        get { return false; }
 
174
                }
 
175
 
 
176
                protected virtual DrawableRectangle InitContentBackground()
 
177
                {
 
178
                        if (RoundedCorners)
 
179
                        {
 
180
                                int radius = CornerRadius;
 
181
                                return new DrawableRectangle(ContentBG, null, 0, 0, radius, radius);
 
182
                        }
 
183
                        else
 
184
                                return new DrawableRectangle(ContentBG, null, 0, 0, 0, 0);
 
185
                }
 
186
                
 
187
                protected virtual DrawableItemsStack InitContentContainer(params IDrawableRectangle[] items)
 
188
                {
 
189
                        DrawableItemsStack content = new DrawableItemsStack();
 
190
                        content.OrientationAxis = Axis.Z;
 
191
                        
 
192
                        content.Add(InitContentBackground());
 
193
                        
 
194
                        foreach (IDrawableRectangle item in items)
 
195
                                content.Add(item);
 
196
                        
 
197
                        return content;
 
198
                }
 
199
                
 
200
                protected virtual IDrawableRectangle InitContent ()
 
201
                {
 
202
                        groups.MinWidth = 80;
 
203
                        groups.Spacing = 5;
 
204
                        groups.Border = 5;
 
205
                        
 
206
                        return groups;
 
207
                }
 
208
                
 
209
                public void Initialize ()
 
210
                {
 
211
                        PrepareMembersContent();
 
212
                        PrepareTitles();
 
213
                        Width = GetAbsoluteContentWidth();
 
214
                }
 
215
                
 
216
                #region Graphics related members
 
217
                
 
218
                static Color titlesBG = Color.FromArgb(255,217, 225, 241);
 
219
                protected virtual Color TitleBackground
 
220
                {
 
221
                        get { return titlesBG; }
 
222
                }
 
223
 
 
224
                protected virtual LinearGradientBrush TitleBG
 
225
                {
 
226
                        get { return grad; }
 
227
                }
 
228
                
 
229
                static Brush innerTitlesBG = new SolidBrush(Color.FromArgb(255, 240, 242, 249));
 
230
                protected virtual Brush InnerTitlesBackground
 
231
                {
 
232
                        get { return innerTitlesBG; }
 
233
                }
 
234
 
 
235
                static Brush contentBG = new SolidBrush(Color.FromArgb(255, 255, 255, 255));
 
236
                protected virtual Brush ContentBG
 
237
                {
 
238
                        get { return contentBG; }
 
239
                }
 
240
                
 
241
                protected virtual bool RoundedCorners
 
242
                {
 
243
                        get { return true; }
 
244
                }
 
245
                
 
246
                protected virtual int CornerRadius
 
247
                {
 
248
                        get { return 15; }
 
249
                }
 
250
                #endregion
 
251
                
 
252
                #region Preparations
 
253
                
 
254
                protected IAmbience GetAmbience()
 
255
                {
 
256
                        IAmbience ambience = AmbienceService.GetCurrentAmbience();
 
257
                        ambience.ConversionFlags = ConversionFlags.None;
 
258
                        return ambience;
 
259
                }
 
260
                
 
261
                protected virtual void PrepareTitles ()
 
262
                {
 
263
                        if (classtype == null) return;
 
264
                        
 
265
                        IAmbience ambience = GetAmbience();
 
266
                        
 
267
                        DrawableItemsStack title = new DrawableItemsStack();
 
268
                        title.OrientationAxis = Axis.X;
 
269
                        
 
270
                        TextSegment titleString = new TextSegment(base.Graphics, classtype.Name, TitleFont, true);
 
271
                        title.Add(titleString);
 
272
                        title.Add(collapseExpandShape);
 
273
                        
 
274
                        collapseExpandShape.Collapsed = Collapsed;
 
275
                        
 
276
                        titles.OrientationAxis = Axis.Y;
 
277
                        
 
278
                        titles.Add(title);
 
279
                        
 
280
                        titles.Add(new TextSegment(base.Graphics, typeclass, SubtextFont, true));
 
281
 
 
282
                        if (classtype.BaseClass != null)
 
283
                        {
 
284
                                DrawableItemsStack inherits = new DrawableItemsStack();
 
285
                                inherits.OrientationAxis = Axis.X;
 
286
                                inherits.Add(new InheritanceShape());
 
287
                                inherits.Add(new TextSegment(base.Graphics, classtype.BaseClass.Name, SubtextFont, true));
 
288
                                titles.Add(inherits);
 
289
                        }
 
290
                        
 
291
                        foreach (IReturnType rt in classtype.BaseTypes)
 
292
                        {
 
293
                                IClass ct = rt.GetUnderlyingClass();
 
294
                                if (ct != null && ct.ClassType == ClassType.Interface)
 
295
                                        interfaces.Add(new TextSegment(base.Graphics, ambience.Convert(rt), SubtextFont, true));
 
296
                        }
 
297
                }
 
298
                
 
299
                protected class MemberData : IComparable<MemberData>
 
300
                {
 
301
                        public MemberData (IMember member, IAmbience ambience, Graphics graphics, Font font)
 
302
                        {
 
303
                                IMethod methodMember = member as IMethod;
 
304
                                IEvent eventMember = member as IEvent;
 
305
                                IProperty propertyMember = member as IProperty;
 
306
                                IField fieldMember = member as IField;
 
307
                                
 
308
                                DrawableItemsStack<VectorShape> image = new DrawableItemsStack<VectorShape>();
 
309
                                image.OrientationAxis = Axis.Z; // stack image components one on top of the other
 
310
                                image.KeepAspectRatio = true;
 
311
                                
 
312
                                if (methodMember != null)
 
313
                                {
 
314
                                        memberString = ambience.Convert(methodMember) + " : " + ambience.Convert(member.ReturnType);
 
315
                                        image.Add(new MethodShape());
 
316
                                }
 
317
                                else if (eventMember != null)
 
318
                                {
 
319
                                        memberString = ambience.Convert(eventMember) + " : " + ambience.Convert(member.ReturnType);
 
320
                                        image.Add(new EventShape());
 
321
                                }
 
322
                                else if (fieldMember != null)
 
323
                                {
 
324
                                        memberString = ambience.Convert(fieldMember) + " : " + ambience.Convert(member.ReturnType);
 
325
                                        image.Add(new FieldShape());
 
326
                                }
 
327
                                else if (propertyMember != null)
 
328
                                {
 
329
                                        memberString = ambience.Convert(propertyMember) + " : " + ambience.Convert(member.ReturnType);
 
330
                                        image.Add(new PropertyShape());
 
331
                                }
 
332
                                
 
333
                                memberItem.OrientationAxis = Axis.X;
 
334
                                memberItem.Add(image);
 
335
                                memberItem.Add(new TextSegment(graphics, memberString, font, true));
 
336
                        
 
337
                                image.Border = 1;
 
338
                        }
 
339
                        
 
340
                        InteractiveItemsStack memberItem = new InteractiveItemsStack(false);
 
341
                        
 
342
                        string memberString;
 
343
                        
 
344
                        public string MemberString
 
345
                        {
 
346
                                get { return memberString; }
 
347
                        }
 
348
                        
 
349
                        public int CompareTo(MemberData other)
 
350
                        {
 
351
                                return memberString.CompareTo(other.MemberString);
 
352
                        }
 
353
                        
 
354
                        public InteractiveItemsStack Item
 
355
                        {
 
356
                                get { return memberItem; }
 
357
                        }
 
358
                }
 
359
                
 
360
                protected InteractiveHeaderedItem PrepareGroup (string title, IDrawableRectangle content)
 
361
                {
 
362
                        #region Prepare Group Container
 
363
                        DrawableItemsStack headerPlus = new DrawableItemsStack();
 
364
                        DrawableItemsStack headerMinus = new DrawableItemsStack();
 
365
                        
 
366
                        headerPlus.OrientationAxis = Axis.X;
 
367
                        headerMinus.OrientationAxis = Axis.X;
 
368
                        #endregion
 
369
                        
 
370
                        #region Create Header
 
371
                        TextSegment titleSegment = new TextSegment(Graphics, title, GroupTitleFont, true);
 
372
                        
 
373
                        PlusShape plus = new PlusShape();
 
374
                        plus.Border = 3;
 
375
                        headerPlus.Add(plus);
 
376
                        headerPlus.Add(titleSegment);
 
377
                        
 
378
                        MinusShape minus = new MinusShape();
 
379
                        minus.Border = 3;
 
380
                        headerMinus.Add(minus);
 
381
                        headerMinus.Add(titleSegment);
 
382
                        
 
383
                        DrawableItemsStack headerCollapsed = new DrawableItemsStack();
 
384
                        DrawableItemsStack headerExpanded = new DrawableItemsStack();
 
385
                        
 
386
                        headerCollapsed.OrientationAxis = Axis.Z;
 
387
                        headerExpanded.OrientationAxis = Axis.Z;
 
388
                        
 
389
                        headerCollapsed.Add (new DrawableRectangle(InnerTitlesBackground, null));
 
390
                        headerCollapsed.Add (headerPlus);
 
391
                        
 
392
                        headerExpanded.Add (new DrawableRectangle(InnerTitlesBackground, null));
 
393
                        headerExpanded.Add (headerMinus);
 
394
                        #endregion
 
395
                        
 
396
                        InteractiveHeaderedItem tg = new InteractiveHeaderedItem(headerCollapsed, headerExpanded, content);
 
397
                        tg.HeaderClicked += delegate { tg.Collapsed = !tg.Collapsed; };
 
398
                        IMouseInteractable interactive = content as IMouseInteractable;
 
399
                        if (interactive != null)
 
400
                                tg.ContentClicked += delegate (object sender, PointF pos) { interactive.HandleMouseClick(pos); };
 
401
                        tg.RedrawNeeded += HandleRedraw;
 
402
                        
 
403
                        return tg;
 
404
                }
 
405
                
 
406
                protected virtual InteractiveItemsStack PrepareMembersContent <MT> (ICollection<MT> members) where MT : IMember
 
407
                {
 
408
                        if (members == null) return null;
 
409
                        if (members.Count == 0) return null;
 
410
                        InteractiveItemsStack content = new InteractiveItemsStack();
 
411
                        content.OrientationAxis = Axis.Y;
 
412
                        PrepareMembersContent <MT> (members, content);
 
413
                        return content;
 
414
                }
 
415
                
 
416
                private InteractiveItemsStack PrepareNestedTypesContent()
 
417
                {
 
418
                        InteractiveItemsStack innerItems = new InteractiveItemsStack();
 
419
                        innerItems.OrientationAxis = Axis.Y;
 
420
                        innerItems.Spacing = 10;
 
421
                        innerItems.Padding = 10;
 
422
                        foreach (IClass ct in classtype.InnerClasses)
 
423
                        {
 
424
                                ClassCanvasItem innerItem = ClassCanvas.CreateItemFromType(ct);
 
425
                                innerItems.Add(innerItem);
 
426
                                innerItem.LayoutChanged += HandleRedraw;
 
427
                        }
 
428
                        return innerItems;
 
429
                }
 
430
                
 
431
                protected virtual void PrepareMembersContent <MT> (ICollection<MT> members, InteractiveItemsStack content) where MT : IMember
 
432
                {
 
433
                        if (members == null) return;
 
434
                        if (members.Count == 0) return;
 
435
                        
 
436
                        IAmbience ambience = GetAmbience();
 
437
                        
 
438
                        #region Prepare Group Members
 
439
                        List<MemberData> membersData = new List<MemberData>();
 
440
                        foreach (MT member in members)
 
441
                        {
 
442
                                membersData.Add(new MemberData(member, ambience, Graphics, MemberFont));
 
443
                        }
 
444
                        membersData.Sort();
 
445
                        #endregion
 
446
                        
 
447
                        #region Add Members To Group
 
448
                        foreach (MemberData memberData in membersData)
 
449
                        {
 
450
                                content.Add(memberData.Item);
 
451
                        }
 
452
                        #endregion
 
453
                }
 
454
                
 
455
                private void AddGroupToContent(string title, InteractiveItemsStack groupContent)
 
456
                {
 
457
                        if (groupContent != null)
 
458
                        {
 
459
                                InteractiveHeaderedItem tg = PrepareGroup (title, groupContent);
 
460
                                groupNames.Add(tg, title);
 
461
                                groupsByName.Add(title, tg);
 
462
                                groups.Add(tg);
 
463
                        }
 
464
                }
 
465
                
 
466
                protected virtual void PrepareMembersContent ()
 
467
                {
 
468
                        if (classtype == null) return;
 
469
                        
 
470
                        groups.Clear();
 
471
                        
 
472
                        InteractiveItemsStack propertiesContent = PrepareMembersContent <IProperty> (classtype.Properties);
 
473
                        InteractiveItemsStack methodsContent = PrepareMembersContent <IMethod> (classtype.Methods);
 
474
                        InteractiveItemsStack fieldsContent = PrepareMembersContent <IField> (classtype.Fields);
 
475
                        InteractiveItemsStack eventsContent = PrepareMembersContent <IEvent> (classtype.Events);
 
476
                        
 
477
                        AddGroupToContent("Properties", propertiesContent);
 
478
                        AddGroupToContent("Methods", methodsContent);
 
479
                        AddGroupToContent("Fields", fieldsContent);
 
480
                        AddGroupToContent("Events", eventsContent);
 
481
                        
 
482
                        if (classtype.InnerClasses.Count > 0)
 
483
                        {
 
484
                                InteractiveItemsStack nestedTypesContent = PrepareNestedTypesContent();
 
485
                                AddGroupToContent("Nested Types", nestedTypesContent);
 
486
                        }
 
487
                }
 
488
                
 
489
                protected virtual void PrepareFrame ()
 
490
                {
 
491
                        ActualHeight = classItemContainer.GetAbsoluteContentHeight();
 
492
                        
 
493
                        if (Container != null) return;
 
494
                        
 
495
                        shadowpath = new GraphicsPath();
 
496
                        if (RoundedCorners)
 
497
                        {
 
498
                                int radius = CornerRadius;
 
499
                                shadowpath.AddArc(ActualWidth-radius + 4, 3, radius, radius, 300, 60);
 
500
                                shadowpath.AddArc(ActualWidth-radius + 4, ActualHeight - radius + 3, radius, radius, 0, 90);
 
501
                                shadowpath.AddArc(4, ActualHeight-radius + 3, radius, radius, 90, 45);
 
502
                                shadowpath.AddArc(ActualWidth-radius, ActualHeight - radius, radius, radius, 90, -90);
 
503
                        }
 
504
                        else
 
505
                        {
 
506
                                shadowpath.AddPolygon(new PointF[] {
 
507
                                                        new PointF(ActualWidth, 3),
 
508
                                                        new PointF(ActualWidth + 4, 3),
 
509
                                                        new PointF(ActualWidth + 4, ActualHeight + 3),
 
510
                                                        new PointF(4, ActualHeight + 3),
 
511
                                                        new PointF(4, ActualHeight),
 
512
                                                        new PointF(ActualWidth, ActualHeight)
 
513
                                                      });
 
514
                        }
 
515
                        shadowpath.CloseFigure();
 
516
                }
 
517
                
 
518
                #endregion
 
519
                
 
520
                public override void DrawToGraphics (Graphics graphics)
 
521
                {
 
522
                        grad.ResetTransform();
 
523
                        grad.TranslateTransform(AbsoluteX, AbsoluteY);
 
524
                        grad.ScaleTransform(ActualWidth, 1);
 
525
                        
 
526
                        GraphicsState state = graphics.Save();
 
527
                        graphics.TranslateTransform (AbsoluteX, AbsoluteY);
 
528
                        
 
529
                        if (Container == null)
 
530
                        {
 
531
                                //Draw Shadow
 
532
                                graphics.FillPath(CanvasItem.ShadowBrush, shadowpath);
 
533
                        }
 
534
                        
 
535
                        classItemContainer.Width = Width;
 
536
                        classItemContainer.Height = Height;
 
537
                                
 
538
                        graphics.Restore(state);
 
539
                        classItemContainer.DrawToGraphics(graphics);
 
540
                        
 
541
                        //Draw interfaces lollipops
 
542
                        //TODO - should be converted to an headered item.
 
543
                        if (interfaces.Count > 0)
 
544
                        {
 
545
                                interfaces.X = AbsoluteX + 15;
 
546
                                interfaces.Y = AbsoluteY - interfaces.ActualHeight - 1;
 
547
                                interfaces.DrawToGraphics(graphics);
 
548
                                
 
549
                                graphics.DrawEllipse(Pens.Black, AbsoluteX + 9, AbsoluteY - interfaces.ActualHeight - 11, 10, 10);
 
550
                                graphics.DrawLine(Pens.Black, AbsoluteX + 14, AbsoluteY - interfaces.ActualHeight - 1, AbsoluteX + 14, AbsoluteY);
 
551
                        }
 
552
                        
 
553
                        base.DrawToGraphics(graphics);
 
554
                }
 
555
                
 
556
                public bool Collapsed
 
557
                {
 
558
                        get { return classItemHeaderedContent.Collapsed; }
 
559
                        set
 
560
                        {
 
561
                                classItemHeaderedContent.Collapsed = value;
 
562
                                collapseExpandShape.Collapsed = value;
 
563
                                PrepareFrame();
 
564
                                EmitLayoutUpdate();
 
565
                        }
 
566
                }
 
567
                
 
568
                private void HandleRedraw (object sender, EventArgs args)
 
569
                {
 
570
                        PrepareFrame();
 
571
                        EmitLayoutUpdate();
 
572
                }
 
573
                
 
574
                #region Behaviour
 
575
                
 
576
                public override void HandleMouseClick (PointF pos)
 
577
                {
 
578
                        base.HandleMouseClick(pos);
 
579
 
 
580
                        if (collapseExpandShape.IsInside(pos.X, pos.Y))
 
581
                        {
 
582
                                Collapsed = !Collapsed;
 
583
                        }
 
584
                        else
 
585
                        {
 
586
                                foreach (InteractiveHeaderedItem tg in groups)
 
587
                                {
 
588
                                        if (tg.HitTest(pos))
 
589
                                        {
 
590
                                                tg.HandleMouseClick(pos);
 
591
                                        }
 
592
                                }
 
593
                        }
 
594
                }
 
595
                
 
596
                #endregion
 
597
                
 
598
                #region Storage
 
599
                
 
600
                protected override XmlElement CreateXmlElement(XmlDocument doc)
 
601
                {
 
602
                        return doc.CreateElement("Class");
 
603
                }
 
604
                
 
605
                protected override void FillXmlElement(XmlElement element, XmlDocument document)
 
606
                {
 
607
                        base.FillXmlElement(element, document);
 
608
                        element.SetAttribute("Name", RepresentedClassType.FullyQualifiedName);
 
609
                        element.SetAttribute("Collapsed", Collapsed.ToString());
 
610
                        
 
611
                        //<Compartments>
 
612
                        XmlElement compartments = document.CreateElement("Compartments");
 
613
                        foreach (InteractiveHeaderedItem tg in groups)
 
614
                        {
 
615
                                XmlElement grp = document.CreateElement("Compartment");
 
616
                                grp.SetAttribute("Name", groupNames[tg]);
 
617
                                grp.SetAttribute("Collapsed", tg.Collapsed.ToString());
 
618
                                compartments.AppendChild(grp);
 
619
                        }
 
620
                        element.AppendChild(compartments);
 
621
                        
 
622
                }
 
623
                
 
624
                public override void LoadFromXml (XPathNavigator navigator)
 
625
                {
 
626
                        base.LoadFromXml(navigator);
 
627
                        
 
628
                        Collapsed = bool.Parse(navigator.GetAttribute("Collapsed", ""));
 
629
                        
 
630
                        XPathNodeIterator compNI = navigator.Select("Compartments/Compartment");
 
631
                        while (compNI.MoveNext())
 
632
                        {
 
633
                                XPathNavigator compNav = compNI.Current;
 
634
                                InteractiveHeaderedItem grp;
 
635
                                if (groupsByName.TryGetValue(compNav.GetAttribute("Name", ""), out grp))
 
636
                                {
 
637
                                        grp.Collapsed = bool.Parse(compNav.GetAttribute("Collapsed", ""));
 
638
                                }
 
639
                        }
 
640
                }
 
641
                
 
642
                #endregion
 
643
                
 
644
                public void Dispose()
 
645
                {
 
646
                        grad.Dispose();
 
647
                        if (shadowpath != null)
 
648
                                shadowpath.Dispose();
 
649
                }
 
650
                
 
651
                public override string ToString()
 
652
                {
 
653
                        return "ClasCanvasItem: " + classtype.Name;
 
654
                }
 
655
        }
 
656
}