Пример #1
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Project");

            CreateAppConfigError = dict.GetPhrase("CreateAppConfigError");
            DeleteAppConfigError = dict.GetPhrase("DeleteAppConfigError");

            dict = Locale.GetDictionary("Scada.Admin.Project.ConfigBase");
            LoadConfigBaseError = dict.GetPhrase("LoadConfigBaseError");
            SaveConfigBaseError = dict.GetPhrase("SaveConfigBaseError");
            LoadBaseTableError  = dict.GetPhrase("LoadBaseTableError");
            SaveBaseTableError  = dict.GetPhrase("SaveBaseTableError");

            dict = Locale.GetDictionary("Scada.Admin.Project.ProjectInstance");
            CreateInstanceFilesError = dict.GetPhrase("CreateInstanceFilesError");
            DeleteInstanceFilesError = dict.GetPhrase("DeleteInstanceFilesError");
            RenameInstanceError      = dict.GetPhrase("RenameInstanceError");
            InstanceNameEmpty        = dict.GetPhrase("InstanceNameEmpty");
            InstanceNameInvalid      = dict.GetPhrase("InstanceNameInvalid");

            dict = Locale.GetDictionary("Scada.Admin.Project.ScadaProject");
            CreateProjectError     = dict.GetPhrase("CreateProjectError");
            LoadProjectError       = dict.GetPhrase("LoadProjectError");
            SaveProjectError       = dict.GetPhrase("SaveProjectError");
            LoadProjectDescrError  = dict.GetPhrase("LoadProjectDescrError");
            ProjectNameEmpty       = dict.GetPhrase("ProjectNameEmpty");
            ProjectNameInvalid     = dict.GetPhrase("ProjectNameInvalid");
            RenameProjectError     = dict.GetPhrase("RenameProjectError");
            ProjectDirectoryExists = dict.GetPhrase("ProjectDirectoryExists");
        }
Пример #2
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtDepPostgreSql.Downloader");

            DownloadTable      = dict["DownloadTable"];
            DownloadView       = dict["DownloadView"];
            DownloadConfigFile = dict["DownloadConfigFile"];

            dict                  = Locale.GetDictionary("Scada.Admin.Extensions.ExtDepPostgreSql.Uploader");
            CreateSchema          = dict["CreateSchema"];
            CreateAppDict         = dict["CreateAppDict"];
            ClearBase             = dict["ClearBase"];
            CreateBase            = dict["CreateBase"];
            DeleteTable           = dict["DeleteTable"];
            CreateTable           = dict["CreateTable"];
            CreateFKs             = dict["CreateFKs"];
            CreateTableFKs        = dict["CreateTableFKs"];
            ClearViews            = dict["ClearViews"];
            CreateViews           = dict["CreateViews"];
            CreateView            = dict["CreateView"];
            ClearAllAppConfig     = dict["ClearAllAppConfig"];
            ClearAppConfig        = dict["ClearAppConfig"];
            CreateAppConfig       = dict["CreateAppConfig"];
            CreateConfigFile      = dict["CreateConfigFile"];
            UnableRestartServices = dict["UnableRestartServices"];
        }
Пример #3
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvModbus.Config.DeviceTemplate");

            LoadTemplateError = dict["LoadTemplateError"];
            SaveTemplateError = dict["SaveTemplateError"];

            dict              = Locale.GetDictionary("Scada.Comm.Drivers.DrvModbus.View.Controls");
            AddressHint       = dict["AddressHint"];
            ElemRemoveWarning = dict["ElemRemoveWarning"];

            dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvModbus.View.Forms.FrmDeviceProps");
            ConfigDirRequired = dict["ConfigDirRequired"];
            TemplateNotExists = dict["TemplateNotExists"];

            dict                   = Locale.GetDictionary("Scada.Comm.Drivers.DrvModbus.View.Forms.FrmDeviceTemplate");
            TemplateTitle          = dict["TemplateTitle"];
            ElemGroupsNode         = dict["ElemGroupsNode"];
            CommandsNode           = dict["CommandsNode"];
            UnnamedElemGroup       = dict["UnnamedElemGroup"];
            UnnamedElem            = dict["UnnamedElem"];
            UnnamedCommand         = dict["UnnamedCommand"];
            SaveTemplateConfirm    = dict["SaveTemplateConfirm"];
            ElemCntExceeded        = dict["ElemCntExceeded"];
            DuplicatedCodes        = dict["DuplicatedCodes"];
            DuplicatedCmdNums      = dict["DuplicatedCmdNums"];
            EmptyTagCodes          = dict["EmptyTagCodes"];
            EmptyCmdCodes          = dict["EmptyCmdCodes"];
            VerificationPassed     = dict["VerificationPassed"];
            CloneElemConfigConfirm = dict["CloneElemConfigConfirm"];
        }
Пример #4
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvCnlBasic.View.BasicChannelView");

            ChannelTypeNotFound = dict["ChannelTypeNotFound"];

            dict         = Locale.GetDictionary("Scada.Comm.Drivers.DrvCnlBasic.View.Forms.FrmTcpClientChannelOptions");
            HostRequired = dict["HostRequired"];
        }
Пример #5
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvMqttPublisher.View.MqttPublisherConfigProvider");

            FormTitle      = dict[nameof(FormTitle)];
            AddItemButton  = dict[nameof(AddItemButton)];
            OptionsNode    = dict[nameof(OptionsNode)];
            ItemsNode      = dict[nameof(ItemsNode)];
            ItemNodeFormat = dict[nameof(ItemNodeFormat)];
        }
Пример #6
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Application");

            UnhandledException    = dict.GetPhrase("UnhandledException");
            ExecutionImpossible   = dict.GetPhrase("ExecutionImpossible");
            StartLogic            = dict.GetPhrase("StartLogic");
            LogicIsAlreadyStarted = dict.GetPhrase("LogicIsAlreadyStarted");
            StartLogicError       = dict.GetPhrase("StartLogicError");
            LogicIsStopped        = dict.GetPhrase("LogicIsStopped");
            UnableToStopLogic     = dict.GetPhrase("UnableToStopLogic");
            StopLogicError        = dict.GetPhrase("StopLogicError");
            LogicCycleError       = dict.GetPhrase("LogicCycleError");
            ThreadFatalError      = dict.GetPhrase("ThreadFatalError");
            WriteInfoError        = dict.GetPhrase("WriteInfoError");
            ConnectionNotFound    = dict.GetPhrase("ConnectionNotFound");

            dict           = Locale.GetDictionary("Scada.ConfigBase");
            ArchiveTable   = dict.GetPhrase("ArchiveTable");
            CmdTypeTable   = dict.GetPhrase("CmdTypeTable");
            CmdValTable    = dict.GetPhrase("CmdValTable");
            CnlStatusTable = dict.GetPhrase("CnlStatusTable");
            CnlTypeTable   = dict.GetPhrase("CnlTypeTable");
            CommLineTable  = dict.GetPhrase("CommLineTable");
            DataTypeTable  = dict.GetPhrase("DataTypeTable");
            DeviceTable    = dict.GetPhrase("DeviceTable");
            DevTypeTable   = dict.GetPhrase("DevTypeTable");
            FormatTable    = dict.GetPhrase("FormatTable");
            InCnlTable     = dict.GetPhrase("InCnlTable");
            LimTable       = dict.GetPhrase("LimTable");
            ObjTable       = dict.GetPhrase("ObjTable");
            ObjRightTable  = dict.GetPhrase("ObjRightTable");
            OutCnlTable    = dict.GetPhrase("OutCnlTable");
            QuantityTable  = dict.GetPhrase("QuantityTable");
            RoleTable      = dict.GetPhrase("RoleTable");
            RoleRefTable   = dict.GetPhrase("RoleRefTable");
            ScriptTable    = dict.GetPhrase("ScriptTable");
            UnitTable      = dict.GetPhrase("UnitTable");
            UserTable      = dict.GetPhrase("UserTable");
            ViewTable      = dict.GetPhrase("ViewTable");
            ViewTypeTable  = dict.GetPhrase("ViewTypeTable");

            dict               = Locale.GetDictionary("Scada.Files");
            FileNotFound       = dict.GetPhrase("FileNotFound");
            NamedFileNotFound  = dict.GetPhrase("NamedFileNotFound");
            LoadAppConfigError = dict.GetPhrase("LoadAppConfigError");
            SaveAppConfigError = dict.GetPhrase("SaveAppConfigError");

            dict            = Locale.GetDictionary("Scada.Format");
            UndefinedSign   = dict.GetPhrase("UndefinedSign");
            NotNumber       = dict.GetPhrase("NotNumber");
            NotHexadecimal  = dict.GetPhrase("NotHexadecimal");
            InvalidParamVal = dict.GetPhrase("InvalidParamVal");
        }
Пример #7
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Web.Plugins.PlgScheme.Template.TemplateBindings");

            LoadTemplateBindingsError = dict.GetPhrase("LoadTemplateBindingsError");
            SaveTemplateBindingsError = dict.GetPhrase("SaveTemplateBindingsError");

            dict                   = Locale.GetDictionary("Scada.Web.Plugins.PlgScheme.CompManager");
            UnknownComponent       = dict.GetPhrase("UnknownComponent");
            CompLibraryNotFound    = dict.GetPhrase("CompLibraryNotFound");
            UnableCreateComponent  = dict.GetPhrase("UnableCreateComponent");
            ErrorCreatingComponent = dict.GetPhrase("ErrorCreatingComponent");
        }
Пример #8
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvMqttClient.View.MqttClientConfigProvider");

            FormTitle             = dict[nameof(FormTitle)];
            AddSubscriptionButton = dict[nameof(AddSubscriptionButton)];
            AddCommandButton      = dict[nameof(AddCommandButton)];
            OptionsNode           = dict[nameof(OptionsNode)];
            SubscriptionsNode     = dict[nameof(SubscriptionsNode)];
            CommandsNode          = dict[nameof(CommandsNode)];
            UnnamedSubscription   = dict[nameof(UnnamedSubscription)];
            UnnamedCommand        = dict[nameof(UnnamedCommand)];
        }
Пример #9
0
        /// <summary>
        /// Получить словарь атрибутов свойств
        /// </summary>
        private static Dictionary <string, PropAttrs> GetPropAttrsDict(LocaleDict dict)
        {
            Dictionary <string, PropAttrs> propAttrsDict = new();

            foreach (string phraseKey in dict.Phrases.Keys)
            {
                string phraseVal = dict.Phrases[phraseKey];
                int    dotPos    = phraseKey.IndexOf('.');

                if (0 < dotPos && dotPos < phraseKey.Length - 1)
                {
                    // если точка в середине ключа фразы, то слева от точки - имя свойства, справа - имя атрибута
                    string propName     = phraseKey[..dotPos];
Пример #10
0
        public static void Init()
        {
            // set phrases depending on the locale
            if (Locale.IsRussian)
            {
                ErrorInPlugin = "Ошибка при вызове метода {0} плагина {1}";
                ErrorInWebApi = "Ошибка при вызове метода веб-API {0}";
                PluginMessage = "Плагин {0}: {1}";
            }
            else
            {
                ErrorInPlugin = "Error calling the {0} method of the {1} plugin";
                ErrorInWebApi = "Error calling the {0} web API method";
                PluginMessage = "Plugin {0}: {1}";
            }

            // load phrases from dictionaries
            LocaleDict dict = Locale.GetDictionary("Scada.Web");

            CorrectErrors   = dict["CorrectErrors"];
            ClientError     = dict["ClientError"];
            UnknownUsername = dict["UnknownUsername"];
            AccessDenied    = dict["AccessDenied"];

            dict                   = Locale.GetDictionary("Scada.Web.Code.ViewLoader");
            ViewNotSpecified       = dict["ViewNotSpecified"];
            ViewNotExists          = dict["ViewNotExists"];
            InsufficientViewRights = dict["InsufficientViewRights"];
            UnableResolveViewSpec  = dict["UnableResolveViewSpec"];
            UnableLoadView         = dict["UnableLoadView"];
            ViewMissingFromCache   = dict["ViewMissingFromCache"];
            ViewUndefined          = dict["ViewUndefined"];

            dict = Locale.GetDictionary("Scada.Web.Plugins");
            LoadPluginConfigError = dict["LoadPluginConfigError"];
            SavePluginConfigError = dict["SavePluginConfigError"];
            CnlNotFound           = dict["CnlNotFound"];
            CnlNotOutput          = dict["CnlNotOutput"];
            CommandsDisabled      = dict["CommandsDisabled"];
            SendCommand           = dict["SendCommand"];
            ActionNotAllowed      = dict["ActionNotAllowed"];

            dict                   = Locale.GetDictionary("Scada.Web.TreeView.MenuItem");
            ReportsMenuItem        = dict["ReportsMenuItem"];
            AdministrationMenuItem = dict["AdministrationMenuItem"];
            ConfigurationMenuItem  = dict["ConfigurationMenuItem"];
            RegistrationMenuItem   = dict["RegistrationMenuItem"];
            PluginsMenuItem        = dict["PluginsMenuItem"];
            AboutMenuItem          = dict["AboutMenuItem"];
        }
Пример #11
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.AB.Forms.FrmAddressBook");

            AddressBookNode        = dict[nameof(AddressBookNode)];
            NewContactGroup        = dict[nameof(NewContactGroup)];
            NewContact             = dict[nameof(NewContact)];
            NewPhoneNumber         = dict[nameof(NewPhoneNumber)];
            NewEmail               = dict[nameof(NewEmail)];
            ContactGroupExists     = dict[nameof(ContactGroupExists)];
            ContactExists          = dict[nameof(ContactExists)];
            PhoneNumberExists      = dict[nameof(PhoneNumberExists)];
            EmailExists            = dict[nameof(EmailExists)];
            IncorrectEmail         = dict[nameof(IncorrectEmail)];
            EmptyValueNotAllowed   = dict[nameof(EmptyValueNotAllowed)];
            SaveAddressBookConfirm = dict[nameof(SaveAddressBookConfirm)];
        }
Пример #12
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtDepAgent.Downloader");

            ImportTable    = dict["ImportTable"];
            ExtractArchive = dict["ExtractArchive"];
            MergeDirectory = dict["MergeDirectory"];
            NothingToMerge = dict["NothingToMerge"];

            dict               = Locale.GetDictionary("Scada.Admin.Extensions.ExtDepAgent.Uploader");
            TestAgentConn      = dict["TestAgentConn"];
            CompressConfig     = dict["CompressConfig"];
            CompressBase       = dict["CompressBase"];
            CompressViews      = dict["CompressViews"];
            CompressAppConfig  = dict["CompressAppConfig"];
            AddProjectInfo     = dict["AddProjectInfo"];
            AddTransferOptions = dict["AddTransferOptions"];
            TransferConfig     = dict["TransferConfig"];
            ArchiveSize        = dict["ArchiveSize"];
        }
Пример #13
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtWirenBoard.Controls.CtrlDeviceTree");

            SelectDevice = dict[nameof(SelectDevice)];

            dict                 = Locale.GetDictionary("Scada.Admin.Extensions.ExtWirenBoard.Controls.CtrlLineSelect");
            CommLineRequired     = dict[nameof(CommLineRequired)];
            MqttLineRequired     = dict[nameof(MqttLineRequired)];
            WirenBoardIpRequired = dict[nameof(WirenBoardIpRequired)];

            dict                  = Locale.GetDictionary("Scada.Admin.Extensions.ExtWirenBoard.Forms.FrmWirenBoardWizard");
            Step1Descr            = dict[nameof(Step1Descr)];
            Step2Descr            = dict[nameof(Step2Descr)];
            Step3Descr            = dict[nameof(Step3Descr)];
            Step4Descr            = dict[nameof(Step4Descr)];
            Step5Descr            = dict[nameof(Step5Descr)];
            CreateConfigCompleted = dict[nameof(CreateConfigCompleted)];
            CreateConfigError     = dict[nameof(CreateConfigError)];
        }
Пример #14
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvOpcUa.View.Forms.FrmConfig");

            ConnectServerError    = dict[nameof(ConnectServerError)];
            DisconnectServerError = dict[nameof(DisconnectServerError)];
            BrowseServerError     = dict[nameof(BrowseServerError)];
            GetDataTypeError      = dict[nameof(GetDataTypeError)];
            ServerUrlRequired     = dict[nameof(ServerUrlRequired)];
            EmptyNode             = dict[nameof(EmptyNode)];
            SubscriptionsNode     = dict[nameof(SubscriptionsNode)];
            CommandsNode          = dict[nameof(CommandsNode)];
            UnnamedSubscription   = dict[nameof(UnnamedSubscription)];
            UnnamedItem           = dict[nameof(UnnamedItem)];
            UnnamedCommand        = dict[nameof(UnnamedCommand)];
            UnknownDataType       = dict[nameof(UnknownDataType)];

            dict          = Locale.GetDictionary("Scada.Comm.Drivers.DrvOpcUa.View.Forms.FrmNodeAttr");
            ReadAttrError = dict[nameof(ReadAttrError)];
        }
Пример #15
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Web.Plugins.PlgMain.Areas.Main.Pages.TableView");

            TableViewTitle = dict[nameof(TableViewTitle)];
            PrevDate       = dict[nameof(PrevDate)];
            SelDate        = dict[nameof(SelDate)];
            MinusOneDay    = dict[nameof(MinusOneDay)];
            ItemColumn     = dict[nameof(ItemColumn)];
            CurrentColumn  = dict[nameof(CurrentColumn)];
            CnlTip         = dict[nameof(CnlTip)];
            DeviceTip      = dict[nameof(DeviceTip)];
            ObjTip         = dict[nameof(ObjTip)];
            QuantityTip    = dict[nameof(QuantityTip)];
            UnitTip        = dict[nameof(UnitTip)];
            SendCommandTip = dict[nameof(SendCommandTip)];

            dict             = Locale.GetDictionary("Scada.Web.Plugins.PlgMain.Code.EventWindowSpec");
            EventWindowTitle = dict[nameof(EventWindowTitle)];
        }
Пример #16
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Code.ChannelMap");

            MapByDeviceTitle        = dict["MapByDeviceTitle"];
            MapByObjectTitle        = dict["MapByObjectTitle"];
            ChannelsCaption         = dict["ChannelsCaption"];
            NoChannels              = dict["NoChannels"];
            GenerateChannelMapError = dict["GenerateChannelMapError"];

            dict                   = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Code.DeviceMap");
            DeviceMapTitle         = dict["DeviceMapTitle"];
            DevicesCaption         = dict["DevicesCaption"];
            NoDevices              = dict["NoDevices"];
            EmptyCommLine          = dict["EmptyCommLine"];
            GenerateDeviceMapError = dict["GenerateDeviceMapError"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Code.IntegrityCheck");
            IntegrityCheckTitle = dict["IntegrityCheckTitle"];
            TableCorrect        = dict["TableCorrect"];
            TableHasErrors      = dict["TableHasErrors"];
            LostPrimaryKeys     = dict["LostPrimaryKeys"];
            BaseHasErrors       = dict["BaseHasErrors"];
            IntegrityCheckError = dict["IntegrityCheckError"];

            dict                   = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Forms.FrmCnlClone");
            KeepUnchanged          = dict["KeepUnchanged"];
            CloneChannelsCompleted = dict["CloneChannelsCompleted"];
            CloneChannelsError     = dict["CloneChannelsError"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Forms.FrmTableExport");
            ExportTableFilter = dict["ExportTableFilter"];
            ExportTableError  = dict["ExportTableError"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtProjectTools.Forms.FrmTableImport");
            ImportTableFilter    = dict["ImportTableFilter"];
            ImportTableCompleted = dict["ImportTableCompleted"];
            ImportTableError     = dict["ImportTableError"];
        }
Пример #17
0
        /// <summary>
        /// Builds a dictionary that contains attribute values accessed by property name.
        /// </summary>
        private static Dictionary <string, PropAttrs> BuildPropAttrsDict(LocaleDict dict)
        {
            Dictionary <string, PropAttrs> propAttrsDict = new Dictionary <string, PropAttrs>();

            foreach (string phraseKey in dict.Phrases.Keys)
            {
                string phraseVal = dict.Phrases[phraseKey];
                int    dotIdx    = phraseKey.IndexOf('.');

                if (0 < dotIdx && dotIdx < phraseKey.Length - 1)
                {
                    // PropertyName.AttributeName
                    string propName  = phraseKey.Substring(0, dotIdx);
                    string attrName  = phraseKey.Substring(dotIdx + 1);
                    bool   itemFound = propAttrsDict.TryGetValue(propName, out PropAttrs propAttrs);

                    if (!itemFound)
                    {
                        propAttrs = new PropAttrs();
                        propAttrsDict.Add(propName, propAttrs);
                    }

                    if (attrName == "DisplayName")
                    {
                        propAttrs.DisplayName = phraseVal;
                    }
                    else if (attrName == "Category")
                    {
                        propAttrs.Category = phraseVal;
                    }
                    else if (attrName == "Description")
                    {
                        propAttrs.Description = phraseVal;
                    }
                }
            }

            return(propAttrsDict);
        }
Пример #18
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtServerConfig.ExtServerConfigLogic");

            GeneralOptionsNode = dict["GeneralOptionsNode"];
            ModulesNode        = dict["ModulesNode"];
            ArchivesNode       = dict["ArchivesNode"];
            LogsNode           = dict["LogsNode"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtServerConfig.Forms.FrmArchives");
            ModuleNotSpecified      = dict["ModuleNotSpecified"];
            ArchiveNotSupported     = dict["ArchiveNotSupported"];
            UnableCreateArchiveView = dict["UnableCreateArchiveView"];
            NoArchiveProperties     = dict["NoArchiveProperties"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtServerConfig.Forms.FrmGeneralOptions");
            InvalidObjectRange = dict["InvalidObjectRange"];

            dict          = Locale.GetDictionary("Scada.Admin.Extensions.ExtServerConfig.Forms.FrmServerLogs");
            AppFilter     = dict["AppFilter"];
            ModulesFilter = dict["ModulesFilter"];
        }
Пример #19
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Drivers.DrvDsOpcUaServer.View.Forms.FrmOpcUaServerDSO");

            ConfigDirRequired = dict["ConfigDirRequired"];
        }
Пример #20
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Web.Plugins.PlgScheme.Areas.Scheme.Pages.SchemeView");

            SchemeViewTitle = dict["SchemeViewTitle"];
        }
Пример #21
0
        /// <summary>
        /// Получить отображаемое наименование из словарей
        /// </summary>
        private static string GetDisplayName(Type compType)
        {
            LocaleDict dict = Locale.GetDictionary(compType.FullName);

            return(dict.Phrases.ContainsKey("DisplayName") ? dict["DisplayName"] : compType.Name);
        }
Пример #22
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.App.Code.AppState");

            LoadAppStateError = dict["LoadAppStateError"];
            SaveAppStateError = dict["SaveAppStateError"];

            dict = Locale.GetDictionary("Scada.Admin.App.Code.ExplorerBuilder");
            ConfigDatabaseNode  = dict["ConfigDatabaseNode"];
            PrimaryTablesNode   = dict["PrimaryTablesNode"];
            SecondaryTablesNode = dict["SecondaryTablesNode"];
            ViewsNode           = dict["ViewsNode"];
            InstancesNode       = dict["InstancesNode"];
            ServerNode          = dict["ServerNode"];
            CommNode            = dict["CommNode"];
            WebNode             = dict["WebNode"];
            AppConfigNode       = dict["AppConfigNode"];
            DeviceFilter        = dict["DeviceFilter"];
            EmptyDeviceFilter   = dict["EmptyDeviceFilter"];

            dict                 = Locale.GetDictionary("Scada.Admin.App.Controls.Deployment.CtrlProfileSelector");
            ProfileNotSet        = dict["ProfileNotSet"];
            ConfirmDeleteProfile = dict["ConfirmDeleteProfile"];

            dict = Locale.GetDictionary("Scada.Admin.App.Controls.Deployment.CtrlTransferOptions");
            ConfigNotSelected   = dict["ConfigNotSelected"];
            InvalidObjectFilter = dict["InvalidObjectFilter"];

            dict                  = Locale.GetDictionary("Scada.Admin.App.Forms");
            SelectedColumn        = dict["SelectedColumn"];
            NoProfileConnections  = dict["NoProfileConnections"];
            ExtensionNotFound     = dict["ExtensionNotFound"];
            ExtensionCannotDeploy = dict["ExtensionCannotDeploy"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Deployment.FrmInstanceProfile");
            AgentConnectionOK    = dict["AgentConnectionOK"];
            AgentConnectionError = dict["AgentConnectionError"];
            DbConnectionOK       = dict["DbConnectionOK"];
            DbConnectionError    = dict["DbConnectionError"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Deployment.FrmInstanceStatus");
            ControlServiceSuccessful = dict["ControlServiceSuccessful"];
            UnableControlService     = dict["UnableControlService"];
            ControlServiceError      = dict["ControlServiceError"];
            AgentDisabled            = dict["AgentDisabled"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Deployment.FrmProfileEdit");
            ProfileNameDuplicated = dict["ProfileNameDuplicated"];

            dict               = Locale.GetDictionary("Scada.Admin.App.Forms.Deployment.FrmTransfer");
            DownloadTitle      = dict["DownloadTitle"];
            DownloadProgress   = dict["DownloadProgress"];
            DownloadError      = dict["DownloadError"];
            UploadTitle        = dict["UploadTitle"];
            UploadProgress     = dict["UploadProgress"];
            UploadError        = dict["UploadError"];
            OperationCompleted = dict["OperationCompleted"];
            OperationCanceled  = dict["OperationCanceled"];
            OperationError     = dict["OperationError"];

            dict              = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmBaseTable");
            GridViewError     = dict["GridViewError"];
            ColumnLabel       = dict["ColumnLabel"];
            DeleteRowConfirm  = dict["DeleteRowConfirm"];
            DeleteRowsConfirm = dict["DeleteRowsConfirm"];
            ClearTableConfirm = dict["ClearTableConfirm"];
            RowsNotDeleted    = dict["RowsNotDeleted"];
            ColumnNotNull     = dict["ColumnNotNull"];
            UniqueRequired    = dict["UniqueRequired"];
            KeyReferenced     = dict["KeyReferenced"];
            DataNotExist      = dict["DataNotExist"];
            DataChangeError   = dict["DataChangeError"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmFilter");
            IncorrectTableFilter = dict["IncorrectTableFilter"];

            dict            = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmFind");
            ValueNotFound   = dict["ValueNotFound"];
            SearchCompleted = dict["SearchCompleted"];
            ReplaceCount    = dict["ReplaceCount"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmLimCreate");
            LimExistsInConfigDatabase = dict["LimExistsInConfigDatabase"];
            DefaultLimName            = dict["DefaultLimName"];

            dict       = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmTextDialog");
            TextLine   = dict["TextLine"];
            TextLength = dict["TextLength"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tools.FrmCulture");
            LoadCulturesError = dict["LoadCulturesError"];
            CultureRequired   = dict["CultureRequired"];
            CultureNotFound   = dict["CultureNotFound"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tools.FrmConfig");
            ProjectExtRegistered = dict["ProjectExtRegistered"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tools.FrmFileAssociation");
            ExecutableFileFilter = dict.GetPhrase("ExecutableFileFilter");

            dict            = Locale.GetDictionary("Scada.Admin.App.Forms.FrmFileNew");
            FileNameEmpty   = dict["FileNameEmpty"];
            FileNameInvalid = dict["FileNameInvalid"];

            dict                = Locale.GetDictionary("Scada.Admin.App.Forms.FrmInstanceEdit");
            NewInstanceTitle    = dict["NewInstanceTitle"];
            EditInstanceTitle   = dict["EditInstanceTitle"];
            InstanceNameEmpty   = dict["InstanceNameEmpty"];
            InstanceNameInvalid = dict["InstanceNameInvalid"];
            InstanceSelectApps  = dict["InstanceSelectApps"];

            dict               = Locale.GetDictionary("Scada.Admin.App.Forms.FrmItemName");
            ItemNameEmpty      = dict["ItemNameEmpty"];
            ItemNameInvalid    = dict["ItemNameInvalid"];
            ItemNameDuplicated = dict["ItemNameDuplicated"];

            dict                      = Locale.GetDictionary("Scada.Admin.App.Forms.FrmMain");
            EmptyTitle                = dict["EmptyTitle"];
            ProjectTitle              = dict["ProjectTitle"];
            WelcomeMessage            = dict["WelcomeMessage"];
            SelectItemMessage         = dict["SelectItemMessage"];
            ProjectFileFilter         = dict["ProjectFileFilter"];
            ConfirmDeleteDirectory    = dict["ConfirmDeleteDirectory"];
            ConfirmDeleteFile         = dict["ConfirmDeleteFile"];
            ConfirmDeleteInstance     = dict["ConfirmDeleteInstance"];
            FileOperationError        = dict["FileOperationError"];
            DirectoryAlreadyExists    = dict["DirectoryAlreadyExists"];
            FileAlreadyExists         = dict["FileAlreadyExists"];
            InstanceAlreadyExists     = dict["InstanceAlreadyExists"];
            SaveConfigDatabaseConfirm = dict["SaveConfigDatabaseConfirm"];
            DeviceNotFoundInComm      = dict["DeviceNotFoundInComm"];
            WebUrlNotSet              = dict["WebUrlNotSet"];
            ReopenProject             = dict["ReopenProject"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.FrmProjectNew");
            ChooseProjectLocation   = dict["ChooseProjectLocation"];
            ProjectNameEmpty        = dict["ProjectNameEmpty"];
            ProjectNameInvalid      = dict["ProjectNameInvalid"];
            ProjectLocationEmpty    = dict["ProjectLocationEmpty"];
            ProjectLocationInvalid  = dict["ProjectLocationInvalid"];
            ProjectAlreadyExists    = dict["ProjectAlreadyExists"];
            ProjectTemplateEmpty    = dict["ProjectTemplateEmpty"];
            ProjectTemplateNotFound = dict["ProjectTemplateNotFound"];

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.FrmTextEditor");
            OpenTextFileError = dict["OpenTextFileError"];
            SaveTextFileError = dict["SaveTextFileError"];
        }
Пример #23
0
        public static void Init()
        {
            // set phrases depending on the locale
            if (Locale.IsRussian)
            {
                ErrorInExtension = "Ошибка при вызове метода {0} расширения {1}";
                ExtensionMessage = "Расширение {0}: {1}";
            }
            else
            {
                ErrorInExtension = "Error calling the {0} method of the {1} extension";
                ExtensionMessage = "Extension {0}: {1}";
            }

            // load phrases from dictionaries
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Deployment.DeploymentConfig");

            LoadDeploymentConfigError = dict["LoadDeploymentConfigError"];
            SaveDeploymentConfigError = dict["SaveDeploymentConfigError"];

            dict                    = Locale.GetDictionary("Scada.Admin.Extensions");
            AgentNotEnabled         = dict["AgentNotEnabled"];
            DbNotEnabled            = dict["DbNotEnabled"];
            UploadConfig            = dict["UploadConfig"];
            UploadConfigCompleted   = dict["UploadConfigCompleted"];
            DownloadConfig          = dict["DownloadConfig"];
            DownloadConfigCompleted = dict["DownloadConfigCompleted"];
            DownloadBase            = dict["DownloadBase"];
            DownloadViews           = dict["DownloadViews"];
            DownloadAppConfig       = dict["DownloadAppConfig"];
            FileCount               = dict["FileCount"];
            FileLoading             = dict["FileLoading"];
            StartNamedService       = dict["StartNamedService"];
            StopNamedService        = dict["StopNamedService"];
            RestartNamedService     = dict["RestartNamedService"];
            ServiceCommandCompleted = dict["ServiceCommandCompleted"];
            ServiceCommandFailed    = dict["ServiceCommandFailed"];
            EmptyDevice             = dict["EmptyDevice"];
            EmptyObject             = dict["EmptyObject"];

            dict           = Locale.GetDictionary("Scada.Admin.Forms.FrmLogs");
            AllFilesFilter = dict["AllFilesFilter"];

            dict            = Locale.GetDictionary("Scada.Admin.Forms.FrmRegistration");
            LoadRegKeyError = dict["LoadRegKeyError"];
            SaveRegKeyError = dict["SaveRegKeyError"];

            dict = Locale.GetDictionary("Scada.Admin.Project");
            CreateAppConfigError = dict["CreateAppConfigError"];
            DeleteAppConfigError = dict["DeleteAppConfigError"];

            dict = Locale.GetDictionary("Scada.Admin.Project.ConfigDatabase");
            LoadConfigDatabaseError = dict["LoadConfigDatabaseError"];
            SaveConfigDatabaseError = dict["SaveConfigDatabaseError"];
            LoadBaseTableError      = dict["LoadBaseTableError"];
            SaveBaseTableError      = dict["SaveBaseTableError"];

            dict = Locale.GetDictionary("Scada.Admin.Project.ProjectInstance");
            CreateInstanceFilesError = dict["CreateInstanceFilesError"];
            DeleteInstanceFilesError = dict["DeleteInstanceFilesError"];
            RenameInstanceError      = dict["RenameInstanceError"];
            InstanceNameEmpty        = dict["InstanceNameEmpty"];
            InstanceNameInvalid      = dict["InstanceNameInvalid"];

            dict = Locale.GetDictionary("Scada.Admin.Project.ScadaProject");
            CreateProjectError     = dict["CreateProjectError"];
            LoadProjectError       = dict["LoadProjectError"];
            SaveProjectError       = dict["SaveProjectError"];
            LoadProjectDescrError  = dict["LoadProjectDescrError"];
            ProjectNameEmpty       = dict["ProjectNameEmpty"];
            ProjectNameInvalid     = dict["ProjectNameInvalid"];
            RenameProjectError     = dict["RenameProjectError"];
            ProjectDirectoryExists = dict["ProjectDirectoryExists"];
        }
Пример #24
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Application");

            ProductName           = dict["ProductName"];
            ServerAppName         = dict["ServerAppName"];
            CommAppName           = dict["CommAppName"];
            WebAppName            = dict["WebAppName"];
            WebsiteUrl            = dict["WebsiteUrl"];
            UnhandledException    = dict["UnhandledException"];
            ExecutionImpossible   = dict["ExecutionImpossible"];
            StartLogic            = dict["StartLogic"];
            LogicAlreadyStarted   = dict["LogicAlreadyStarted"];
            StartLogicError       = dict["StartLogicError"];
            LogicStopped          = dict["LogicStopped"];
            UnableToStopLogic     = dict["UnableToStopLogic"];
            StopLogicError        = dict["StopLogicError"];
            LogicCycleError       = dict["LogicCycleError"];
            ThreadFatalError      = dict["ThreadFatalError"];
            WriteInfoError        = dict["WriteInfoError"];
            ConnectionNotFound    = dict["ConnectionNotFound"];
            ConnOptionsNotFound   = dict["ConnOptionsNotFound"];
            DatabaseNotSupported  = dict["DatabaseNotSupported"];
            OperationNotSupported = dict["OperationNotSupported"];
            CommandSent           = dict["CommandSent"];
            SendCommandError      = dict["SendCommandError"];
            AgentDisabled         = dict["AgentDisabled"];

            dict           = Locale.GetDictionary("Scada.ConfigDatabase");
            UndefinedTable = dict["UndefinedTable"];
            ArchiveTable   = dict["ArchiveTable"];
            CnlTable       = dict["CnlTable"];
            CnlStatusTable = dict["CnlStatusTable"];
            CnlTypeTable   = dict["CnlTypeTable"];
            CommLineTable  = dict["CommLineTable"];
            DataTypeTable  = dict["DataTypeTable"];
            DeviceTable    = dict["DeviceTable"];
            DevTypeTable   = dict["DevTypeTable"];
            FormatTable    = dict["FormatTable"];
            LimTable       = dict["LimTable"];
            ObjTable       = dict["ObjTable"];
            ObjRightTable  = dict["ObjRightTable"];
            QuantityTable  = dict["QuantityTable"];
            RoleTable      = dict["RoleTable"];
            RoleRefTable   = dict["RoleRefTable"];
            ScriptTable    = dict["ScriptTable"];
            UnitTable      = dict["UnitTable"];
            UserTable      = dict["UserTable"];
            ViewTable      = dict["ViewTable"];
            ViewTypeTable  = dict["ViewTypeTable"];
            IndexNotFound  = dict["IndexNotFound"];
            EntityCaption  = dict["EntityCaption"];

            dict               = Locale.GetDictionary("Scada.Files");
            FileNotFound       = dict["FileNotFound"];
            NamedFileNotFound  = dict["NamedFileNotFound"];
            DirectoryNotExists = dict["DirectoryNotExists"];
            PathNotSupported   = dict["PathNotSupported"];
            InvalidFileFormat  = dict["InvalidFileFormat"];
            LoadConfigError    = dict["LoadConfigError"];
            SaveConfigError    = dict["SaveConfigError"];
            SaveConfigConfirm  = dict["SaveConfigConfirm"];
            LoadViewError      = dict["LoadViewError"];
            SaveViewError      = dict["SaveViewError"];

            dict                   = Locale.GetDictionary("Scada.Format");
            IntegerRequired        = dict["IntegerRequired"];
            IntegerInRangeRequired = dict["IntegerInRangeRequired"];
            RealRequired           = dict["RealRequired"];
            NonemptyRequired       = dict["NonemptyRequired"];
            ValidUrlRequired       = dict["ValidUrlRequired"];
            ValidRangeRequired     = dict["ValidRangeRequired"];
            DateTimeRequired       = dict["DateTimeRequired"];
            NotNumber              = dict["NotNumber"];
            NotHexadecimal         = dict["NotHexadecimal"];
            InvalidParamVal        = dict["InvalidParamVal"];
            InvalidSecretKey       = dict["InvalidSecretKey"];
            UndefinedSign          = dict["UndefinedSign"];
            CriticalSeverity       = dict["CriticalSeverity"];
            MajorSeverity          = dict["MajorSeverity"];
            MinorSeverity          = dict["MinorSeverity"];
            InfoSeverity           = dict["InfoSeverity"];

            dict              = Locale.GetDictionary("Scada.Forms");
            InfoCaption       = dict["InfoCaption"];
            QuestionCaption   = dict["QuestionCaption"];
            ErrorCaption      = dict["ErrorCaption"];
            WarningCaption    = dict["WarningCaption"];
            NoData            = dict["NoData"];
            EmptyData         = dict["EmptyData"];
            CorrectErrors     = dict["CorrectErrors"];
            HiddenPassword    = dict["HiddenPassword"];
            NewConnection     = dict["NewConnection"];
            UnnamedConnection = dict["UnnamedConnection"];
            XmlFileFilter     = dict["XmlFileFilter"];

            dict            = Locale.GetDictionary("Scada.ComponentModel");
            TrueValue       = dict["TrueValue"];
            FalseValue      = dict["FalseValue"];
            EmptyValue      = dict["EmptyValue"];
            CollectionValue = dict["CollectionValue"];

            dict = Locale.GetDictionary("Scada.CnlDataFormatter");
            CommandDescrPrefix = dict["CommandDescrPrefix"];
            StatusFormat       = dict["StatusFormat"];

            dict              = Locale.GetDictionary("Scada.Forms.BitItemCollection");
            EventEnabled      = dict["EventEnabled"];
            EventBeep         = dict["EventBeep"];
            DataChangeEvent   = dict["DataChangeEvent"];
            ValueChangeEvent  = dict["ValueChangeEvent"];
            StatusChangeEvent = dict["StatusChangeEvent"];
            CnlUndefinedEvent = dict["CnlUndefinedEvent"];
            CommandEvent      = dict["CommandEvent"];
        }
Пример #25
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.ExtCommConfigLogic");

            GeneralOptionsNode = dict["GeneralOptionsNode"];
            DriversNode        = dict["DriversNode"];
            DataSourcesNode    = dict["DataSourcesNode"];
            LinesNode          = dict["LinesNode"];
            LineOptionsNode    = dict["LineOptionsNode"];
            LineStatsNode      = dict["LineStatsNode"];
            LogsNode           = dict["LogsNode"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Code.ExtensionUtils");
            DeviceNotSupported     = dict["DeviceNotSupported"];
            UnableCreateDeviceView = dict["UnableCreateDeviceView"];
            NoDeviceProperties     = dict["NoDeviceProperties"];

            dict             = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Controls.CtrlCnlCreate1");
            AllCommLines     = dict["AllCommLines"];
            DeviceInfo       = dict["DeviceInfo"];
            DeviceNotFound   = dict["DeviceNotFound"];
            NoDeviceSelected = dict["NoDeviceSelected"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Controls.CtrlExtensionMenu");
            ConfirmDeleteLine = dict["ConfirmDeleteLine"];
            CnlNodeNotFound   = dict["CnlNodeNotFound"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Controls.CtrlLineMain");
            UndefinedChannelType    = dict["UndefinedChannelType"];
            ChannelNotSupported     = dict["ChannelNotSupported"];
            UnableCreateChannelView = dict["UnableCreateChannelView"];
            NoChannelProperties     = dict["NoChannelProperties"];

            dict                = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmCnlCreate");
            CreateCnlsStep1     = dict["CreateCnlsStep1"];
            CreateCnlsStep2     = dict["CreateCnlsStep2"];
            CreateCnlsStep3     = dict["CreateCnlsStep3"];
            CreateCnlsCompleted = dict["CreateCnlsCompleted"];

            dict          = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmCommLogs");
            AppFilter     = dict["AppFilter"];
            LinesFilter   = dict["LinesFilter"];
            DevicesFilter = dict["DevicesFilter"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmDataSources");
            DriverNotSpecified         = dict["DriverNotSpecified"];
            DataSourceNotSupported     = dict["DataSourceNotSupported"];
            UnableCreateDataSourceView = dict["UnableCreateDataSourceView"];
            NoDataSourceProperties     = dict["NoDataSourceProperties"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmDeviceAdd");
            DeviceExistsInConfigDatabase = dict["DeviceExistsInConfigDatabase"];
            DeviceExistsInLineConfig     = dict["DeviceExistsInLineConfig"];
            LineNotFoundInCommConfig     = dict["LineNotFoundInCommConfig"];
            ChooseLine = dict["ChooseLine"];

            dict = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmLineAdd");
            LineExistsInConfigDatabase = dict["LineExistsInConfigDatabase"];
            LineExistsInCommConfig     = dict["LineExistsInCommConfig"];

            dict            = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmLineConfig");
            LineConfigTitle = dict["LineConfigTitle"];

            dict           = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmLineStats");
            LineStatsTitle = dict["LineStatsTitle"];

            dict                   = Locale.GetDictionary("Scada.Admin.Extensions.ExtCommConfig.Forms.FrmSync");
            SyncCompleted          = dict["SyncCompleted"];
            SyncCompletedWithError = dict["SyncCompletedWithError"];
            NoDataToSync           = dict["NoDataToSync"];
        }
Пример #26
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.App.Code.AppState");

            LoadAppStateError = dict.GetPhrase("LoadAppStateError");
            SaveAppStateError = dict.GetPhrase("SaveAppStateError");

            dict              = Locale.GetDictionary("Scada.Admin.App.Code.AppUtils");
            EventEnabled      = dict.GetPhrase("EventEnabled");
            EventBeep         = dict.GetPhrase("EventBeep");
            DataChangeEvent   = dict.GetPhrase("DataChangeEvent");
            ValueChangeEvent  = dict.GetPhrase("ValueChangeEvent");
            StatusChangeEvent = dict.GetPhrase("StatusChangeEvent");
            CnlUndefinedEvent = dict.GetPhrase("CnlUndefinedEvent");

            dict                = Locale.GetDictionary("Scada.Admin.App.Code.ExplorerBuilder");
            BaseNode            = dict.GetPhrase("BaseNode");
            PrimaryTablesNode   = dict.GetPhrase("PrimaryTablesNode");
            SecondaryTablesNode = dict.GetPhrase("SecondaryTablesNode");
            TableByDeviceNode   = dict.GetPhrase("TableByDeviceNode");
            EmptyDeviceNode     = dict.GetPhrase("EmptyDeviceNode");
            ViewsNode           = dict.GetPhrase("ViewsNode");
            InstancesNode       = dict.GetPhrase("InstancesNode");
            ServerNode          = dict.GetPhrase("ServerNode");
            CommNode            = dict.GetPhrase("CommNode");
            WebNode             = dict.GetPhrase("WebNode");
            EmptyNode           = dict.GetPhrase("EmptyNode");
            DeviceFilter        = dict.GetPhrase("DeviceFilter");
            EmptyDeviceFilter   = dict.GetPhrase("EmptyDeviceFilter");

            dict          = Locale.GetDictionary("Scada.Admin.App.Forms");
            CorrectErrors = dict.GetPhrase("CorrectErrors");

            dict              = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmBaseTable");
            GridViewError     = dict.GetPhrase("GridViewError");
            ColumnLabel       = dict.GetPhrase("ColumnLabel");
            DeleteRowConfirm  = dict.GetPhrase("DeleteRowConfirm");
            DeleteRowsConfirm = dict.GetPhrase("DeleteRowsConfirm");
            ClearTableConfirm = dict.GetPhrase("ClearTableConfirm");
            RowsNotDeleted    = dict.GetPhrase("RowsNotDeleted");
            ColumnNotNull     = dict.GetPhrase("ColumnNotNull");
            UniqueRequired    = dict.GetPhrase("UniqueRequired");
            KeyReferenced     = dict.GetPhrase("KeyReferenced");
            DataNotExist      = dict.GetPhrase("DataNotExist");
            DataChangeError   = dict.GetPhrase("DataChangeError");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmFilter");
            IncorrectTableFilter = dict.GetPhrase("IncorrectTableFilter");

            dict           = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmFind");
            ValueNotFound  = dict.GetPhrase("ValueNotFound");
            SearchComplete = dict.GetPhrase("SearchComplete");
            ReplaceCount   = dict.GetPhrase("ReplaceCount");

            dict       = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmTextDialog");
            TextLine   = dict.GetPhrase("TextLine");
            TextLength = dict.GetPhrase("TextLength");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tools.FrmCulture");
            LoadCulturesError = dict.GetPhrase("LoadCulturesError");
            CultureRequired   = dict.GetPhrase("CultureRequired");
            CultureNotFound   = dict.GetPhrase("CultureNotFound");

            dict            = Locale.GetDictionary("Scada.Admin.App.Forms.FrmFileNew");
            FileNameEmpty   = dict.GetPhrase("FileNameEmpty");
            FileNameInvalid = dict.GetPhrase("FileNameInvalid");

            dict                = Locale.GetDictionary("Scada.Admin.App.Forms.FrmInstanceEdit");
            NewInstanceTitle    = dict.GetPhrase("NewInstanceTitle");
            EditInstanceTitle   = dict.GetPhrase("EditInstanceTitle");
            InstanceNameEmpty   = dict.GetPhrase("InstanceNameEmpty");
            InstanceNameInvalid = dict.GetPhrase("InstanceNameInvalid");
            InstanceSelectApps  = dict.GetPhrase("InstanceSelectApps");

            dict               = Locale.GetDictionary("Scada.Admin.App.Forms.FrmItemName");
            ItemNameEmpty      = dict.GetPhrase("ItemNameEmpty");
            ItemNameInvalid    = dict.GetPhrase("ItemNameInvalid");
            ItemNameDuplicated = dict.GetPhrase("ItemNameDuplicated");

            dict                   = Locale.GetDictionary("Scada.Admin.App.Forms.FrmMain");
            EmptyTitle             = dict.GetPhrase("EmptyTitle");
            ProjectTitle           = dict.GetPhrase("ProjectTitle");
            WelcomeMessage         = dict.GetPhrase("WelcomeMessage");
            SelectItemMessage      = dict.GetPhrase("SelectItemMessage");
            ProjectFileFilter      = dict.GetPhrase("ProjectFileFilter");
            ConfirmDeleteDirectory = dict.GetPhrase("ConfirmDeleteDirectory");
            ConfirmDeleteFile      = dict.GetPhrase("ConfirmDeleteFile");
            ConfirmDeleteInstance  = dict.GetPhrase("ConfirmDeleteInstance");
            ConfirmDeleteCommLine  = dict.GetPhrase("ConfirmDeleteCommLine");
            FileOperationError     = dict.GetPhrase("FileOperationError");
            DirectoryAlreadyExists = dict.GetPhrase("DirectoryAlreadyExists");
            FileAlreadyExists      = dict.GetPhrase("FileAlreadyExists");
            InstanceAlreadyExists  = dict.GetPhrase("InstanceAlreadyExists");
            SaveConfigBaseConfirm  = dict.GetPhrase("SaveConfigBaseConfirm");
            DeviceNotFoundInComm   = dict.GetPhrase("DeviceNotFoundInComm");
            WebUrlNotSet           = dict.GetPhrase("WebUrlNotSet");
            ReopenProject          = dict.GetPhrase("ReopenProject");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.FrmProjectNew");
            ChooseProjectLocation    = dict.GetPhrase("ChooseProjectLocation");
            ProjectNameEmpty         = dict.GetPhrase("ProjectNameEmpty");
            ProjectNameInvalid       = dict.GetPhrase("ProjectNameInvalid");
            ProjectLocationNotExists = dict.GetPhrase("ProjectLocationNotExists");
            ProjectAlreadyExists     = dict.GetPhrase("ProjectAlreadyExists");
            ProjectTemplateEmpty     = dict.GetPhrase("ProjectTemplateEmpty");
            ProjectTemplateNotFound  = dict.GetPhrase("ProjectTemplateNotFound");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.FrmTextEditor");
            OpenTextFileError = dict.GetPhrase("OpenTextFileError");
            SaveTextFileError = dict.GetPhrase("SaveTextFileError");
        }
Пример #27
0
        public static void Init()
        {
            // set phrases that are used in the bilingual service logic, depending on the locale
            if (Locale.IsRussian)
            {
                ErrorInArchive = "Ошибка при вызове метода {0} архива {1}";
                ErrorInModule  = "Ошибка при вызове метода {0} модуля {1}";

                ArchiveMessage             = "Архив {0}: {1}";
                NullResultNotAllowed       = "Результат метода не может быть null.";
                InvalidWritingPeriod       = "Период записи должен быть положительным.";
                WritingModeNotSupported    = "Режим записи не поддерживается архивом {0}.";
                WritingModeIsSlow          = "Выбранный режим записи может снизить производительность";
                DeleteOutdatedData         = "Удаление устаревших данных из архива {0}, которые старше {1}";
                ReadingTrendsCompleted     = "Чтение трендов длины {0} успешно завершено за {1} мс";
                ReadingTrendCompleted      = "Чтение тренда длины {0} успешно завершено за {1} мс";
                ReadingTimestampsCompleted = "Чтение меток времени длины {0} успешно завершено за {1} мс";
                ReadingSliceCompleted      = "Чтение среза длины {0} успешно завершено за {1} мс";
                ReadingPointsCompleted     = "Чтение {0} точек данных успешно завершено за {1} мс";
                WritingSliceCompleted      = "Запись среза длины {0} успешно завершена за {1} мс";
                WritingPointsCompleted     = "Запись {0} точек данных успешно завершена за {1} мс";
                QueueingPointsCompleted    = "Постановка в очередь {0} точек данных успешно завершена за {1} мс";
                QueueBecameEmpty           = "Очередь данных стала пустой";
                PointsWereLost             = "{0} точек данных были потеряны";
                UpdateCompleted            = "Обновление данных успешно завершено за {0} мс";
                ReadingEventsCompleted     = "Чтение {0} событий успешно завершено за {1} мс";
                ReadingEventCompleted      = "Чтение события успешно завершено за {0} мс";
                WritingEventCompleted      = "Запись события успешно завершена за {0} мс";
                QueueingEventCompleted     = "Постановка события в очередь успешно завершена за {0} мс";
                EventsWereLost             = "{0} событий были потеряны";
                AckEventCompleted          = "Квитирование события с ид. {0} успешно завершено за {1} мс";
                AckEventNotFound           = "Квитируемое событие с ид. {0} не найдено";

                StartModule          = "Модуль {0} {1} запущен";
                StopModule           = "Модуль {0} остановлен";
                ModuleMessage        = "Модуль {0}: {1}";
                ReadDbError          = "Ошибка при чтении из базы данных";
                WriteDbError         = "Ошибка при записи в базу данных";
                ModuleStateLoaded    = "Состояние модуля загружено";
                ModuleStateNotExists = "Файл состояния модуля отсутствует или устарел";
                LoadModuleStateError = "Ошибка при загрузке состояния модуля";
                SaveModuleStateError = "Ошибка при сохранении состояния модуля";
            }
            else
            {
                ErrorInArchive = "Error calling the {0} method of the {1} archive";
                ErrorInModule  = "Error calling the {0} method of the {1} module";

                ArchiveMessage             = "Archive {0}: {1}";
                NullResultNotAllowed       = "Method result must not be null.";
                InvalidWritingPeriod       = "Writing period must be positive.";
                WritingModeNotSupported    = "Writing mode is not supported by the {0} archive.";
                WritingModeIsSlow          = "The selected writing mode may decrease performance";
                DeleteOutdatedData         = "Delete outdated data from the {0} archive older than {1}";
                ReadingTrendsCompleted     = "Reading trends of length {0} completed successfully in {1} ms";
                ReadingTrendCompleted      = "Reading a trend of length {0} completed successfully in {1} ms";
                ReadingTimestampsCompleted = "Reading timestamps of length {0} completed successfully in {1} ms";
                ReadingSliceCompleted      = "Reading a slice of length {0} completed successfully in {1} ms";
                ReadingPointsCompleted     = "Reading of {0} data points completed successfully in {1} ms";
                WritingSliceCompleted      = "Writing a slice of length {0} completed successfully in {1} ms";
                WritingPointsCompleted     = "Writing of {0} data points completed successfully in {1} ms";
                QueueingPointsCompleted    = "Enqueueing of {0} data points completed successfully in {1} ms";
                QueueBecameEmpty           = "Data queue has become empty";
                PointsWereLost             = "{0} data points were lost";
                UpdateCompleted            = "Data update completed successfully in {0} ms";
                ReadingEventsCompleted     = "Reading of {0} events completed successfully in {1} ms";
                ReadingEventCompleted      = "Reading an event completed successfully in {0} ms";
                WritingEventCompleted      = "Event writing completed successfully in {0} ms";
                QueueingEventCompleted     = "Enqueueing an event completed successfully in {0} ms";
                EventsWereLost             = "{0} events were lost";
                AckEventCompleted          = "Acknowledging an event with ID {0} completed successfully in {1} ms";
                AckEventNotFound           = "Acknowledged event with ID {0} not found";

                StartModule          = "Module {0} {1} started";
                StopModule           = "Module {0} is stopped";
                ModuleMessage        = "Module {0}: {1}";
                ReadDbError          = "Error reading from database";
                WriteDbError         = "Error writing to database";
                ModuleStateLoaded    = "Module state loaded";
                ModuleStateNotExists = "Module state file is missing or outdated";
                LoadModuleStateError = "Error loading module state";
                SaveModuleStateError = "Error saving module state";
            }

            // load phrases that are used in the multilingual user interface from dictionaries
            LocaleDict dict = Locale.GetDictionary("Scada.Server.Archives");

            UnspecifiedArchiveKind = dict.GetPhrase("UnspecifiedArchiveKind");
            CurrentArchiveKind     = dict.GetPhrase("CurrentArchiveKind");
            HistoricalArchiveKind  = dict.GetPhrase("HistoricalArchiveKind");
            EventsArchiveKind      = dict.GetPhrase("EventsArchiveKind");

            dict = Locale.GetDictionary("Scada.Server.Modules");
            LoadModuleConfigError   = dict.GetPhrase("LoadModuleConfigError");
            SaveModuleConfigError   = dict.GetPhrase("SaveModuleConfigError");
            SaveModuleConfigConfirm = dict.GetPhrase("SaveModuleConfigConfirm");

            dict          = Locale.GetDictionary("Scada.Server.Engine.CoreLogic");
            CommandSentBy = dict.GetPhrase("CommandSentBy");
        }
Пример #28
0
        public static void Init()
        {
            LocaleDict dict = Locale.GetDictionary("Scada.Admin.App.Code.AppState");

            LoadAppStateError = dict.GetPhrase("LoadAppStateError");
            SaveAppStateError = dict.GetPhrase("SaveAppStateError");

            dict                = Locale.GetDictionary("Scada.Admin.App.Code.ExplorerBuilder");
            BaseNode            = dict.GetPhrase("BaseNode");
            PrimaryTablesNode   = dict.GetPhrase("PrimaryTablesNode");
            SecondaryTablesNode = dict.GetPhrase("SecondaryTablesNode");
            TableByDeviceNode   = dict.GetPhrase("TableByDeviceNode");
            EmptyDeviceNode     = dict.GetPhrase("EmptyDeviceNode");
            ViewsNode           = dict.GetPhrase("ViewsNode");
            InstancesNode       = dict.GetPhrase("InstancesNode");
            ServerNode          = dict.GetPhrase("ServerNode");
            CommNode            = dict.GetPhrase("CommNode");
            WebNode             = dict.GetPhrase("WebNode");
            EmptyNode           = dict.GetPhrase("EmptyNode");
            DeviceFilter        = dict.GetPhrase("DeviceFilter");
            EmptyDeviceFilter   = dict.GetPhrase("EmptyDeviceFilter");

            dict              = Locale.GetDictionary("Scada.Admin.App.Forms.Tables.FrmBaseTable");
            GridViewError     = dict.GetPhrase("GridViewError");
            ColumnLabel       = dict.GetPhrase("ColumnLabel");
            DeleteRowConfirm  = dict.GetPhrase("DeleteRowConfirm");
            DeleteRowsConfirm = dict.GetPhrase("DeleteRowsConfirm");
            ClearTableConfirm = dict.GetPhrase("ClearTableConfirm");
            RowsNotDeleted    = dict.GetPhrase("RowsNotDeleted");
            ColumnNotNull     = dict.GetPhrase("ColumnNotNull");
            UniqueRequired    = dict.GetPhrase("UniqueRequired");
            KeyReferenced     = dict.GetPhrase("KeyReferenced");
            DataNotExist      = dict.GetPhrase("DataNotExist");
            DataChangeError   = dict.GetPhrase("DataChangeError");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.Tools.FrmCulture");
            LoadCulturesError = dict.GetPhrase("LoadCulturesError");
            CultureRequired   = dict.GetPhrase("CultureRequired");
            CultureNotFound   = dict.GetPhrase("CultureNotFound");

            dict                   = Locale.GetDictionary("Scada.Admin.App.Forms.FrmMain");
            EmptyTitle             = dict.GetPhrase("EmptyTitle");
            ProjectTitle           = dict.GetPhrase("ProjectTitle");
            WelcomeMessage         = dict.GetPhrase("WelcomeMessage");
            SelectItemMessage      = dict.GetPhrase("SelectItemMessage");
            ProjectFileFilter      = dict.GetPhrase("ProjectFileFilter");
            ConfirmDeleteDirectory = dict.GetPhrase("ConfirmDeleteDirectory");
            ConfirmDeleteFile      = dict.GetPhrase("ConfirmDeleteFile");
            ConfirmDeleteInstance  = dict.GetPhrase("ConfirmDeleteInstance");
            ConfirmDeleteCommLine  = dict.GetPhrase("ConfirmDeleteCommLine");
            FileOperationError     = dict.GetPhrase("FileOperationError");
            DirectoryAlreadyExists = dict.GetPhrase("DirectoryAlreadyExists");
            FileAlreadyExists      = dict.GetPhrase("FileAlreadyExists");
            InstanceAlreadyExists  = dict.GetPhrase("InstanceAlreadyExists");
            SaveConfigBaseConfirm  = dict.GetPhrase("SaveConfigBaseConfirm");
            DeviceNotFoundInComm   = dict.GetPhrase("DeviceNotFoundInComm");
            WebUrlNotSet           = dict.GetPhrase("WebUrlNotSet");
            ReopenProject          = dict.GetPhrase("ReopenProject");

            dict = Locale.GetDictionary("Scada.Admin.App.Forms.FrmProjectNew");
            ChooseProjectLocation    = dict.GetPhrase("ChooseProjectLocation");
            ProjectNameEmpty         = dict.GetPhrase("ProjectNameEmpty");
            ProjectNameInvalid       = dict.GetPhrase("ProjectNameInvalid");
            ProjectLocationNotExists = dict.GetPhrase("ProjectLocationNotExists");
            ProjectAlreadyExists     = dict.GetPhrase("ProjectAlreadyExists");
            ProjectTemplateEmpty     = dict.GetPhrase("ProjectTemplateEmpty");
            ProjectTemplateNotFound  = dict.GetPhrase("ProjectTemplateNotFound");
        }
Пример #29
0
        public static void Init()
        {
            // load phrases from dictionaries, because the service user interface is multilingual
            LocaleDict dict = Locale.GetDictionary("Scada.Server.Modules");

            LoadModuleConfigError = dict.GetPhrase("LoadModuleConfigError");
            SaveModuleConfigError = dict.GetPhrase("SaveModuleConfigError");

            // set phrases depending on locale, because the service logic supports only 2 languages
            if (Locale.IsRussian)
            {
                ErrorInArchive = "Ошибка при вызове метода {0} архива {1}";
                ErrorInModule  = "Ошибка при вызове метода {0} модуля {1}";

                ArchiveMessage             = "Архив {0}: {1}";
                NullResultNotAllowed       = "Результат метода не может быть null.";
                InvalidWritingPeriod       = "Период записи должен быть положительным.";
                WritingModeNotSupported    = "Режим записи не поддерживается архивом {0}.";
                WritingModeIsSlow          = "Выбранный режим записи может снизить производительность";
                DeleteOutdatedData         = "Удаление устаревших данных из архива {0}, которые старше {1}";
                ReadingTrendsCompleted     = "Чтение трендов длины {0} успешно завершено за {1} мс";
                ReadingTrendCompleted      = "Чтение тренда длины {0} успешно завершено за {1} мс";
                ReadingTimestampsCompleted = "Чтение меток времени длины {0} успешно завершено за {1} мс";
                ReadingSliceCompleted      = "Чтение среза длины {0} успешно завершено за {1} мс";
                ReadingPointsCompleted     = "Чтение {0} точек данных успешно завершено за {1} мс";
                WritingSliceCompleted      = "Запись среза длины {0} успешно завершена за {1} мс";
                WritingPointsCompleted     = "Запись {0} точек данных успешно завершена за {1} мс";
                QueueingPointsCompleted    = "Постановка в очередь {0} точек данных успешно завершена за {1} мс";
                QueueBecameEmpty           = "Очередь данных стала пустой";
                PointsWereLost             = "{0} точек данных были потеряны";
                UpdateCompleted            = "Обновление данных успешно завершено за {0} мс";
                ReadingEventsCompleted     = "Чтение {0} событий успешно завершено за {1} мс";
                ReadingEventCompleted      = "Чтение события успешно завершено за {0} мс";
                WritingEventCompleted      = "Запись события успешно завершена за {0} мс";
                QueueingEventCompleted     = "Постановка события в очередь успешно завершена за {0} мс";
                EventsWereLost             = "{0} событий были потеряны";
                AckEventCompleted          = "Квитирование события с ид. {0} успешно завершено за {1} мс";
                AckEventNotFound           = "Квитируемое событие с ид. {0} не найдено";

                ReadDbError  = "Ошибка при чтении из базы данных";
                WriteDbError = "Ошибка при записи в базу данных";
            }
            else
            {
                ErrorInArchive = "Error calling the {0} method of the {1} archive";
                ErrorInModule  = "Error calling the {0} method of the {1} module";

                ArchiveMessage             = "Archive {0}: {1}";
                NullResultNotAllowed       = "Method result must not be null.";
                InvalidWritingPeriod       = "Writing period must be positive.";
                WritingModeNotSupported    = "Writing mode is not supported by the {0} archive.";
                WritingModeIsSlow          = "The selected writing mode may decrease performance";
                DeleteOutdatedData         = "Delete outdated data from the {0} archive older than {1}";
                ReadingTrendsCompleted     = "Reading trends of length {0} completed successfully in {1} ms";
                ReadingTrendCompleted      = "Reading a trend of length {0} completed successfully in {1} ms";
                ReadingTimestampsCompleted = "Reading timestamps of length {0} completed successfully in {1} ms";
                ReadingSliceCompleted      = "Reading a slice of length {0} completed successfully in {1} ms";
                ReadingPointsCompleted     = "Reading of {0} data points completed successfully in {1} ms";
                WritingSliceCompleted      = "Writing a slice of length {0} completed successfully in {1} ms";
                WritingPointsCompleted     = "Writing of {0} data points completed successfully in {1} ms";
                QueueingPointsCompleted    = "Enqueueing of {0} data points completed successfully in {1} ms";
                QueueBecameEmpty           = "Data queue has become empty";
                PointsWereLost             = "{0} data points were lost";
                UpdateCompleted            = "Data update completed successfully in {0} ms";
                ReadingEventsCompleted     = "Reading of {0} events completed successfully in {1} ms";
                ReadingEventCompleted      = "Reading an event completed successfully in {0} ms";
                WritingEventCompleted      = "Event writing completed successfully in {0} ms";
                QueueingEventCompleted     = "Enqueueing an event completed successfully in {0} ms";
                EventsWereLost             = "{0} events were lost";
                AckEventCompleted          = "Acknowledging an event with ID {0} completed successfully in {1} ms";
                AckEventNotFound           = "Acknowledged event with ID {0} not found";

                ReadDbError  = "Error reading from database";
                WriteDbError = "Error writing to database";
            }
        }
Пример #30
0
        public static void Init()
        {
            // set phrases that are used in the bilingual service logic, depending on the locale
            if (Locale.IsRussian)
            {
                ErrorInDriver     = "Ошибка при вызове метода {0} драйвера {1}";
                ErrorInChannel    = "Ошибка при вызове метода {0} канала связи {1}";
                ErrorInDevice     = "Ошибка при вызове метода {0} устройства {1}";
                ErrorInDataSource = "Ошибка при вызове метода {0} источника данных {1}";

                DataSourceMessage = "Источник данных {0}: {1}";

                SendNotation          = "Отправка";
                ReceiveNotation       = "Приём";
                ReadDataError         = "Ошибка при считывании данных";
                ReadDataStopCondError = "Ошибка при считывании данных с условием остановки";
                ReadLinesError        = "Ошибка при считывании строк";
                WriteDataError        = "Ошибка при записи данных";
                WriteLineError        = "Ошибка при записи строки";
                UnableFindDevice      = "Не удалось найти ни одного устройства с адресом {0}";

                DeviceMessage    = "Устройство {0}: {1}";
                ResponseOK       = "OK";
                ResponseError    = "Ошибка связи";
                ResponseCsError  = "Ошибка КС";
                ResponseCrcError = "Ошибка CRC";
                InvalidCommand   = "Ошибка: недопустимая команда";
                ErrorPrefix      = "Ошибка: ";
                Off = "Откл";
                On  = "Вкл";

                DriverMessage = "Драйвер {0}: {1}";
                SharedObject  = "<Объект>";
            }
            else
            {
                ErrorInDriver     = "Error calling the {0} method of the {1} driver";
                ErrorInChannel    = "Error calling the {0} method of the {1} communication channel";
                ErrorInDevice     = "Error calling the {0} method of the {1} device";
                ErrorInDataSource = "Error calling the {0} method of the {1} data source";

                DataSourceMessage = "Data source {0}: {1}";

                SendNotation          = "Send";
                ReceiveNotation       = "Receive";
                ReadDataError         = "Error reading data";
                ReadDataStopCondError = "Error reading data with stop condition";
                ReadLinesError        = "Error reading lines";
                WriteDataError        = "Error writing data";
                WriteLineError        = "Error writing line";
                UnableFindDevice      = "Unable to find any device with address {0}";

                DeviceMessage    = "Device {0}: {1}";
                ResponseOK       = "OK";
                ResponseError    = "Error: communication failed";
                ResponseCsError  = "Error: invalid checksum";
                ResponseCrcError = "Error: invalid CRC";
                InvalidCommand   = "Error: invalid command";
                ErrorPrefix      = "Error: ";
                Off = "Off";
                On  = "On";

                DriverMessage = "Driver {0}: {1}";
                SharedObject  = "<Object>";
            }


            // load phrases that are used in the multilingual user interface from dictionaries
            LocaleDict dict = Locale.GetDictionary("Scada.Comm.Devices");

            LoadDeviceConfigError   = dict["LoadDeviceConfigError"];
            SaveDeviceConfigError   = dict["SaveDeviceConfigError"];
            SaveDeviceConfigConfirm = dict["SaveDeviceConfigConfirm"];

            dict = Locale.GetDictionary("Scada.Comm.Drivers");
            LoadDriverConfigError   = dict["LoadDriverConfigError"];
            SaveDriverConfigError   = dict["SaveDriverConfigError"];
            SaveDriverConfigConfirm = dict["SaveDriverConfigConfirm"];
        }