Subversion Repositories SoapBoxCore

Rev

Rev 7 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7 Rev 17
1
//Copyright (c) 2007-2009, Adolfo Marinucci
1
//Copyright (c) 2007-2010, Adolfo Marinucci
2
//All rights reserved.
2
//All rights reserved.
3
 
3
 
4
//Redistribution and use in source and binary forms, with or without modification, 
4
//Redistribution and use in source and binary forms, with or without modification, 
5
//are permitted provided that the following conditions are met:
5
//are permitted provided that the following conditions are met:
6
//
6
//
7
//* Redistributions of source code must retain the above copyright notice, 
7
//* Redistributions of source code must retain the above copyright notice, 
8
//  this list of conditions and the following disclaimer.
8
//  this list of conditions and the following disclaimer.
9
//* Redistributions in binary form must reproduce the above copyright notice, 
9
//* Redistributions in binary form must reproduce the above copyright notice, 
10
//  this list of conditions and the following disclaimer in the documentation 
10
//  this list of conditions and the following disclaimer in the documentation 
11
//  and/or other materials provided with the distribution.
11
//  and/or other materials provided with the distribution.
12
//* Neither the name of Adolfo Marinucci nor the names of its contributors may 
12
//* Neither the name of Adolfo Marinucci nor the names of its contributors may 
13
//  be used to endorse or promote products derived from this software without 
13
//  be used to endorse or promote products derived from this software without 
14
//  specific prior written permission.
14
//  specific prior written permission.
15
//
15
//
16
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
16
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
17
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
17
//AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
18
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
18
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
19
//IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
19
//IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
20
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
20
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
21
//PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
21
//PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
22
//HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
22
//HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
23
//OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
23
//OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
24
//EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24
//EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25
 
25
 
26
using System;
26
using System;
27
using System.Collections.Generic;
27
using System.Collections.Generic;
28
using System.Text;
28
using System.Text;
29
using System.Windows;
29
using System.Windows;
30
using System.Windows.Controls;
30
using System.Windows.Controls;
31
using System.Windows.Controls.Primitives;
31
using System.Windows.Controls.Primitives;
32
using System.Windows.Data;
32
using System.Windows.Data;
33
using System.Windows.Documents;
33
using System.Windows.Documents;
34
using System.Windows.Input;
34
using System.Windows.Input;
35
using System.Windows.Media;
35
using System.Windows.Media;
36
using System.Windows.Media.Imaging;
36
using System.Windows.Media.Imaging;
37
using System.Windows.Shapes;
37
using System.Windows.Shapes;
38
using System.Windows.Markup;
38
using System.Windows.Markup;
39
using System.Diagnostics;
39
using System.Diagnostics;
40
using System.Linq;
40
using System.Linq;
41
 
41
 
42
 
42
 
43
namespace AvalonDock
43
namespace AvalonDock
44
{
44
{
45
    public class ResizingPanel : Panel, IDockableControl
45
    public class ResizingPanel : Panel, IDockableControl
46
    {
46
    {
47
        /// <summary>
47
        /// <summary>
48
        /// Gets or sets the orientation of the panel
48
        /// Gets or sets the orientation of the panel
49
        /// </summary>
49
        /// </summary>
50
        /// <remarks>If horizontal oriented children are positioned from left to right and width of each child is computed according to <see cref="ResizingWidth"/> attached property value. When vertical oriented children are arranged from top to bottom, according to <see cref="ResizingHeight"/> of each child.</remarks>
50
        /// <remarks>If horizontal oriented children are positioned from left to right and width of each child is computed according to <see cref="ResizingWidth"/> attached property value. When vertical oriented children are arranged from top to bottom, according to <see cref="ResizingHeight"/> of each child.</remarks>
51
        public Orientation Orientation
51
        public Orientation Orientation
52
        {
52
        {
53
            get { return (Orientation)GetValue(OrientationProperty); }
53
            get { return (Orientation)GetValue(OrientationProperty); }
54
            set { SetValue(OrientationProperty, value); }
54
            set { SetValue(OrientationProperty, value); }
55
        }
55
        }
56
 
56
 
57
        /// <summary>
57
        /// <summary>
58
        /// Give access to Orientation attached property
58
        /// Give access to Orientation attached property
59
        /// </summary>
59
        /// </summary>
60
        /// <remarks>If horizontal oriented children are positioned from left to right and width of each child is computed according to <see cref="ResizingWidth"/> attached property value. When vertical oriented children are arranged from top to bottom, according to <see cref="ResizingHeight"/> of each child.</remarks>
60
        /// <remarks>If horizontal oriented children are positioned from left to right and width of each child is computed according to <see cref="ResizingWidth"/> attached property value. When vertical oriented children are arranged from top to bottom, according to <see cref="ResizingHeight"/> of each child.</remarks>
61
        public static readonly DependencyProperty OrientationProperty =
61
        public static readonly DependencyProperty OrientationProperty =
62
            DependencyProperty.Register("Orientation", typeof(Orientation), typeof(ResizingPanel), new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure, OnOrientationChanged));
62
            DependencyProperty.Register("Orientation", typeof(Orientation), typeof(ResizingPanel), new FrameworkPropertyMetadata(Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure, OnOrientationChanged));
63
 
63
 
64
        static void OnOrientationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
64
        static void OnOrientationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
65
        {
65
        {
66
            ((ResizingPanel)d).splitterListIsDirty = true;
66
            ((ResizingPanel)d).splitterListIsDirty = true;
67
        }
67
        }
68
 
68
 
69
        public static GridLength GetResizeWidth(DependencyObject obj)
69
        public static GridLength GetResizeWidth(DependencyObject obj)
70
        {
70
        {
71
            return (GridLength)obj.GetValue(ResizeWidthProperty);
71
            return (GridLength)obj.GetValue(ResizeWidthProperty);
72
        }
72
        }
73
 
73
 
74
        public static void SetResizeWidth(DependencyObject obj, GridLength value)
74
        public static void SetResizeWidth(DependencyObject obj, GridLength value)
75
        {
75
        {
76
            obj.SetValue(ResizeWidthProperty, value);
76
            obj.SetValue(ResizeWidthProperty, value);
77
        }
77
        }
78
 
78
 
79
 
79
 
80
        public static readonly DependencyProperty ResizeWidthProperty =
80
        public static readonly DependencyProperty ResizeWidthProperty =
81
            DependencyProperty.RegisterAttached("ResizeWidth",
81
            DependencyProperty.RegisterAttached("ResizeWidth",
82
            typeof(GridLength),
82
            typeof(GridLength),
83
            typeof(ResizingPanel),
83
            typeof(ResizingPanel),
84
            new FrameworkPropertyMetadata(new GridLength(1.0, GridUnitType.Star),
84
            new FrameworkPropertyMetadata(new GridLength(1.0, GridUnitType.Star),
85
                OnSplitSizeChanged,
85
                OnSplitSizeChanged,
86
                OnCoerceSplitSize),
86
                OnCoerceSplitSize),
87
                new ValidateValueCallback(IsSplitSizeValid));
87
                new ValidateValueCallback(IsSplitSizeValid));
88
 
88
 
89
        public static GridLength GetResizeHeight(DependencyObject obj)
89
        public static GridLength GetResizeHeight(DependencyObject obj)
90
        {
90
        {
91
            return (GridLength)obj.GetValue(ResizeHeightProperty);
91
            return (GridLength)obj.GetValue(ResizeHeightProperty);
92
        }
92
        }
93
 
93
 
94
        public static void SetResizeHeight(DependencyObject obj, GridLength value)
94
        public static void SetResizeHeight(DependencyObject obj, GridLength value)
95
        {
95
        {
96
            obj.SetValue(ResizeHeightProperty, value);
96
            obj.SetValue(ResizeHeightProperty, value);
97
        }
97
        }
98
 
98
 
99
 
99
 
100
        public static readonly DependencyProperty ResizeHeightProperty =
100
        public static readonly DependencyProperty ResizeHeightProperty =
101
            DependencyProperty.RegisterAttached("ResizeHeight",
101
            DependencyProperty.RegisterAttached("ResizeHeight",
102
            typeof(GridLength),
102
            typeof(GridLength),
103
            typeof(ResizingPanel),
103
            typeof(ResizingPanel),
104
            new FrameworkPropertyMetadata(new GridLength(1.0, GridUnitType.Star),
104
            new FrameworkPropertyMetadata(new GridLength(1.0, GridUnitType.Star),
105
                OnSplitSizeChanged,
105
                OnSplitSizeChanged,
106
                OnCoerceSplitSize),
106
                OnCoerceSplitSize),
107
                new ValidateValueCallback(IsSplitSizeValid));
107
                new ValidateValueCallback(IsSplitSizeValid));
108
 
108
 
109
        static void OnSplitSizeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
109
        static void OnSplitSizeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
110
        {
110
        {
111
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(sender) as ResizingPanel;
111
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(sender) as ResizingPanel;
112
            if (parentPanel != null)
112
            if (parentPanel != null)
113
                parentPanel.InvalidateMeasure();
113
                parentPanel.InvalidateMeasure();
114
        }
114
        }
115
 
115
 
116
        static object OnCoerceSplitSize(DependencyObject sender, object value)
116
        static object OnCoerceSplitSize(DependencyObject sender, object value)
117
        {
117
        {
118
            GridLength gd = (GridLength)value;
118
            GridLength gd = (GridLength)value;
119
 
119
 
120
            if (gd.Value < 0.0)
120
            if (gd.Value < 0.0)
121
                gd = new GridLength(0.0, gd.GridUnitType);
121
                gd = new GridLength(0.0, gd.GridUnitType);
122
 
122
 
123
            return gd;
123
            return gd;
124
        }
124
        }
125
 
125
 
126
        static bool IsSplitSizeValid(object value)
126
        static bool IsSplitSizeValid(object value)
127
        {
127
        {
128
            GridLength v = (GridLength)value;
128
            GridLength v = (GridLength)value;
129
            return v.IsStar || v.IsAbsolute;//at the moment auto is not supported
129
            return v.IsStar || v.IsAbsolute;//at the moment auto is not supported
130
        }
130
        }
131
 
131
 
132
 
132
 
133
 
133
 
134
        public static Size GetEffectiveSize(DependencyObject obj)
134
        public static Size GetEffectiveSize(DependencyObject obj)
135
        {
135
        {
136
            return (Size)obj.GetValue(EffectiveSizeProperty);
136
            return (Size)obj.GetValue(EffectiveSizeProperty);
137
        }
137
        }
138
 
138
 
139
        public static void SetEffectiveSize(DependencyObject obj, Size value)
139
        public static void SetEffectiveSize(DependencyObject obj, Size value)
140
        {
140
        {
141
            obj.SetValue(EffectiveSizeProperty, value);
141
            obj.SetValue(EffectiveSizeProperty, value);
142
        }
142
        }
143
 
143
 
144
        public static readonly DependencyProperty EffectiveSizeProperty =
144
        public static readonly DependencyProperty EffectiveSizeProperty =
145
            DependencyProperty.RegisterAttached("EffectiveSize", typeof(Size), typeof(ResizingPanel), new FrameworkPropertyMetadata(new Size()));
145
            DependencyProperty.RegisterAttached("EffectiveSize", typeof(Size), typeof(ResizingPanel), new FrameworkPropertyMetadata(new Size()));
146
 
146
 
147
 
147
 
148
        List<ResizingPanelSplitter> _splitterList = new List<ResizingPanelSplitter>();
148
        List<Resizer> _splitterList = new List<Resizer>();
149
 
149
 
150
        /// <summary>
150
        /// <summary>
151
        /// Correct sizes of children if all of them are set to absolutes
151
        /// Correct sizes of children if all of them are set to absolutes
152
        /// </summary>
152
        /// </summary>
153
        void CorrectSizes()
153
        void CorrectSizes()
154
        {
154
        {
155
            IEnumerable<FrameworkElement> children = Children.OfType<FrameworkElement>().Where<FrameworkElement>(c => !(c is ResizingPanelSplitter));
155
            IEnumerable<FrameworkElement> children = Children.OfType<FrameworkElement>().Where<FrameworkElement>(c => !(c is Resizer));
156
 
156
 
157
            if (children.All<FrameworkElement>(c => c.IsAbsolute()))
157
            if (children.All<FrameworkElement>(c => c.IsAbsolute()))
158
            {
158
            {
159
                double totSum = children.Sum<FrameworkElement>(f => f.GetAbsoluteValue());
159
                double totSum = children.Sum<FrameworkElement>(f => f.GetAbsoluteValue());
160
                foreach (var c in children)
160
                foreach (var c in children)
161
                {
161
                {
162
                    if (Orientation == Orientation.Horizontal)
162
                    if (Orientation == Orientation.Horizontal)
163
                        SetResizeWidth(c, new GridLength(c.GetAbsoluteValue() / totSum, GridUnitType.Star));
163
                        SetResizeWidth(c, new GridLength(c.GetAbsoluteValue() / totSum, GridUnitType.Star));
164
                    else
164
                    else
165
                        SetResizeHeight(c, new GridLength(c.GetAbsoluteValue() / totSum, GridUnitType.Star));
165
                        SetResizeHeight(c, new GridLength(c.GetAbsoluteValue() / totSum, GridUnitType.Star));
166
                }
166
                }
167
            }
167
            }
168
        }
168
        }
169
 
169
 
170
        /// <summary>
170
        /// <summary>
171
        /// Helper funcs which correct elements size of a resizing panel
171
        /// Helper funcs which correct elements size of a resizing panel
172
        /// </summary>
172
        /// </summary>
173
        internal void AdjustPanelSizes()
173
        internal void AdjustPanelSizes()
174
        {
174
        {
175
            IEnumerable<FrameworkElement> children = Children.OfType<FrameworkElement>().Where<FrameworkElement>(c => !(c is ResizingPanelSplitter));
175
            IEnumerable<FrameworkElement> children = Children.OfType<FrameworkElement>().Where<FrameworkElement>(c => !(c is Resizer));
176
 
176
 
177
            if (!this.IsLogicalChildContained<DocumentPane>())
177
            if (!this.IsLogicalChildContained<DocumentPane>())
178
            {
178
            {
179
                //if no document pane is contained in this panel
179
                //if no document pane is contained in this panel
180
                //adjust elements so that any child will get a proportional star size
180
                //adjust elements so that any child will get a proportional star size
181
                if (Orientation == Orientation.Horizontal)
181
                if (Orientation == Orientation.Horizontal)
182
                {
182
                {
183
                    double totSum = children.Sum<FrameworkElement>(f => f.IsAbsolute() ? f.GetAbsoluteValue() : GetEffectiveSize(f).Width);
183
                    double totSum = children.Sum<FrameworkElement>(f => f.IsAbsolute() ? f.GetAbsoluteValue() : GetEffectiveSize(f).Width);
184
                    foreach (var c in children)
184
                    foreach (var c in children)
185
                        SetResizeWidth(c, new GridLength((c.IsAbsolute() ? c.GetAbsoluteValue() : GetEffectiveSize(c).Width) / totSum, GridUnitType.Star));
185
                        SetResizeWidth(c, new GridLength((c.IsAbsolute() ? c.GetAbsoluteValue() : GetEffectiveSize(c).Width) / totSum, GridUnitType.Star));
186
                }
186
                }
187
                else
187
                else
188
                {
188
                {
189
                    double totSum = children.Sum<FrameworkElement>(f => f.IsAbsolute() ? f.GetAbsoluteValue() : GetEffectiveSize(f).Height);
189
                    double totSum = children.Sum<FrameworkElement>(f => f.IsAbsolute() ? f.GetAbsoluteValue() : GetEffectiveSize(f).Height);
190
                    foreach (var c in children)
190
                    foreach (var c in children)
191
                        SetResizeHeight(c, new GridLength((c.IsAbsolute() ? c.GetAbsoluteValue() : GetEffectiveSize(c).Height) / totSum, GridUnitType.Star));
191
                        SetResizeHeight(c, new GridLength((c.IsAbsolute() ? c.GetAbsoluteValue() : GetEffectiveSize(c).Height) / totSum, GridUnitType.Star));
192
                }
192
                }
193
            }
193
            }
194
 
194
 
195
        }
195
        }
196
 
196
 
197
 
197
 
198
        /// <summary>
198
        /// <summary>
199
        /// Compute the desidered size of the panel
199
        /// Compute the desidered size of the panel
200
        /// </summary>
200
        /// </summary>
201
        /// <param name="availableSize"></param>
201
        /// <param name="availableSize"></param>
202
        /// <returns></returns>
202
        /// <returns></returns>
203
        protected override Size MeasureOverride(Size availableSize)
203
        protected override Size MeasureOverride(Size availableSize)
204
        {
204
        {
-
 
205
            //Debug.WriteLine("ResizingPanel.MeasureOverride()");
-
 
206
 
205
            SetupSplitters();
207
            SetupSplitters();
206
 
208
 
207
            CorrectSizes();
209
            CorrectSizes();
208
 
210
 
209
            //Compute the list of visible children
211
            //Compute the list of visible children
210
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
212
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
211
            for (int i = 0; i < VisualChildrenCount; i++)
213
            for (int i = 0; i < VisualChildrenCount; i++)
212
            {
214
            {
213
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
215
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
214
 
216
 
215
                IDockableControl dockableControl = child as IDockableControl;
217
                IDockableControl dockableControl = child as IDockableControl;
216
                if (dockableControl  != null &&
218
                if (dockableControl  != null &&
217
                    !dockableControl.IsDocked)
219
                    !dockableControl.IsDocked)
218
                {
220
                {
219
                    child.Measure(Size.Empty);
221
                    child.Measure(Size.Empty);
220
 
222
 
221
                    if (i == VisualChildrenCount - 1 &&
223
                    if (i == VisualChildrenCount - 1 &&
222
                        i > 0)
224
                        i > 0)
223
                    {
225
                    {
224
                        child = GetVisualChild(i - 1) as FrameworkElement;
226
                        child = GetVisualChild(i - 1) as FrameworkElement;
225
                        Debug.Assert(child is ResizingPanelSplitter);
227
                        Debug.Assert(child is Resizer);
226
 
228
 
227
                        child.Measure(Size.Empty);
229
                        child.Measure(Size.Empty);
228
 
230
 
229
                        if (visibleChildren.Count > 0)
231
                        if (visibleChildren.Count > 0)
230
                        {
232
                        {
231
                            Debug.Assert(visibleChildren[visibleChildren.Count - 1] is ResizingPanelSplitter);
233
                            Debug.Assert(visibleChildren[visibleChildren.Count - 1] is Resizer);
232
                            visibleChildren[visibleChildren.Count - 1].Measure(Size.Empty);
234
                            visibleChildren[visibleChildren.Count - 1].Measure(Size.Empty);
233
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
235
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
234
                        }
236
                        }
235
                    }
237
                    }
236
                    else if (i < VisualChildrenCount - 1)
238
                    else if (i < VisualChildrenCount - 1)
237
                    {
239
                    {
238
                        i++;
240
                        i++;
239
                        child = GetVisualChild(i) as FrameworkElement;
241
                        child = GetVisualChild(i) as FrameworkElement;
240
                        Debug.Assert(child is ResizingPanelSplitter);
242
                        Debug.Assert(child is Resizer);
241
                        child.Measure(Size.Empty);
243
                        child.Measure(Size.Empty);
242
                    }
244
                    }
243
 
245
 
244
                    continue;
246
                    continue;
245
                }
247
                }
246
 
248
 
247
                visibleChildren.Add(child);
249
                visibleChildren.Add(child);
248
            }
250
            }
249
 
251
 
250
 
252
 
251
            //with no children no space needed
253
            //with no children no space needed
252
            if (visibleChildren.Count == 0)
254
            if (visibleChildren.Count == 0)
253
                return new Size();
255
                return new Size();
254
 
256
 
-
 
257
            NormalizeStarLength(visibleChildren);
-
 
258
 
255
            Debug.Assert(!(visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter));
259
            Debug.Assert(!(visibleChildren.Last<FrameworkElement>() is Resizer));
256
 
260
 
257
            if (availableSize.Width == double.PositiveInfinity &&
261
            if (availableSize.Width == double.PositiveInfinity &&
258
                Orientation == Orientation.Horizontal)
262
                Orientation == Orientation.Horizontal)
259
            {
263
            {
260
                Size newAvailSize = new Size();
264
                Size newAvailSize = new Size();
261
                foreach (FrameworkElement child in visibleChildren)
265
                foreach (FrameworkElement child in visibleChildren)
262
                {
266
                {
263
                    child.Measure(availableSize);
267
                    child.Measure(availableSize);
264
                    newAvailSize.Width += child.DesiredSize.Width;
268
                    newAvailSize.Width += child.DesiredSize.Width;
265
                    newAvailSize.Height = Math.Max(child.DesiredSize.Height, newAvailSize.Height);
269
                    newAvailSize.Height = Math.Max(child.DesiredSize.Height, newAvailSize.Height);
266
                }
270
                }
267
                availableSize = newAvailSize;
271
                availableSize = newAvailSize;
268
            }
272
            }
269
            //Thx to TMx
273
            //Thx to TMx
270
            else if (availableSize.Height == double.PositiveInfinity &&
274
            else if (availableSize.Height == double.PositiveInfinity &&
271
                Orientation == Orientation.Vertical)
275
                Orientation == Orientation.Vertical)
272
            {
276
            {
273
                Size newAvailSize = new Size();
277
                Size newAvailSize = new Size();
274
                foreach (FrameworkElement child in visibleChildren)
278
                foreach (FrameworkElement child in visibleChildren)
275
                {
279
                {
276
                    child.Measure(newAvailSize);
280
                    child.Measure(newAvailSize);
277
                    newAvailSize.Width = Math.Max(child.DesiredSize.Width, newAvailSize.Width);
281
                    newAvailSize.Width = Math.Max(child.DesiredSize.Width, newAvailSize.Width);
278
                    newAvailSize.Height += child.DesiredSize.Height;
282
                    newAvailSize.Height += child.DesiredSize.Height;
279
                }
283
                }
280
                availableSize = newAvailSize;
284
                availableSize = newAvailSize;
281
            }
285
            }
282
 
286
 
283
            var splitters = from FrameworkElement child in visibleChildren
287
            var splitters = from FrameworkElement child in visibleChildren
284
                            where child is ResizingPanelSplitter
288
                            where child is Resizer
285
                            select child;
289
                            select child;
286
            var childStars = from FrameworkElement child in visibleChildren
290
            var childStars = from FrameworkElement child in visibleChildren
287
                             where (!(child is ResizingPanelSplitter)) && child.IsStar()
291
                             where (!(child is Resizer)) && child.IsStar()
288
                             select child;
292
                             select child;
289
 
293
 
290
            var childAbsolutes = from FrameworkElement child in visibleChildren
294
            var childAbsolutes = from FrameworkElement child in visibleChildren
291
                                 where (!(child is ResizingPanelSplitter)) && child.IsAbsolute()
295
                                 where (!(child is Resizer)) && child.IsAbsolute()
292
                                 select child;
296
                                 select child;
293
 
297
 
294
            var childAutoSizes = from FrameworkElement child in visibleChildren
298
            var childAutoSizes = from FrameworkElement child in visibleChildren
295
                                 where (!(child is ResizingPanelSplitter)) && child.IsAuto()
299
                                 where (!(child is Resizer)) && child.IsAuto()
296
                                 select child;
300
                                 select child;
297
 
301
 
298
            //calculate the size of the splitters
302
            //calculate the size of the splitters
299
            Size splitterSize = new Size();
303
            Size splitterSize = new Size();
300
            foreach (ResizingPanelSplitter splitter in splitters)
304
            foreach (Resizer splitter in splitters)
301
            {
305
            {
302
                splitterSize.Width += splitter.MinWidth;
306
                splitterSize.Width += splitter.MinWidth;
303
                splitterSize.Height += splitter.MinHeight;
307
                splitterSize.Height += splitter.MinHeight;
304
            }
308
            }
305
 
309
 
306
            Size minimumSize = new Size(splitterSize.Width, splitterSize.Height);
310
            Size minimumSize = new Size(splitterSize.Width, splitterSize.Height);
307
            foreach (FrameworkElement child in childStars)
311
            foreach (FrameworkElement child in childStars)
308
            {
312
            {
309
                minimumSize.Width += child.MinWidth;
313
                minimumSize.Width += child.MinWidth;
310
                minimumSize.Height += child.MinHeight;
314
                minimumSize.Height += child.MinHeight;
311
            }
315
            }
312
            foreach (FrameworkElement child in childAbsolutes)
316
            foreach (FrameworkElement child in childAbsolutes)
313
            {
317
            {
314
                minimumSize.Width += child.MinWidth;
318
                minimumSize.Width += child.MinWidth;
315
                minimumSize.Height += child.MinHeight;
319
                minimumSize.Height += child.MinHeight;
316
            }
320
            }
317
            foreach (FrameworkElement child in childAutoSizes)
321
            foreach (FrameworkElement child in childAutoSizes)
318
            {
322
            {
319
                minimumSize.Width += child.MinWidth;
323
                minimumSize.Width += child.MinWidth;
320
                minimumSize.Height += child.MinHeight;
324
                minimumSize.Height += child.MinHeight;
321
            }
325
            }
322
 
326
 
323
 
327
 
324
            Size minimumPrefferedSize = new Size(minimumSize.Width, minimumSize.Height);
328
            Size minimumPrefferedSize = new Size(minimumSize.Width, minimumSize.Height);
325
            foreach (FrameworkElement child in childAbsolutes)
329
            foreach (FrameworkElement child in childAbsolutes)
326
            {
330
            {
327
                minimumPrefferedSize.Width += child.GetAbsoluteValue() - child.MinWidth;
331
                minimumPrefferedSize.Width += child.GetAbsoluteValue() - child.MinWidth;
328
                minimumPrefferedSize.Height += child.GetAbsoluteValue() - child.MinHeight;
332
                minimumPrefferedSize.Height += child.GetAbsoluteValue() - child.MinHeight;
329
            }
333
            }
330
            foreach (FrameworkElement child in childAutoSizes)
334
            foreach (FrameworkElement child in childAutoSizes)
331
            {
335
            {
332
                minimumPrefferedSize.Width += child.DesiredSize.Width - child.MinWidth;
336
                minimumPrefferedSize.Width += child.DesiredSize.Width - child.MinWidth;
333
                minimumPrefferedSize.Height += child.DesiredSize.Height - child.MinHeight;
337
                minimumPrefferedSize.Height += child.DesiredSize.Height - child.MinHeight;
334
            }
338
            }
335
 
339
 
336
            if (Orientation == Orientation.Horizontal)
340
            if (Orientation == Orientation.Horizontal)
337
            {
341
            {
338
                #region Horizontal Orientation
342
                #region Horizontal Orientation
339
 
343
 
340
                //if finalSize is not sufficient...
344
                //if finalSize is not sufficient...
341
                double offset = 0.0;
345
                double offset = 0.0;
342
                double maxHeight = 0.0;
346
                double maxHeight = 0.0;
343
                if (minimumSize.Width >= availableSize.Width)
347
                if (minimumSize.Width >= availableSize.Width)
344
                {
348
                {
345
                    foreach (FrameworkElement child in visibleChildren)
349
                    foreach (FrameworkElement child in visibleChildren)
346
                    {
350
                    {
347
                        child.Measure(new Size(child.MinWidth, availableSize.Height));
351
                        child.Measure(new Size(child.MinWidth, availableSize.Height));
348
                        maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
352
                        maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
349
                        offset += child.MinWidth;
353
                        offset += child.MinWidth;
350
                    }
354
                    }
351
                }
355
                }
352
                else if (minimumPrefferedSize.Width >= availableSize.Width)
356
                else if (minimumPrefferedSize.Width >= availableSize.Width)
353
                {
357
                {
354
                    double delta = (minimumPrefferedSize.Width - availableSize.Width) / childAbsolutes.Count<FrameworkElement>();
358
                    double delta = (minimumPrefferedSize.Width - availableSize.Width) / childAbsolutes.Count<FrameworkElement>();
355
 
359
 
356
                    foreach (FrameworkElement child in visibleChildren)
360
                    foreach (FrameworkElement child in visibleChildren)
357
                    {
361
                    {
358
                        if (child is ResizingPanelSplitter)
362
                        if (child is Resizer)
359
                        {
363
                        {
360
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
364
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
361
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
365
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
362
                            offset += child.MinWidth;
366
                            offset += child.MinWidth;
363
                        }
367
                        }
364
                        else if (child.IsAbsolute())
368
                        else if (child.IsAbsolute())
365
                        {
369
                        {
366
                            child.Measure(new Size(Math.Max(child.GetAbsoluteValue() - delta, child.MinWidth), availableSize.Height));
370
                            child.Measure(new Size(Math.Max(child.GetAbsoluteValue() - delta, child.MinWidth), availableSize.Height));
367
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
371
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
368
                            offset += child.GetAbsoluteValue() - delta;
372
                            offset += child.GetAbsoluteValue() - delta;
369
                        }
373
                        }
370
                        else
374
                        else
371
                        {
375
                        {
372
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
376
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
373
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
377
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
374
                            offset += child.MinWidth;
378
                            offset += child.MinWidth;
375
                        }
379
                        }
376
                    }
380
                    }
377
                }
381
                }
378
                else
382
                else
379
                {
383
                {
380
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
384
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
381
                    double starsFinalWidth =
385
                    double starsFinalWidth =
382
                        availableSize.Width -
386
                        availableSize.Width -
383
                        splitters.Sum<FrameworkElement>(s => s.MinWidth) -
387
                        splitters.Sum<FrameworkElement>(s => s.MinWidth) -
384
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
388
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
385
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Width);
389
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Width);
386
 
390
 
387
                    foreach (FrameworkElement child in visibleChildren)
391
                    foreach (FrameworkElement child in visibleChildren)
388
                    {
392
                    {
389
                        if (child is ResizingPanelSplitter)
393
                        if (child is Resizer)
390
                        {
394
                        {
391
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
395
                            child.Measure(new Size(child.MinWidth, availableSize.Height));
392
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
396
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
393
                            offset += child.MinWidth;
397
                            offset += child.MinWidth;
394
                        }
398
                        }
395
                        else if (child.IsAbsolute())
399
                        else if (child.IsAbsolute())
396
                        {
400
                        {
397
                            child.Measure(new Size(child.GetAbsoluteValue(), availableSize.Height));
401
                            child.Measure(new Size(child.GetAbsoluteValue(), availableSize.Height));
398
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
402
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
399
                            offset += child.GetAbsoluteValue();
403
                            offset += child.GetAbsoluteValue();
400
                        }
404
                        }
401
                        else if (child.IsStar())
405
                        else if (child.IsStar())
402
                        {
406
                        {
403
                            double w = child.GetStarValue() / starsSum * starsFinalWidth;
407
                            double w = child.GetStarValue() / starsSum * starsFinalWidth;
404
                            child.Measure(new Size(w, availableSize.Height));
408
                            child.Measure(new Size(w, availableSize.Height));
405
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
409
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
406
                            offset += w;
410
                            offset += w;
407
                        }
411
                        }
408
                        else
412
                        else
409
                        {
413
                        {
410
                            child.Measure(new Size(child.DesiredSize.Width, availableSize.Height));
414
                            child.Measure(new Size(child.DesiredSize.Width, availableSize.Height));
411
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
415
                            maxHeight = Math.Max(child.DesiredSize.Height, maxHeight);
412
                            offset += child.DesiredSize.Width;
416
                            offset += child.DesiredSize.Width;
413
                        }
417
                        }
414
                    }
418
                    }
415
                }
419
                }
416
 
420
 
417
                return new Size(offset, maxHeight);
421
                return new Size(offset, maxHeight);
418
 
422
 
419
                #endregion
423
                #endregion
420
            }
424
            }
421
            else
425
            else
422
            {
426
            {
423
                #region Vertical Orientation
427
                #region Vertical Orientation
424
 
428
 
425
                //if finalSize is not sufficient...
429
                //if finalSize is not sufficient...
426
                double offset = 0.0;
430
                double offset = 0.0;
427
                double maxWidth = 0.0;
431
                double maxWidth = 0.0;
428
                if (minimumSize.Height >= availableSize.Height)
432
                if (minimumSize.Height >= availableSize.Height)
429
                {
433
                {
430
                    foreach (FrameworkElement child in visibleChildren)
434
                    foreach (FrameworkElement child in visibleChildren)
431
                    {
435
                    {
432
                        child.Measure(new Size(availableSize.Width, child.MinHeight));
436
                        child.Measure(new Size(availableSize.Width, child.MinHeight));
433
                        maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
437
                        maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
434
                        offset += child.MinHeight;
438
                        offset += child.MinHeight;
435
                    }
439
                    }
436
                }
440
                }
437
                else if (minimumPrefferedSize.Height >= availableSize.Height)
441
                else if (minimumPrefferedSize.Height >= availableSize.Height)
438
                {
442
                {
439
                    double delta = (minimumPrefferedSize.Height - availableSize.Height) / childAbsolutes.Count<FrameworkElement>();
443
                    double delta = (minimumPrefferedSize.Height - availableSize.Height) / childAbsolutes.Count<FrameworkElement>();
440
 
444
 
441
                    foreach (FrameworkElement child in visibleChildren)
445
                    foreach (FrameworkElement child in visibleChildren)
442
                    {
446
                    {
443
                        if (child is ResizingPanelSplitter)
447
                        if (child is Resizer)
444
                        {
448
                        {
445
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
449
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
446
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
450
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
447
                            offset += child.MinHeight;
451
                            offset += child.MinHeight;
448
                        }
452
                        }
449
                        else if (child.IsAbsolute())
453
                        else if (child.IsAbsolute())
450
                        {
454
                        {
451
                            child.Measure(new Size(availableSize.Width, Math.Max(child.GetAbsoluteValue() - delta, child.MinHeight)));
455
                            child.Measure(new Size(availableSize.Width, Math.Max(child.GetAbsoluteValue() - delta, child.MinHeight)));
452
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
456
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
453
                            offset += child.GetAbsoluteValue() - delta;
457
                            offset += child.GetAbsoluteValue() - delta;
454
                        }
458
                        }
455
                        else
459
                        else
456
                        {
460
                        {
457
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
461
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
458
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
462
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
459
                            offset += child.MinWidth;
463
                            offset += child.MinWidth;
460
                        }
464
                        }
461
                    }
465
                    }
462
                }
466
                }
463
                else
467
                else
464
                {
468
                {
465
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
469
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
466
                    double starsFinalHeight =
470
                    double starsFinalHeight =
467
                        availableSize.Height -
471
                        availableSize.Height -
468
                        splitters.Sum<FrameworkElement>(s => s.MinHeight) -
472
                        splitters.Sum<FrameworkElement>(s => s.MinHeight) -
469
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
473
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
470
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Height);
474
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Height);
471
 
475
 
472
                    foreach (FrameworkElement child in visibleChildren)
476
                    foreach (FrameworkElement child in visibleChildren)
473
                    {
477
                    {
474
                        if (child is ResizingPanelSplitter)
478
                        if (child is Resizer)
475
                        {
479
                        {
476
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
480
                            child.Measure(new Size(availableSize.Width, child.MinHeight));
477
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
481
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
478
                            offset += child.MinWidth;
482
                            offset += child.MinWidth;
479
                        }
483
                        }
480
                        else if (child.IsAbsolute())
484
                        else if (child.IsAbsolute())
481
                        {
485
                        {
482
                            child.Measure(new Size(availableSize.Width, child.GetAbsoluteValue()));
486
                            child.Measure(new Size(availableSize.Width, child.GetAbsoluteValue()));
483
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
487
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
484
                            offset += child.GetAbsoluteValue();
488
                            offset += child.GetAbsoluteValue();
485
                        }
489
                        }
486
                        else if (child.IsStar())
490
                        else if (child.IsStar())
487
                        {
491
                        {
488
                            double w = child.GetStarValue() / starsSum * starsFinalHeight;
492
                            double w = child.GetStarValue() / starsSum * starsFinalHeight;
489
                            child.Measure(new Size(availableSize.Width, w));
493
                            child.Measure(new Size(availableSize.Width, w));
490
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
494
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
491
                            offset += w;
495
                            offset += w;
492
                        }
496
                        }
493
                        else
497
                        else
494
                        {
498
                        {
495
                            child.Measure(new Size(availableSize.Width, child.DesiredSize.Height));
499
                            child.Measure(new Size(availableSize.Width, child.DesiredSize.Height));
496
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
500
                            maxWidth = Math.Max(child.DesiredSize.Width, maxWidth);
497
                            offset += child.DesiredSize.Width;
501
                            offset += child.DesiredSize.Width;
498
                        }
502
                        }
499
                    }
503
                    }
500
                }
504
                }
501
 
505
 
502
                return new Size(maxWidth, offset);
506
                return new Size(maxWidth, offset);
503
 
507
 
504
                #endregion
508
                #endregion
505
 
509
 
506
            }
510
            }
-
 
511
        }
-
 
512
 
-
 
513
        private void NormalizeStarLength(IEnumerable<FrameworkElement> visibleChildren)
-
 
514
        {
-
 
515
            var childrenWithStarLength = visibleChildren.Where(c => c is IDockableControl && c.IsStar());
-
 
516
            int childrenWithStartLengthCount = childrenWithStarLength.Count();
-
 
517
 
-
 
518
            if (childrenWithStartLengthCount == 0)
-
 
519
                return;
-
 
520
 
-
 
521
            if (childrenWithStartLengthCount == 1)
-
 
522
            {
-
 
523
                ResizingPanel.SetResizeWidth(childrenWithStarLength.First(), new GridLength(1.0, GridUnitType.Star));
-
 
524
                return;
-
 
525
            }
-
 
526
 
-
 
527
            double sumStars = childrenWithStarLength.Sum(c => c.GetStarValue());
-
 
528
 
-
 
529
            if (sumStars == 0)
-
 
530
            {
-
 
531
                //problem!?! try to fix...
-
 
532
                childrenWithStarLength.ForEach(c =>
-
 
533
                    {
-
 
534
                        ResizingPanel.SetResizeWidth(c, new GridLength(1.0 / childrenWithStartLengthCount, GridUnitType.Star));
-
 
535
                    });
-
 
536
            }
-
 
537
            else
-
 
538
            {
-
 
539
                childrenWithStarLength.ForEach(c =>
-
 
540
                {
-
 
541
                    ResizingPanel.SetResizeWidth(c, new GridLength(1.0 * c.GetStarValue() / sumStars, GridUnitType.Star));
-
 
542
                });                
-
 
543
            }
-
 
544
           
507
        }
545
        }
508
 
546
 
509
        Size[] _childrenFinalSizes = null;
547
        Size[] _childrenFinalSizes = null;
510
 
548
 
511
        /// <summary>
549
        /// <summary>
512
        /// Arranges children giving them a proportional space according to their <see cref="SplitSize"/> attached property value
550
        /// Arranges children giving them a proportional space according to their <see cref="SplitSize"/> attached property value
513
        /// </summary>
551
        /// </summary>
514
        /// <param name="finalSize"></param>
552
        /// <param name="finalSize"></param>
515
        /// <returns></returns>
553
        /// <returns></returns>
516
        protected override Size ArrangeOverride(Size finalSize)
554
        protected override Size ArrangeOverride(Size finalSize)
517
        {
555
        {
-
 
556
            //Debug.WriteLine("ResizingPanel.ArrangeOverride()");
-
 
557
 
518
            //Compute the list of visible children
558
            //Compute the list of visible children
519
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
559
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
520
            for (int i = 0; i < VisualChildrenCount; i++)
560
            for (int i = 0; i < VisualChildrenCount; i++)
521
            {
561
            {
522
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
562
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
523
 
563
 
524
                IDockableControl dockableControl = child as IDockableControl;
564
                IDockableControl dockableControl = child as IDockableControl;
525
                if (dockableControl != null &&
565
                if (dockableControl != null &&
526
                    !dockableControl.IsDocked)
566
                    !dockableControl.IsDocked)
527
                {
567
                {
528
                    child.Arrange(new Rect());
568
                    child.Arrange(new Rect());
529
 
569
 
530
                    if (i == VisualChildrenCount - 1 &&
570
                    if (i == VisualChildrenCount - 1 &&
531
                        i > 0)
571
                        i > 0)
532
                    {
572
                    {
533
                        child = GetVisualChild(i - 1) as FrameworkElement;
573
                        child = GetVisualChild(i - 1) as FrameworkElement;
534
                        Debug.Assert(child is ResizingPanelSplitter);
574
                        Debug.Assert(child is Resizer);
535
 
575
 
536
                        child.Arrange(new Rect());
576
                        child.Arrange(new Rect());
537
 
577
 
538
                        if (visibleChildren.Count > 0)
578
                        if (visibleChildren.Count > 0)
539
                        {
579
                        {
540
                            Debug.Assert(visibleChildren[visibleChildren.Count - 1] is ResizingPanelSplitter);
580
                            Debug.Assert(visibleChildren[visibleChildren.Count - 1] is Resizer);
541
                            visibleChildren[visibleChildren.Count - 1].Arrange(new Rect());
581
                            visibleChildren[visibleChildren.Count - 1].Arrange(new Rect());
542
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
582
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
543
                        }
583
                        }
544
 
584
 
545
                    }
585
                    }
546
                    else if (i < VisualChildrenCount - 1)
586
                    else if (i < VisualChildrenCount - 1)
547
                    {
587
                    {
548
                        i++;
588
                        i++;
549
                        child = GetVisualChild(i) as FrameworkElement;
589
                        child = GetVisualChild(i) as FrameworkElement;
550
                        child.Arrange(new Rect());
590
                        child.Arrange(new Rect());
551
                        Debug.Assert(child is ResizingPanelSplitter);
591
                        Debug.Assert(child is Resizer);
552
                    }
592
                    }
553
 
593
 
554
                    continue;
594
                    continue;
555
                }
595
                }
556
 
596
 
557
                visibleChildren.Add(child);
597
                visibleChildren.Add(child);
558
            }
598
            }
559
 
599
 
560
            //with no children fill the space
600
            //with no children fill the space
561
            if (visibleChildren.Count == 0)
601
            if (visibleChildren.Count == 0)
562
            {
602
            {
563
                _childrenFinalSizes = new Size[] { };
603
                _childrenFinalSizes = new Size[] { };
564
                return new Size();
604
                return new Size();
565
            }
605
            }
566
 
606
 
567
            Debug.Assert(!(visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter));
607
            Debug.Assert(!(visibleChildren.Last<FrameworkElement>() is Resizer));
568
               
608
               
569
 
609
 
570
            _childrenFinalSizes = new Size[visibleChildren.Count];
610
            _childrenFinalSizes = new Size[visibleChildren.Count];
571
 
611
 
572
            var splitters = from FrameworkElement child in visibleChildren
612
            var splitters = from FrameworkElement child in visibleChildren
573
                            where child is ResizingPanelSplitter
613
                            where child is Resizer
574
                            select child;
614
                            select child;
575
            var childStars = from FrameworkElement child in visibleChildren
615
            var childStars = from FrameworkElement child in visibleChildren
576
                             where (!(child is ResizingPanelSplitter)) && child.IsStar()
616
                             where (!(child is Resizer)) && child.IsStar()
577
                             select child;
617
                             select child;
578
 
618
 
579
            var childAbsolutes = from FrameworkElement child in visibleChildren
619
            var childAbsolutes = from FrameworkElement child in visibleChildren
580
                                 where (!(child is ResizingPanelSplitter)) && child.IsAbsolute()
620
                                 where (!(child is Resizer)) && child.IsAbsolute()
581
                                 select child;
621
                                 select child;
582
 
622
 
583
            var childAutoSizes = from FrameworkElement child in visibleChildren
623
            var childAutoSizes = from FrameworkElement child in visibleChildren
584
                                 where (!(child is ResizingPanelSplitter)) && child.IsAuto()
624
                                 where (!(child is Resizer)) && child.IsAuto()
585
                                 select child;
625
                                 select child;
586
 
626
 
587
            //calculate the size of the splitters
627
            //calculate the size of the splitters
588
            Size splitterSize = new Size();
628
            Size splitterSize = new Size();
589
            foreach (ResizingPanelSplitter splitter in splitters)
629
            foreach (Resizer splitter in splitters)
590
            {
630
            {
591
                splitterSize.Width += splitter.MinWidth;
631
                splitterSize.Width += splitter.MinWidth;
592
                splitterSize.Height += splitter.MinHeight;
632
                splitterSize.Height += splitter.MinHeight;
593
            }
633
            }
594
 
634
 
595
            Size minimumSize = new Size(splitterSize.Width, splitterSize.Height);
635
            Size minimumSize = new Size(splitterSize.Width, splitterSize.Height);
596
            foreach (FrameworkElement child in childStars)
636
            foreach (FrameworkElement child in childStars)
597
            {
637
            {
598
                minimumSize.Width += child.MinWidth;
638
                minimumSize.Width += child.MinWidth;
599
                minimumSize.Height += child.MinHeight;
639
                minimumSize.Height += child.MinHeight;
600
            }
640
            }
601
            foreach (FrameworkElement child in childAbsolutes)
641
            foreach (FrameworkElement child in childAbsolutes)
602
            {
642
            {
603
                minimumSize.Width += child.MinWidth;
643
                minimumSize.Width += child.MinWidth;
604
                minimumSize.Height += child.MinHeight;
644
                minimumSize.Height += child.MinHeight;
605
            }
645
            }
606
            foreach (FrameworkElement child in childAutoSizes)
646
            foreach (FrameworkElement child in childAutoSizes)
607
            {
647
            {
608
                minimumSize.Width += child.MinWidth;
648
                minimumSize.Width += child.MinWidth;
609
                minimumSize.Height += child.MinHeight;
649
                minimumSize.Height += child.MinHeight;
610
            }
650
            }
611
 
651
 
612
 
652
 
613
            Size minimumPrefferedSize = new Size(minimumSize.Width, minimumSize.Height);
653
            Size minimumPrefferedSize = new Size(minimumSize.Width, minimumSize.Height);
614
            foreach (FrameworkElement child in childAbsolutes)
654
            foreach (FrameworkElement child in childAbsolutes)
615
            {
655
            {
616
                minimumPrefferedSize.Width += child.GetAbsoluteValue() - child.MinWidth;
656
                minimumPrefferedSize.Width += child.GetAbsoluteValue() - child.MinWidth;
617
                minimumPrefferedSize.Height += child.GetAbsoluteValue() - child.MinHeight;
657
                minimumPrefferedSize.Height += child.GetAbsoluteValue() - child.MinHeight;
618
            }
658
            }
619
            foreach (FrameworkElement child in childAutoSizes)
659
            foreach (FrameworkElement child in childAutoSizes)
620
            {
660
            {
621
                minimumPrefferedSize.Width += child.DesiredSize.Width - child.MinWidth;
661
                minimumPrefferedSize.Width += child.DesiredSize.Width - child.MinWidth;
622
                minimumPrefferedSize.Height += child.DesiredSize.Height - child.MinHeight;
662
                minimumPrefferedSize.Height += child.DesiredSize.Height - child.MinHeight;
623
            }
663
            }
624
 
664
 
625
            int iChild = 0;
665
            int iChild = 0;
626
 
666
 
627
            if (Orientation == Orientation.Horizontal)
667
            if (Orientation == Orientation.Horizontal)
628
            {
668
            {
629
                #region Horizontal Orientation
669
                #region Horizontal Orientation
630
 
670
 
631
                //if finalSize is not sufficient...
671
                //if finalSize is not sufficient...
632
                if (minimumSize.Width >= finalSize.Width)
672
                if (minimumSize.Width >= finalSize.Width)
633
                {
673
                {
634
                    foreach (FrameworkElement child in visibleChildren)
674
                    foreach (FrameworkElement child in visibleChildren)
635
                    {
675
                    {
636
                        _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
676
                        _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
637
                    }
677
                    }
638
                }
678
                }
639
                else if (minimumPrefferedSize.Width >= finalSize.Width)
679
                else if (minimumPrefferedSize.Width >= finalSize.Width)
640
                {
680
                {
641
                    double delta = (minimumPrefferedSize.Width - finalSize.Width) / childAbsolutes.Count<FrameworkElement>();
681
                    double delta = (minimumPrefferedSize.Width - finalSize.Width) / childAbsolutes.Count<FrameworkElement>();
642
 
682
 
643
                    foreach (FrameworkElement child in visibleChildren)
683
                    foreach (FrameworkElement child in visibleChildren)
644
                    {
684
                    {
645
                        if (child is ResizingPanelSplitter)
685
                        if (child is Resizer)
646
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
686
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
647
                        else if (child.IsAbsolute())
687
                        else if (child.IsAbsolute())
648
                            _childrenFinalSizes[iChild++] = new Size(Math.Max(child.GetAbsoluteValue() - delta, 0.0), finalSize.Height);
688
                            _childrenFinalSizes[iChild++] = new Size(Math.Max(child.GetAbsoluteValue() - delta, 0.0), finalSize.Height);
649
                        else
689
                        else
650
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
690
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
651
                    }
691
                    }
652
                }
692
                }
653
                else
693
                else
654
                {
694
                {
655
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
695
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
656
                    double starsFinalWidth =
696
                    double starsFinalWidth =
657
                        finalSize.Width -
697
                        finalSize.Width -
658
                        splitters.Sum<FrameworkElement>(s => s.MinWidth) -
698
                        splitters.Sum<FrameworkElement>(s => s.MinWidth) -
659
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
699
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
660
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Width);
700
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Width);
661
 
701
 
662
                    foreach (FrameworkElement child in visibleChildren)
702
                    foreach (FrameworkElement child in visibleChildren)
663
                    {
703
                    {
664
                        if (child is ResizingPanelSplitter)
704
                        if (child is Resizer)
665
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
705
                            _childrenFinalSizes[iChild++] = new Size(child.MinWidth, finalSize.Height);
666
                        else if (child.IsAbsolute())
706
                        else if (child.IsAbsolute())
667
                            _childrenFinalSizes[iChild++] = new Size(child.GetAbsoluteValue(), finalSize.Height);
707
                            _childrenFinalSizes[iChild++] = new Size(child.GetAbsoluteValue(), finalSize.Height);
668
                        else if (child.IsStar())
708
                        else if (child.IsStar())
669
                            _childrenFinalSizes[iChild++] = new Size(child.GetStarValue() / starsSum * starsFinalWidth, finalSize.Height);
709
                            _childrenFinalSizes[iChild++] = new Size(child.GetStarValue() / starsSum * starsFinalWidth, finalSize.Height);
670
                        else
710
                        else
671
                            _childrenFinalSizes[iChild++] = new Size(child.DesiredSize.Width, finalSize.Height);
711
                            _childrenFinalSizes[iChild++] = new Size(child.DesiredSize.Width, finalSize.Height);
672
                    }
712
                    }
673
 
713
 
674
                }
714
                }
675
 
715
 
676
                double offset = 0.0;
716
                double offset = 0.0;
677
 
717
 
678
                for (int i = 0; i < visibleChildren.Count; i++)
718
                for (int i = 0; i < visibleChildren.Count; i++)
679
                {
719
                {
680
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
720
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
681
                    child.Arrange(new Rect(offset, 0.0, _childrenFinalSizes[i].Width, finalSize.Height));
721
                    child.Arrange(new Rect(offset, 0.0, _childrenFinalSizes[i].Width, finalSize.Height));
682
                    offset += _childrenFinalSizes[i].Width;
722
                    offset += _childrenFinalSizes[i].Width;
683
 
723
 
684
                    SetEffectiveSize(child, new Size(_childrenFinalSizes[i].Width, finalSize.Height));
724
                    SetEffectiveSize(child, new Size(_childrenFinalSizes[i].Width, finalSize.Height));
685
                }
725
                }
686
 
726
 
687
                return new Size(offset, finalSize.Height);
727
                return new Size(offset, finalSize.Height);
688
                #endregion
728
                #endregion
689
            }
729
            }
690
            else
730
            else
691
            {
731
            {
692
                #region Vertical Orientation
732
                #region Vertical Orientation
693
 
733
 
694
                //if finalSize is not sufficient...
734
                //if finalSize is not sufficient...
695
                if (minimumSize.Height >= finalSize.Height)
735
                if (minimumSize.Height >= finalSize.Height)
696
                {
736
                {
697
                    foreach (FrameworkElement child in visibleChildren)
737
                    foreach (FrameworkElement child in visibleChildren)
698
                    {
738
                    {
699
                        _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
739
                        _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
700
                    }
740
                    }
701
                }
741
                }
702
                else if (minimumPrefferedSize.Height >= finalSize.Height)
742
                else if (minimumPrefferedSize.Height >= finalSize.Height)
703
                {
743
                {
704
                    double delta = (minimumPrefferedSize.Height - finalSize.Height) / childAbsolutes.Count<FrameworkElement>();
744
                    double delta = (minimumPrefferedSize.Height - finalSize.Height) / childAbsolutes.Count<FrameworkElement>();
705
 
745
 
706
                    foreach (FrameworkElement child in visibleChildren)
746
                    foreach (FrameworkElement child in visibleChildren)
707
                    {
747
                    {
708
                        if (child is ResizingPanelSplitter)
748
                        if (child is Resizer)
709
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
749
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
710
                        else if (child.IsAbsolute())
750
                        else if (child.IsAbsolute())
711
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, Math.Max(child.GetAbsoluteValue() - delta, 0.0));
751
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, Math.Max(child.GetAbsoluteValue() - delta, 0.0));
712
                        else
752
                        else
713
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
753
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
714
                    }
754
                    }
715
                }
755
                }
716
                else
756
                else
717
                {
757
                {
718
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
758
                    double starsSum = childStars.Sum<FrameworkElement>(v => v.GetStarValue());
719
                    double starsFinalHeight =
759
                    double starsFinalHeight =
720
                        finalSize.Height -
760
                        finalSize.Height -
721
                        splitters.Sum<FrameworkElement>(s => s.MinHeight) -
761
                        splitters.Sum<FrameworkElement>(s => s.MinHeight) -
722
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
762
                        childAbsolutes.Sum<FrameworkElement>(a => a.GetAbsoluteValue()) -
723
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Height);
763
                        childAutoSizes.Sum<FrameworkElement>(a => a.DesiredSize.Height);
724
 
764
 
725
                    foreach (FrameworkElement child in visibleChildren)
765
                    foreach (FrameworkElement child in visibleChildren)
726
                    {
766
                    {
727
                        if (child is ResizingPanelSplitter)
767
                        if (child is Resizer)
728
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
768
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.MinHeight);
729
                        else if (child.IsAbsolute())
769
                        else if (child.IsAbsolute())
730
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.GetAbsoluteValue());
770
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.GetAbsoluteValue());
731
                        else if (child.IsStar())
771
                        else if (child.IsStar())
732
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.GetStarValue() / starsSum * starsFinalHeight);
772
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.GetStarValue() / starsSum * starsFinalHeight);
733
                        else
773
                        else
734
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.DesiredSize.Height);
774
                            _childrenFinalSizes[iChild++] = new Size(finalSize.Width, child.DesiredSize.Height);
735
                    }
775
                    }
736
 
776
 
737
                }
777
                }
738
 
778
 
739
                double offset = 0.0;
779
                double offset = 0.0;
740
 
780
 
741
                for (int i = 0; i < visibleChildren.Count; i++)
781
                for (int i = 0; i < visibleChildren.Count; i++)
742
                {
782
                {
743
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
783
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
744
                    child.Arrange(new Rect(0.0, offset, finalSize.Width, _childrenFinalSizes[i].Height));
784
                    child.Arrange(new Rect(0.0, offset, finalSize.Width, _childrenFinalSizes[i].Height));
745
                    offset += _childrenFinalSizes[i].Height;
785
                    offset += _childrenFinalSizes[i].Height;
746
                    SetEffectiveSize(child, new Size(finalSize.Width, _childrenFinalSizes[i].Height));
786
                    SetEffectiveSize(child, new Size(finalSize.Width, _childrenFinalSizes[i].Height));
747
                }
787
                }
748
 
788
 
749
                return new Size(finalSize.Width, offset);
789
                return new Size(finalSize.Width, offset);
750
                #endregion
790
                #endregion
751
            }
791
            }
752
 
792
 
753
 
793
 
754
        }
794
        }
755
 
795
 
756
        bool setupSplitters = false;
796
        bool setupSplitters = false;
757
        bool splitterListIsDirty = false;
797
        bool splitterListIsDirty = false;
758
 
798
 
759
        void SetupSplitters()
799
        void SetupSplitters()
760
        {
800
        {
761
            if (!splitterListIsDirty)
801
            if (!splitterListIsDirty)
762
                return;
802
                return;
763
 
803
 
764
            if (setupSplitters)
804
            if (setupSplitters)
765
                return;
805
                return;
766
 
806
 
767
            setupSplitters = true;
807
            setupSplitters = true;
768
 
808
 
769
            while (_splitterList.Count > 0)
809
            while (_splitterList.Count > 0)
770
            {
810
            {
771
                ResizingPanelSplitter splitter = _splitterList[0];
811
                Resizer splitter = _splitterList[0];
772
                splitter.DragStarted -= new DragStartedEventHandler(splitter_DragStarted);
812
                splitter.DragStarted -= new DragStartedEventHandler(splitter_DragStarted);
773
                splitter.DragDelta -= new DragDeltaEventHandler(splitter_DragDelta);
813
                splitter.DragDelta -= new DragDeltaEventHandler(splitter_DragDelta);
774
                splitter.DragCompleted -= new DragCompletedEventHandler(splitter_DragCompleted);
814
                splitter.DragCompleted -= new DragCompletedEventHandler(splitter_DragCompleted);
775
                _splitterList.Remove(splitter);
815
                _splitterList.Remove(splitter);
776
                Children.Remove(splitter);
816
                Children.Remove(splitter);
777
            }
817
            }
778
 
818
 
779
            int i = 0;//child index
819
            int i = 0;//child index
780
            int j = 0;//splitter index
820
            int j = 0;//splitter index
781
 
821
 
782
            while (i < Children.Count - 1)
822
            while (i < Children.Count - 1)
783
            {
823
            {
784
                if (j == _splitterList.Count)
824
                if (j == _splitterList.Count)
785
                {
825
                {
786
                    ResizingPanelSplitter splitter = new ResizingPanelSplitter();
826
                    Resizer splitter = new Resizer();
-
 
827
                    splitter.Cursor =  this.Orientation == Orientation.Horizontal ? Cursors.SizeWE : Cursors.SizeNS;
787
                    _splitterList.Add(splitter);
828
                    _splitterList.Add(splitter);
788
                    splitter.DragStarted += new DragStartedEventHandler(splitter_DragStarted);
829
                    splitter.DragStarted += new DragStartedEventHandler(splitter_DragStarted);
789
                    splitter.DragDelta += new DragDeltaEventHandler(splitter_DragDelta);
830
                    splitter.DragDelta += new DragDeltaEventHandler(splitter_DragDelta);
790
                    splitter.DragCompleted += new DragCompletedEventHandler(splitter_DragCompleted);
831
                    splitter.DragCompleted += new DragCompletedEventHandler(splitter_DragCompleted);
791
                    Children.Insert(i + 1, splitter);
832
                    Children.Insert(i + 1, splitter);
792
                }
833
                }
793
 
834
 
794
                i += 2;
835
                i += 2;
795
                j++;
836
                j++;
796
            }
837
            }
797
 
838
 
798
            for (j = 0; j < _splitterList.Count; j++)
839
            for (j = 0; j < _splitterList.Count; j++)
799
            {
840
            {
800
                _splitterList[j].Width = (Orientation == Orientation.Horizontal) ? 4 : double.NaN;
841
                _splitterList[j].Width = (Orientation == Orientation.Horizontal) ? 6 : double.NaN;
801
                _splitterList[j].Height = (Orientation == Orientation.Vertical) ? 4 : double.NaN;
842
                _splitterList[j].Height = (Orientation == Orientation.Vertical) ? 6 : double.NaN;
802
            }
843
            }
803
 
844
 
804
#if DEBUG
845
#if DEBUG
805
            Debug.Assert(_splitterList.Count == Children.Count / 2);
846
            Debug.Assert(_splitterList.Count == Children.Count / 2);
806
            i = 0;
847
            i = 0;
807
            while (Children.Count > 0)
848
            while (Children.Count > 0)
808
            {
849
            {
809
                Debug.Assert(Children[i] != null);
850
                Debug.Assert(Children[i] != null);
810
                Debug.Assert(!(Children[i] is ResizingPanelSplitter));
851
                Debug.Assert(!(Children[i] is Resizer));
811
                i++;
852
                i++;
812
                if (i >= Children.Count)
853
                if (i >= Children.Count)
813
                    break;
854
                    break;
814
 
855
 
815
                Debug.Assert((Children[i] is ResizingPanelSplitter));
856
                Debug.Assert((Children[i] is Resizer));
816
                i++;
857
                i++;
817
 
858
 
818
            }
859
            }
819
#endif
860
#endif
820
            splitterListIsDirty = false;
861
            splitterListIsDirty = false;
821
            setupSplitters = false;
862
            setupSplitters = false;
822
        }
863
        }
823
 
864
 
824
        protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved)
865
        protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved)
825
        {
866
        {
826
            base.OnVisualChildrenChanged(visualAdded, visualRemoved);
867
            base.OnVisualChildrenChanged(visualAdded, visualRemoved);
827
 
868
 
828
            splitterListIsDirty = true;
869
            splitterListIsDirty = true;
829
        }
870
        }
830
 
871
 
831
        void splitter_DragCompleted(object sender, DragCompletedEventArgs e)
-
 
832
        {
-
 
833
            Cursor = Cursors.Arrow;
-
 
834
        }
-
 
835
 
872
 
836
        /// <summary>
873
        /// <summary>
837
        /// This method is called by a splitter when it is dragged
874
        /// This method is called by a splitter when it is dragged
838
        /// </summary>
875
        /// </summary>
839
        /// <param name="splitter">Dragged splitter</param>
876
        /// <param name="splitter">Dragged splitter</param>
840
        /// <param name="delta"></param>
877
        /// <param name="delta"></param>
841
        void splitter_DragDelta(object sender, DragDeltaEventArgs e)
878
        void splitter_DragDelta(object sender, DragDeltaEventArgs e)
842
        {
879
        {
-
 
880
            Resizer splitter = sender as Resizer;
-
 
881
 
-
 
882
            if (Orientation == System.Windows.Controls.Orientation.Horizontal)
-
 
883
            {
-
 
884
                Canvas.SetLeft(_resizerGhost, _initialStartPoint.X + e.HorizontalChange);
-
 
885
            }
-
 
886
            else
-
 
887
            {
-
 
888
                Canvas.SetTop(_resizerGhost, _initialStartPoint.Y + e.VerticalChange);
-
 
889
            }
-
 
890
 
-
 
891
 
843
            ResizingPanelSplitter splitter = e.Source as ResizingPanelSplitter;
892
            //ResizingPanelSplitter splitter = e.Source as ResizingPanelSplitter;
-
 
893
            //int i = 0;
-
 
894
 
-
 
895
            ////Compute the list of visible children
-
 
896
            //List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
-
 
897
            //for (i = 0; i < VisualChildrenCount; i++)
-
 
898
            //{
-
 
899
            //    FrameworkElement child = GetVisualChild(i) as FrameworkElement;
-
 
900
 
-
 
901
            //    IDockableControl dockableControl = child as IDockableControl;
-
 
902
            //    if (dockableControl != null &&
-
 
903
            //        !dockableControl.IsDocked)
-
 
904
            //    {
-
 
905
            //        if (i == VisualChildrenCount - 1 &&
-
 
906
            //            i > 0)
-
 
907
            //        {
-
 
908
            //            //remove the last splitter added
-
 
909
            //            if (visibleChildren.Count > 0 &&
-
 
910
            //                visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter)
-
 
911
            //                visibleChildren.RemoveAt(visibleChildren.Count - 1);
-
 
912
            //        }
-
 
913
            //        else if (i < VisualChildrenCount - 1)
-
 
914
            //        {
-
 
915
            //            //discard the next splitter
-
 
916
            //            i++;
-
 
917
            //        }
-
 
918
 
-
 
919
            //        continue;
-
 
920
            //    }
-
 
921
 
-
 
922
            //    visibleChildren.Add(child);
-
 
923
            //}
-
 
924
 
-
 
925
            //if (visibleChildren.Count == 0)
-
 
926
            //    return;
-
 
927
 
-
 
928
            //if (visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter)
-
 
929
            //    visibleChildren.RemoveAt(visibleChildren.Count - 1);
-
 
930
 
-
 
931
            //Size[] currentSizes = new Size[visibleChildren.Count];
-
 
932
            //double delta = Orientation == Orientation.Horizontal ? e.HorizontalChange : e.VerticalChange;
-
 
933
 
-
 
934
            //if (_childrenFinalSizes == null)
-
 
935
            //    return;
-
 
936
 
-
 
937
            //_childrenFinalSizes.CopyTo(currentSizes, 0);
-
 
938
 
-
 
939
            //int iSplitter = visibleChildren.IndexOf(splitter);
-
 
940
 
-
 
941
            //Debug.Assert(iSplitter > -1);
-
 
942
 
-
 
943
            //List<FrameworkElement> prevChildren = new List<FrameworkElement>();
-
 
944
            //for (i = iSplitter - 1; i >= 0; i--)
-
 
945
            //{
-
 
946
            //    FrameworkElement child = visibleChildren[i] as FrameworkElement;
-
 
947
            //    if (child is ResizingPanelSplitter)
-
 
948
            //        continue;
-
 
949
            //    if (child.IsAbsolute() || child.IsAuto())
-
 
950
            //    {
-
 
951
            //        if (prevChildren.Count == 0)
-
 
952
            //        {
-
 
953
            //            prevChildren.Add(child);
-
 
954
            //        }
-
 
955
            //        break;
-
 
956
            //    }
-
 
957
            //    if (child.IsStar())
-
 
958
            //    {
-
 
959
            //        prevChildren.Add(child);
-
 
960
            //    }
-
 
961
            //}
-
 
962
 
-
 
963
            //List<FrameworkElement> nextChildren = new List<FrameworkElement>();
-
 
964
 
-
 
965
            //for (i = iSplitter + 1; i < visibleChildren.Count; i++)
-
 
966
            //{
-
 
967
            //    FrameworkElement child = visibleChildren[i] as FrameworkElement;
-
 
968
            //    if (child is ResizingPanelSplitter)
-
 
969
            //        continue;
-
 
970
            //    if (child.IsAbsolute() || child.IsAuto())
-
 
971
            //    {
-
 
972
            //        if (nextChildren.Count == 0)
-
 
973
            //            nextChildren.Add(child);
-
 
974
            //        break;
-
 
975
            //    }
-
 
976
            //    if (child.IsStar())
-
 
977
            //    {
-
 
978
            //        nextChildren.Add(child);
-
 
979
            //    }
-
 
980
            //}
-
 
981
 
-
 
982
 
-
 
983
            //double prevMinSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
-
 
984
            //double nextMinSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
-
 
985
            //double prevMaxSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
-
 
986
            //double nextMaxSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
-
 
987
 
-
 
988
            //double prevSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
-
 
989
            //double nextSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
-
 
990
 
-
 
991
            //if (prevSize + delta < prevMinSize)
-
 
992
            //    delta = prevMinSize - prevSize;
-
 
993
            //if (nextSize - delta < nextMinSize)
-
 
994
            //    delta = -(nextMinSize - nextSize);
-
 
995
 
-
 
996
            //double remDelta = delta * 2;
-
 
997
 
-
 
998
            //while (!HelperFunc.AreClose(delta, 0.0))
-
 
999
            //{
-
 
1000
            //    int prevChildrenCountWithNoMinLen =
-
 
1001
            //        prevChildren.Count<FrameworkElement>(c => delta > 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
-
 
1002
            //    int nextChildrenCountWithNoMinLen =
-
 
1003
            //        nextChildren.Count<FrameworkElement>(c => delta < 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
-
 
1004
               
-
 
1005
            //    delta = remDelta / 2.0;
-
 
1006
 
-
 
1007
            //    for (i = 0; i < currentSizes.Length; i++)
-
 
1008
            //    {
-
 
1009
            //        FrameworkElement child = visibleChildren[i] as FrameworkElement;
-
 
1010
            //        if (child is ResizingPanelSplitter)
-
 
1011
            //            continue;
-
 
1012
 
-
 
1013
            //        if (Orientation == Orientation.Horizontal)
-
 
1014
            //        {
-
 
1015
            //            if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
-
 
1016
            //            {
-
 
1017
            //                double s = delta / prevChildrenCountWithNoMinLen;
-
 
1018
            //                if (currentSizes[i].Width + s < child.MinWidth)
-
 
1019
            //                    s = child.MinWidth - currentSizes[i].Width;
-
 
1020
                           
-
 
1021
            //                currentSizes[i].Width += s;
-
 
1022
            //                remDelta -= s;
-
 
1023
            //            }
-
 
1024
            //            if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
-
 
1025
            //            {
-
 
1026
            //                double s = delta / nextChildrenCountWithNoMinLen;
-
 
1027
            //                if (currentSizes[i].Width - s < child.MinWidth)
-
 
1028
            //                    s = currentSizes[i].Width - child.MinWidth;
-
 
1029
 
-
 
1030
            //                currentSizes[i].Width -= s;
-
 
1031
            //                remDelta -= s;
-
 
1032
            //            }
-
 
1033
            //        }
-
 
1034
            //        else
-
 
1035
            //        {
-
 
1036
            //            if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
-
 
1037
            //            {
-
 
1038
            //                double s = delta / prevChildrenCountWithNoMinLen;
-
 
1039
            //                if (currentSizes[i].Height + s < child.MinHeight)
-
 
1040
            //                    s = child.MinHeight - currentSizes[i].Height;
-
 
1041
 
-
 
1042
            //                currentSizes[i].Height += s;
-
 
1043
            //                remDelta -= s;
-
 
1044
            //            }
-
 
1045
            //            if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
-
 
1046
            //            {
-
 
1047
            //                double s = delta / nextChildrenCountWithNoMinLen;
-
 
1048
            //                if (currentSizes[i].Height - s < child.MinHeight)
-
 
1049
            //                    s = currentSizes[i].Height - child.MinHeight;
-
 
1050
 
-
 
1051
            //                currentSizes[i].Height -= s;
-
 
1052
            //                remDelta -= s;
-
 
1053
            //            }
-
 
1054
            //        }
-
 
1055
            //    }
-
 
1056
            //}
-
 
1057
 
-
 
1058
            //Debug.Assert(HelperFunc.AreClose(delta, 0.0));
-
 
1059
 
-
 
1060
            //double totalStartsSum = 0.0;
-
 
1061
            //double totalSizeForStarts = 0.0;
-
 
1062
 
-
 
1063
            //for (i = 0; i < visibleChildren.Count; i++)
-
 
1064
            //{ 
-
 
1065
            //    FrameworkElement child = visibleChildren[i] as FrameworkElement;
-
 
1066
            //    if (child is ResizingPanelSplitter)
-
 
1067
            //        continue;
-
 
1068
            //    if (child.IsStar())
-
 
1069
            //    {
-
 
1070
            //        totalStartsSum += child.GetStarValue();
-
 
1071
            //        totalSizeForStarts += Orientation == Orientation.Horizontal ? currentSizes[i].Width : currentSizes[i].Height;
-
 
1072
            //    }
-
 
1073
            //}
-
 
1074
               
-
 
1075
 
-
 
1076
            //double starsScaleFactor = totalStartsSum / totalSizeForStarts;
-
 
1077
 
-
 
1078
            //for (i = 0; i < currentSizes.Length; i++)
-
 
1079
            //{
-
 
1080
            //    FrameworkElement child = visibleChildren[i] as FrameworkElement;
-
 
1081
 
-
 
1082
            //    if (child is ResizingPanelSplitter)
-
 
1083
            //        continue;
-
 
1084
 
-
 
1085
            //    if (child.IsStar())
-
 
1086
            //    {
-
 
1087
            //        if (Orientation == Orientation.Horizontal)
-
 
1088
            //        {
-
 
1089
            //            SetResizeWidth(child,
-
 
1090
            //                new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Width, starsScaleFactor), GridUnitType.Star));
-
 
1091
            //        }
-
 
1092
            //        else
-
 
1093
            //        {
-
 
1094
            //            SetResizeHeight(child,
-
 
1095
            //                new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Height, starsScaleFactor), GridUnitType.Star));
-
 
1096
            //        }
-
 
1097
            //    }
-
 
1098
            //    else if (child.IsAbsolute())
-
 
1099
            //    {
-
 
1100
            //        if (Orientation == Orientation.Horizontal)
-
 
1101
            //        {
-
 
1102
            //            SetResizeWidth(child,
-
 
1103
            //                new GridLength(currentSizes[i].Width, GridUnitType.Pixel));
-
 
1104
            //        }
-
 
1105
            //        else
-
 
1106
            //        {
-
 
1107
            //            SetResizeHeight(child,
-
 
1108
            //                new GridLength(currentSizes[i].Height, GridUnitType.Pixel)); 
-
 
1109
            //        }
-
 
1110
            //    }
-
 
1111
            //}
-
 
1112
 
-
 
1113
            //InvalidateMeasure();
-
 
1114
        }
-
 
1115
 
-
 
1116
        void splitter_DragStarted(object sender, DragStartedEventArgs e)
-
 
1117
        {
-
 
1118
            var resizer = sender as Resizer;
-
 
1119
            ShowResizerOverlayWindow(resizer);
-
 
1120
        }
-
 
1121
 
-
 
1122
        void splitter_DragCompleted(object sender, DragCompletedEventArgs e)
-
 
1123
        {
-
 
1124
            HideResizerOverlayWindow();
-
 
1125
 
-
 
1126
            Resizer splitter = e.Source as Resizer;
844
            int i = 0;
1127
            int i = 0;
845
 
1128
 
846
            //Compute the list of visible children
1129
            //Compute the list of visible children
847
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
1130
            List<FrameworkElement> visibleChildren = new List<FrameworkElement>();
848
            for (i = 0; i < VisualChildrenCount; i++)
1131
            for (i = 0; i < VisualChildrenCount; i++)
849
            {
1132
            {
850
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
1133
                FrameworkElement child = GetVisualChild(i) as FrameworkElement;
851
 
1134
 
852
                IDockableControl dockableControl = child as IDockableControl;
1135
                IDockableControl dockableControl = child as IDockableControl;
853
                if (dockableControl != null &&
1136
                if (dockableControl != null &&
854
                    !dockableControl.IsDocked)
1137
                    !dockableControl.IsDocked)
855
                {
1138
                {
856
                    if (i == VisualChildrenCount - 1 &&
1139
                    if (i == VisualChildrenCount - 1 &&
857
                        i > 0)
1140
                        i > 0)
858
                    {
1141
                    {
859
                        //remove the last splitter added
1142
                        //remove the last splitter added
860
                        if (visibleChildren.Count > 0 &&
1143
                        if (visibleChildren.Count > 0 &&
861
                            visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter)
1144
                            visibleChildren.Last<FrameworkElement>() is Resizer)
862
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
1145
                            visibleChildren.RemoveAt(visibleChildren.Count - 1);
863
                    }
1146
                    }
864
                    else if (i < VisualChildrenCount - 1)
1147
                    else if (i < VisualChildrenCount - 1)
865
                    {
1148
                    {
866
                        //discard the next splitter
1149
                        //discard the next splitter
867
                        i++;
1150
                        i++;
868
                    }
1151
                    }
869
 
1152
 
870
                    continue;
1153
                    continue;
871
                }
1154
                }
872
 
1155
 
873
                visibleChildren.Add(child);
1156
                visibleChildren.Add(child);
874
            }
1157
            }
875
 
1158
 
876
            if (visibleChildren.Count == 0)
1159
            if (visibleChildren.Count == 0)
877
                return;
1160
                return;
878
 
1161
 
879
            if (visibleChildren.Last<FrameworkElement>() is ResizingPanelSplitter)
1162
            if (visibleChildren.Last<FrameworkElement>() is Resizer)
880
                visibleChildren.RemoveAt(visibleChildren.Count - 1);
1163
                visibleChildren.RemoveAt(visibleChildren.Count - 1);
881
 
1164
 
882
            Size[] currentSizes = new Size[visibleChildren.Count];
1165
            Size[] currentSizes = new Size[visibleChildren.Count];
883
            double delta = Orientation == Orientation.Horizontal ? e.HorizontalChange : e.VerticalChange;
1166
            double delta = Orientation == Orientation.Horizontal ? e.HorizontalChange : e.VerticalChange;
884
 
1167
 
885
            if (_childrenFinalSizes == null)
1168
            if (_childrenFinalSizes == null)
886
                return;
1169
                return;
887
 
1170
 
888
            _childrenFinalSizes.CopyTo(currentSizes, 0);
1171
            _childrenFinalSizes.CopyTo(currentSizes, 0);
889
 
1172
 
890
            int iSplitter = visibleChildren.IndexOf(splitter);
1173
            int iSplitter = visibleChildren.IndexOf(splitter);
891
 
1174
 
892
            Debug.Assert(iSplitter > -1);
1175
            Debug.Assert(iSplitter > -1);
893
 
1176
 
894
            List<FrameworkElement> prevChildren = new List<FrameworkElement>();
1177
            List<FrameworkElement> prevChildren = new List<FrameworkElement>();
895
            for (i = iSplitter - 1; i >= 0; i--)
1178
            for (i = iSplitter - 1; i >= 0; i--)
896
            {
1179
            {
897
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1180
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
898
                if (child is ResizingPanelSplitter)
1181
                if (child is Resizer)
899
                    continue;
1182
                    continue;
900
                if (child.IsAbsolute() || child.IsAuto())
1183
                if (child.IsAbsolute() || child.IsAuto())
901
                {
1184
                {
902
                    if (prevChildren.Count == 0)
1185
                    if (prevChildren.Count == 0)
903
                    {
1186
                    {
904
                        prevChildren.Add(child);
1187
                        prevChildren.Add(child);
905
                    }
1188
                    }
906
                    break;
1189
                    break;
907
                }
1190
                }
908
                if (child.IsStar())
1191
                if (child.IsStar())
909
                {
1192
                {
910
                    prevChildren.Add(child);
1193
                    prevChildren.Add(child);
911
                }
1194
                }
912
            }
1195
            }
913
 
1196
 
914
            List<FrameworkElement> nextChildren = new List<FrameworkElement>();
1197
            List<FrameworkElement> nextChildren = new List<FrameworkElement>();
915
 
1198
 
916
            for (i = iSplitter + 1; i < visibleChildren.Count; i++)
1199
            for (i = iSplitter + 1; i < visibleChildren.Count; i++)
917
            {
1200
            {
918
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1201
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
919
                if (child is ResizingPanelSplitter)
1202
                if (child is Resizer)
920
                    continue;
1203
                    continue;
921
                if (child.IsAbsolute() || child.IsAuto())
1204
                if (child.IsAbsolute() || child.IsAuto())
922
                {
1205
                {
923
                    if (nextChildren.Count == 0)
1206
                    if (nextChildren.Count == 0)
924
                        nextChildren.Add(child);
1207
                        nextChildren.Add(child);
925
                    break;
1208
                    break;
926
                }
1209
                }
927
                if (child.IsStar())
1210
                if (child.IsStar())
928
                {
1211
                {
929
                    nextChildren.Add(child);
1212
                    nextChildren.Add(child);
930
                }
1213
                }
931
            }
1214
            }
932
 
1215
 
933
 
1216
 
934
            double prevMinSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
1217
            double prevMinSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
935
            double nextMinSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
1218
            double nextMinSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MinWidth : c.MinHeight);
936
            double prevMaxSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
1219
            double prevMaxSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
937
            double nextMaxSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
1220
            double nextMaxSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? c.MaxWidth : c.MaxHeight);
938
 
1221
 
939
            double prevSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
1222
            double prevSize = prevChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
940
            double nextSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
1223
            double nextSize = nextChildren.Sum<FrameworkElement>(c => Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width : currentSizes[visibleChildren.IndexOf(c)].Height);
941
 
1224
 
942
            if (prevSize + delta < prevMinSize)
1225
            if (prevSize + delta < prevMinSize)
943
                delta = prevMinSize - prevSize;
1226
                delta = prevMinSize - prevSize;
944
            if (nextSize - delta < nextMinSize)
1227
            if (nextSize - delta < nextMinSize)
945
                delta = -(nextMinSize - nextSize);
1228
                delta = -(nextMinSize - nextSize);
946
 
1229
 
947
            double remDelta = delta * 2;
1230
            double remDelta = delta * 2;
948
 
1231
 
949
            while (!HelperFunc.AreClose(delta, 0.0))
1232
            while (!HelperFunc.AreClose(delta, 0.0))
950
            {
1233
            {
951
                int prevChildrenCountWithNoMinLen =
1234
                int prevChildrenCountWithNoMinLen =
952
                    prevChildren.Count<FrameworkElement>(c => delta > 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
1235
                    prevChildren.Count<FrameworkElement>(c => delta > 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
953
                int nextChildrenCountWithNoMinLen =
1236
                int nextChildrenCountWithNoMinLen =
954
                    nextChildren.Count<FrameworkElement>(c => delta < 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
1237
                    nextChildren.Count<FrameworkElement>(c => delta < 0 ? true : (Orientation == Orientation.Horizontal ? currentSizes[visibleChildren.IndexOf(c)].Width > c.MinWidth : currentSizes[visibleChildren.IndexOf(c)].Height > c.MinHeight));
955
               
1238
 
956
                delta = remDelta / 2.0;
1239
                delta = remDelta / 2.0;
957
 
1240
 
958
                for (i = 0; i < currentSizes.Length; i++)
1241
                for (i = 0; i < currentSizes.Length; i++)
959
                {
1242
                {
960
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
1243
                    FrameworkElement child = visibleChildren[i] as FrameworkElement;
961
                    if (child is ResizingPanelSplitter)
1244
                    if (child is Resizer)
962
                        continue;
1245
                        continue;
963
 
1246
 
964
                    if (Orientation == Orientation.Horizontal)
1247
                    if (Orientation == Orientation.Horizontal)
965
                    {
1248
                    {
966
                        if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
1249
                        if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
967
                        {
1250
                        {
968
                            double s = delta / prevChildrenCountWithNoMinLen;
1251
                            double s = delta / prevChildrenCountWithNoMinLen;
969
                            if (currentSizes[i].Width + s < child.MinWidth)
1252
                            if (currentSizes[i].Width + s < child.MinWidth)
970
                                s = child.MinWidth - currentSizes[i].Width;
1253
                                s = child.MinWidth - currentSizes[i].Width;
971
                           
1254
 
972
                            currentSizes[i].Width += s;
1255
                            currentSizes[i].Width += s;
973
                            remDelta -= s;
1256
                            remDelta -= s;
974
                        }
1257
                        }
975
                        if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
1258
                        if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
976
                        {
1259
                        {
977
                            double s = delta / nextChildrenCountWithNoMinLen;
1260
                            double s = delta / nextChildrenCountWithNoMinLen;
978
                            if (currentSizes[i].Width - s < child.MinWidth)
1261
                            if (currentSizes[i].Width - s < child.MinWidth)
979
                                s = currentSizes[i].Width - child.MinWidth;
1262
                                s = currentSizes[i].Width - child.MinWidth;
980
 
1263
 
981
                            currentSizes[i].Width -= s;
1264
                            currentSizes[i].Width -= s;
982
                            remDelta -= s;
1265
                            remDelta -= s;
983
                        }
1266
                        }
984
                    }
1267
                    }
985
                    else
1268
                    else
986
                    {
1269
                    {
987
                        if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
1270
                        if (prevChildren.Contains(child) && prevChildrenCountWithNoMinLen > 0)
988
                        {
1271
                        {
989
                            double s = delta / prevChildrenCountWithNoMinLen;
1272
                            double s = delta / prevChildrenCountWithNoMinLen;
990
                            if (currentSizes[i].Height + s < child.MinHeight)
1273
                            if (currentSizes[i].Height + s < child.MinHeight)
991
                                s = child.MinHeight - currentSizes[i].Height;
1274
                                s = child.MinHeight - currentSizes[i].Height;
992
 
1275
 
993
                            currentSizes[i].Height += s;
1276
                            currentSizes[i].Height += s;
994
                            remDelta -= s;
1277
                            remDelta -= s;
995
                        }
1278
                        }
996
                        if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
1279
                        if (nextChildren.Contains(child) && nextChildrenCountWithNoMinLen > 0)
997
                        {
1280
                        {
998
                            double s = delta / nextChildrenCountWithNoMinLen;
1281
                            double s = delta / nextChildrenCountWithNoMinLen;
999
                            if (currentSizes[i].Height - s < child.MinHeight)
1282
                            if (currentSizes[i].Height - s < child.MinHeight)
1000
                                s = currentSizes[i].Height - child.MinHeight;
1283
                                s = currentSizes[i].Height - child.MinHeight;
1001
 
1284
 
1002
                            currentSizes[i].Height -= s;
1285
                            currentSizes[i].Height -= s;
1003
                            remDelta -= s;
1286
                            remDelta -= s;
1004
                        }
1287
                        }
1005
                    }
1288
                    }
1006
                }
1289
                }
1007
            }
1290
            }
1008
 
1291
 
1009
            Debug.Assert(HelperFunc.AreClose(delta, 0.0));
1292
            Debug.Assert(HelperFunc.AreClose(delta, 0.0));
1010
 
1293
 
1011
            double totalStartsSum = 0.0;
1294
            double totalStartsSum = 0.0;
1012
            double totalSizeForStarts = 0.0;
1295
            double totalSizeForStarts = 0.0;
1013
 
1296
 
1014
            for (i = 0; i < visibleChildren.Count; i++)
1297
            for (i = 0; i < visibleChildren.Count; i++)
1015
            {
1298
            {
1016
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1299
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1017
                if (child is ResizingPanelSplitter)
1300
                if (child is Resizer)
1018
                    continue;
1301
                    continue;
1019
                if (child.IsStar())
1302
                if (child.IsStar())
1020
                {
1303
                {
1021
                    totalStartsSum += child.GetStarValue();
1304
                    totalStartsSum += child.GetStarValue();
1022
                    totalSizeForStarts += Orientation == Orientation.Horizontal ? currentSizes[i].Width : currentSizes[i].Height;
1305
                    totalSizeForStarts += Orientation == Orientation.Horizontal ? currentSizes[i].Width : currentSizes[i].Height;
1023
                }
1306
                }
1024
            }
1307
            }
1025
               
-
 
1026
 
1308
 
1027
            double starsScaleFactor = totalStartsSum / totalSizeForStarts;
1309
            double starsScaleFactor = totalStartsSum / totalSizeForStarts;
1028
 
1310
 
1029
            for (i = 0; i < currentSizes.Length; i++)
1311
            for (i = 0; i < currentSizes.Length; i++)
1030
            {
1312
            {
1031
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1313
                FrameworkElement child = visibleChildren[i] as FrameworkElement;
1032
 
1314
 
1033
                if (child is ResizingPanelSplitter)
1315
                if (child is Resizer)
1034
                    continue;
1316
                    continue;
1035
 
1317
 
1036
                if (child.IsStar())
1318
                if (child.IsStar())
1037
                {
1319
                {
1038
                    if (Orientation == Orientation.Horizontal)
1320
                    if (Orientation == Orientation.Horizontal)
1039
                    {
1321
                    {
1040
                        SetResizeWidth(child,
1322
                        SetResizeWidth(child,
1041
                            new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Width, starsScaleFactor), GridUnitType.Star));
1323
                            new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Width, starsScaleFactor), GridUnitType.Star));
1042
                    }
1324
                    }
1043
                    else
1325
                    else
1044
                    {
1326
                    {
1045
                        SetResizeHeight(child,
1327
                        SetResizeHeight(child,
1046
                            new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Height, starsScaleFactor), GridUnitType.Star));
1328
                            new GridLength(HelperFunc.MultiplyCheckNaN(currentSizes[i].Height, starsScaleFactor), GridUnitType.Star));
1047
                    }
1329
                    }
1048
                }
1330
                }
1049
                else if (child.IsAbsolute())
1331
                else if (child.IsAbsolute())
1050
                {
1332
                {
1051
                    if (Orientation == Orientation.Horizontal)
1333
                    if (Orientation == Orientation.Horizontal)
1052
                    {
1334
                    {
1053
                        SetResizeWidth(child,
1335
                        SetResizeWidth(child,
1054
                            new GridLength(currentSizes[i].Width, GridUnitType.Pixel));
1336
                            new GridLength(currentSizes[i].Width, GridUnitType.Pixel));
1055
                    }
1337
                    }
1056
                    else
1338
                    else
1057
                    {
1339
                    {
1058
                        SetResizeHeight(child,
1340
                        SetResizeHeight(child,
1059
                            new GridLength(currentSizes[i].Height, GridUnitType.Pixel));
1341
                            new GridLength(currentSizes[i].Height, GridUnitType.Pixel));
1060
                    }
1342
                    }
1061
                }
1343
                }
1062
            }
1344
            }
1063
 
1345
 
1064
            InvalidateMeasure();
1346
            InvalidateMeasure();
1065
           
1347
        }
1066
            //ResizingPanelSplitter splitter = e.Source as ResizingPanelSplitter;
-
 
1067
            //int iSplitter = Children.IndexOf(splitter);
-
 
1068
 
1348
 
1069
            //UIElement childPrev = null;
1349
        Border _resizerGhost = null;
1070
            //UIElement childNext = null;
1350
        Window _resizerWindowHost = null;
-
 
1351
        Vector _initialStartPoint;
1071
 
1352
 
1072
            ////int posInc = ResizingDirection == ResizingDirection.Direct ? 2 : -2;
1353
        void ShowResizerOverlayWindow(Resizer splitter)
1073
            //int posInc = 2;// FlowDirection == FlowDirection.LeftToRight ? 2 : -2;
-
 
1074
            //int negInc = -posInc;
1354
        {
1075
            //int i = iSplitter;
1355
            Point ptTopLeftScreen = this.PointToScreen(new Point());
1076
 
1356
 
1077
            //while (i >= 0 ||
-
 
1078
            //    i < Children.Count - 1)
1357
            _resizerGhost = new Border()
1079
            //{
1358
            {
1080
            //    if (NextChildIsVisible(i))
1359
                Background = Brushes.Black,
1081
            //    {
-
 
1082
            //        //childNext = Children[ResizingDirection == ResizingDirection.Direct ? i + 1 : i - 1];
-
 
1083
            //        childNext = Children[i + 1];//FlowDirection == FlowDirection.LeftToRight ? i + 1 : i - 1];
-
 
1084
            //        break;
1360
                Opacity = 0.7
1085
            //    }
1361
            };
1086
 
1362
 
-
 
1363
            if (Orientation == System.Windows.Controls.Orientation.Horizontal)
-
 
1364
            {
1087
            //    i += posInc;
1365
                _resizerGhost.Width = 5.0;
-
 
1366
                _resizerGhost.Height = ActualHeight;
-
 
1367
            }
-
 
1368
            else
-
 
1369
            {
-
 
1370
                _resizerGhost.Height = 5.0;
-
 
1371
                _resizerGhost.Width = ActualWidth;
1088
            //}
1372
            }
1089
 
1373
 
1090
            //i = iSplitter;
1374
            _initialStartPoint = splitter.PointToScreen(new Point()) - this.PointToScreen(new Point());
1091
 
1375
 
-
 
1376
            if (Orientation == System.Windows.Controls.Orientation.Horizontal)
1092
            //while (i >= 0 ||
1377
            {
1093
            //        i < Children.Count - 1)
1378
                Canvas.SetLeft(_resizerGhost, _initialStartPoint.X);
1094
            //{
1379
            }
1095
            //    if (PrevChildIsVisible(i))
1380
            else
1096
            //    {
1381
            {
1097
            //        //childPrev = Children[ResizingDirection == ResizingDirection.Direct ? i - 1 : i + 1];
1382
                Canvas.SetTop(_resizerGhost, _initialStartPoint.Y);
1098
            //        childPrev = Children[i - 1];//FlowDirection == FlowDirection.LeftToRight ? i - 1 : i + 1]; 
-
 
1099
            //        break;
-
 
1100
            //    }
1383
            }
1101
 
1384
 
-
 
1385
            Canvas panelHostResizer = new Canvas()
1102
            //    i -= posInc;
1386
            {
-
 
1387
                HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch,
-
 
1388
                VerticalAlignment = System.Windows.VerticalAlignment.Stretch
1103
            //}
1389
            };
1104
 
1390
 
1105
            //Size resExtPrev = new Size((double)childPrev.GetValue(ResizeWidthProperty), (double)childPrev.GetValue(ResizeHeightProperty));
1391
            panelHostResizer.Children.Add(_resizerGhost);
1106
            //Size resExtNext = new Size((double)childNext.GetValue(ResizeWidthProperty), (double)childNext.GetValue(ResizeHeightProperty));
-
 
1107
 
1392
 
-
 
1393
            _resizerWindowHost = new Window()
-
 
1394
            {
-
 
1395
                ResizeMode = ResizeMode.NoResize,
-
 
1396
                WindowStyle = System.Windows.WindowStyle.None,
-
 
1397
                ShowInTaskbar = false,
-
 
1398
                AllowsTransparency = true,
-
 
1399
                Background = null,
-
 
1400
                Width = ActualWidth,
-
 
1401
                Height = ActualHeight,
-
 
1402
                Left = ptTopLeftScreen.X,
-
 
1403
                Top = ptTopLeftScreen.Y,
-
 
1404
                ShowActivated = false,
-
 
1405
                Owner = Window.GetWindow(this),
-
 
1406
                Content = panelHostResizer
-
 
1407
            };
1108
 
1408
 
1109
            //#region Orientation == Horizontal
-
 
1110
            //if (Orientation == Orientation.Horizontal)
-
 
1111
            //{
-
 
1112
            //    double delta = e.HorizontalChange;
-
 
1113
 
-
 
1114
            //    if (!double.IsPositiveInfinity(resExtPrev.Width) &&
-
 
1115
            //        (resExtPrev.Width + delta < 0))
-
 
1116
            //        delta = -resExtPrev.Width;
-
 
1117
 
-
 
1118
            //    if (!double.IsPositiveInfinity(resExtNext.Width) &&
-
 
1119
            //        resExtNext.Width - delta < 0)
-
 
1120
            //        delta = resExtNext.Width;
-
 
1121
 
-
 
1122
 
-
 
1123
            //    if (!double.IsPositiveInfinity(resExtPrev.Width))
-
 
1124
            //        childPrev.SetValue(ResizeWidthProperty, resExtPrev.Width + delta);
-
 
1125
            //    if (!double.IsPositiveInfinity(resExtNext.Width))
-
 
1126
            //        childNext.SetValue(ResizeWidthProperty, resExtNext.Width - delta);
-
 
1127
            //}
-
 
1128
            //#endregion
-
 
1129
            //#region Orientation == Vertical
1409
            _resizerWindowHost.Show();
1130
            //else //if (Orientation == Orientation.Vertical)
-
 
1131
            //{
-
 
1132
            //    double delta = e.VerticalChange;
-
 
1133
 
-
 
1134
            //    if (!double.IsPositiveInfinity(resExtPrev.Height) &&
-
 
1135
            //        (resExtPrev.Height + delta < 0))
-
 
1136
            //        delta = -resExtPrev.Height;
-
 
1137
 
-
 
1138
            //    if (!double.IsPositiveInfinity(resExtNext.Height) &&
-
 
1139
            //        resExtNext.Height - delta < 0)
-
 
1140
            //        delta = resExtNext.Height;
-
 
1141
 
-
 
1142
 
-
 
1143
            //    if (!double.IsPositiveInfinity(resExtPrev.Height))
-
 
1144
            //        childPrev.SetValue(ResizeHeightProperty, resExtPrev.Height + delta);
-
 
1145
 
-
 
1146
            //    if (!double.IsPositiveInfinity(resExtNext.Height))
-
 
1147
            //        childNext.SetValue(ResizeHeightProperty, resExtNext.Height - delta);
-
 
1148
            //}
-
 
1149
            //#endregion
-
 
1150
 
-
 
1151
        }
1410
        }
1152
 
1411
 
1153
        void splitter_DragStarted(object sender, DragStartedEventArgs e)
1412
        void HideResizerOverlayWindow()
1154
        {
1413
        {
-
 
1414
            if (_resizerWindowHost != null)
-
 
1415
            {
1155
            Cursor = Orientation == Orientation.Horizontal ? Cursors.SizeWE : Cursors.SizeNS;
1416
                _resizerWindowHost.Close();
-
 
1417
                _resizerWindowHost = null;
-
 
1418
            }
1156
        }
1419
        }
1157
 
1420
 
1158
        #region IDockableControl Membri di
1421
        #region IDockableControl Membri di
1159
 
1422
 
1160
        public bool IsDocked
1423
        public bool IsDocked
1161
        {
1424
        {
1162
            get
1425
            get
1163
            {
1426
            {
1164
                foreach (UIElement child in this.Children)
1427
                foreach (UIElement child in this.Children)
1165
                {
1428
                {
1166
                    if (child is IDockableControl)
1429
                    if (child is IDockableControl)
1167
                        if (((IDockableControl)child).IsDocked)
1430
                        if (((IDockableControl)child).IsDocked)
1168
                            return true;
1431
                            return true;
1169
                }
1432
                }
1170
 
1433
 
1171
                return false;
1434
                return false;
1172
            }
1435
            }
1173
        }
1436
        }
1174
 
1437
 
1175
        #endregion
1438
        #endregion
1176
 
1439
 
1177
 
1440
 
1178
        /// <summary>
1441
        /// <summary>
1179
        /// Remove a child from children collection
1442
        /// Remove a child from children collection
1180
        /// </summary>
1443
        /// </summary>
1181
        /// <param name="childToRemove"></param>
1444
        /// <param name="childToRemove"></param>
1182
        internal void RemoveChild(FrameworkElement childToRemove)
1445
        internal void RemoveChild(FrameworkElement childToRemove)
1183
        {
1446
        {
1184
            int indexOfChildToRemove = Children.IndexOf(childToRemove);
1447
            int indexOfChildToRemove = Children.IndexOf(childToRemove);
1185
 
1448
 
1186
            Debug.Assert(indexOfChildToRemove != -1);
1449
            Debug.Assert(indexOfChildToRemove != -1);
1187
 
1450
 
1188
            Children.RemoveAt(indexOfChildToRemove);
1451
            Children.RemoveAt(indexOfChildToRemove);
1189
 
1452
 
1190
            if (Children.Count > 0)
1453
            if (Children.Count > 0)
1191
            {
1454
            {
1192
                SetupSplitters();
1455
                SetupSplitters();
1193
 
1456
 
1194
                if (Children.Count == 1)
1457
                if (Children.Count == 1)
1195
                {
1458
                {
1196
                    UIElement singleChild = this.Children[0];
1459
                    UIElement singleChild = this.Children[0];
1197
 
1460
 
1198
                    if (Parent is ResizingPanel)
1461
                    if (Parent is ResizingPanel)
1199
                    {
1462
                    {
1200
                        ResizingPanel parentPanel = Parent as ResizingPanel;
1463
                        ResizingPanel parentPanel = Parent as ResizingPanel;
1201
                        if (parentPanel != null)
1464
                        if (parentPanel != null)
1202
                        {
1465
                        {
1203
                            int indexOfThisPanel = parentPanel.Children.IndexOf(this);
1466
                            int indexOfThisPanel = parentPanel.Children.IndexOf(this);
1204
                            parentPanel.Children.RemoveAt(indexOfThisPanel);
1467
                            parentPanel.Children.RemoveAt(indexOfThisPanel);
1205
                            this.Children.Remove(singleChild);
1468
                            this.Children.Remove(singleChild);
1206
                            parentPanel.Children.Insert(indexOfThisPanel, singleChild);
1469
                            parentPanel.Children.Insert(indexOfThisPanel, singleChild);
1207
 
1470
 
1208
                            if (parentPanel.Orientation == Orientation.Horizontal)
1471
                            if (parentPanel.Orientation == Orientation.Horizontal)
1209
                            {
1472
                            {
1210
                                SetResizeWidth(singleChild, GetResizeWidth(this));
1473
                                SetResizeWidth(singleChild, GetResizeWidth(this));
1211
                            }
1474
                            }
1212
                            else
1475
                            else
1213
                            {
1476
                            {
1214
                                SetResizeHeight(singleChild, GetResizeHeight(this));
1477
                                SetResizeHeight(singleChild, GetResizeHeight(this));
1215
                            }
1478
                            }
1216
                        }
1479
                        }
1217
                    }
1480
                    }
1218
                    else if (Parent is DockingManager)
1481
                    else if (Parent is DockingManager)
1219
                    {
1482
                    {
1220
                        DockingManager manager = Parent as DockingManager;
1483
                        DockingManager manager = Parent as DockingManager;
1221
                        if (manager != null)
1484
                        if (manager != null)
1222
                        {
1485
                        {
1223
                            this.Children.Remove(singleChild);
1486
                            this.Children.Remove(singleChild);
1224
                            manager.Content = singleChild;
1487
                            manager.Content = singleChild;
1225
                        }
1488
                        }
1226
                    }
1489
                    }
1227
 
1490
 
1228
                }
1491
                }
1229
            }
1492
            }
1230
            else
1493
            else
1231
            {
1494
            {
1232
                ResizingPanel parentPanel = Parent as ResizingPanel;
1495
                ResizingPanel parentPanel = Parent as ResizingPanel;
1233
                if (parentPanel != null)
1496
                if (parentPanel != null)
1234
                {
1497
                {
1235
                    parentPanel.RemoveChild(this);
1498
                    parentPanel.RemoveChild(this);
1236
                }
1499
                }
1237
            }
1500
            }
1238
        }
1501
        }
1239
 
1502
 
1240
        /// <summary>
1503
        /// <summary>
1241
        /// Insert a new child element into the children collection.
1504
        /// Insert a new child element into the children collection.
1242
        /// </summary>
1505
        /// </summary>
1243
        /// <param name="childToInsert">New child element to insert.</param>
1506
        /// <param name="childToInsert">New child element to insert.</param>
1244
        /// <param name="relativeChild">Child after or before which <see cref="childToInsert"/> element must be insert.</param>
1507
        /// <param name="relativeChild">Child after or before which <see cref="childToInsert"/> element must be insert.</param>
1245
        /// <param name="next">True if new child must be insert after the <see cref="relativeChild"/> element. False otherwise.</param>
1508
        /// <param name="next">True if new child must be insert after the <see cref="relativeChild"/> element. False otherwise.</param>
1246
        internal void InsertChildRelativeTo(FrameworkElement childToInsert, FrameworkElement relativeChild, bool next)
1509
        internal void InsertChildRelativeTo(FrameworkElement childToInsert, FrameworkElement relativeChild, bool next)
1247
        {
1510
        {
1248
            int childRelativeIndex = Children.IndexOf(relativeChild);
1511
            int childRelativeIndex = Children.IndexOf(relativeChild);
1249
 
1512
 
1250
            Debug.Assert(childRelativeIndex != -1);
1513
            Debug.Assert(childRelativeIndex != -1);
1251
 
1514
 
1252
            Children.Insert(
1515
            Children.Insert(
1253
                next ? childRelativeIndex + 1 : childRelativeIndex, childToInsert);
1516
                next ? childRelativeIndex + 1 : childRelativeIndex, childToInsert);
1254
 
1517
 
1255
            SetupSplitters();
1518
            SetupSplitters();
-
 
1519
 
-
 
1520
            InvalidateMeasure();
1256
        }
1521
        }
-
 
1522
 
-
 
1523
       
1257
 
1524
 
1258
 
1525
 
1259
    }
1526
    }
1260
 
1527
 
1261
 
1528
 
1262
    internal static class ResizingPanelExFuncs
1529
    internal static class ResizingPanelExFuncs
1263
    {
1530
    {
1264
        public static double GetAbsoluteValue(this FrameworkElement child)
1531
        public static double GetAbsoluteValue(this FrameworkElement child)
1265
        {
1532
        {
1266
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1533
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1267
            GridLength len = parentPanel.Orientation == Orientation.Horizontal ? ResizingPanel.GetResizeWidth(child) : ResizingPanel.GetResizeHeight(child);
1534
            GridLength len = parentPanel.Orientation == Orientation.Horizontal ? ResizingPanel.GetResizeWidth(child) : ResizingPanel.GetResizeHeight(child);
1268
            if (!len.IsAbsolute)
1535
            if (!len.IsAbsolute)
1269
                throw new InvalidOperationException();
1536
                throw new InvalidOperationException();
1270
            return len.Value;
1537
            return len.Value;
1271
        }
1538
        }
1272
 
1539
 
1273
        public static double GetStarValue(this FrameworkElement child)
1540
        public static double GetStarValue(this FrameworkElement child)
1274
        {
1541
        {
1275
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1542
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1276
            GridLength len = parentPanel.Orientation == Orientation.Horizontal ? ResizingPanel.GetResizeWidth(child) : ResizingPanel.GetResizeHeight(child);
1543
            GridLength len = parentPanel.Orientation == Orientation.Horizontal ? ResizingPanel.GetResizeWidth(child) : ResizingPanel.GetResizeHeight(child);
1277
            if (!len.IsStar)
1544
            if (!len.IsStar)
1278
                throw new InvalidOperationException();
1545
                throw new InvalidOperationException();
1279
            return len.Value;
1546
            return len.Value;
1280
        }
1547
        }
1281
 
1548
 
1282
        public static bool IsStar(this FrameworkElement child)
1549
        public static bool IsStar(this FrameworkElement child)
1283
        {
1550
        {
1284
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1551
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1285
            return parentPanel.Orientation == Orientation.Horizontal ?
1552
            return parentPanel.Orientation == Orientation.Horizontal ?
1286
                ResizingPanel.GetResizeWidth(child).IsStar :
1553
                ResizingPanel.GetResizeWidth(child).IsStar :
1287
                ResizingPanel.GetResizeHeight(child).IsStar;
1554
                ResizingPanel.GetResizeHeight(child).IsStar;
1288
        }
1555
        }
1289
        public static bool IsAbsolute(this FrameworkElement child)
1556
        public static bool IsAbsolute(this FrameworkElement child)
1290
        {
1557
        {
1291
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1558
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1292
            return parentPanel.Orientation == Orientation.Horizontal ?
1559
            return parentPanel.Orientation == Orientation.Horizontal ?
1293
                ResizingPanel.GetResizeWidth(child).IsAbsolute :
1560
                ResizingPanel.GetResizeWidth(child).IsAbsolute :
1294
                ResizingPanel.GetResizeHeight(child).IsAbsolute;
1561
                ResizingPanel.GetResizeHeight(child).IsAbsolute;
1295
        }
1562
        }
1296
 
1563
 
1297
        public static bool IsAuto(this FrameworkElement child)
1564
        public static bool IsAuto(this FrameworkElement child)
1298
        {
1565
        {
1299
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1566
            ResizingPanel parentPanel = LogicalTreeHelper.GetParent(child) as ResizingPanel;
1300
            return parentPanel.Orientation == Orientation.Horizontal ?
1567
            return parentPanel.Orientation == Orientation.Horizontal ?
1301
                ResizingPanel.GetResizeWidth(child).IsAuto :
1568
                ResizingPanel.GetResizeWidth(child).IsAuto :
1302
                ResizingPanel.GetResizeHeight(child).IsAuto;
1569
                ResizingPanel.GetResizeHeight(child).IsAuto;
1303
        }
1570
        }
1304
 
1571
 
1305
    }
1572
    }
1306
 
1573
 
1307
}
1574
}
1308
 
1575