/// <summary>
        ///     Translates only the given element.
        /// </summary>
        /// <param name="visual"></param>
        private static void TranslateGuiElement(FrameworkElement visual)
        {
            //special treatment.
            switch (visual)
            {
            case DataGrid grid:
                HandleDataGrid(grid);
                return;

            case Ribbon ribbon when ribbon.ApplicationMenu != null:
                TranslateGui(ribbon.ApplicationMenu);
                return;
            }

            var guiString = AbstractLiteralProvider.Instance.GetGuiTranslationOfCurrentCulture(visual);

            //visual is non translatable, does not have a Name or not supported type like Grid, Stackpanel ...
            if (guiString == null)
            {
                return;
            }

            //write to element specific Property.
            ControlElementInspector.WriteToControlElement(visual, guiString);
        }
        public override string GetGuiTranslationOfCurrentCulture(DependencyObject element)
        {
            if (!ControlElementInspector.GetControlProperties(element, out var controlId, out _,
                                                              out var controlType, out var parentDialogName))
            {
                return(null);
            }

            return(GetLiteral(Thread.CurrentThread.CurrentUICulture, parentDialogName, controlType,
                              controlId, false).Text);
        }
        public override void SetGuiTranslation(DependencyObject element, IEnumerable <TextLocalization> texts)
        {
            if (!ControlElementInspector.GetControlProperties(element, out var controlId, out _,
                                                              out var controlType, out var parentDialogName))
            {
                _logger.Log(LogLevel.Debug,
                            "Failed to override translation for dialog '{0}', type '{1}' and name '{2}'.",
                            parentDialogName, controlType, controlId);
                return;
            }

            SetLiteral(parentDialogName, controlType, controlId, texts.ToList());
        }
        public override ObservableCollection <TextLocalization> GetGuiTranslation(DependencyObject element)
        {
            if (!ControlElementInspector.GetControlProperties(element, out var controlId, out var currentText,
                                                              out var controlType, out var parentDialogName))
            {
                return(null);
            }

            var dictOfDicts = GetDictionaryFromFileProvider();

            ICollection <TextLocalization> localizations = new Collection <TextLocalization>();

            foreach (var language in dictOfDicts.Keys)
            {
                localizations.Add(GetLiteral(language, parentDialogName, controlType,
                                             controlId, true));
            }

            //if entry is new, use text from XAML.
            if (localizations.All(localization => string.IsNullOrWhiteSpace(localization.Text)))
            {
                localizations.First(localization => Equals(localization.Language, InputLanguage)).Text = currentText;
            }

            GetTranslationDummyText(localizations, InputLanguage, PreferredLanguage);

            //fill known translations and convert to ObservableCollection.
            var sourceLocalization = localizations.FirstOrDefault(loc =>
                                                                  Equals(loc.Language, InputLanguage));
            var observableLocalizations =
                new ObservableCollection <TextLocalization>();

            foreach (var localization in localizations)
            {
                if (sourceLocalization != null)
                {
                    localization.KnownTranslations = TextLocalizationsUtils
                                                     .ExtractKnownTranslations(sourceLocalization.Text, localization.Language,
                                                                               InputLanguage, dictOfDicts);
                }

                observableLocalizations.Add(localization);
            }

            return(observableLocalizations);
        }