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
 

 /// <summary>
        /// Checks if already exists an opened form of the specified type in the 
        /// collection of opened forms. If not creates and registers one.
        /// </summary>
        /// <typeparam name="T"> The type of Form to search for or create.</typeparam>
        /// <param name="args"> Additional Form contstruction parameters. The order must
        /// be the same with the order of appearance in each form's constructor.</param>
        /// <returns> A singleton instance of a form of the requested type. </returns>
        public static T GetFormInstance<T>(params object[] args) where T:IMdiChildForm
        {
            // If the form is not registered.
            if (!m_openedFormsCollection.ContainsKey( typeof(T) ))
            {

                // Create it.
                IMdiChildForm nForm = (IMdiChildForm)Activator.CreateInstance( typeof(T), args );
                
                nForm.MdiParent = GmdMainForm.SingletonInstance;

                // Register it.
                m_openedFormsCollection.Add( nForm.GetType(), nForm );
                
                if (MdiChildFormRegistered != null)
                {
                    MdiChildFormRegistered( nForm );
                }
                
                // If the form is the first to open, or it opens in maximized environment
                // then it is also Maximized.
                nForm.WindowState = m_openedFormsCollection.Count == 1 ||
                    GmdMainForm.SingletonInstance.MdiChildren.Where( w => w.WindowState == FormWindowState.Maximized ).
                        Count() > 0
                        ? FormWindowState.Maximized
                        : FormWindowState.Normal;

                // Set the closed event to finalize the form instance.
                nForm.OnMdiChildFormClosed += Form_FormClosed;
            }

            T result = (T)m_openedFormsCollection[typeof(T)];
            
            return result;
        }

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
 

/// <summary>
    /// An interface used to expose necessery Properties of Forms and Form facades and
    /// facilitate the access to all form related objects of this program.
    /// </summary>
    public interface IMdiChildForm
    {         
        /// <summary>
        /// Exposes the OnFormClose event of an MdiForm.
        /// </summary>
        event OpenedFormsProvider.OnMdiChildFormClosed OnMdiChildFormClosed;
        
        /// <summary>
        /// Exposes the MdiParent of an MdiForm.
        /// </summary>
        Form MdiParent { get; set; }

        /// <summary>
        /// Exposes the Window state of an MdiForm.
        /// </summary>
        FormWindowState WindowState { get; set; }

        /// <summary>
        /// Exposes the Window Title of an MdiForm.
        /// </summary>
        string Text { get; }
       
        IntPtr Handle { get; }

        /// <summary>
        /// Exposes the function that brings an MdiForm to the Front of the visibility
        /// Z-Buffer.
        /// </summary>
        void BringToFront();

        void ShowMdiForm();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 

public static void ShowMdiChildForm(this IMdiChildForm referencedForm)
        {
            //(referencedForm as Form).Show();
            referencedForm.ShowMdiForm();
            
            // Each time a form is Shown, it is brought to the front of the Z-buffer.
            referencedForm.BringToFront();

            // If a form remains minimized after the BringToFront event, it means that
            // the collection of minimized forms is visible, accesible by the mouse and 
            // thus the global state of forms in the MDI container is NOT maximized. We 
            // assume that the user normalized the front form, and to maintain the Normal
            // state as the global one, we bring the window at Normal state.
            if (referencedForm.WindowState == FormWindowState.Minimized)
            {
                referencedForm.WindowState = FormWindowState.Normal;
            }
        }