Moving back to trunk!

git-svn-id: http://svn.code.sf.net/p/greenshot/code/trunk@1602 7dccd23d-a4a3-4e1f-8c07-b4c1b4018ab4

GreenshotConfluencePlugin/Support/ITranslationProvider.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace TranslationByMarkupExtension {
+    public interface ITranslationProvider {
+        /// <summary>
+        /// Translates the specified key.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <returns></returns>
+        object Translate(string key);
+
+        /// <summary>
+        /// Gets the available languages.
+        /// </summary>
+        /// <value>The available languages.</value>
+        IEnumerable<CultureInfo> Languages { get; }
+    }
+}

GreenshotConfluencePlugin/Support/LanguageChangedEventManager.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Windows;
+
+namespace TranslationByMarkupExtension
+{
+    public class LanguageChangedEventManager : WeakEventManager
+    {
+        public static void AddListener(TranslationManager source, IWeakEventListener listener)
+        {
+            CurrentManager.ProtectedAddListener(source, listener);
+        }
+
+        public static void RemoveListener(TranslationManager source, IWeakEventListener listener)
+        {
+            CurrentManager.ProtectedRemoveListener(source, listener);
+        }
+
+        private void OnLanguageChanged(object sender, EventArgs e)
+        {
+            DeliverEvent(sender, e);
+        }
+
+        protected override void StartListening(object source)
+        {
+            var manager = (TranslationManager)source;
+            manager.LanguageChanged += OnLanguageChanged;
+        }
+
+        protected override void StopListening(Object source)
+        {
+            var manager = (TranslationManager)source;
+            manager.LanguageChanged -= OnLanguageChanged;
+        }
+
+        private static LanguageChangedEventManager CurrentManager
+        {
+            get
+            {
+                Type managerType = typeof(LanguageChangedEventManager);
+                var manager = (LanguageChangedEventManager)GetCurrentManager(managerType);
+                if (manager == null)
+                {
+                    manager = new LanguageChangedEventManager();
+                    SetCurrentManager(managerType, manager);
+                }
+                return manager;
+            }
+        } 
+
+    }
+}

GreenshotConfluencePlugin/Support/LanguageXMLTranslationProvider.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+using GreenshotConfluencePlugin;
+using GreenshotPlugin.Core;
+
+namespace TranslationByMarkupExtension {
+    /// <summary>
+    /// 
+    /// </summary>
+    public class LanguageXMLTranslationProvider : ITranslationProvider {
+        #region Private Members
+
+        private readonly ILanguage language = Language.GetInstance();
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResxTranslationProvider"/> class.
+        /// </summary>
+        /// <param name="baseName">Name of the base.</param>
+        /// <param name="assembly">The assembly.</param>
+        public LanguageXMLTranslationProvider() {
+        }
+
+        #endregion
+
+        #region ITranslationProvider Members
+
+        /// <summary>
+        /// See <see cref="ITranslationProvider.Translate" />
+        /// </summary>
+        public object Translate(string key) {
+        	if (language.hasKey(key)) {
+        		return language.GetString(key);
+        	}
+            return key;
+        }
+
+        #endregion
+
+        #region ITranslationProvider Members
+
+        /// <summary>
+        /// See <see cref="ITranslationProvider.AvailableLanguages" />
+        /// </summary>
+        public IEnumerable<CultureInfo> Languages {
+            get {
+            	foreach (LanguageConfiguration supportedLanguage in language.SupportedLanguages) {
+            		yield return new CultureInfo(supportedLanguage.Ietf);
+            	}
+            }
+        }
+
+        #endregion
+    }
+}

GreenshotConfluencePlugin/Support/TranslateExtension.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Windows.Data;
+using System.Windows.Markup;
+
+namespace TranslationByMarkupExtension
+{
+    /// <summary>
+    /// The Translate Markup extension returns a binding to a TranslationData
+    /// that provides a translated resource of the specified key
+    /// </summary>
+    public class TranslateExtension : MarkupExtension
+    {
+        #region Private Members
+
+        private string _key;
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TranslateExtension"/> class.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        public TranslateExtension(string key)
+        {
+            _key = key;
+        }
+
+        #endregion
+
+        [ConstructorArgument("key")]
+        public string Key
+        {
+            get { return _key; }
+            set { _key = value;}
+        }
+
+        /// <summary>
+        /// See <see cref="MarkupExtension.ProvideValue" />
+        /// </summary>
+        public override object ProvideValue(IServiceProvider serviceProvider)
+        {
+            var binding = new Binding("Value")
+                  {
+                      Source = new TranslationData(_key)
+                  };
+            return binding.ProvideValue(serviceProvider);
+        }
+    }
+}

GreenshotConfluencePlugin/Support/TranslationData.cs

@@ -0,0 +1,64 @@
+using System;
+using System.ComponentModel;
+using System.Windows;
+
+namespace TranslationByMarkupExtension {
+    public class TranslationData : IWeakEventListener, INotifyPropertyChanged {
+        #region Private Members
+
+        private string _key;
+
+        #endregion
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TranslationData"/> class.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        public TranslationData( string key) {
+            _key = key;
+            LanguageChangedEventManager.AddListener(TranslationManager.Instance, this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged resources and performs other cleanup operations before the
+        /// <see cref="TranslationData"/> is reclaimed by garbage collection.
+        /// </summary>
+        ~TranslationData() {
+            LanguageChangedEventManager.RemoveListener(TranslationManager.Instance, this);
+        }
+
+        public object Value {
+            get {
+                return TranslationManager.Instance.Translate(_key);
+            }
+        }
+
+        #region IWeakEventListener Members
+
+        public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
+        {
+            if (managerType == typeof(LanguageChangedEventManager))
+            {
+                OnLanguageChanged(sender, e);
+                return true;
+            }
+            return false;
+        }
+
+        private void OnLanguageChanged(object sender, EventArgs e)
+        {
+            if( PropertyChanged != null )
+            {
+                PropertyChanged( this, new PropertyChangedEventArgs("Value"));
+            }
+        }
+
+        #endregion
+
+        #region INotifyPropertyChanged Members
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        #endregion
+    }
+}

GreenshotConfluencePlugin/Support/TranslationManager.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+
+namespace TranslationByMarkupExtension
+{
+    public class TranslationManager
+    {
+        private static TranslationManager _translationManager;
+
+        public event EventHandler LanguageChanged;
+
+        public CultureInfo CurrentLanguage
+        {
+            get { return Thread.CurrentThread.CurrentUICulture; }
+            set
+            {
+                if( value != Thread.CurrentThread.CurrentUICulture)
+                {
+                    Thread.CurrentThread.CurrentUICulture = value;
+                    OnLanguageChanged();
+                }
+            }
+        }
+
+        public IEnumerable<CultureInfo> Languages
+        {
+            get
+            {
+               if( TranslationProvider != null)
+               {
+                   return TranslationProvider.Languages;
+               }
+               return Enumerable.Empty<CultureInfo>();
+            }
+        }
+
+        public static TranslationManager Instance
+        {
+            get
+            {
+                if (_translationManager == null)
+                    _translationManager = new TranslationManager();
+                return _translationManager;
+            }
+        }
+
+        public ITranslationProvider TranslationProvider { get; set; }
+
+        private void OnLanguageChanged()
+        {
+            if (LanguageChanged != null)
+            {
+                LanguageChanged(this, EventArgs.Empty);
+            }
+        }
+
+        public object Translate(string key)
+        {
+            if( TranslationProvider!= null)
+            {
+                object translatedValue =TranslationProvider.Translate(key);
+                if( translatedValue != null)
+                {
+                    return translatedValue;
+                }
+            }
+            return string.Format("!{0}!", key);
+        }
+    }
+}