public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //a(a+b+c+d)/((a+b)(a+c))- 1
     return
         (float)(
              quantifierSetting.secondContingencyTableRows[0][0] *
             (
                 quantifierSetting.secondContingencyTableRows[0][0] +
                 quantifierSetting.secondContingencyTableRows[0][1] +
                 quantifierSetting.secondContingencyTableRows[1][0] +
                 quantifierSetting.secondContingencyTableRows[1][1]
             )
         )
         /
         (float)((
             (
             quantifierSetting.secondContingencyTableRows[0][0] +
             quantifierSetting.secondContingencyTableRows[0][1]
             )
             *
             (
             quantifierSetting.secondContingencyTableRows[0][0] +
             quantifierSetting.secondContingencyTableRows[1][0]
             )
         ) - 1);
 }

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //Differences between EConfidence (a+d)/(a+b+c+d)
     return
         ((float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         )
         /
         (float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[0][1] +
         quantifierSetting.firstContingencyTableRows[1][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         ))
         -
         ((float)(
         quantifierSetting.secondContingencyTableRows[0][0] +
         quantifierSetting.secondContingencyTableRows[1][1]
         )
         /
         (float)(
         quantifierSetting.secondContingencyTableRows[0][0] +
         quantifierSetting.secondContingencyTableRows[0][1] +
         quantifierSetting.secondContingencyTableRows[1][0] +
         quantifierSetting.secondContingencyTableRows[1][1]
         ))
         ;
 }

 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="ownerOfAddIn">Owner of addin</param>
 public AttributeFrequencyIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
 {
     this.ownerOfAddIn = ownerOfAddIn;
     resManager = new ResourceManager("Ferda.FrontEnd.AddIns.AttributeFr.Localization_en-US",
     Assembly.GetExecutingAssembly());
     localizationString = "en-US";
 }

 /// <summary>
 /// Default constructor for the class
 /// </summary>
 /// <param name="ownerOfAddIn">OwnerofAddIn</param>
 /// <param name="form">Parent form</param>
 public ExceptionCatcher(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn, 
     WaitDialog parent)
 {
     this.projectManager = ownerOfAddIn.ProjectManager;
     this.ownerOfAddIn = ownerOfAddIn;
     this.parentDialog = parent;
 }

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //a+b
     return
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[0][1];
 }

 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="localePrefs">localeprefs</param>
 /// <param name="tprx">Proxy</param>
 /// <param name="ownerOfAddIn">Owner of addin</param>
 public WaitDialog(string[] localePrefs, AbstractLMTaskFunctionsPrx tprx, Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
 {
     //setting the ResManager resource manager and localization string
     string locale;
     try
     {
         locale = localePrefs[0];
         localizationString = locale;
         locale = "Ferda.FrontEnd.AddIns.WaitDialog.Localization_" + locale;
         resManager = new ResourceManager(locale, Assembly.GetExecutingAssembly());
     }
     catch
     {
         resManager = new ResourceManager("Ferda.FrontEnd.AddIns.WaitDialog.Localization_en-US",
     Assembly.GetExecutingAssembly());
         localizationString = "en-US";
     }
     this.KeyDown += new KeyEventHandler(WaitDialog_KeyDown);
     this.tprx = tprx;
     this.ownerOfAddIn = ownerOfAddIn;
     InitializeComponent();
     this.ChangeLocale(this.resManager);
     ExceptionCatcher catcher = new ExceptionCatcher(this.ownerOfAddIn, this);
     this.tprx.runAction_async(catcher);
 }

 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="ownerOfAddIn">Owner of addin</param>
 public ExplainTableIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
 {
     this.ownerOfAddIn = ownerOfAddIn;
     //setting the ResManager resource manager and localization string
     resManager = new ResourceManager("Ferda.FrontEnd.AddIns.ExplainTable.Localization_en-US",
     Assembly.GetExecutingAssembly());
     localizationString = "en-US";
 }

 /// <summary>
 /// Default constructor of the class
 /// </summary>
 /// <param name="mod">Modules manager of the application</param>
 /// <param name="resManager">Resource manager</param>
 /// <param name="box">Box that has thrown the exception</param>
 /// <param name="userMessage">Message to be displayed to the user</param>
 public BoxExceptionClass(IBoxModule box, string userMessage, Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
 {
     //   this.resourceManager = resManager;
     this.box = box;
     this.userMessage = userMessage;
     this.modulesManager = ownerOfAddIn.ProjectManager.ModulesManager;
     this.ownerOfAddIn = ownerOfAddIn;
 }

 public ResultBrowserIce(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn, Ferda.FrontEnd.Properties.IOtherObjectDisplayer Displayer)
 {
     this.ownerOfAddIn = ownerOfAddIn;
     //setting the ResManager resource manager and localization string
     resManager = new ResourceManager("Ferda.FrontEnd.AddIns.ResultBrowser.Localization_en-US",
     Assembly.GetExecutingAssembly());
     localizationString = "en-US";
     this.Displayer = Displayer;
 }

 public void AddFactory(Ferda.Modules.BoxModuleFactoryPrx factoryPrx)
 {
     lock(this)
     {
         _factories[factoryPrx]=
             Ferda.Modules.BoxModuleFactoryPrxHelper.uncheckedCast(
                 factoryPrx.ice_batchOneway()
             );
     }
 }

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //a/(a+b)
     return
         (float)quantifierSetting.secondContingencyTableRows[0][0] /
         (float)(
         quantifierSetting.secondContingencyTableRows[0][0] +
         quantifierSetting.secondContingencyTableRows[0][1]
         );
 }

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     //(a+d)/(a+b+c+d)
     return
         (float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         )
         /
         (float)(
         quantifierSetting.firstContingencyTableRows[0][0] +
         quantifierSetting.firstContingencyTableRows[0][1] +
         quantifierSetting.firstContingencyTableRows[1][0] +
         quantifierSetting.firstContingencyTableRows[1][1]
         );
 }

            public BoxModule(Ferda.Modules.BoxModulePrx iceBoxModulePrx, BoxModuleFactoryCreator madeInCreator, Helper helper, ModulesManager modulesManager)
            {
                this.iceBoxModulePrx = iceBoxModulePrx;
                this.madeInCreator = madeInCreator;
                this.iceIdentity = Ice.Util.identityToString(
                    iceBoxModulePrx.ice_getIdentity());
                this.helper = helper;
                this.modulesManager = modulesManager;
                this.managersLocatorI = this.helper.ManagersEngineI.ManagersLocatorI;
                foreach(PropertyInfo property in madeInCreator.Properties)
                {
                    this.propertyNames.Add(property.name);
                }

                //string[] driver = this.MadeInCreator.PropertyDrivingLabel;
                //if (driver != null && driver.Length != 0)
                //{
                //    propertyDrivingLabel = driver[0];
                //}
            }

 public abstract void GetProperty_async(Ferda.Modules.AMI_BoxModule_getProperty callBack, string name);

 public StringSeqSettingModule(Ferda.FrontEnd.AddIns.IOwnerOfAddIn ownerOfAddIn)
 {
     this.ownerOfAddIn = ownerOfAddIn;
 }

        /// <summary>
        /// Ice run
        /// </summary>
        /// <param name="boxModuleParam">BoxModuleParams</param>
        /// <param name="localePrefs">localeprefs</param>
        /// <param name="manager">Manager proxy</param>
        /// <param name="__current">Ice context</param>
        public override void run(Ferda.Modules.BoxModulePrx boxModuleParam, string[] localePrefs, ManagersEnginePrx manager, Ice.Current __current)
        {
            string locale;
            try
            {
                locale = localePrefs[0];
                localizationString = locale;
                locale = "Ferda.FrontEnd.AddIns.ExplainTable.Localization_" + locale;
                resManager = new ResourceManager(locale, Assembly.GetExecutingAssembly());
            }
            catch
            {
            }
            Ferda.Modules.Boxes.DataMiningCommon.DataMatrix.DataMatrixFunctionsPrx prx =
                Ferda.Modules.Boxes.DataMiningCommon.DataMatrix.DataMatrixFunctionsPrxHelper.checkedCast(boxModuleParam.getFunctions());

            try
            {
                string label = manager.getProjectInformation().getUserLabel(Ice.Util.identityToString(boxModuleParam.ice_getIdentity()));
                Ferda.FrontEnd.AddIns.ExplainTable.ExplainTable control = new ExplainTable(localePrefs, prx.explain(), prx.getDataMatrixInfo(), ownerOfAddIn);
                this.ownerOfAddIn.ShowDockableControl(control, resManager.GetString("Explain") + " " + label);
            }

            catch (Ferda.Modules.NoConnectionInSocketError)
            {
                MessageBox.Show(resManager.GetString("BoxNotConnected"), resManager.GetString("Error"),
                           MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

            catch (Ferda.Modules.BadParamsError ex)
            {
                if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbConnectionString)
                {
                    MessageBox.Show(resManager.GetString("BadConnectionString"), resManager.GetString("Error"),
                               MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                else if (ex.restrictionType == Ferda.Modules.restrictionTypeEnum.DbTable)
                {
                    MessageBox.Show(resManager.GetString("NoDataMatrix"), resManager.GetString("Error"),
                               MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
        }

 public abstract void SetConnection(string socketName, Ferda.ModulesManager.IBoxModule otherModule);

 public override float getStatistics(Ferda.Modules.AbstractQuantifierSetting quantifierSetting, Ice.Current current__)
 {
     return (float)Common.Functions.Max(quantifierSetting.firstContingencyTableRows);
 }

 /// <summary>
 /// Helper method for registering standard box to Ice Object Adapter
 /// </summary>
 /// <param name="identity">Name of box</param>
 /// <param name="boxInfo">An <see cref="T:Ferda.Modules.Boxes.IBoxInfo"/> implementation for this box</param>
 public void registerBox(string identity, Ferda.Modules.Boxes.IBoxInfo boxInfo)
 {
     Debug.WriteLine("Registering " + identity + "...");
     BoxModuleFactoryCreatorI boxModuleFactoryCreator = new BoxModuleFactoryCreatorI(boxInfo, reaper);
     Ice.ObjectPrx newPrx = _adapter.add(boxModuleFactoryCreator, Ice.Util.stringToIdentity(identity));
 }

 void Ferda.Modules.IFunctions.setBoxModuleInfo(Ferda.Modules.BoxModuleI boxModule, Ferda.Modules.Boxes.IBoxInfo boxInfo)
 {
     this.boxModule = boxModule;
     this.boxInfo = boxInfo;
 }