public MainViewModel(ITtsService ttsService)
        {
            this.ttsService = ttsService;
            //// .... this was a test
            //ttsService.AddWordCallback((textBeingRead, start, length) =>
            //{
            //    // word
            //    PrependToLog($"[{start}:{length}] {textBeingRead.Substring(start, length)}");
            //});

            //TODO: use config file maybe
            var xmlFile = @"C:\OtherMiktemk\datafiles\german-grammar\german-grammar-split.xml";

            outputLang = "de";
            CurIndex   = 900;

            allText = XmlFactory.LoadFromFile <MultiLanguageText>(xmlFile);

            PlayStopCommand = new RelayCommand(PlayStop, () => true);

            PreviewKeyDownCommand = new RelayCommand <KeyEventArgs>((args) => {
                if (args.Key == Key.Left)
                {
                    CurIndex--;
                }
                if (args.Key == Key.Right)
                {
                    CurIndex++;
                }
                if (args.Key == Key.Space)
                {
                    PlayStop();
                }
            });
        }
Example #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="BlockInformation"/> class.
 /// </summary>
 /// TODO Edit XML Comment Template for #ctor
 public BlockInformation()
 {
     BlockNetworks  = new List <Network>();
     BlockInterface = new BlockInterface();
     BlockTitle     = new MultiLanguageText();
     BlockComment   = new MultiLanguageText();
 }
Example #3
0
        /// <summary>Initializes a new instance of the <see cref="Member"/> class.</summary>
        /// <param name="name">The name.</param>
        /// <param name="datatype">The datatype.</param>
        /// <param name="defaultValue">The default value.</param>
        /// <param name="comment">The comment.</param>
        /// TODO Edit XML Comment Template for #ctor
        // ReSharper disable once UnusedParameter.Local
        public Member(string name, string datatype, string defaultValue = "", string comment = "")
        {
            MemberName         = name;
            MemberDatatype     = datatype;
            MemberDefaultValue = defaultValue;

            MemberComment = new MultiLanguageText();
        }
Example #4
0
 public static void MapToMultiLanguageText(List<LocalizedValueModel> values, MultiLanguageText text, IEnumerable<Language> languages)
 {
     foreach (var language in languages)
     {
         var value = values.FirstOrDefault(x => x.Id == language.Id);
         text.AddLocalizedText(value.Value, language);
     }
 }
Example #5
0
        public ITableSchemeEx CreateObject(params object[] args)
        {
            string tableDesc = MultiLanguageText.ToString(TableDesc);

            var schemes = from item in Items
                          select item.CreateScheme();

            return(new UnionScheme(TableName, tableDesc, NameField, schemes));
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="Network"/> class.
        /// </summary>
        /// TODO Edit XML Comment Template for #ctor
        public Network()
        {
            NetworkAccess       = new List <Access>();
            NetworkInstructions = new List <Instruction>();
            NetworkCalls        = new List <CallRef>();

            NetworkTitle   = new MultiLanguageText();
            NetworkComment = new MultiLanguageText();
        }
Example #7
0
        /// <summary>Gets the title or comment.</summary>
        /// <param name="nodeToMultiLanguageText">The node to multi language text.</param>
        /// <param name="textItems">The text items.</param>
        /// TODO Edit XML Comment Template for GetTitleOrComment
        private void GetTitleOrComment(XmlNode nodeToMultiLanguageText, MultiLanguageText textItems)
        {
            var listTextItemValue = nodeToMultiLanguageText.SelectNodes(".//Value");

            if (listTextItemValue != null)
            {
                foreach (XmlNode nodeValue in listTextItemValue)
                {
                    if (nodeValue.Attributes != null)
                    {
                        textItems.MultiLanguageTextItems.Add(nodeValue.Attributes["lang"].Value, nodeValue.InnerText);
                    }
                }
            }
        }
Example #8
0
        public static IDataRight SetErrorText(this IDataRight right, MultiLanguageText errorMessage)
        {
            if (right == null || errorMessage == null)
            {
                return(right);
            }
            IRightCustomMessage message = right as IRightCustomMessage;

            if (message != null)
            {
                message.ErrorMessage = errorMessage.ToString();
            }

            return(right);
        }
 public void SetMultiLanguageText(MultiLanguageText text)
 {
     Init();
     //var font = LanguageManager.Instance.AlphabetFontMatrix.GetFont(
     //    _latinFont,LanguageManager.Instance.SelectedLanguage);
     //if (font)
     //    TextPro.font = font;
     if (TextPro)
     {
         TextPro.alignment = GetAlignment(LanguageManager.Instance.SelectedLanguage);
     }
     _multiLanguageText = text;
     if (_multiLanguageText != null)
     {
         SetText(LanguageManager.GetText(_multiLanguageText));
     }
 }
Example #10
0
        /// <summary>
        /// Initializes a new instance of the OperatorConfig class.
        /// </summary>
        public OperatorConfig(string id, string caption, OperatorPosition position, string info,
                              string confirmData, string iconClass, MarcoConfigItem content)
        {
            TkDebug.AssertArgumentNullOrEmpty(id, "id", null);
            TkDebug.AssertArgumentNullOrEmpty(caption, "caption", null);

            Id       = id;
            Caption  = new MultiLanguageText(caption);
            Position = position;
            Info     = info;
            if (!string.IsNullOrEmpty(confirmData))
            {
                ConfirmData = new MultiLanguageText(confirmData);
            }
            IconClass = iconClass;
            Content   = content;
        }
    public override void OnInspectorGUI()
    {
        MultiLanguageText multiLanguageText = (MultiLanguageText)target;

        //SHOW THE CURRENT TRADUCTION IN EDITOR//
        GUILayout.Label("Current traduction: " + multiLanguageText.currentTraduction.language.ToString(), EditorStyles.boldLabel);
        base.OnInspectorGUI();

        //ASSIGN THE EDITOR TEXT TO THE OBJECT//
        multiLanguageText.currentTraduction.text = multiLanguageText.text;

        //SHOW OTHER TRADUCTIONS//
        GUILayout.Label("Traductions", EditorStyles.boldLabel);
        foreach (Traduction _traduction in multiLanguageText.otherTraductions)
        {
            GUILayout.BeginHorizontal();
            if (GUILayout.Button("Select " + _traduction.language.ToString()))
            {
                multiLanguageText.UpdateLanguage(_traduction);
                Repaint();
                return;
            }
            else if (GUILayout.Button("Remove " + _traduction.language.ToString()))
            {
                multiLanguageText.RemoveTraduction(_traduction);
                return;
            }
            GUILayout.EndHorizontal();
        }

        //ADD LANGUAGE//
        SystemLanguage newLanguage = multiLanguageText.currentTraduction.language;

        newLanguage = (SystemLanguage)EditorGUILayout.EnumPopup("Add", newLanguage);
        if (newLanguage != multiLanguageText.currentTraduction.language)
        {
            Traduction newTraduction = multiLanguageText.AddTraduction(newLanguage);
            multiLanguageText.UpdateLanguage(newTraduction);
            Repaint();
            return;
        }
    }
Example #12
0
        /// <summary>Gets the block title or comment.</summary>
        /// <param name="xpath">The xpath.</param>
        /// <returns>MultiLanguageText</returns>
        /// TODO Edit XML Comment Template for GetBlockTitleOrComment
        private MultiLanguageText GetBlockTitleOrComment(string xpath)
        {
            var listTitleOrComment = RootNode.SelectNodes(xpath);
            var textItems          = new MultiLanguageText();

            if (listTitleOrComment != null)
            {
                foreach (XmlNode blockTitleNode in listTitleOrComment)
                {
                    if (blockTitleNode.ParentNode?.ParentNode != null && blockTitleNode.ParentNode.ParentNode.Name.Contains("SW.Blocks"))
                    {
                        if (blockTitleNode.Attributes != null)
                        {
                            textItems.CompositionNameInXml = blockTitleNode.Attributes["CompositionName"].Value;
                        }
                        GetTitleOrComment(blockTitleNode, textItems);
                    }
                }
            }

            return(textItems);
        }
Example #13
0
        public Program()
        {
            // TODO: use config file maybe
            var langCodeLatin = "de";
            var langCodeCyril = "ru";
            var inFile        = @"C:\OtherMiktemk\datafiles\german-grammar\german-grammar.txt";
            var outFile       = @"C:\OtherMiktemk\datafiles\german-grammar\german-grammar-split.xml";

            var textFile          = File.ReadAllLines(inFile);
            var textSentenceSplit = textFile.SelectMany(para => para.Split(new [] { ".", "?", "!" }, StringSplitOptions.RemoveEmptyEntries));

            var allTextStruct = new MultiLanguageText();

            foreach (var sentence in textSentenceSplit)
            {
                var phraseSplits = Utils.SplitAwayCyrillics(sentence, langCodeLatin, langCodeCyril).ToList();
                foreach (var phrase in phraseSplits)
                {
                    allTextStruct.Phrases.Add(phrase);
                }
            }

            XmlFactory.WriteToFile(allTextStruct, outFile);
        }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //	* New Static Method: Read From File
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    public static void ReadFromFile(LinkedList <CustomEditor_GameManager.MultiLanguageTextInstanceInfo> a_lMultiLanguageTextItems, GameManager.SystemLanguages a_eSelectedLanguage)
    {
        string openFilename = (Application.dataPath + "/Multi-Language-Urdu-Updated.xml");

        if (!System.IO.File.Exists(openFilename))
        {
            openFilename = EditorUtility.OpenFilePanel("Open File", @"C:\", "xml");
        }
        if (openFilename != "")
        {
            using (System.IO.StreamReader textReader = new System.IO.StreamReader(openFilename))
            {
                m_sErrorMessage = "";
                Dictionary <string, string> translationData = ReadExcelDocument(textReader.ReadToEnd().Replace("\r", "").Replace("\n", ""));
                if (translationData != null)
                {
                    LinkedList <string>    lUnTranslatedComponenets = new LinkedList <string>();
                    LinkedList <Component> lDirtyComponentsList     = new LinkedList <Component>();
                    foreach (CustomEditor_GameManager.MultiLanguageTextInstanceInfo mlti in a_lMultiLanguageTextItems)
                    {
                        MultiLanguageText textComponent = mlti.rInstance;
                        if (!(textComponent.m_arLanguageText.Length > (int)a_eSelectedLanguage))
                        {
                            ResizeArray(ref textComponent.m_arLanguageText, (int)a_eSelectedLanguage + 1);
                        }

                        string sTranslation = Regex.Replace(textComponent.m_arLanguageText[(int)GameManager.SystemLanguages.ENGLISH].text.Replace("\n", "").Replace("\r", ""), @"<color=#[a-zA-Z0-9]+?>(.*?)</color>",
                                                            m =>
                        {
                            return((m.Groups.Count > 1 && m.Groups[1].Value != "") ? string.Format("{0}", m.Groups[1].Value) : "");
                        },
                                                            RegexOptions.Multiline | RegexOptions.IgnoreCase).Replace(" ", "").ToUpper();
                        if (translationData.ContainsKey(sTranslation))
                        {
                            // Assign Translation Fixes and Alignment!
                            switch (a_eSelectedLanguage)
                            {
                            case GameManager.SystemLanguages.ARABIC:
                            case GameManager.SystemLanguages.PERSIAN:
                            case GameManager.SystemLanguages.URDU:
                                sTranslation = RTLService.RTL.Convert(Regex.Replace(translationData[sTranslation], "<color=#[a-zA-Z0-9]+?>", "").Replace("</color>", ""));
                                //textComponent.m_arLanguageText[(int)a_eSelectedLanguage].textAlignment = TextAlignment.Right;
                                break;

                            case GameManager.SystemLanguages.CHINESE_SIMPLIFIED:
                            case GameManager.SystemLanguages.JAPANESE:
                                sTranslation = translationData[sTranslation];
                                break;

                            default:
                                textComponent.m_arLanguageText[(int)a_eSelectedLanguage].chosenFont = textComponent.m_arLanguageText[(int)GameManager.SystemLanguages.ENGLISH].chosenFont;
                                sTranslation = translationData[sTranslation];
                                break;
                            }
                            textComponent.m_arLanguageText[(int)a_eSelectedLanguage].text = sTranslation;

                            if (textComponent.m_arLanguageText[(int)a_eSelectedLanguage].fontPosition == Vector3.zero)
                            {
                                textComponent.m_arLanguageText[(int)a_eSelectedLanguage].fontPosition = textComponent.m_arLanguageText[(int)GameManager.SystemLanguages.ENGLISH].fontPosition;
                            }

                            if (textComponent.m_arLanguageText[(int)a_eSelectedLanguage].fontSize == 0)
                            {
                                textComponent.m_arLanguageText[(int)a_eSelectedLanguage].fontSize = textComponent.m_arLanguageText[(int)GameManager.SystemLanguages.ENGLISH].fontSize;
                            }

                            if (textComponent.m_arLanguageText[(int)a_eSelectedLanguage].lineSpacing == 0.0f)
                            {
                                textComponent.m_arLanguageText[(int)a_eSelectedLanguage].lineSpacing = textComponent.m_arLanguageText[(int)GameManager.SystemLanguages.ENGLISH].lineSpacing;
                            }

                            if (!lDirtyComponentsList.Contains(mlti.rOwningParent))
                            {
                                lDirtyComponentsList.AddLast(mlti.rOwningParent);
                            }
                        }
                        else
                        {
                            if (sTranslation != "")
                            {
                                lUnTranslatedComponenets.AddLast(mlti.sDisplayLabel);
                            }
                        }
                    }

                    if (lUnTranslatedComponenets.Count > 0)
                    {
                        string msg = "Non-Translated Components Count: " + lUnTranslatedComponenets.Count + "\n";
                        foreach (string s in lUnTranslatedComponenets)
                        {
                            msg += s + "\n";
                        }
                        Debug.LogWarning(msg);
                    }

                    foreach (Component c in lDirtyComponentsList)
                    {
                        if (c != null)
                        {
                            EditorUtility.SetDirty(c);
                        }
                    }

                    //EditorUtility.DisplayDialog("Success", "Load Successful. Check your Multi-Language Text Components to make sure everything imported correctly and looks nice.", "Okay");
                }

                if (m_sErrorMessage != "")
                {
                    Debug.LogError(m_sErrorMessage);
                }
            }
        }
        else
        {
            Debug.Log("TEXT FILE LOAD CANCELLED");
        }
    }
Example #15
0
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //	* New Method: Capture the MultiLanugageText Reference we found earlier
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    private static void CaptureMultiTextObject(GameManager rGameManager, GameManager.SystemLanguages eChosenLanguage, ref MultiLanguageTextList[] alMultiLanguageTextItems, MultiLanguageText a_rMultiTextObject, int a_iCurrentSceneID, Component a_parent, MultiLanguageTextReceiveMode eMultiLanguageTextReceiveMode, string a_variableName, string appendedName = "")
    {
        if (eMultiLanguageTextReceiveMode == MultiLanguageTextReceiveMode.BLANK_ONLY)
        {
            if (a_rMultiTextObject.m_arLanguageText[(int)eChosenLanguage].text != "")
            {
                return;
            }
        }
        else if (eMultiLanguageTextReceiveMode == MultiLanguageTextReceiveMode.FILLED_ONLY)
        {
            if (a_rMultiTextObject.m_arLanguageText[(int)eChosenLanguage].text == "")
            {
                return;
            }
        }

        MultiLanguageTextInstanceInfo mlti = new MultiLanguageTextInstanceInfo();

        mlti.rInstance     = a_rMultiTextObject;
        mlti.rOwningParent = a_parent;

        Transform trans = a_parent.transform;

        mlti.sDisplayLabel = a_parent.name + "\\" + a_variableName + appendedName;
        while (trans != rGameManager.m_agoRootParentsOfMultiLanguageTextComponents[a_iCurrentSceneID].transform)
        {
            mlti.sDisplayLabel = trans.name + "\\" + mlti.sDisplayLabel;
            trans = trans.parent;
        }

        if (!alMultiLanguageTextItems[a_iCurrentSceneID].Contains(mlti))
        {
            alMultiLanguageTextItems[a_iCurrentSceneID].AddLast(mlti);
        }
    }
Example #16
0
    public void OpenConfirmationWindow(URLType eURLType, string androidURLWeblink, string appleURLWeblink, MultiLanguageText confirmationDescription, SubSceneManager previousScene = null, ObjectTransitionAnimation previousNotePage = null)
    {
        if (m_rConfirmationWindowDisplay != null)
        {
            // Hide whatever notes are currently active (if applicable)
            if (ObjectTransitionAnimation.CurrentlyActive != null)
            {
                ObjectTransitionAnimation.CurrentlyActive.Disappear(false);
            }

            // Reveal Confirmation Window & Show URL Confirmation Description
            m_rConfirmationWindowDisplay.Reveal();
            if (m_rTextDisplay != null && confirmationDescription != null)
            {
                confirmationDescription.ApplyEffects(m_rTextDisplay);
            }

            // Show Background Vignette
            VignetteManager.TransitionVignette(m_oVignetteInfo);

            // Assign URL variables as provided.
            m_eType = eURLType;
            androidURL = androidURLWeblink;
            URL = appleURLWeblink;

            m_rPreviousScene = previousScene;
            m_rPreviousNotePage = previousNotePage;

            if (m_rDoNotOpenURLButton != null)
            {
                m_rDoNotOpenURLButton.PreviousScene = previousScene;
                m_rDoNotOpenURLButton.PreviousNotePage = previousNotePage;
            }
        }
    }
Example #17
0
 /// <summary>Initializes a new instance of the <see cref="Member"/> class.</summary>
 /// TODO Edit XML Comment Template for #ctor
 public Member()
 {
     MemberComment = new MultiLanguageText();
 }
Example #18
0
 public static List<LocalizedValueModel> Create(IEnumerable<Language> availableLanguages, MultiLanguageText text)
 {
     return availableLanguages.Select(x => new LocalizedValueModel(x.Id, x.Name, text.GetText(x.Type))).ToList();
 }
 public static string GetText(MultiLanguageText text, params object[] args)
 {
     return(string.Format(text.GetString(Instance.SelectedLanguage), args));
 }