CurrentObject.cs

#region Header
/*
    ==============================================================================
      Author: Zoltan Hrabovszki <zh@openkeyword.de>

      Copyright © 2012, 2013, 2014, 2015 IT-Beratung Hrabovszki
      www.OpenKeyWord.de
    ============================================================================== 

    This file is part of OpenKeyWord.

    OpenKeyWord is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenKeyWord 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
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with OpenKeyWord.  If not, see <http://www.gnu.org/licenses/>.

    Diese Datei ist Teil von OpenKeyWord.

    OpenKeyWord ist Freie Software: Sie können es unter den Bedingungen
    der GNU General Public License, wie von der Free Software Foundation,
    Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren
    veröffentlichten Version, weiterverbreiten und/oder modifizieren.

    OpenKeyWord wird in der Hoffnung, dass es nützlich sein wird, aber
    OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
    Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
    Siehe die GNU General Public License für weitere Details.

    Sie sollten eine Kopie der GNU General Public License zusammen mit 
    OpenKeyWord erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
*/
#endregion Header

namespace OKW
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Text.RegularExpressions;

    using OKW;
    using OKW.Log;

    public class CurrentObject : OKWSingeltonBase<CurrentObject>
    {
        #region Fields

        protected string cvsChildName = string.Empty;
        
        protected string cvsWindowName = string.Empty;
        
        //private static readonly CurrentObject instance = new CurrentObject();
        
        private object cvoObject = null;

        private string cvsObjectFunctionalName = string.Empty;

        private string cvsObjectName = string.Empty;

        private LogMessenger LM = null;

        private Logger Log = Logger.Instance;

        FrameObjectDictionary myFrameObjectDictionary = new FrameObjectDictionary();

        #endregion Fields

        #region Constructors

        private CurrentObject()
        {
            this.LM = new LogMessenger(this.GetType().Name);
        }

        #endregion Constructors

        #region Properties

        /*public static CurrentObject Instance
        {
            get
            {
                return instance;
            }
        }
        */

        #endregion Properties

        #region Methods

        public void CallMethod(string fpsMethod)
        {
            this.Log.LogFunctionStartDebug("CallMethod", "string fpsMethod", fpsMethod);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, null);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        public void CallMethod(string fpsMethod, List<string> fpLsParameter)
        {
            this.Log.LogFunctionStartDebug("CallMethod", "string fpsMethod", fpsMethod, "List<string> fplsParameter",  fpLsParameter.ToString());
            object[] lvoParameter = new object[1];
            lvoParameter[0] = fpLsParameter;
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { typeof(List<string>) },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            
            return;
        }

        public void CallMethod(string fpsMethod, List<string> fpLsParameter_1, string fpsParameter_2)
        {
            this.Log.LogFunctionStartDebug("CallMethod", "string fpsMethod", fpsMethod, "List<string> fpLsParameter_1",  fpLsParameter_1.ToString(), "string fpsParameter_2", fpsParameter_2);
            object[] lvoParameter = new object[2];

            lvoParameter[0] = fpLsParameter_1;     // Der letzte Parameter ist immer der zu übergebende Wert
            lvoParameter[1] = fpsParameter_2;      // Hier sind Kooerdinaten usw. zu finden
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(List<string>), typeof(string)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja: Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            
            return;
        }

        public void CallMethod(string fpsMethod, string fpsParameter_1)
        {
            this.Log.LogFunctionStartDebug("CallMethod", "string fpsMethod", fpsMethod, "string fps_Parameter_1", fpsParameter_1);
            object[] lvoParameter = new object[1];
            lvoParameter[0] = fpsParameter_1; // Hier sind z.B. Kooerdinaten usw. zu finden
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { typeof(string) },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        public void CallMethod(string fpsMethod, string fpsParameter_1, string fpsParameter_2)
        {
            this.Log.LogFunctionStartDebug("CallMethod", "string fpsMethod", fpsMethod, "string fps_Parameter_1", fpsParameter_1, "string fps_Parameter_2", fpsParameter_2);
            object[] lvoParameter = new object[2];
            lvoParameter[0] = fpsParameter_1; // Hier sind z.B. Kooerdinaten usw. zu finden
            lvoParameter[1] = fpsParameter_2; // Auch hier sind Kooerdinaten usw. zu finden
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { typeof(string), typeof(string) },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        public void CallMethod(string fpsMethod, string fpsParameter_1, string fpsParameter_2, string fpsParameter_3)
        {
            this.Log.LogFunctionStartDebug("CallMethod",
                                           "string fpsMethod", fpsMethod,
                                           "string fpsParameter_1", fpsParameter_1,
                                           "string fpsParameter_2", fpsParameter_2,
                                           "string fpsParameter_3", fpsParameter_3);
            object[] lvoParameter = new object[3];
            lvoParameter[0] = fpsParameter_1;
            lvoParameter[1] = fpsParameter_2;
            lvoParameter[2] = fpsParameter_3;
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(string), typeof(string), typeof(string)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        public void CallMethod(string fpsMethod, string fpsParameter_1, string fpsParameter_2, List<string> fpLsValue)
        {
            this.Log.LogFunctionStartDebug("CallMethod",
                                           "string fpsMethod", fpsMethod,
                                           "string fpsParameter_1", fpsParameter_1,
                                           "string fpsParameter_2", fpsParameter_2,
                                           "string fpsLValue",  "fpLsValue.ToString");
            object[] lvoParameter = new object[3];
            lvoParameter[0] = fpsParameter_1;
            lvoParameter[1] = fpsParameter_2;
            lvoParameter[2] = fpLsValue;
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(string), typeof(string), typeof(List<string>)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        public bool CallMethodReturn_Boolean(string fpsMethod)
        {
            bool lvbReturn = false;
            this.Log.LogFunctionStartDebug("CallMethodWithReturn",
                                           "string fpsMethod", fpsMethod);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvbReturn = (bool)myMethodInfo.Invoke(this.cvoObject, null);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug(lvbReturn);
            }
            return lvbReturn;
        }

        public bool CallMethodReturn_BooleanPb(string fpsMethod, bool fpbParameter_1)
        {
            bool lvbReturn = false;
            object[] lvoParameter = new object[1];
            lvoParameter[0] = fpbParameter_1;
            this.Log.LogFunctionStartDebug("CallMethodReturn_BooleanPb",
                                           "string fpsMethod", fpsMethod,
                                           "bool fpsParameter_1", fpbParameter_1.ToString());
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(bool)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvbReturn = (bool)myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug(lvbReturn);
            }
            return lvbReturn;
        }

        public int CallMethodReturn_Int(string fpsMethod)
        {
            int lviReturn = 0;
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CallMethodReturn_Int",
                                           "string fpsMethod", fpsMethod);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lviReturn = (int)myMethodInfo.Invoke(this.cvoObject, null);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lviReturn.ToString());
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lviReturn;
        }

        public List<string> CallMethodReturn_ListString(string fpsMethod)
        {
            List<string> lvLsReturn = new List<string>();
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CallMethodReturn_ListString",
                                           "string fpsMethod", fpsMethod);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] { },
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKW.OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvLsReturn = (List<string>)myMethodInfo.Invoke(this.cvoObject, null);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvLsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvLsReturn;
        }

        public List<string> CallMethodReturn_ListString(string fpsMethod, string fpsParam1, string fpsParam2)
        {
            List<string> lvLsReturn = new List<string>();
            object[] lvoParameter = new object[2];
            bool bOK = false;
            lvoParameter[0] = fpsParam1;
            lvoParameter[1] = fpsParam2;
            this.Log.LogFunctionStartDebug("CallMethodReturn_ListString",
                                           "string fpsMethod", fpsMethod,
                                           "string fpsParam1", fpsParam1,
                                           "string fpsParam2", fpsParam2);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(string), typeof(string)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKW.OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvLsReturn = (List<string>)myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvLsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvLsReturn;
        }

        public List<string> CallMethodReturn_ListString(string fpsMethod, List<string> fpLsParameter_1)
        {
            List<string> lvLsReturn = new List<string>();
            object[] lvoParameter = new object[1];
            bool bOK = false;
            lvoParameter[0] = fpLsParameter_1;
            this.Log.LogFunctionStartDebug("CallMethodWithReturn",
                                           "string fpsMethod", fpsMethod,
                                           "List<string> fpLsParameter_1", fpLsParameter_1.ToString());
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(List<string>)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvLsReturn = (List<string>)myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvLsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvLsReturn;
        }

        public List<string> CallMethodReturn_ListString(string fpsMethod, string fpsParameter_1, string fpsParameter_2, List<string> fpLsParameter_3)
        {
            List<string> lvLsReturn = new List<string>();
            object[] lvoParameter = new object[3];
            bool bOK = false;
            lvoParameter[0] = fpsParameter_1;
            lvoParameter[1] = fpsParameter_2;
            lvoParameter[2] = fpLsParameter_3;
            this.Log.LogFunctionStartDebug("CallMethodReturn_ListString",
                                           "string fpsMethod", fpsMethod,
                                           "string fpsParam1", fpsParameter_1,
                                           "string fpsParameter_2", fpsParameter_2,
                                           "List<string> fpLsParameter_3", fpLsParameter_3.ToString());
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvLsReturn = (List<string>)myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvLsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvLsReturn;
        }

        public string CallMethodReturn_String(string fpsMethod)
        {
            string lvsReturn = string.Empty;
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CallMethodWithReturn",
                                           "string fpsMethod", fpsMethod);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvsReturn = (string)myMethodInfo.Invoke(this.cvoObject, null);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvsReturn;
        }

        public string CallMethodReturn_String(string fpsMethod, string fpsParameter_1)
        {
            string lvsReturn = string.Empty;
            object[] lvoParameter = new object[1];
            bool bOK = false;
            lvoParameter[0] = fpsParameter_1;
            this.Log.LogFunctionStartDebug("CallMethodWithReturn",
                                           "string fpsMethod", fpsMethod,
                                           "string fpsParameter_1", fpsParameter_1);
            try
            {
                Type myTypeObject = this.cvoObject.GetType();
                MethodInfo myMethodInfo = myTypeObject.GetMethod(fpsMethod,
                                                                 BindingFlags.Public | BindingFlags.Instance,
                                                                 null,
                                                                 new Type[] {typeof(string)},
                                                                 null);
                // Existiert die Methode des Objektes?
                if (myMethodInfo == null)
                {
                    // Nein: -> Mit einem OKWFrameObjectMethodNotFoundException aussteigen...
                    string errorText = this.LM.GetMessage("CallMethod", "MethodNotDefined", fpsMethod);
                    throw new OKWFrameObjectMethodNotFoundException(errorText);
                }
                else
                {
                    // Ja, Methode via Invoke aufrufen
                    lvsReturn = (string)myMethodInfo.Invoke(this.cvoObject, lvoParameter);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvsReturn;
        }

        public bool CheckCharacter(string fpsFunctionalname)
        {
            // Variable
            bool lvb_Return = false;
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.GetObjectName");
            // Initialisierung
            try
            {
                // Define a regular expression OKW_Object Name.
                // FIXME:  Regulärenausdruck für Fachlich-funktionalen-Namen anpassen
                Regex rx = new Regex(@"^\w+");
                // Check each test string against the regular expression.
                if (rx.IsMatch(fpsFunctionalname))
                {
                    lvb_Return = true;
                }
                else
                {
                    // FrameObjekt-Name enthält nicht erlaubte Zeichen, daher Exception auslösen.
                    string errorText = this.LM.GetMessage("CheckCharacter", "OKWFrameObjectIllegalNameCharacterException", fpsFunctionalname);
                    throw new OKWFrameObjectIllegalNameCharacterException(errorText);
                }
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvb_Return);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvb_Return;
        }

        public object GetCurrentObject()
        {
            object lvoReturn = new object();
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.GetCurrentObject");
            try
            {
                lvoReturn = this.cvoObject;
                bOK = true;
            }
            catch
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(this.cvoObject.GetType().FullName);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return this.cvoObject;
        }

        public string GetObjectName()
        {
            string lvsReturn = string.Empty;;
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.GetObjectName");
            try
            {
                lvsReturn = this.cvsObjectName;
                bOK = true;
            }
            catch
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvsReturn);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvsReturn;
        }

        public void Init()
        {
            Logger.Instance.LogFunctionStartDebug("CurrentObject.Init");
            try
            {
                this.LM = new LogMessenger(this.GetType().Name);
                this.cvoObject = null;
                this.cvsChildName = string.Empty;
                this.cvsWindowName = string.Empty;
                this.cvsObjectName = string.Empty;
                this.myFrameObjectDictionary = null;
                this.myFrameObjectDictionary = new FrameObjectDictionary();
            }
            finally
            {
                Logger.Instance.LogFunctionEndDebug();
            }
            return;
        }

        public void LogObjectData()
        {
            Logger.Instance.LogFunctionStartDebug("CurrentObject.LogObjectData");
            try
            {
                Logger.Instance.ResOpenList("Object Data:");
                Logger.Instance.LogPrint(this.LM.GetMessage("LogObjectData", "WindowName", this.cvsWindowName));
                Logger.Instance.LogPrint(this.LM.GetMessage("LogObjectData", "ChildWindowName", this.cvsChildName));
                Logger.Instance.LogPrint(this.LM.GetMessage("LogObjectData", "Class of Object", this.cvoObject.GetType().Name));
                Logger.Instance.LogPrint(this.LM.GetMessage("LogObjectData", "FullNameOfObject", this.cvsObjectName));
            }
            catch (SystemException e)
            {
                Logger.Instance.LogPrint(e.Message);
            }
            finally
            {
                Logger.Instance.ResCloseList();
            }
            Logger.Instance.LogFunctionEndDebug();
        }

        public object SetChildName(string fpsChildName)
        {
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.SetChildName", "string fpsChildName", fpsChildName);
            this.Log.LogPrintDebug(this.LM.GetMessage("SetChildName", "GivenWindownameDebug"));
            try
            {
                if (this.cvsWindowName != string.Empty)
                {
                    this.Log.LogPrintDebug(this.LM.GetMessage("SetChildName", "SetChildwindowNameDebug", this.cvsWindowName, this.cvsChildName));
                    this.cvsChildName = fpsChildName;
                    this.UpdateObject();
                    bOK = true;
                }
                else
                {
                    // Fenster Objekt wurde nicht gesetzt, Exception auslösen...
                    string ErrorText = this.LM.GetMessage("SetChildName", "OKWFrameObjectWindowNotSetException");
                    throw new OKWFrameObjectWindowNotSetException(ErrorText);
                }
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(this.cvoObject.GetType().FullName);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return this.cvoObject;
        }

        public object SetWindowName(string fpsWindowName)
        {
            object lvoReturn = new object();
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.SetWindowName", "string fpsWindowName", fpsWindowName);
            try
            {
                this.cvsWindowName = fpsWindowName;
                this.cvsChildName = string.Empty;
                this.UpdateObject();
                lvoReturn = this.cvoObject;
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(lvoReturn.ToString());
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return lvoReturn;
        }

        private object ResetToWindow()
        {
            bool bOK = false;
            this.Log.LogFunctionStartDebug("CurrentObject.ResetToWindow");
            this.Log.LogPrintDebug(this.LM.GetMessage("ResetToWindow", "ResetToWindowDebug"));
            try
            {
                this.cvsChildName = string.Empty;
                this.UpdateObject();
                bOK = true;
            }
            finally
            {
                if (bOK)
                {
                    this.Log.LogFunctionEndDebug(this.cvoObject.GetType().FullName);
                }
                else
                {
                    this.Log.LogFunctionEndDebug();
                }
            }
            return this.cvoObject;
        }

        private void UpdateObject()
        {
            this.Log.LogFunctionStartDebug("CurrentObject.UpdateObject");
            try
            {
                if (this.cvsChildName == string.Empty)
                {
                    // < 2. Get the Window-Object...
                    this.cvoObject = this.myFrameObjectDictionary.GetParentObjectByName(this.cvsWindowName);
                    // "frm_" + this.cvsWindowName; //< 1. Set the cvsObjectName for a window-object.
                    this.cvsObjectName = this.cvoObject.GetType().Name;
                }
                else
                {
                    // < 1. Set the cvsObjectName for a child-object.
                    this.cvsObjectName = this.cvsWindowName + "." + this.cvsChildName;
                    // < 2. Now get the Window-Object...
                    this.cvoObject = this.myFrameObjectDictionary.GetChildObjectByName(this.cvsWindowName, this.cvsChildName);
                }
            }
            finally
            {
                this.Log.LogFunctionEndDebug();
            }
            return;
        }

        #endregion Methods
    }
}