Click here to Skip to main content
Click here to Skip to main content
 
Add your own
alternative version

SVG Artiste - An SVG Editor

, 3 Aug 2010 CPOL
A Vector based tool to create and edit SVG images
SVGArtiste2_exe.zip
SvgArtiste.exe
SvgArtiste.vshost.exe.manifest
SVGLib.dll
Crom.Controls.dll
Draw.dll
SVGArtiste2_SampleSVGDrawings.zip
mercialago18.svg
SVGArtiste.svg
SVGArtiste2_src.zip
SVGLib
SVGLib.csproj.user
SVGLib.ndoc
SvgArtiste2.suo
Crom.Controls
Dock16x16.bmp
Internal
Docking
ControlCollections
Controls
DockButtons
Forms
Engine
Enums
EventArgs
Helpers
SharedHelpers
Properties
Public
Docking
Enums
EventArgs
Helpers
Renderers
TabbedDocument
Controls
Enums
Helpers
Renderers
Base
Draw
Command
Draw.csproj.user
RulerControl
Ruler.bmp
SvgArtiste2
Properties
Settings.settings
Resources
cancel.png
Ellipse.cur
exit.png
exit1.png
Line.cur
new.png
new_page.png
open.png
open1.png
pan.cur
pan_close.cur
Pencil.cur
Rectangle.cur
save.png
save_as.png
save_as1.png
Text.cur
SVGArtiste.csproj.user
Tools
Forms
UserControls
/***************************************************************************
 *   CopyRight (C) 2009 by Cristinel Mazarine                              *
 *   Author:   Cristinel Mazarine                                          *
 *   Contact:  cristinel@osec.ro                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the Crom Free License as published by           *
 *   the SC Crom-Osec SRL; version 1 of the License                        *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   Crom Free License for more details.                                   *
 *                                                                         *
 *   You should have received a copy of the Crom Free License along with   *
 *   this program; if not, write to the contact@osec.ro                    *
 ***************************************************************************/

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

using Crom.Controls.TabbedDocument;

namespace Crom.Controls.Docking
{
   /// <summary>
   /// Tabed host control
   /// </summary>
   internal class FormsTabbedView : ButtonsPanel
   {
      #region Fields

      private FormsTabbedViewControlCollection _controls = null;

      private bool                     _isDocked               = false;
      private DockStyle                _hostContainerDock      = Globals.DockNotSet;
      private DockStyle                _dock                   = Globals.DockNotSet;
      private zDockMode                _dockMode               = zDockMode.Inner;
      private Size                     _floatingSize           = new Size();
      private Form                     _selectedForm           = null;
      private List<DockableFormInfo>   _cachedInfos            = new List<DockableFormInfo>();

      private int                      _movedIndex             = -1;
      private Form                     _movedForm              = null;
      private TabButton                _movedButton            = null;
      private FormsDecorator           _movedDecorator         = null;

      #endregion Fields

      #region Instance

      /// <summary>
      /// Constructor
      /// </summary>
      /// <param name="pagesPanel">pages panel</param>
      public FormsTabbedView()
      {
         PagesPanel.ContextButtonClick   += OnPagesContextMenuClick;
         PagesPanel.AutohideButtonClick  += OnPagesAutohideClick;
         PagesPanel.CloseButtonClick     += OnPagesCloseClick;
         PagesPanel.ColorsChanged        += OnPagesColorsChanged;
      }

      #endregion Instance

      #region Public section

      /// <summary>
      /// Undock a form
      /// </summary>
      public event EventHandler<FormEventArgs> UndockForm;

      /// <summary>
      /// Occurs when autohide button was clicked
      /// </summary>
      public event EventHandler AutohideClick;

      /// <summary>
      /// Occurs when context menu button was clicked
      /// </summary>
      public event EventHandler<FormEventArgs> ContextMenuClick;

      /// <summary>
      /// Occurs when a form is closing
      /// </summary>
      public event EventHandler<DockableFormClosingEventArgs> FormClosing;

      /// <summary>
      /// Occurs when close button was clicked
      /// </summary>
      public event EventHandler<FormEventArgs> FormClosed;

      /// <summary>
      /// Occurs when a form was removed from view
      /// </summary>
      public event EventHandler<FormEventArgs> FormRemoved;

      /// <summary>
      /// Occurs when a form was added to view
      /// </summary>
      public event EventHandler<FormEventArgs> FormAdded;

      /// <summary>
      /// Occurs when a form was selected into view
      /// </summary>
      public event EventHandler<FormEventArgs> FormSelected;


      /// <summary>
      /// Gets the count of available pages
      /// </summary>
      public int Count
      {
         get { return base.ButtonsCount; }
      }

      /// <summary>
      /// Add a new tab page
      /// </summary>
      /// <param name="pageInfo">tab page info</param>
      public void Add(DockableFormInfo pageInfo)
      {
         if (pageInfo.AllowedDock != AllowedDock && AllowedDock != zAllowedDock.Unknown)
         {
            throw new InvalidOperationException("Err");
         }

         pageInfo.DockableForm.SetBounds(-15000, 0, PagesPanel.Width, PagesPanel.Height);
         pageInfo.DockableForm.Dock = DockStyle.None;
         PagesPanel.Add(pageInfo.DockableForm);

         _cachedInfos.Add(pageInfo);

         pageInfo.ExplicitDisposing += OnInfoDisposing;
         pageInfo.SelectedChanged   += OnInfoSelectedChanged;

         pageInfo.HostContainerDock = HostContainerDock;

         pageInfo.DockableForm.FormClosing   += OnPageClosing;
         pageInfo.DockableForm.FormClosed    += OnPageClosed;
         pageInfo.DockableForm.ParentChanged += OnPageParentChanged;

         AddButton(pageInfo.Button);

         IsFocused = true;
      }

      /// <summary>
      /// Remove an existing tab page
      /// </summary>
      /// <param name="pageInfo">page info to be removed</param>
      public bool Remove(DockableFormInfo pageInfo)
      {
         return RemoveButton(pageInfo.Button);
      }

      /// <summary>
      /// Move all the pages to given view
      /// </summary>
      /// <param name="view">view where to move the pages</param>
      /// <returns>moved pages</returns>
      public DockableFormInfo[] MovePagesTo(FormsTabbedView view)
      {
         List<DockableFormInfo> movedPages = new List<DockableFormInfo>();

         if (view == this)
         {
            return movedPages.ToArray();
         }


         for (int index = _cachedInfos.Count - 1; index >= 0; index--)
         {
            DockableFormInfo info = _cachedInfos[index];
            Remove(info);
            view.Add(info);

            movedPages.Add(info);
         }

         return movedPages.ToArray();
      }

      /// <summary>
      /// Get the page at given index
      /// </summary>
      /// <param name="pageIndex">zero based page index</param>
      /// <returns>page at given index</returns>
      public Form GetPageAt(int pageIndex)
      {
         TabButton buton = GetButtonAt(pageIndex);
         if (buton == null)
         {
            return null;
         }

         return (Form)buton.Page;
      }

      /// <summary>
      /// Get page info at given index
      /// </summary>
      /// <param name="pageIndex">zero based page index</param>
      /// <returns>info</returns>
      public DockableFormInfo GetPageInfoAt(int pageIndex)
      {
         ValidateNotDisposed();

         Form page = GetPageAt(pageIndex);
         if (page == null)
         {
            return null;
         }

         return GetPageInfo(page);
      }

      /// <summary>
      /// Gets the page info
      /// </summary>
      /// <remarks>Throw an exception if the form is not part of this view</remarks>
      /// <param name="form">form</param>
      /// <returns>info</returns>
      public DockableFormInfo GetPageInfo(Form form)
      {
         foreach (DockableFormInfo cachedInfo in _cachedInfos)
         {
            if (cachedInfo.DockableForm == form)
            {
               return cachedInfo;
            }
         }

         throw new InvalidOperationException("Err");
      }

      /// <summary>
      /// Gets the index of the page
      /// </summary>
      /// <param name="page">page</param>
      /// <returns>index of the page</returns>
      public int GetPageIndex(Form page)
      {
         int pageIndex  = -1;

         for (int index = 0; index < Count; index++)
         {
            if (GetPageAt(index) == page)
            {
               pageIndex = index;
               break;
            }
         }

         return pageIndex;
      }

      /// <summary>
      /// Get pages
      /// </summary>
      /// <returns>pages</returns>
      public Form[] GetPages()
      {
         Form[] pages = new Form[Count];
         for (int index = 0; index < Count; index++)
         {
            pages[index] = GetPageAt(index);
         }

         return pages;
      }

      /// <summary>
      /// Select given page
      /// </summary>
      /// <param name="page">page</param>
      public void SelectPage(Form page)
      {
         for (int index = 0; index < Count; index++)
         {
            if (page == GetPageAt(index))
            {
               SelectedIndex = index;
               return;
            }
         }
      }

      /// <summary>
      /// Change is docked state
      /// </summary>
      public bool IsDocked
      {
         get { return _isDocked; }
         private set
         {
            if (_isDocked != value)
            {
               _isDocked = value;
               PagesPanel.CanResizeByMouse = IsDocked == false;
               SetCutRoundRect(IsDocked == false && HostContainerDock != Globals.DockAutoHide, true);
            }
         }
      }

      /// <summary>
      /// Flag indicating if can move the control
      /// </summary>
      public bool CanMoveByMouse
      {
         get { return PagesPanel.CanMoveByMouse; }
         set { PagesPanel.CanMoveByMouse = value; }
      }

      /// <summary>
      /// Accessor of IsAutoHideMode flag
      /// </summary>
      public bool IsAutoHideMode
      {
         get
         {
            ValidateNotDisposed();

            if (_cachedInfos.Count > 0)
            {
               return _cachedInfos[0].IsAutoHideMode;
            }

            return false;
         }
         set
         {
            ValidateNotDisposed();

            if (IsAutoHideMode != value)
            {
               foreach (DockableFormInfo info in _cachedInfos)
               {
                  info.IsAutoHideMode = value;
               }
            }
         }
      }

      /// <summary>
      /// Change is focused state
      /// </summary>
      public bool IsFocused
      {
         get { return PagesPanel.IsFocused; }
         set 
         {
            if (PagesPanel.IsFocused != value)
            {
               PagesPanel.IsFocused = value;

               if (value && SelectedForm != null)
               {
                  SelectedForm.Activate();
                  SelectedForm.Focus();
               }
            }
         }
      }

      /// <summary>
      /// Accessor for allowed dock
      /// </summary>
      public zAllowedDock AllowedDock
      {
         get
         {
            ValidateNotDisposed();

            if (_cachedInfos.Count > 0)
            {
               return _cachedInfos[0].AllowedDock;
            }

            return zAllowedDock.Unknown;
         }
      }

      /// <summary>
      /// Accessor of the logical dock
      /// </summary>
      public DockStyle HostContainerDock
      {
         get { return _hostContainerDock; }
      }

      /// <summary>
      /// Accessor of the dock
      /// </summary>
      public DockStyle CurrentDock
      {
         get { return _dock; }
      }

      /// <summary>
      /// Accessor of the logical dock mode
      /// </summary>
      public zDockMode CurrentDockMode
      {
         get { return _dockMode; }
      }

      /// <summary>
      /// Accessor of the floating size
      /// </summary>
      public Size FloatingSize
      {
         get { return _floatingSize; }
      }

      /// <summary>
      /// Save floating size
      /// </summary>
      public void SaveFloatingSize()
      {
         _floatingSize = Size;
      }

      /// <summary>
      /// Set logical dock
      /// </summary>
      /// <param name="hostContainerDock">host container dock</param>
      /// <param name="dock">dock</param>
      /// <param name="mode">mode</param>
      public void SetDock(DockStyle hostContainerDock, DockStyle dock, zDockMode mode)
      {
         if (_hostContainerDock != hostContainerDock)
         {
            if (AllowedDock != zAllowedDock.Unknown)
            {
               bool isAllowed = false;
               switch (hostContainerDock)
               {
                  case DockStyle.Left:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.Left);
                     break;

                  case DockStyle.Right:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.Right);
                     break;

                  case DockStyle.Top:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.Top);
                     break;

                  case DockStyle.Bottom:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.Bottom);
                     break;

                  case DockStyle.None:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.None);
                     break;

                  case DockStyle.Fill:
                     isAllowed = EnumUtility.Contains(AllowedDock, zAllowedDock.Fill);
                     break;

                  case Globals.DockAutoHide:
                     isAllowed = _hostContainerDock == DockStyle.Left  || 
                                 _hostContainerDock == DockStyle.Right || 
                                 _hostContainerDock == DockStyle.Top   ||
                                 _hostContainerDock == DockStyle.Bottom;
                     break;
               }

               if (isAllowed == false)
               {
                  throw new NotSupportedException("Err");
               }
            }

            _hostContainerDock = hostContainerDock;

            IsDocked = hostContainerDock != DockStyle.None && hostContainerDock != Globals.DockAutoHide;

            PagesPanel.ShowAutohideButton = (hostContainerDock != DockStyle.None && hostContainerDock != DockStyle.Fill);
         }

         _dock     = dock;
         _dockMode = mode;

         foreach (DockableFormInfo info in _cachedInfos)
         {
            info.HostContainerDock = _hostContainerDock;
            info.Dock     = _dock;
            info.DockMode = _dockMode;
         }
      }

      /// <summary>
      /// Positioner
      /// </summary>
      public ControlPositioner Positioner
      {
         get { return PagesPanel.Positioner; }
         set { PagesPanel.Positioner = value; }
      }

      /// <summary>
      /// Accessor of the text
      /// </summary>
      public override string Text
      {
         get
         {
            if (SelectedForm != null)
            {
               return SelectedForm.Text;
            }

            return string.Empty;
         }
         set
         {
            if (SelectedForm != null)
            {
               SelectedForm.Text = value;
            }
         }
      }

      /// <summary>
      /// Accessor of the icon
      /// </summary>
      public Icon Icon
      {
         get
         {
            if (SelectedForm != null)
            {
               return SelectedForm.Icon;
            }

            return null;
         }
         set
         {
            if (SelectedForm != null)
            {
               SelectedForm.Icon = value;
            }
         }
      }

      /// <summary>
      /// Accessor of the selected form
      /// </summary>
      public Form SelectedForm
      {
         get { return _selectedForm; }
         private set 
         {
            if (_selectedForm != value)
            {
               DockableFormInfo info = null;
               if (value != null)
               {
                  info = GetPageInfo(value);
               }

               _selectedForm = value;

               PagesPanel.SelectForm(_selectedForm);

               EventHandler<FormEventArgs> handler = FormSelected;
               if (handler != null)
               {
                  FormEventArgs args = null;
                  if (info != null)
                  {
                     args = new FormEventArgs(info.DockableForm, info.Id);
                  }
                  else
                  {
                     args = new FormEventArgs(null, Guid.Empty);
                  }
                  handler(this, args);
               }
            }
         }
      }

      /// <summary>
      /// Accessor of the pages panel
      /// </summary>
      public FormsDecorator PagesPanel
      {
         get { return InternalControls.PagesPanel; }
      }

      /// <summary>
      /// Text representation of this view
      /// </summary>
      /// <returns>text representation of this view</returns>
      public override string ToString()
      {
         if (SelectedForm != null)
         {
            return "FTV: " + SelectedForm.Text;
         }

         return "FTV";
      }

      #endregion Public section.

      #region Protected section

      /// <summary>
      /// Create controls
      /// </summary>
      /// <returns>controls</returns>
      protected override ControlCollection CreateControlsInstance()
      {
         return InternalControls;
      }

      /// <summary>
      /// Occurs when the pages panel bounds were changed
      /// </summary>
      /// <param name="bounds">new bounds</param>
      protected override void OnPagesPanelBoundsChanged(Rectangle bounds)
      {
         if (PagesPanel != null)
         {
            PagesPanel.SetBounds(bounds.X, bounds.Y, bounds.Width, bounds.Height);
            OnSelectedIndexSet(EventArgs.Empty);
         }

         base.OnPagesPanelBoundsChanged(bounds);
      }

      /// <summary>
      /// Occurs after selected index was set
      /// </summary>
      /// <param name="e">event argument</param>
      protected override void OnSelectedIndexSet(EventArgs e)
      {
         DockableFormInfo info = GetPageInfoAt(SelectedIndex);
         if (info != null)
         {
            info.IsSelected   = true;
            SelectedForm      = info.DockableForm;
         }

         Invalidate();

         base.OnSelectedIndexSet(e);
      }

      /// <summary>
      /// Gets the margins for pages panel
      /// </summary>
      protected override int PagesPanelMargins
      {
         get { return 4; }
      }

      /// <summary>
      /// Gets the radius for round rect
      /// </summary>
      protected override int RoundRadius
      {
         get { return 2; }
      }

      /// <summary>
      /// Count of caption buttons
      /// </summary>
      protected override int CaptionButtonsCount
      {
         get { return 0; }
      }

      /// <summary>
      /// Set cut round rect state
      /// </summary>
      /// <param name="cutRect">cut rect</param>
      /// <param name="forceNow">force now</param>
      protected void SetCutRoundRect(bool cutRect, bool forceNow)
      {
         CutRoundRect = cutRect;

         if (forceNow)
         {
            UpdateSize();
         }
      }

      /// <summary>
      /// Draw round border
      /// </summary>
      /// <param name="e">e</param>
      protected override void DrawRoundBorder(PaintEventArgs e)
      {
         if (CutRoundRect)
         {
            base.DrawRoundBorder(e);
         }
      }

      /// <summary>
      /// Begin button drag
      /// </summary>
      /// <param name="selected">selected button</param>
      /// <param name="mousePosition">mouse position</param>
      /// <param name="cursor">cursor</param>
      /// <returns>true if button drag is started</returns>
      protected override bool BeginButtonDrag(TabButton selected, Point mousePosition, ref Cursor cursor)
      {
         if (CanMoveByMouse == false)
         {
            return true;
         }

         EventHandler<FormEventArgs> handler = UndockForm;
         if (handler != null)
         {
            _movedButton   = selected;
            _movedForm     = (Form)_movedButton.Page;
            _movedIndex    = SelectedIndex;

            Point mouseScreenPosition = Control.MousePosition;
            FormEventArgs args  = new FormEventArgs(_movedForm, GetPageInfo(_movedForm).Id);
            handler(this, args);

            RemoveButton(_movedButton);

            _movedDecorator = HierarchyUtility.GetFormsDecorator(_movedForm);

            IsFocused = false;
            _movedDecorator.IsFocused = true;

            _movedDecorator.BeginMovementByMouse(mouseScreenPosition);

            cursor = Cursors.SizeAll;
         }

         return true;
      }

      /// <summary>
      /// Continue button drag
      /// </summary>
      /// <param name="mousePosition">mouse position</param>
      /// <param name="cursor">cursor</param>
      protected override void ContinueButtonDrag(Point mousePosition, ref Cursor cursor)
      {
         if (_movedDecorator != null)
         {
            Point mouseScreenPosition = Control.MousePosition;
            _movedDecorator.ContinueMovementByMouse(mouseScreenPosition);

            cursor = Cursors.SizeAll;
         }
      }

      /// <summary>
      /// End button drag
      /// </summary>
      /// <param name="cancel">cancel</param>
      protected override void EndButtonDrag(bool cancel)
      {
         if (cancel)
         {
            InsertButton(_movedButton, _movedIndex);
         }
         else if (_movedDecorator != null)
         {
            _movedDecorator.EndMovementByMouse();
            _movedDecorator = null;
         }
      }

      /// <summary>
      /// Occurs when tab button is removed
      /// </summary>
      /// <param name="button">button removed</param>
      protected override void OnButtonRemoved(TabButton button)
      {
         Form page = (Form)button.Page;
         page.FormClosing    -= OnPageClosing;
         page.FormClosed     -= OnPageClosed;
         page.ParentChanged  -= OnPageParentChanged;

         PagesPanel.Remove(page);

         DockableFormInfo info = null;
         for (int index = _cachedInfos.Count - 1; index >= 0; index--)
         {
            if (_cachedInfos[index].Button == button)
            {
               info = _cachedInfos[index];
               _cachedInfos.RemoveAt(index);

               info.ExplicitDisposing -= OnInfoDisposing;
               info.SelectedChanged   -= OnInfoSelectedChanged;

               break;
            }
         }

         EventHandler<FormEventArgs> handler = FormRemoved;
         if (handler != null)
         {
            FormEventArgs args = new FormEventArgs(page, info.Id);
            handler(this, args);
         }
      }

      /// <summary>
      /// Occurs when tab button is added
      /// </summary>
      /// <param name="button">button added</param>
      protected override void OnButtonAdded(TabButton button)
      {
         EventHandler<FormEventArgs> handler = FormAdded;
         if (handler != null)
         {
            DockableFormInfo info = GetPageInfo((Form)button.Page);
            FormEventArgs args    = new FormEventArgs(info.DockableForm, info.Id);
            handler(this, args);
         }
      }

      /// <summary>
      /// Called when tab button renderer is changed
      /// </summary>
      protected override void OnTabButonRendererChanged()
      {
         ButtonsRenderer.SelectedBackGradient2 = PagesPanel.SelectedColor1;
      }

      #endregion Protected section

      #region Private section
      #region Received events

      /// <summary>
      /// Occurs when info is disposing
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnInfoDisposing(object sender, EventArgs e)
      {
         Remove((DockableFormInfo)sender);
      }

      /// <summary>
      /// Occurs when info is selected
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnInfoSelectedChanged(object sender, EventArgs e)
      {
         DockableFormInfo info = (DockableFormInfo)sender;
         if (info.IsSelected)
         {
            SelectedIndex = GetPageIndex(info.DockableForm);
         }
      }

      /// <summary>
      /// Occurs when pages close button was clicked
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnPagesCloseClick(object sender, EventArgs e)
      {
         Form form = GetPageAt(SelectedIndex);
         form.Close();
      }

      /// <summary>
      /// Occurs when pages autohide button was clicked
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnPagesAutohideClick(object sender, EventArgs e)
      {
         EventHandler handler = AutohideClick;
         if (handler != null)
         {
            handler(this, EventArgs.Empty);
         }
      }

      /// <summary>
      /// Occurs when pages context menu button was clicked
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnPagesContextMenuClick(object sender, EventArgs e)
      {
         EventHandler<FormEventArgs> handler = ContextMenuClick;
         if (handler != null)
         {
            DockableFormInfo info = GetPageInfo(PagesPanel.GetFormAt(SelectedIndex));
            FormEventArgs args = new FormEventArgs(info.DockableForm, info.Id);
            handler(this, args);
         }
      }

      /// <summary>
      /// Occurs when pages colors were changed
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event arguments</param>
      private void OnPagesColorsChanged(object sender, EventArgs e)
      {
         ButtonsRenderer.SelectedBackGradient2 = PagesPanel.SelectedColor1;
      }

      /// <summary>
      /// Occurs when the page parent is changed
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event argument</param>
      private void OnPageParentChanged(object sender, EventArgs e)
      {
         TabButton button = GetButton((Form)sender);
         RemoveButton(button);
      }

      /// <summary>
      /// Occurs when the page is closed
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event argument</param>
      private void OnPageClosed(object sender, FormClosedEventArgs e)
      {
         DockableFormInfo info = GetPageInfo((Form)sender);
         Guid id          = info.Id;
         Form form        = info.DockableForm;
         TabButton button = GetButton(form);
         button.Dispose();

         EventHandler<FormEventArgs> handler = FormClosed;
         if (handler != null)
         {
            FormEventArgs args = new FormEventArgs(form, id);
            handler(this, args);
         }
      }

      /// <summary>
      /// Occurs when the page is closing
      /// </summary>
      /// <param name="sender">sender of the event</param>
      /// <param name="e">event argument</param>
      private void OnPageClosing(object sender, FormClosingEventArgs e)
      {
         EventHandler<DockableFormClosingEventArgs> handler = FormClosing;
         if (handler != null)
         {
            DockableFormInfo info = GetPageInfo((Form)sender);
            DockableFormClosingEventArgs args = new DockableFormClosingEventArgs(info.DockableForm, info.Id);
            args.Cancel = false;
            handler(this, args);

            e.Cancel = args.Cancel;
         }
      }

      #endregion Received events

      /// <summary>
      /// Accessor of the controls
      /// </summary>
      private FormsTabbedViewControlCollection InternalControls
      {
         get
         {
            if (_controls == null)
            {
               _controls = new FormsTabbedViewControlCollection(this);
            }

            return _controls;
         }
      }

      /// <summary>
      /// Get the button
      /// </summary>
      /// <param name="form">form that created the button</param>
      /// <returns>button</returns>
      private TabButton GetButton(Form form)
      {
         for (int index = 0; index < Count; index++)
         {
            if (GetButtonAt(index).Page == form)
            {
               return GetButtonAt(index);
            }
         }

         throw new InvalidOperationException();
      }

      #endregion Private section
   }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Ajay Britto
Engineer
Singapore Singapore
He is a Microsoft technology enthusiast, who wish to create applications which others find useful.He loves making small tools and getting involved in architecting bigger systems.

He is currently working as a professional developer in a software development firm in .Net technologies.
 
He likes reading technical blogs, contributing to opensource and most importantly, enjoying life.
 
His ambition is to be an impressive software maker.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.141220.1 | Last Updated 3 Aug 2010
Article Copyright 2010 by Ajay Britto
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid