Core.cs

#region Header

/*
    ==============================================================================
    Copyright © 2012, 2013, 2014, 2015 IT-Beratung Hrabovszki
    ============================================================================== 

    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;

    public class Core : IOKW_State
    {
        #region Fields

        // zeigt auf die Klasse des aktuellen Zustandes
        private IOKW_State CurrentState;

        #endregion Fields

        #region Constructors

        public Core()
        {
            this.SetCurrentState(new OK(this));
        }

        #endregion Constructors

        #region Methods

        public void BeginTest(string Testname)
        {
            this.CurrentState.BeginTest(Testname);
        }

        public void ClickOn(string fpsFunctionalname)
        {
            this.CurrentState.ClickOn(fpsFunctionalname);
        }

        public void ClickOn(string fpsFunctionalname, string fpsClickType)
        {
            this.CurrentState.ClickOn(fpsFunctionalname, fpsClickType);
        }

        public void EndTest()
        {
            this.CurrentState.EndTest();
        }

        public void LogExists(string fpsFunctionalname)
        {
            this.CurrentState.LogExists(fpsFunctionalname);
        }

        public void LogHasFocus(string fpsFunctionalname)
        {
            this.CurrentState.LogHasFocus(fpsFunctionalname);
        }

        public void LogIsActive(string fpsFunctionalname)
        {
            this.CurrentState.LogIsActive(fpsFunctionalname);
        }

        public void LogSelected(string fpsFunctionalname)
        {
            this.CurrentState.LogSelected(fpsFunctionalname);
        }

        public void LogTablecellValue(string fpsFunctionalname, string fpsCol, string fpsRow)
        {
            this.CurrentState.LogTablecellValue(fpsFunctionalname, fpsCol, fpsRow);
        }

        public void LogTooltip(string fpsFunctionalname)
        {
            this.CurrentState.LogTooltip(fpsFunctionalname);
        }

        public void LogCaption(string fpsFunctionalname)
        {
            this.CurrentState.LogCaption(fpsFunctionalname);
        }

        public void LogLabel(string fpsFunctionalname)
        {
            this.CurrentState.LogLabel(fpsFunctionalname);
        }

        public void LogValue(string fpsFunctionalname)
        {
            this.CurrentState.LogValue(fpsFunctionalname);
        }

        public void MemorizeExists(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeExists(fpsFunctionalname, fpsValue);
        }

        public void MemorizeHasFocus(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeHasFocus(fpsFunctionalname, fpsValue);
        }

        public void MemorizeIsActive(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeIsActive(fpsFunctionalname, fpsValue);
        }

        public void MemorizeSelectedValue(string fpsFunctionalname, string fpsValue)
        {
        this.CurrentState.MemorizeSelectedValue(fpsFunctionalname, fpsValue);
        }

        public void MemorizeTablecellValue(string fpsFunctionalname, string fpsCol, string fpsRow, string fpsKeyName)
        {
            this.CurrentState.MemorizeTablecellValue(fpsFunctionalname, fpsCol, fpsRow, fpsKeyName);
        }

        public void MemorizeTooltip(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeTooltip(fpsFunctionalname, fpsValue);
        }

        public void MemorizeLabel(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeLabel(fpsFunctionalname, fpsValue);
        }

        public void MemorizeCaption(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeCaption(fpsFunctionalname, fpsValue);
        }

        public void MemorizeValue(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.MemorizeValue(fpsFunctionalname, fpsValue);
        }

        public void Select(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.Select(fpsFunctionalname, fpsValue);
        }

        public void Select(string fpsFunctionalname, string fpsValue, string fpsClickType)
        {
            this.CurrentState.Select(fpsFunctionalname, fpsValue, fpsClickType);
        }

        public void SelectMenu(string fpsFunctionalname)
        {
            this.CurrentState.SelectMenu(fpsFunctionalname);
        }

        public void SelectMenu(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.SelectMenu(fpsFunctionalname, fpsValue);
        }

        public void SelectTablecell(string fpsFunctionalname, string fpsCol, string fpsRow)
        {
            this.CurrentState.SelectTablecell(fpsFunctionalname, fpsCol, fpsRow);
        }

        public void SelectTablecell(string fpsFunctionalname, string fpsCol, string fpsRow, string fpsClickType)
        {
            this.CurrentState.SelectTablecell(fpsFunctionalname, fpsCol, fpsRow, fpsClickType);
        }

        public void SelectWindow(string fpsFunctionalname)
        {
            this.CurrentState.SelectWindow(fpsFunctionalname);
        }

        public void Sequence(string fpsFunctionalname, string fpsSequenName, string SEQID)
        {
            this.CurrentState.Sequence(fpsFunctionalname, fpsSequenName, SEQID);
        }

        public void SetCurrentState(IOKW_State fp_CurrentState)
        {
            this.CurrentState = fp_CurrentState;
        }

        public void SetFocus(string fpsFunctionalname)
        {
            this.CurrentState.SetFocus(fpsFunctionalname);
        }

        public void SetLanguage(string Language)
        {
            this.CurrentState.SetLanguage(Language);
        }

        public void SetValue(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.SetValue(fpsFunctionalname, fpsValue);
        }

        public void StartApp(string fpsApplikationName)
        {
            this.CurrentState.StartApp(fpsApplikationName);
        }

        public void StopApp(string fpsApplicationName)
        {
            this.CurrentState.StopApp(fpsApplicationName);
        }

        public void TypeKey(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.TypeKey(fpsFunctionalname, fpsValue);
        }

        public void TypeKeyTablecell(string fpsFunctionalname, string fpsCol, string fpsRow, string fpsValue)
        {
            this.CurrentState.TypeKeyTablecell(fpsFunctionalname, fpsCol, fpsRow, fpsValue);
        }

        public void TypeKeyWindow(string fpsFunctionalname, string fpsValue)
        {
            this.CurrentState.TypeKeyWindow(fpsFunctionalname, fpsValue);
        }

        public void VerifyExists(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyExists(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyHasFocus(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyHasFocus(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyIsActive(string fpsFunctionalname, string fpsExpectedValue)
        {
        this.CurrentState.VerifyIsActive(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifySelectedValue(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifySelectedValue(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyTablecellValue(string fpsFunctionalname, string fpsCol, string fpsRow, string fpsExpectedValue)
        {
            this.CurrentState.VerifyTablecellValue(fpsFunctionalname, fpsCol, fpsRow, fpsExpectedValue);
        }

        public void VerifyTooltip(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyTooltip(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyCaption(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyCaption(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyLabel(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyLabel(fpsFunctionalname, fpsExpectedValue);
        }

        public void VerifyValue(string fpsFunctionalname, string fpsExpectedValue)
        {
            this.CurrentState.VerifyValue(fpsFunctionalname, fpsExpectedValue);
        }

        public void FileDelete(string fpsPathAndFileName)
        {
            this.CurrentState.FileDelete(fpsPathAndFileName);
        }

        public void VerifyFileExists(string fpsPathAndFileName, string fpsExpectedValue)
        {
            this.CurrentState.VerifyFileExists(fpsPathAndFileName, fpsExpectedValue);
        }

        public void VerifyDirectoryExists(string fpsPathAndFileName, string fpsExpectedValue)
        {
            this.CurrentState.VerifyDirectoryExists(fpsPathAndFileName, fpsExpectedValue);
        }

        #endregion Methods
    }
}