/// <summary>
        /// Constuctor that should be used
        /// </summary>
        /// <param name="seq">The control will be filled with this data</param>
        public StringComboAddingControl(StringSequence seq)
            : base()
        {
            SizeChanged += new EventHandler(StringComboAddingControl_SizeChanged);

            InitializeComponent();
            sequence = seq;

            LText.Text = sequence.ResManager.GetString("StringComboAddingControlText");
            BAddOption.Text = seq.ResManager.GetString("StringComboAddingControlButtonText");

            //filling the listbox
            foreach (SelectString ss in sequence.GetArray())
            {
                LBOptions.Items.Add(ss.label);
            }
        }
        /// <summary>
        /// The property value is changed, so the the propertiesDisplayer should be
        /// refilled with new values
        /// </summary>
        /// <param name="catcher">Catcher of the connection</param>
        /// <param name="value">New value of the property</param>
        /// <param name="moreBoxes">If the refresh of the property grid is 
        /// from one or more boxes</param>
        public void ChangedPropertyValue(AsyncPropertyCatcher catcher, object value, bool moreBoxes)
        {
            //changing one of the temporary values
            //writing to the temporaryValues dictionary
            switch (catcher.PropertyType)
            {
                case "System.Int32":
                    Int32 int32Value = ((IntT)value).intValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = int32Value;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (int32Value != (Int32)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = (Int32)0;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = int32Value;
                        }
                    }
                    break;

                case "Ferda.FrontEnd.Properties.OtherProperty":
                    //here is no moreBoxes here
                    string resultValue = SelectedBox.GetPropertyOtherAboutFromValue(catcher.PropertyName,
                        (PropertyValue)value);
                    OtherProperty prop = new OtherProperty(SelectedBox, catcher.PropertyName,
                        archiveDisplayer, viewDisplayers, this, ResManager);
                    prop.Result = resultValue;
                    lock (tempLocker)
                    {
                        temporaryValues[catcher.PropertyName] = prop;
                    }
                    break;

                case "Ferda.FrontEnd.Properties.StringSequence":
                    string selectedValue = ((StringT)value).stringValue;
                    //creating a new stringSequence
                    StringSequence seq = new StringSequence(catcher.PropertyName,
                        new IBoxModule[] { SelectedBox },
                        ResManager, ArchiveDisplayer, ViewDisplayers,
                        this, selectedValue);
                    lock (tempLocker)
                    {
                        temporaryValues[catcher.PropertyName] = seq;
                    }
                    break;

                case "System.String":
                    string valueString = ((StringT)value).stringValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = valueString;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (valueString != (string)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = string.Empty;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = valueString;
                        }
                    }
                    break;

                case "System.Boolean":
                    bool boolValue = ((BoolT)value).boolValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = boolValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (boolValue != (bool)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = false;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = boolValue;
                        }
                    }
                    break;

                case "System.Int16":
                    Int16 shortValue = ((ShortT)value).shortValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = shortValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (shortValue != (Int16)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = (Int16)0;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = shortValue;
                        }
                    }
                    break;

                case "System.Int64":
                    Int64 longValue = ((LongT)value).longValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = longValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (longValue != (Int64)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = (Int64)0;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = longValue;
                        }
                    }
                    break;

                case "System.Double":
                    Double doubleValue = ((DoubleT)value).doubleValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = doubleValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (doubleValue != (Double)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = (Double)0;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = doubleValue;
                        }
                    }
                    break;

                case "System.Single":
                    Single singleValue = ((FloatT)value).floatValue;
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = singleValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (singleValue != (Single)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = (Single)0;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = singleValue;
                        }
                    }
                    break;

                case "System.DateTime":
                    //a date property is treated differently due to unexisting conversion
                    if (value is DateT)
                    {
                        DateT v = (DateT)value;
                        DateTime dateTimeValue = new DateTime();
                        try
                        {
                            dateTimeValue = new DateTime(v.year, v.month, v.day);
                        }
                        catch (ArgumentOutOfRangeException)
                        {
                        }

                        lock (tempLocker)
                        {
                            if (moreBoxes)
                            {
                                switch (moreBoxesValuesState[catcher.PropertyName])
                                {
                                    //no box has written to the property
                                    case EMoreBoxesTemporaryValueState.First:
                                        temporaryValues[catcher.PropertyName] = dateTimeValue;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Right;
                                        break;

                                    //all the previos boxes wrote the same value
                                    case EMoreBoxesTemporaryValueState.Right:
                                        if (dateTimeValue != (DateTime)temporaryValues[catcher.PropertyName])
                                        {
                                            temporaryValues[catcher.PropertyName] = new DateTime();
                                            moreBoxesValuesState[catcher.PropertyName] =
                                                EMoreBoxesTemporaryValueState.Wrong;
                                        }
                                        break;
                                    //values from the boxes are different
                                    case EMoreBoxesTemporaryValueState.Wrong:
                                        break;
                                }
                            }
                            else
                            {
                                temporaryValues[catcher.PropertyName] = dateTimeValue;
                            }
                        }
                    }
                    else //it is a DateTimeT thing
                    {
                        DateTimeT v = (DateTimeT)value;

                        //the value does not have to be correct
                        DateTime dtValue = new DateTime();
                        try
                        {

                            dtValue = new DateTime(v.year,
                                    v.month, v.day, v.hour, v.minute, v.second);
                        }
                        catch (ArgumentOutOfRangeException)
                        {
                        }

                        lock (tempLocker)
                        {
                            if (moreBoxes)
                            {
                                switch (moreBoxesValuesState[catcher.PropertyName])
                                {
                                    //no box has written to the property
                                    case EMoreBoxesTemporaryValueState.First:
                                        temporaryValues[catcher.PropertyName] = dtValue;
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Right;
                                        break;

                                    //all the previos boxes wrote the same value
                                    case EMoreBoxesTemporaryValueState.Right:
                                        if (dtValue != (DateTime)temporaryValues[catcher.PropertyName])
                                        {
                                            temporaryValues[catcher.PropertyName] = new DateTime();
                                            moreBoxesValuesState[catcher.PropertyName] =
                                                EMoreBoxesTemporaryValueState.Wrong;
                                        }
                                        break;
                                    //values from the boxes are different
                                    case EMoreBoxesTemporaryValueState.Wrong:
                                        break;
                                }
                            }
                            else
                            {
                                temporaryValues[catcher.PropertyName] = dtValue;
                            }
                        }
                    }
                    break;

                case "System.TimeSpan":
                    TimeT val = (TimeT)value;
                    TimeSpan timeSpanValue = new TimeSpan(val.hour, val.minute, val.second);
                    lock (tempLocker)
                    {
                        if (moreBoxes)
                        {
                            switch (moreBoxesValuesState[catcher.PropertyName])
                            {
                                //no box has written to the property
                                case EMoreBoxesTemporaryValueState.First:
                                    temporaryValues[catcher.PropertyName] = timeSpanValue;
                                    moreBoxesValuesState[catcher.PropertyName] =
                                        EMoreBoxesTemporaryValueState.Right;
                                    break;

                                //all the previos boxes wrote the same value
                                case EMoreBoxesTemporaryValueState.Right:
                                    if (timeSpanValue != (TimeSpan)temporaryValues[catcher.PropertyName])
                                    {
                                        temporaryValues[catcher.PropertyName] = new TimeSpan();
                                        moreBoxesValuesState[catcher.PropertyName] =
                                            EMoreBoxesTemporaryValueState.Wrong;
                                    }
                                    break;
                                //values from the boxes are different
                                case EMoreBoxesTemporaryValueState.Wrong:
                                    break;
                            }
                        }
                        else
                        {
                            temporaryValues[catcher.PropertyName] = timeSpanValue;
                        }
                    }
                    break;

                default:
                    break;
            }

            //refilling the propertiesDisplayer
            SetPropertyGrid(propertyBag);
        }
 /*
 /// <summary>
 /// Function returns, if 2 sequences have identical option arrays
 /// </summary>
 /// <param name="sequence1">First sequence to compare</param>
 /// <param name="sequence2">Second sequence to compare</param>
 /// <returns>True if identical, false otherwise</returns>
 */
 //public static bool EqualArrays(StringSequence sequence1,
 //    StringSequence sequence2)
 //{
 //    if (sequence1.array.Length != sequence2.array.Length)
 //    {
 //        return false;
 //    }
 //    for (int i = 0; i < sequence1.array.Length; i++)
 //    {
 //        if (sequence1.array[i] != sequence2.array[i])
 //        {
 //            return false;
 //        }
 //    }
 //    return true;
 //}
 /// <summary>
 /// Function returns, if 2 sequences have identical selected strings
 /// </summary>
 /// <param name="sequence1">First sequence to compare</param>
 /// <param name="sequence2">Second sequence to compare</param>
 /// <returns>True if identical, false otherwise</returns>
 public static bool EqualSelections(StringSequence sequence1,
     StringSequence sequence2)
 {
     return String.Equals(sequence1.selectedLabel, sequence2.selectedLabel);
 }