aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Tango.Touch/Controls/TouchPanel.cs
blob: bb715abba097f9daf045daedd9010f7dae1afee9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
<UserControl x:Class="Tango.MachineStudio.Dispensers.Views.DispensersView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             xmlns:observables="clr-namespace:Tango.BL.Entities;assembly=Tango.BL"
             xmlns:mahapps="http://metro.mahapps.com/winfx/xaml/controls"
             xmlns:converters="clr-namespace:Tango.SharedUI.Converters;assembly=Tango.SharedUI"
             xmlns:vm="clr-namespace:Tango.MachineStudio.Dispensers.ViewModels"
             xmlns:controls="clr-namespace:Tango.SharedUI.Controls;assembly=Tango.SharedUI"
             xmlns:global="clr-namespace:Tango.MachineStudio.Dispensers"
             xmlns:local="clr-namespace:Tango.MachineStudio.Dispensers.Views"
             mc:Ignorable="d" 
             d:DesignHeight="1080" d:DesignWidth="1920" Background="Transparent" d:DataContext="{d:DesignInstance Type=vm:MainViewVM, IsDesignTimeCreatable=False}" DataContext="{x:Static global:ViewModelLocator.MainViewVM}">

    <UserControl.Resources>
        <converters:DateTimeUTCToShortDateTimeConverter x:Key="DateTimeUTCToShortDateTimeConverter" />
    </UserControl.Resources>

    <Grid>
        <DockPanel Margin="100" MaxWidth="1200">
            <Grid DockPanel.Dock="Top">
                <StackPanel Orientation="Horizontal
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using Tango.Core.Commands;
using Tango.Core.EventArguments;
using Tango.SharedUI;
using Tango.Touch.Keyboard;

namespace Tango.Touch.Controls
{
    public class TouchPanel : ContentControl
    {
        private TouchListBox _combobox_list;
        private Grid _combobox_grid;
        private TouchIconButton _comboBoxCloseButton;
        private TouchCalendar _calendar;
        private Grid _calendar_grid;

        static TouchPanel()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(TouchPanel), new FrameworkPropertyMetadata(typeof(TouchPanel)));
        }

        public TouchPanel()
        {
            ComboBoxPickedCommand = new RelayCommand((x) => 
            {
                CurrentComboBox.SetResultFromTouchPanel(x);
                CurrentComboBox = null;
            });

            DateSelectedCommand = new RelayCommand(() => 
            {
                CurrentDatePicker.SetResultFromTouchPanel(_calendar.SelectedDate.Value);
                CurrentDatePicker = null;
            });

            CancelDateCommand = new RelayCommand(() => 
            {
                CurrentDatePicker = null;
            });

            this.RegisterForMouseOrTouchDown(OnMouseDown);
        }

        private void OnMouseDown(object sender, MouseOrTouchEventArgs e)
        {
            var element = e.OriginalSource as FrameworkElement;

            if (element != null && GetPreventFocusSteal(element)) return;
            if (element != null && element.FindAncestor(x => GetPreventFocusSteal(x as FrameworkElement)) != null) return;
            if (element != null && (element.Focusable || element.FindAncestor<TouchKeyboard>() != null)) return;

            Focus(); //TODO: Notice that this does not cause trouble. (Originally inserted for stealing focus from pop-ups)
        }

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            _combobox_list = GetTemplateChild("PART_ComboBoxList") as TouchListBox;
            _combobox_grid = GetTemplateChild("PART_combobox_grid") as Grid;
            _comboBoxCloseButton = GetTemplateChild("PART_comboboxCloseButton") as TouchIconButton;
            _calendar_grid = GetTemplateChild("PART_datepicker_grid") as Grid;
            _calendar = GetTemplateChild("PART_calendar") as TouchCalendar;

            _comboBoxCloseButton.RegisterForPreviewMouseOrTouchUp(OnComboBoxClose);
            _combobox_grid.RegisterForMouseOrTouchDown(OnComboBoxGridDown);
            _calendar_grid.RegisterForMouseOrTouchDown(OnCalendarGridDown);

            _calendar.SelectionMode = CalendarSelectionMode.SingleDate;
            _calendar.SelectedDatesChanged += _calendar_SelectedDatesChanged;
        }

        private void _calendar_SelectedDatesChanged(object sender, SelectionChangedEventArgs e)
        {
            Mouse.Capture(null);
            ReleaseAllTouchCaptures();
        }

        private void OnCalendarGridDown(object sender, MouseOrTouchEventArgs e)
        {
            if (e.Source == _calendar_grid)
            {
                CurrentDatePicker = null;
            }
        }

        private void OnComboBoxGridDown(object sender, MouseOrTouchEventArgs e)
        {
            if (e.Source == _combobox_grid)
            {
                CurrentComboBox = null;
            }
        }

        private void OnComboBoxClose(object sender, MouseOrTouchEventArgs e)
        {
            CurrentComboBox = null;
        }

        private async void OnCurrentComboBoxChanged()
        {
            if (CurrentComboBox != null)
            {
                await Task.Delay(100);

                if (CurrentComboBox.SelectedItem != null)
                {
                    _combobox_list.ScrollToItem(CurrentComboBox.SelectedItem);
                }
                else
                {
                    _combobox_list.ScrollViewer.ScrollToTop();
                }
            }
        }

        private void OnCurrentDatePickerChanged()
        {
            if (CurrentDatePicker != null)
            {
                _calendar.SelectedDate = CurrentDatePicker.SelectedDate;
                _calendar.DisplayDateStart = CurrentDatePicker.DisplayDateStart;
                _calendar.DisplayDateEnd = CurrentDatePicker.DisplayDateEnd;
            }
        }

        internal RelayCommand ComboBoxPickedCommand
        {
            get { return (RelayCommand)GetValue(ComboBoxPickedCommandProperty); }
            set { SetValue(ComboBoxPickedCommandProperty, value); }
        }
        internal static readonly DependencyProperty ComboBoxPickedCommandProperty =
            DependencyProperty.Register("ComboBoxPickedCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));


        internal TouchComboBox CurrentComboBox
        {
            get { return (TouchComboBox)GetValue(CurrentComboBoxProperty); }
            set { SetValue(CurrentComboBoxProperty, value); }
        }
        internal static readonly DependencyProperty CurrentComboBoxProperty =
            DependencyProperty.Register("CurrentComboBox", typeof(TouchComboBox), typeof(TouchPanel), new PropertyMetadata(null,(d,e) => (d as TouchPanel).OnCurrentComboBoxChanged()));

        internal TouchDatePicker CurrentDatePicker
        {
            get { return (TouchDatePicker)GetValue(CurrentDatePickerProperty); }
            set { SetValue(CurrentDatePickerProperty, value); }
        }
        internal static readonly DependencyProperty CurrentDatePickerProperty =
            DependencyProperty.Register("CurrentDatePicker", typeof(TouchDatePicker), typeof(TouchPanel), new PropertyMetadata(null, (d, e) => (d as TouchPanel).OnCurrentDatePickerChanged()));

        internal RelayCommand DateSelectedCommand
        {
            get { return (RelayCommand)GetValue(DateSelectedCommandProperty); }
            set { SetValue(DateSelectedCommandProperty, value); }
        }
        internal static readonly DependencyProperty DateSelectedCommandProperty =
            DependencyProperty.Register("DateSelectedCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));

        internal RelayCommand CancelDateCommand
        {
            get { return (RelayCommand)GetValue(CancelDateCommandProperty); }
            set { SetValue(CancelDateCommandProperty, value); }
        }
        internal static readonly DependencyProperty CancelDateCommandProperty =
            DependencyProperty.Register("CancelDateCommand", typeof(RelayCommand), typeof(TouchPanel), new PropertyMetadata(null));



        public bool HasMessageBox
        {
            get { return (bool)GetValue(HasMessageBoxProperty); }
            set { SetValue(HasMessageBoxProperty, value); }
        }
        public static readonly DependencyProperty HasMessageBoxProperty =
            DependencyProperty.Register("HasMessageBox", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public MessageBoxVM CurrentMessageBox
        {
            get { return (MessageBoxVM)GetValue(CurrentMessageBoxProperty); }
            set { SetValue(CurrentMessageBoxProperty, value); }
        }
        public static readonly DependencyProperty CurrentMessageBoxProperty =
            DependencyProperty.Register("CurrentMessageBox", typeof(MessageBoxVM), typeof(TouchPanel), new PropertyMetadata(null));

        public bool HasDialog
        {
            get { return (bool)GetValue(HasDialogProperty); }
            set { SetValue(HasDialogProperty, value); }
        }
        public static readonly DependencyProperty HasDialogProperty =
            DependencyProperty.Register("HasDialog", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public FrameworkElement CurrentDialog
        {
            get { return (FrameworkElement)GetValue(CurrentDialogProperty); }
            set { SetValue(CurrentDialogProperty, value); }
        }
        public static readonly DependencyProperty CurrentDialogProperty =
            DependencyProperty.Register("CurrentDialog", typeof(FrameworkElement), typeof(TouchPanel), new PropertyMetadata(null));

        public bool HasNotifications
        {
            get { return (bool)GetValue(HasNotificationsProperty); }
            set { SetValue(HasNotificationsProperty, value); }
        }
        public static readonly DependencyProperty HasNotificationsProperty =
            DependencyProperty.Register("HasNotifications", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public IList Notifications
        {
            get { return (IList)GetValue(NotificationsProperty); }
            set { SetValue(NotificationsProperty, value); }
        }
        public static readonly DependencyProperty NotificationsProperty =
            DependencyProperty.Register("Notifications", typeof(IList), typeof(TouchPanel), new PropertyMetadata(null));

        public DataTemplate NotificationTemplate
        {
            get { return (DataTemplate)GetValue(NotificationTemplateProperty); }
            set { SetValue(NotificationTemplateProperty, value); }
        }
        public static readonly DependencyProperty NotificationTemplateProperty =
            DependencyProperty.Register("NotificationTemplate", typeof(DataTemplate), typeof(TouchPanel), new PropertyMetadata(null));

        public String ItemExpandedPropertyPath
        {
            get { return (String)GetValue(ItemExpandedPropertyPathProperty); }
            set { SetValue(ItemExpandedPropertyPathProperty, value); }
        }
        public static readonly DependencyProperty ItemExpandedPropertyPathProperty =
            DependencyProperty.Register("ItemExpandedPropertyPath", typeof(String), typeof(TouchPanel), new PropertyMetadata(null));

        public FrameworkElement TaskBarElement
        {
            get { return (FrameworkElement)GetValue(TaskBarElementProperty); }
            set { SetValue(TaskBarElementProperty, value); }
        }
        public static readonly DependencyProperty TaskBarElementProperty =
            DependencyProperty.Register("TaskBarElement", typeof(FrameworkElement), typeof(TouchPanel), new PropertyMetadata(null));

        public Visibility NotificationBarVisibility
        {
            get { return (Visibility)GetValue(NotificationBarVisibilityProperty); }
            set { SetValue(NotificationBarVisibilityProperty, value); }
        }
        public static readonly DependencyProperty NotificationBarVisibilityProperty =
            DependencyProperty.Register("NotificationBarVisibility", typeof(Visibility), typeof(TouchPanel), new PropertyMetadata(Visibility.Visible));

        public bool IsBusy
        {
            get { return (bool)GetValue(IsBusyProperty); }
            set { SetValue(IsBusyProperty, value); }
        }
        public static readonly DependencyProperty IsBusyProperty =
            DependencyProperty.Register("IsBusy", typeof(bool), typeof(TouchPanel), new PropertyMetadata(false));

        public String BusyMessage
        {
            get { return (String)GetValue(BusyMessageProperty); }
            set { SetValue(BusyMessageProperty, value); }
        }
        public static readonly DependencyProperty BusyMessageProperty =
            DependencyProperty.Register("BusyMessage", typeof(String), typeof(TouchPanel), new PropertyMetadata(null));


        #region Attached Properties

        #region Prevent Focus Steal

        /// <summary>
        /// The prevent scroll property
        /// </summary>
        public static readonly DependencyProperty PreventFocusStealProperty =
            DependencyProperty.RegisterAttached("PreventFocusSteal",
            typeof(bool), typeof(TouchPanel),
            new FrameworkPropertyMetadata(false));

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

        /// <summary>
        /// Gets the PreventFocusSteal attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static bool GetPreventFocusSteal(FrameworkElement element)
        {
            if (element != null)
            {
                return (bool)element.GetValue(PreventFocusStealProperty);
            }
            else
            {
                return false;
            }
        }

        #endregion

        #endregion
    }
}