Software/Visual_Studio/FSE/Tango.FSE.Common/WindowsManager/WindowsManagerHelper.cs


1
2
3
4
5
6
7
8<using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.SharedUI;

namespace Tango.Scripting.IDE
{
    public class IDEDialogViewModel : DialogViewVM
    {
        public String Title { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace Tango.FSE.Common.WindowsManager
{
    public static class WindowsManagerHelper
    {
        #region IsDetached

        /// <summary>
        /// Determines whether the element is currently attached.
        /// </summary>
        public static readonly DependencyProperty IsDetachedProperty =
            DependencyProperty.RegisterAttached("IsDetached",
            typeof(bool), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the IsDetached attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetIsDetached(FrameworkElement element, bool value)
        {
            element.SetValue(IsDetachedProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetIsDetached(FrameworkElement element)
        {
            return (bool)element.GetValue(IsDetachedProperty);
        }

        #endregion

        #region WindowTitle

        /// <summary>
        /// The detached element window title.
        /// </summary>
        public static readonly DependencyProperty WindowTitleProperty =
            DependencyProperty.RegisterAttached("WindowTitle",
            typeof(String), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(null));

        /// <summary>
        /// Sets the WindowTitle attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetWindowTitle(FrameworkElement element, String value)
        {
            element.SetValue(WindowTitleProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static String GetWindowTitle(FrameworkElement element)
        {
            return (String)element.GetValue(WindowTitleProperty);
        }

        #endregion

        #region StartWidth

        /// <summary>
        /// The detached element window title.
        /// </summary>
        public static readonly DependencyProperty StartWidthProperty =
            DependencyProperty.RegisterAttached("StartWidth",
            typeof(double?), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(null));

        /// <summary>
        /// Sets the StartWidth attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetStartWidth(FrameworkElement element, double? value)
        {
            element.SetValue(StartWidthProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double? GetStartWidth(FrameworkElement element)
        {
            return (double?)element.GetValue(StartWidthProperty);
        }

        #endregion

        #region StartHeight

        /// <summary>
        /// The detached element window title.
        /// </summary>
        public static readonly DependencyProperty StartHeightProperty =
            DependencyProperty.RegisterAttached("StartHeight",
            typeof(double?), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(null));

        /// <summary>
        /// Sets the StartHeight attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetStartHeight(FrameworkElement element, double? value)
        {
            element.SetValue(StartHeightProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double? GetStartHeight(FrameworkElement element)
        {
            return (double?)element.GetValue(StartHeightProperty);
        }

        #endregion

        #region MinWidth

        /// <summary>
        /// The detached element window title.
        /// </summary>
        public static readonly DependencyProperty MinWidthProperty =
            DependencyProperty.RegisterAttached("MinWidth",
            typeof(double?), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(null));

        /// <summary>
        /// Sets the MinWidth attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetMinWidth(FrameworkElement element, double? value)
        {
            element.SetValue(MinWidthProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double? GetMinWidth(FrameworkElement element)
        {
            return (double?)element.GetValue(MinWidthProperty);
        }

        #endregion

        #region MinHeight

        /// <summary>
        /// The detached element window title.
        /// </summary>
        public static readonly DependencyProperty MinHeightProperty =
            DependencyProperty.RegisterAttached("MinHeight",
            typeof(double?), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(null));

        /// <summary>
        /// Sets the MinHeight attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetMinHeight(FrameworkElement element, double? value)
        {
            element.SetValue(MinHeightProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double? GetMinHeight(FrameworkElement element)
        {
            return (double?)element.GetValue(MinHeightProperty);
        }

        #endregion

        #region LockAspectRatio

        /// <summary>
        /// Determines whether the element is currently attached.
        /// </summary>
        public static readonly DependencyProperty LockAspectRatioProperty =
            DependencyProperty.RegisterAttached("LockAspectRatio",
            typeof(bool), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the LockAspectRatio attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetLockAspectRatio(FrameworkElement element, bool value)
        {
            element.SetValue(LockAspectRatioProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetLockAspectRatio(FrameworkElement element)
        {
            return (bool)element.GetValue(LockAspectRatioProperty);
        }

        #endregion

        #region PreservePlaceHolder

        /// <summary>
        /// Determines whether the element is currently attached.
        /// </summary>
        public static readonly DependencyProperty PreservePlaceHolderProperty =
            DependencyProperty.RegisterAttached("PreservePlaceHolder",
            typeof(bool), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the PreservePlaceHolder attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetPreservePlaceHolder(FrameworkElement element, bool value)
        {
            element.SetValue(PreservePlaceHolderProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetPreservePlaceHolder(FrameworkElement element)
        {
            return (bool)element.GetValue(PreservePlaceHolderProperty);
        }

        #endregion

        #region DisableMaximize

        /// <summary>
        /// Determines whether the element is currently attached.
        /// </summary>
        public static readonly DependencyProperty DisableMaximizeProperty =
            DependencyProperty.RegisterAttached("DisableMaximize",
            typeof(bool), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the DisableMaximize attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetDisableMaximize(FrameworkElement element, bool value)
        {
            element.SetValue(DisableMaximizeProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetDisableMaximize(FrameworkElement element)
        {
            return (bool)element.GetValue(DisableMaximizeProperty);
        }

        #endregion

        #region DisableResolutionServiceInjection

        /// <summary>
        /// Determines whether the element is currently attached.
        /// </summary>
        public static readonly DependencyProperty DisableResolutionServiceInjectionProperty =
            DependencyProperty.RegisterAttached("DisableResolutionServiceInjection",
            typeof(bool), typeof(WindowsManagerHelper),
            new FrameworkPropertyMetadata(false));

        /// <summary>
        /// Sets the DisableResolutionServiceInjection attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetDisableResolutionServiceInjection(FrameworkElement element, bool value)
        {
            element.SetValue(DisableResolutionServiceInjectionProperty, value);
        }

        /// <summary>
        /// Gets the is dragging attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetDisableResolutionServiceInjection(FrameworkElement element)
        {
            return (bool)element.GetValue(DisableResolutionServiceInjectionProperty);
        }

        #endregion

        #region Detached Event

        /// <summary>
        /// Occurs when a successful Detached has occurred. 
        /// </summary>
        public static readonly RoutedEvent DetachedEvent =
            EventManager.RegisterRoutedEvent("Detached",
                                            RoutingStrategy.Bubble,
                                            typeof(RoutedEventHandler),
                                            typeof(WindowsManagerHelper));

        /// <summary>
        /// Adds the Detached event handler.
        /// </summary>
        /// <param name="o">The o.</param>
        /// <param name="handler">The handler.</param>
        public static void AddDetachedHandler(DependencyObject o, RoutedEventHandler handler)
        {
            ((UIElement)o).AddHandler(DetachedEvent, handler);
        }

        /// <summary>
        /// Removes the Detached event handler.
        /// </summary>
        /// <param name="o">The o.</param>
        /// <param name="handler">The handler.</param>
        public static void RemoveDetachedHandler(DependencyObject o, RoutedEventHandler handler)
        {
            ((UIElement)o).RemoveHandler(DetachedEvent, handler);
        }

        #endregion

        #region Attached Event

        /// <summary>
        /// Occurs when a successful Attached has occurred. 
        /// </summary>
        public static readonly RoutedEvent AttachedEvent =
            EventManager.RegisterRoutedEvent("Attached",
                                            RoutingStrategy.Bubble,
                                            typeof(RoutedEventHandler),
                                            typeof(WindowsManagerHelper));

        /// <summary>
        /// Adds the Attached event handler.
        /// </summary>
        /// <param name="o">The o.</param>
        /// <param name="handler">The handler.</param>
        public static void AddAttachedHandler(DependencyObject o, RoutedEventHandler handler)
        {
            ((UIElement)o).AddHandler(AttachedEvent, handler);
        }

        /// <summary>
        /// Removes the Attached event handler.
        /// </summary>
        /// <param name="o">The o.</param>
        /// <param name="handler">The handler.</param>
        public static void RemoveAttachedHandler(DependencyObject o, RoutedEventHandler handler)
        {
            ((UIElement)o).RemoveHandler(AttachedEvent, handler);
        }

        #endregion
    }
}