1:
2:
3:
4:

private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{ 
  //Hier halt den gerdrückten Knoten auswerten und entsprechendes UserControl anzeigen      
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Media;


namespace Irgendwas
{
    public partial class Form1 : Form
    {  
        public Form1()
        {
            InitializeComponent();
            treeView1.ImageList = imageList1;    
        }
      
        private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {

            // Alle Usercontrols
            User1Control1_Main7 US_7_Main = new User1Control1_Main7();
            User2Control1_Main7_Char US_7_Char = new User2Control1_Main7_Char();
            User5Control1_Main7_tips US_7_tips = new User5Control1_Main7_tips();
            User3Control1_Main7_secrets US_7_secrets = new User3Control1_Main7_secrets();
            User4Control1_Main7_Feindeskoennen US_7_feindeskoennen = new User4Control1_Main7_Feindeskoennen();
            User6Control1_Main7_Substanzen US_7_Substanzen = new User6Control1_Main7_Substanzen();
            User7Control1_Main7_Music US_7_Music = new User7Control1_Main7_Music();
            User8Control1_Main7_Bilder US_7_Bilder = new User8Control1_Main7_Bilder();
            User9Control1_Main7_Karte US_7_Karte = new User9Control1_Main7_Karte();
            User10Control1_Main7_waffen US_7_waffen = new User10Control1_Main7_waffen();
            User11Control1_Main7_squest US_7_Quests = new User11Control1_Main7_squest();
            User12Control1_Main7_Goldfort US_7_Goldfort = new User12Control1_Main7_Goldfort();
            User13Control1_Main7_Feinde US_7_Feinde = new User13Control1_Main7_Feinde();
            User14Control1_Main7_Chocobos US_7_Choco = new User14Control1_Main7_Chocobos();

            // Controls den Panels zuweisen
            US_7_Main.Parent = FF7_mainpan;
            US_7_Char.Parent = FF7_charpan;
            US_7_tips.Parent = FF7_tipspan;
            US_7_secrets.Parent = FF7_secretspan;
            US_7_feindeskoennen.Parent = FF7_feindeskoennenpan;
            US_7_Substanzen.Parent = FF7_substanzenpan;
            US_7_Music.Parent = FF7_musicpan;
            US_7_Bilder.Parent = FF7_bilderpan;
            US_7_Karte.Parent = FF7_Kartenpan;
            US_7_waffen.Parent = FF7_waffenpan;
            US_7_Quests.Parent = FF7_squestpan;
            US_7_Goldfort.Parent = FF7_Gold_fortpan;
            US_7_Feinde.Parent = FF7_feinespan;
            US_7_Choco.Parent = FF7_chocobopan;

            // Controls auf Fill setzen
            US_7_Main.Dock = DockStyle.Fill;
            US_7_Char.Dock = DockStyle.Fill;
            US_7_tips.Dock = DockStyle.Fill;
            US_7_secrets.Dock = DockStyle.Fill;
            US_7_feindeskoennen.Dock = DockStyle.Fill;
            US_7_Substanzen.Dock = DockStyle.Fill;
            US_7_Music.Dock = DockStyle.Fill;
            US_7_Bilder.Dock = DockStyle.Fill;
            US_7_Karte.Dock = DockStyle.Fill;
            US_7_waffen.Dock = DockStyle.Fill;
            US_7_Quests.Dock = DockStyle.Fill;
            US_7_Goldfort.Dock = DockStyle.Fill;
            US_7_Feinde.Dock = DockStyle.Fill;
            US_7_Choco.Dock = DockStyle.Fill;

            // Panels dem Splitcontainer zuweisen
            FF7_mainpan.Parent = splitContainer1.Panel2;
            FF7_charpan.Parent = splitContainer1.Panel2;
            FF7_tipspan.Parent = splitContainer1.Panel2;
            FF7_secretspan.Parent = splitContainer1.Panel2;
            FF7_feindeskoennenpan.Parent = splitContainer1.Panel2;
            FF7_substanzenpan.Parent = splitContainer1.Panel2;
            FF7_musicpan.Parent = splitContainer1.Panel2;
            FF7_bilderpan.Parent = splitContainer1.Panel2;
            FF7_Kartenpan.Parent = splitContainer1.Panel2;
            FF7_waffenpan.Parent = splitContainer1.Panel2;
            FF7_squestpan.Parent = splitContainer1.Panel2;
            FF7_Gold_fortpan.Parent = splitContainer1.Panel2;
            FF7_feinespan.Parent = splitContainer1.Panel2;
            FF7_chocobopan.Parent = splitContainer1.Panel2;

             //Panels Invisible machen
            FF7_mainpan.Visible = false; FF7_mainpan.Hide();
            FF7_charpan.Visible = false; FF7_charpan.Hide();
            FF7_tipspan.Visible = false; FF7_tipspan.Hide();
            FF7_secretspan.Visible = false; FF7_secretspan.Hide();
            FF7_feindeskoennenpan.Visible = false; FF7_feindeskoennenpan.Hide();
            FF7_substanzenpan.Visible = false; FF7_substanzenpan.Hide();
            FF7_musicpan.Visible = false; FF7_musicpan.Hide();
            FF7_bilderpan.Visible = false; FF7_bilderpan.Hide();
            FF7_Kartenpan.Visible = false; FF7_Kartenpan.Hide();
            FF7_waffenpan.Visible = false; FF7_waffenpan.Hide();
            FF7_squestpan.Visible = false; FF7_squestpan.Hide();
            FF7_Gold_fortpan.Visible = false; FF7_Gold_fortpan.Hide();
            FF7_feinespan.Visible = false; FF7_feinespan.Hide();
            FF7_chocobopan.Visible = false; FF7_chocobopan.Hide();

            // Switche die einzelnen Knoten
            if (e.Button == MouseButtons.Left)
            {  
                switch (e.Node.SelectedImageIndex)
                {
                    case 14:                   
                        FF7_mainpan.Show();
                        FF7_mainpan.Update();
                        FF7_mainpan.Visible = true;
                        break;

                    case 0:
                        FF7_charpan.Show();
                        FF7_charpan.Visible = true;
                        FF7_charpan.Update();
                        break;

                    case 4:
                        FF7_tipspan.Show();
                        FF7_tipspan.Visible = true;
                        FF7_tipspan.Update();
                        break;

                    case 5:
                        FF7_secretspan.Show();
                        FF7_secretspan.Visible = true;
                        FF7_secretspan.Update();
                        break;

                    case 6:
                        FF7_feindeskoennenpan.Show();
                        FF7_feindeskoennenpan.Visible = true;
                        FF7_feindeskoennenpan.Update();
                        break;

                    case 7:
                        FF7_substanzenpan.Show();
                        FF7_substanzenpan.Visible = true;
                        FF7_substanzenpan.Update();
                        break;

                    case 12:
                        FF7_musicpan.Show();
                        FF7_musicpan.Visible = true;
                        FF7_musicpan.Update();
                        break;

                    case 13:
                        FF7_bilderpan.Show();
                        FF7_bilderpan.Visible = true;
                        FF7_bilderpan.Update();
                        break;

                    case 3:
                        FF7_Kartenpan.Show();
                        FF7_Kartenpan.Visible = true;
                        FF7_Kartenpan.Update();
                        break;

                    default:
                        FF7_mainpan.Visible = false; FF7_mainpan.Hide();
                        FF7_charpan.Visible = false; FF7_charpan.Hide();
                        FF7_tipspan.Visible = false; FF7_tipspan.Hide();
                        FF7_secretspan.Visible = false; FF7_secretspan.Hide();
                        FF7_feindeskoennenpan.Visible = false; FF7_feindeskoennenpan.Hide();
                        FF7_substanzenpan.Visible = false; FF7_substanzenpan.Hide();
                        FF7_musicpan.Visible = false; FF7_musicpan.Hide();
                        FF7_bilderpan.Visible = false; FF7_bilderpan.Hide();
                        FF7_Kartenpan.Visible = false; FF7_Kartenpan.Hide();
                        FF7_feinespan.Visible = false;
                        FF7_chocobopan.Visible = false;
                        break;
                }   
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            Application.Exit();
        }

        private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {

        }
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace TabHideTest
{
    public partial class Form1 : Form
    {
        private List<HiddenTabPage> m_TabPages;

        public Form1()
        {
            InitializeComponent();

            m_TabPages = new List<HiddenTabPage>();
            int index = 0;
            foreach( TabPage tb in tabControl.TabPages )
            {
                m_TabPages.Add( new HiddenTabPage( tb, index ++ ));
            }
            tabControl.TabPages.Clear();

            // Initialize the Checked List Box
            foreach( HiddenTabPage hiddenTabPage in m_TabPages )
            {
                tabControlCheckListBox.Items.Add( hiddenTabPage );
            }

            tabControlCheckListBox.ItemCheck += new ItemCheckEventHandler( this.ItemCheckHandler );
        }

        private void ItemCheckHandler( object sender, ItemCheckEventArgs args )
        {
            HiddenTabPage tabPage = tabControlCheckListBox.Items[args.Index] as HiddenTabPage;
            if( ! tabPage.Visible && args.NewValue == CheckState.Checked ) // The page is currently not visible so we have to show it
            {                
                int insertPosition = GetInsertPosition( tabPage.Index );
                if( insertPosition != -1 )
                {
                    tabControl.TabPages.Insert( insertPosition, tabPage.TabPage );
                }
                else
                {
                    tabControl.TabPages.Add( tabPage.TabPage );
                }
                tabPage.Visible = true;
            }
            else
            {
                if( tabControl.TabPages.Count > 0 )
                {
                    foreach( TabPage tb in tabControl.TabPages )
                    {
                        if( tb.Equals( tabPage.TabPage ))
                        {
                            tabControl.TabPages.Remove( tb );
                            tabPage.Visible = false;
                            return;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Determines the correct insert position for the Tab
        /// </summary>
        /// <param name="toInsert">The index at which the Tab wanted to be placed</param>
        /// <returns>the real position at which the Tab needs to be inserted</returns>
        private int GetInsertPosition( int toInsert )
        {
            int[] shownIndexes = new int[tabControl.TabPages.Count];
            int index = 0;
            foreach( HiddenTabPage hiddenTabPage in m_TabPages )
            {
                if( hiddenTabPage.Visible ) shownIndexes[index++] = hiddenTabPage.Index;
            }

            int insertPos = 0;
            for( index = 0; index < shownIndexes.Length; index ++ )
            {
                try
                {
                    if( toInsert > shownIndexes[index] && toInsert < shownIndexes[index+1] )
                    {
                        insertPos = index +1;
                    }
                }
                catch
                {
                    insertPos = -1;
                }
            }

            return insertPos;
        }
    }

    internal class HiddenTabPage
    {
        private TabPage m_TabPage;
        private int m_Index;
        private bool m_Visible;

        public HiddenTabPage( TabPage tabPage, int index )
        {
            m_TabPage = tabPage;
            m_Index = index;
            m_Visible = false;
        }

        public TabPage TabPage
        {
            get
            {
                return m_TabPage;
            }

            set
            {
                m_TabPage = value;
            }
        }

        public bool Visible
        {
            get
            {
                return m_Visible;
            }

            set
            {
                m_Visible = value;
            }
        }

        public int Index
        {
            get
            {
                return m_Index;
            }
        }

        public override string ToString()
        {
            return m_TabPage.Text;
        }
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

namespace TabHideTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            treeView1.ImageList = imageList1;
            tabControl.ImageList = imageList1;
        }

        private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if (treeView1.SelectedImageIndex == 0)
            {
                tabControl.SelectedTab = tabPage1;
                tabControl.TabPages.Remove(tabControl.SelectedTab);

            }
        }
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:

namespace Controls
{
    [DefaultProperty("SelectedPanel")]
    [DefaultEvent("SelectedIndexChanged")]
    [Designer(typeof(Design.PanelManagerDesigner))]
    public class PanelManager : System.Windows.Forms.Control
    {
        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public PanelManager()
        {
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();

            // TODO: Add any initialization after the InitializeComponent call

        }

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code
        /// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
        }
        #endregion

        private Controls.ManagedPanel m_SelectedPanel;

        public event EventHandler SelectedIndexChanged;

        //ManagedPanels
        [Editor(typeof(Editors.ManagedPanelCollectionEditor), typeof(UITypeEditor))]
        public ControlCollection ManagedPanels
        {
            get { return base.Controls; }
        }


        //SelectedPanel
        [TypeConverter(typeof(TypeConverters.SelectedPanelConverter))]
        public Controls.ManagedPanel SelectedPanel
        {
            get { return m_SelectedPanel; }
            set
            {
                if (m_SelectedPanel == value) return;
                m_SelectedPanel = value;
                OnSelectedPanelChanged(EventArgs.Empty);
            }
        }


        //SelectedIndex
        [Browsable(false)]
        public int SelectedIndex
        {
            get { return this.ManagedPanels.IndexOf((ManagedPanel)this.SelectedPanel); }
            set
            {
                if (value == -1)
                    this.SelectedPanel = null;
                else
                    this.SelectedPanel = (ManagedPanel)this.ManagedPanels[value];
            }
        }


        //DefaultSize
        protected override Size DefaultSize
        {
            get
            {
                return new Size(200, 100);
            }
        }


        private ManagedPanel oldSelection = null;

        protected void OnSelectedPanelChanged(EventArgs e)
        {
            if (oldSelection != null)
                oldSelection.Visible = false;

            if (m_SelectedPanel != null)
                ((Controls.ManagedPanel)m_SelectedPanel).Visible = true;

            bool tabChanged = false;
            if (m_SelectedPanel == null)
                tabChanged = (oldSelection != null);
            else
                tabChanged = (!m_SelectedPanel.Equals(oldSelection));

            if (tabChanged && this.Created)
                if (SelectedIndexChanged != null)
                    SelectedIndexChanged(this, EventArgs.Empty);

            oldSelection = (Controls.ManagedPanel)m_SelectedPanel;

        }


        protected override void OnControlAdded(ControlEventArgs e)
        {
            if ((e.Control is Controls.ManagedPanel) == false)
                throw new ArgumentException("Only Mangel.Controls.ManagedPanels can be added to a Mangel.Controls.PanelManger.");

            if (this.SelectedPanel != null)
                ((Controls.ManagedPanel)this.SelectedPanel).Visible = false;

            this.SelectedPanel = (Controls.ManagedPanel)e.Control;
            e.Control.Visible = true;
            base.OnControlAdded(e);
        }


        protected override void OnControlRemoved(ControlEventArgs e)
        {
            if (e.Control is Controls.ManagedPanel)
            {
                if (this.ManagedPanels.Count > 0)
                    this.SelectedIndex = 0;
                else
                    this.SelectedPanel = null;
            }
            base.OnControlRemoved(e);
        }


    }


    [Designer(typeof(Design.ManagedPanelDesigner))]
    [ToolboxItem(false)]
    public class ManagedPanel : System.Windows.Forms.ScrollableControl
    {

        public ManagedPanel()
        {
            base.Dock = DockStyle.Fill;
            SetStyle(ControlStyles.ResizeRedraw, true);
        }


        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DefaultValue(typeof(DockStyle), "Fill")]
        public override DockStyle Dock
        {
            get
            {
                return base.Dock;
            }
            set
            {
                base.Dock = DockStyle.Fill;
            }
        }


        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        [DefaultValue(typeof(AnchorStyles), "None")]
        public override AnchorStyles Anchor
        {
            get
            {
                return AnchorStyles.None;
            }
            set
            {
                base.Anchor = AnchorStyles.None;
            }
        }


        protected override void OnLocationChanged(EventArgs e)
        {
            base.OnLocationChanged(e);
            base.Location = Point.Empty;
        }


        protected override void OnSizeChanged(EventArgs e)
        {
            base.OnSizeChanged(e);
            if (this.Parent == null)
                this.Size = Size.Empty;
            else
                this.Size = this.Parent.ClientSize;
        }


        protected override void OnParentChanged(EventArgs e)
        {
            if ((this.Parent is Controls.PanelManager) == false && this.Parent != null)
                throw new ArgumentException("Managed Panels may only be added to a Panel Manager.");
            base.OnParentChanged(e);
        }


    }


}


namespace Design
{
    public class PanelManagerDesigner : System.Windows.Forms.Design.ParentControlDesigner
    {
        private DesignerVerbCollection m_verbs = new DesignerVerbCollection();
        private IDesignerHost m_DesignerHost;
        private ISelectionService m_SelectionService;

        private Controls.PanelManager HostControl
        {
            get { return (Controls.PanelManager)this.Control; }
        }


        public PanelManagerDesigner()
            : base()
        {
            DesignerVerb verb1 = new DesignerVerb("Add MangedPanel", new EventHandler(OnAddPanel));
            DesignerVerb verb2 = new DesignerVerb("Remove ManagedPanel", new EventHandler(OnRemovePanel));
            m_verbs.AddRange(new DesignerVerb[] { verb1, verb2 });
        }


        protected override void OnPaintAdornments(PaintEventArgs pe)
        {
            // Don't want DrawGrid Dots.
        }


        public override DesignerVerbCollection Verbs
        {
            get
            {
                if (m_verbs.Count == 2)
                    m_verbs[1].Enabled = HostControl.ManagedPanels.Count > 0;
                return m_verbs;
            }
        }


        public IDesignerHost DesignerHost
        {
            get
            {
                if (m_DesignerHost == null)
                    m_DesignerHost = (IDesignerHost)GetService(typeof(IDesignerHost));
                return m_DesignerHost;
            }
        }


        public ISelectionService SelectionService
        {
            get
            {
                if (m_SelectionService == null)
                    m_SelectionService = (ISelectionService)GetService(typeof(ISelectionService));

                return m_SelectionService;
            }
        }


        private void OnAddPanel(Object sender, EventArgs e)
        {
            Control.ControlCollection oldManagedPanels = HostControl.Controls;

            RaiseComponentChanging(TypeDescriptor.GetProperties(HostControl)["ManagedPanels"]);

            Controls.ManagedPanel P = (Controls.ManagedPanel)DesignerHost.CreateComponent(typeof(Controls.ManagedPanel));
            P.Text = P.Name;
            HostControl.ManagedPanels.Add(P);

            RaiseComponentChanged(TypeDescriptor.GetProperties(HostControl)["ManagedPanels"], oldManagedPanels, HostControl.ManagedPanels);
            HostControl.SelectedPanel = P;

            SetVerbs();
        }


        private void OnRemovePanel(Object sender, EventArgs e)
        {
            Control.ControlCollection oldManagedPanels = HostControl.Controls;

            if (HostControl.SelectedIndex < 0) return;

            RaiseComponentChanging(TypeDescriptor.GetProperties(HostControl)["TabPages"]);

            DesignerHost.DestroyComponent((Controls.ManagedPanel)HostControl.ManagedPanels[HostControl.SelectedIndex]);

            RaiseComponentChanged(TypeDescriptor.GetProperties(HostControl)["ManagedPanels"], oldManagedPanels, HostControl.ManagedPanels);

            SelectionService.SetSelectedComponents(new IComponent[] { HostControl }, SelectionTypes.Normal);

            SetVerbs();
        }


        private void SetVerbs()
        {
            Verbs[1].Enabled = HostControl.ManagedPanels.Count == 1;
        }


        protected override void PostFilterProperties(IDictionary properties)
        {
            properties.Remove("AutoScroll");
            properties.Remove("AutoScrollMargin");
            properties.Remove("AutoScrollMinSize");
            properties.Remove("Text");
            base.PostFilterProperties(properties);
        }


        public override void OnSetComponentDefaults()
        {
            HostControl.ManagedPanels.Add((Controls.ManagedPanel)DesignerHost.CreateComponent(typeof(Controls.ManagedPanel)));
            HostControl.ManagedPanels.Add((Controls.ManagedPanel)DesignerHost.CreateComponent(typeof(Controls.ManagedPanel)));
            Controls.PanelManager pm = (Controls.PanelManager)this.Control;
            pm.ManagedPanels[0].Text = pm.ManagedPanels[0].Name;
            pm.ManagedPanels[1].Text = pm.ManagedPanels[1].Name;
            HostControl.SelectedIndex = 0;
        }

    }


    public class ManagedPanelDesigner : System.Windows.Forms.Design.ScrollableControlDesigner
    {

        private DesignerVerbCollection m_verbs = new DesignerVerbCollection();
        private ISelectionService m_SelectionService;

        private Controls.ManagedPanel HostControl
        {
            get
            { return (Controls.ManagedPanel)this.Control; }
        }


        public ISelectionService SelectionService
        {
            get
            {
                if (m_SelectionService == null)
                    m_SelectionService = (ISelectionService)GetService(typeof(ISelectionService));

                return m_SelectionService;
            }
        }


        public ManagedPanelDesigner()
            : base()
        {
            DesignerVerb verb1 = new DesignerVerb("Select PanelManager", new EventHandler(OnSelectManager));
            m_verbs.Add(verb1);
        }


        private void OnSelectManager(Object sender, EventArgs e)
        {
            if (this.HostControl.Parent != null)
                this.SelectionService.SetSelectedComponents(new Component[] { this.HostControl.Parent });
        }


        public override System.Windows.Forms.Design.SelectionRules SelectionRules
        {
            get
            {
                return System.Windows.Forms.Design.SelectionRules.Visible;
            }
        }


        protected override void OnPaintAdornments(PaintEventArgs pe)
        {
            base.OnPaintAdornments(pe);
            Color penColor;
            if (this.Control.BackColor.GetBrightness() >= 0.5)
                penColor = ControlPaint.Dark(this.Control.BackColor);
            else
                penColor = Color.White;

            Pen dashedPen = new Pen(penColor);
            Rectangle borderRectangle = this.Control.ClientRectangle;
            borderRectangle.Width -= 1;
            borderRectangle.Height -= 1;
            dashedPen.DashStyle = DashStyle.Dash;
            pe.Graphics.DrawRectangle(dashedPen, borderRectangle);
            dashedPen.Dispose();
        }


        public override DesignerVerbCollection Verbs
        {
            get
            {
                return m_verbs;
            }
        }


        protected override void PostFilterProperties(IDictionary properties)
        {
            properties.Remove("Anchor");
            properties.Remove("TabStop");
            properties.Remove("TabIndex");
            base.PostFilterProperties(properties);
        }


        public override void OnSetComponentDefaults()
        {
            base.OnSetComponentDefaults();
            this.Control.Visible = true;
        }


    }

}


namespace Editors
{
    public class ManagedPanelCollectionEditor : System.ComponentModel.Design.CollectionEditor
    {
        public ManagedPanelCollectionEditor(Type type) : base(type) { }

        protected override Type CreateCollectionItemType()
        {
            return typeof(Controls.ManagedPanel);
        }


    }

}


namespace TypeConverters
{
    public class SelectedPanelConverter : ReferenceConverter
    {
        public SelectedPanelConverter() : base(typeof(Controls.ManagedPanel)) { }

        protected override bool IsValueAllowed(ITypeDescriptorContext context, object value)
        {
            if (context != null)
            {
                Controls.PanelManager pm = (Controls.PanelManager)context.Instance;
                return pm.ManagedPanels.Contains((Controls.ManagedPanel)value);
            }
            return false;

        }

    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

private System.ComponentModel.IContainer components1 = null;

private void treeView1_AfterExpand(object sender, TreeViewEventArgs e)
        {
            this.components1 = new System.ComponentModel.Container();
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));

            if (e.Node.SelectedImageIndex == 0)
            {
                this.uC_Main7_main1 = new FinalFantasyMusik.UC_Main7_main();

                this.Pan_FF7_main.Controls.Add(this.uC_Main7_main1);
                // 
                // uC_Main7_main1
                // 
                // Backround imgae muss nicht gesetzt werden, denn es wurde schon im UC festgelegt
                //this.uC_Main7_main1.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("uC_Main7_main1.BackgroundImage")));
                //this.uC_Main7_main1.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch;
                this.uC_Main7_main1.Location = new System.Drawing.Point(0, 0);
                this.uC_Main7_main1.Name = "uC_Main7_main1";
                this.uC_Main7_main1.Size = new System.Drawing.Size(847, 1202);
                this.uC_Main7_main1.TabIndex = 0;
            }