예제 #1
0
        /// <summary>
        /// Internal method that performs execution of actions on controllers (usually triggered by Controller.Action())
        /// </summary>
        /// <param name="requestContext">Executing request context</param>
        protected virtual void Execute(RequestContext requestContext)
        {
            var oldContext = RequestContext;
            try
            {
                RequestContext = requestContext;
                requestContext.ProcessingController = this;

                var methodName = "index";
                if (requestContext.RouteData.Data.ContainsKey("action")) methodName = requestContext.RouteData.Data["action"].ToString();
                else requestContext.RouteData.Data.Add("action", methodName);

                var routedParameters = requestContext.RouteData.Data.Keys.Where(key => key != "controller" && key != "action").ToDictionary(key => key, key => requestContext.RouteData.Data[key].GetType());
                var methods = GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);

                foreach (var method in methods)
                    if (method.Name.ToLower() == methodName.ToLower() && (method.ReturnType == typeof (ActionResult) || method.ReturnType.IsSubclassOf(typeof (ActionResult))))
                    {
                        // Potential match!
                        var paras = new List<object>();
                        var expectedParameters = method.GetParameters();
                        if (expectedParameters.Length != routedParameters.Count) continue;
                        // We look at each parameter this method expects and see if we have them in the route info
                        foreach (var expectedParameter in expectedParameters)
                        {
                            var expectedParameterName = expectedParameter.Name.ToLower();
                            if (routedParameters.ContainsKey(expectedParameterName) && expectedParameter.ParameterType == routedParameters[expectedParameterName])
                                paras.Add(requestContext.RouteData.Data[expectedParameterName]);
                        }
                        if (paras.Count == expectedParameters.Length) // Looks like we found values for all parameters
                        {
                            requestContext.Result = method.Invoke(this, paras.ToArray()) as ActionResult;
                            return; // We found and invoked the method, so we are done
                        }
                    }

                // We haven't found the desired method yet, but we attempt another way of matching it
                if (routedParameters.Count == 1)
                    foreach (var method in methods)
                        if (method.Name.ToLower() == methodName.ToLower() && (method.ReturnType == typeof (ActionResult) || method.ReturnType.IsSubclassOf(typeof (ActionResult))))
                        {
                            // Potential match!
                            var expectedParameters = method.GetParameters();
                            if (expectedParameters.Length != 1) continue;

                            if (expectedParameters[0].ParameterType != routedParameters.First().Value) continue;
                            // We have a single-parameter method with a parameter type match, so we use that
                            var paras = (from key in requestContext.RouteData.Data.Keys where key != "controller" && key != "action" select requestContext.RouteData.Data[key]).ToList();
                            requestContext.Result = method.Invoke(this, paras.ToArray()) as ActionResult;
                            return; // We found and invoked the method, so we are done
                        }

                // Since we got to this point, we weren't able to find the desired action, so we indicate this to the caller
                requestContext.Result = null;

                var exceptionMessage = "The action '" + methodName + "'";
                if (routedParameters.Count > 0)
                {
                    exceptionMessage += " with parameter(s) named '";
                    var parameterList = string.Empty;
                    foreach (var parameterKey in routedParameters.Keys)
                    {
                        if (!string.IsNullOrEmpty(parameterList)) parameterList += ", ";
                        parameterList += parameterKey;
                    }
                    exceptionMessage += parameterList;
                    exceptionMessage += "'";
                }
                exceptionMessage += " on controller '" + GetType().Name + "' was not found.";
                throw new ActionNotFoundException(exceptionMessage);
            }
            finally
            {
                RequestContext = oldContext;
            }
        }
예제 #2
0
 /// <summary>
 /// Executes all the registered view handlers based on the current context
 /// </summary>
 /// <param name="context"></param>
 private static void ExecuteViewHandlers(RequestContext context)
 {
     if (_viewHandlers != null)
     {
         var currentHandlers = _viewHandlers.Values.ToList(); // We get a new list of handlers, because it could actually happen that calling Openview() on a handler registers handlers and thus change the _viewHandlers collection
         foreach (var handler in currentHandlers)
             handler.OpenView(context);
         var viewResult = context.Result as ViewResult;
         if (viewResult != null)
             viewResult.RaiseViewOpened();
     }
 }
예제 #3
0
        /// <summary>Finds a view within the context of the specified controller</summary>
        /// <param name="controller">Controller the action is to be triggered on</param>
        /// <param name="view">Name of the view that is to be found</param>
        /// <returns>Request context (can be ignored except for special cases)</returns>
        public static RequestContext ViewOnly(string controller = "Home", string view = "Index")
        {
            if (!controller.EndsWith("Controller")) controller += "Controller";

            if (_controllers == null) PopulateControllers();

            var controllerKey = controller.ToLower();
            if (_controllers != null && _controllers.ContainsKey(controllerKey))
            {
                var context = new RequestContext(new RouteData(view, null))
                {
                    Result = _controllers[controllerKey].Instance.PartialView(view)
                };

                if (_viewHandlers != null)
                {
                    var currentHandlers = _viewHandlers.Values.ToList(); // We get a new list of handlers, because it could actually happen that calling Openview() on a handler registers handlers and thus change the _viewHandlers collection
                    foreach (var handler in currentHandlers)
                        handler.OpenView(context);

                    var viewResult = context.Result as ViewResult;
                    if (viewResult != null)
                        viewResult.RaiseViewOpened();
                }

                return context;
            }
            return null;
        }
예제 #4
0
        /// <summary>Displays a message box</summary>
        /// <param name="messageBoxText">Message box text message (plain text)</param>
        /// <param name="caption">Message box caption (title)</param>
        /// <param name="buttons">Standard buttons displayed by the message box</param>
        /// <param name="icon">Standard icon displayed by the message box.</param>
        /// <param name="defaultResult">Default standard button</param>
        /// <param name="onComplete">Code to run when the message box closes.</param>
        /// <param name="actions">Custom actions to be added to the message box as buttons. (Note: If this parameter is not null, the 'buttons' parameter is ignored)</param>
        /// <param name="model">Custom message box view model. (Note: Only used in exceptional scenarios where the standard view model .</param>
        /// <param name="viewName">Name of a custom view to be used by the message box (optional).</param>
        /// <param name="controllerType">Type of the controller (used as a context to find views)</param>
        public static void Message(string messageBoxText = "", string caption = "Message", MessageBoxButtons buttons = MessageBoxButtons.OK, MessageBoxImages icon = MessageBoxImages.Information, MessageBoxResults defaultResult = MessageBoxResults.OK, Action<MessageBoxResult> onComplete = null, IEnumerable<IViewAction> actions = null, MessageBoxViewModel model = null, string viewName = "", Type controllerType = null)
        {
            var context = new RequestContext(new RouteData("MessageBox", new {viewName = string.Empty, messageBoxText, caption, buttons, icon, defaultResult}));

            // If a controller type was specified, we try to use it, which provides a context to find views
            Controller controller;
            if (controllerType == null) controller = new Controller();
            else controller = Activator.CreateInstance(controllerType) as Controller;
            if (controller == null) controller = new Controller();
            context.ProcessingController = controller;

            if (model != null && onComplete != null) model.OnComplete = onComplete; // Could be used later, especially for test scenarios where queued results simulate closing of message boxes

            bool mustHandle = _messageBoxResultQueue == null || _messageBoxResultQueue.Count == 0;

            context.Result = controller.MessageBox(viewName, messageBoxText, caption, buttons, icon, defaultResult, actions, model);
            var result = context.Result as MessageBoxResult;
            if (result != null && onComplete != null) result.ViewClosed += (o, e) => onComplete(result);

            if (mustHandle)
                // By default, we let view handlers handle the message box, unless simulated results are queued up.
                ExecuteViewHandlers(context);
        }
예제 #5
0
        /// <summary>
        /// Triggers an action on the specified controller
        /// </summary>
        /// <param name="controller">Controller the action is to be triggered on</param>
        /// <param name="action">Action to be called on the controller</param>
        /// <param name="routeValues">Additional parameters passed to the controller</param>
        /// <param name="eventSinks">Object containing the event handlers that are to be attached to the view result (if the result is in fact a view result)</param>
        /// <returns>Request context (can be ignored except for special cases)</returns>
        /// <example>
        /// Controller.Action("Customer", "List"); // Invokes CustomerController.List
        /// var context = Controller.Action("Customer", "List"); // Invokes CustomerController.List and retrieves the context
        /// Controller.Action("Customer", "Detail", new {id = x}); // Invokes CustomerController.Detail(id) and passes a parameter called "id")
        /// </example>
        public static RequestContext Action(string controller = "Home", string action = "Index", dynamic routeValues = null, ViewResultEventSinks eventSinks = null)
        {
            if (!controller.EndsWith("Controller")) controller += "Controller";

            if (_controllers == null) PopulateControllers();

            var controllerKey = controller.ToLower();
            if (_controllers != null && _controllers.ContainsKey(controllerKey))
            {
                var context = new RequestContext(new RouteData(action, routeValues));
                _controllers[controllerKey].Instance.Execute(context);

                var viewResult = context.Result as ViewResult;
                if (viewResult != null)
                {
                    if (eventSinks != null)
                    {
                        viewResult.ViewClosed += eventSinks.ViewClosed;
                        viewResult.ViewOpened += eventSinks.ViewOpened;
                    }

                    viewResult.ViewOpened += (o, e) => AfterViewOpened(viewResult);

                    var openable = viewResult.Model as IOpenable;
                    if (openable != null)
                        openable.RaiseOpeningEvent();
                }

                ExecuteViewHandlers(context);

                if (viewResult != null)
                {
                    var openable = viewResult.Model as IOpenable;
                    if (openable != null)
                        openable.RaiseOpenedEvent();
                }

                return context;
            }
            return null;
        }
예제 #6
0
        /// <summary>Displays the specified notification</summary>
        /// <param name="text">Main text</param>
        /// <param name="text2">Secondary text</param>
        /// <param name="number">Numeric information (such as an item count) passed as a string</param>
        /// <param name="imageResource">Generic image resource to load a brush from (if this parameter is passed an the resource is found the image parameter is ignored)</param>
        /// <param name="image">A logo image (passed as a brush).</param>
        /// <param name="model">Notification view model (if passed, text, number, image and overrideTimeout parameters are ignored)</param>
        /// <param name="viewName">Name of a custom view to be used by the status.</param>
        /// <param name="controllerType">Type of the controller (used as a context to find views)</param>
        /// <param name="overrideTimeout">Overrides the theme's default notification timeout. If model is passed, set this property in model.</param>
        public static void Notification(string text = "", string text2 = "", string number = "", string imageResource = "", Brush image = null, NotificationViewModel model = null, string viewName = "", Type controllerType = null, TimeSpan? overrideTimeout = null)
        {
            var context = new RequestContext(new RouteData("NotificationMessage", new {viewName = string.Empty}));

            // If a controller type was specified, we try to use it, which provides a context to find views
            Controller controller;
            if (controllerType == null) controller = new Controller();
            else controller = Activator.CreateInstance(controllerType) as Controller;
            if (controller == null) controller = new Controller();
            context.ProcessingController = controller;

            context.Result = controller.NotificationMessage(viewName, text, text2, number, imageResource, image, model, overrideTimeout);

            ExecuteViewHandlers(context);
        }
예제 #7
0
        /// <summary>Sets the application status (typically displayed in a status bar).</summary>
        /// <param name="message">Message that is to be displayed</param>
        /// <param name="status">Application status</param>
        /// <param name="model">Application status view model</param>
        /// <param name="viewName">Name of a custom view to be used by the status.</param>
        /// <param name="controllerType">Type of the controller (used as a context to find views)</param>
        public static void Status(string message = "", ApplicationStatus status = ApplicationStatus.Ready, StatusViewModel model = null, string viewName = "", Type controllerType = null)
        {
            var context = new RequestContext(new RouteData("StatusMessage", new {viewName = string.Empty}));

            // If a controller type was specified, we try to use it, which provides a context to find views
            Controller controller;
            if (controllerType == null) controller = new Controller();
            else controller = Activator.CreateInstance(controllerType) as Controller;
            if (controller == null) controller = new Controller();
            context.ProcessingController = controller;

            context.Result = controller.StatusMessage(viewName, message, status, model);

            ExecuteViewHandlers(context);
        }
예제 #8
0
        /// <summary>
        /// Opens the top level view in a separate window.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="messageBoxResult">The message box result.</param>
        /// <param name="viewResult">The view result.</param>
        /// <returns>True if successfully opened</returns>
        private bool OpenTopLevelView(RequestContext context, MessageBoxResult messageBoxResult, ViewResult viewResult)
        {
            if (messageBoxResult != null && string.IsNullOrEmpty(viewResult.ViewIconResourceKey))
                viewResult.ViewIconResourceKey = messageBoxResult.ModelMessageBox.IconResourceKey;

            //Brush iconBrush = Brushes.Transparent;
            //if (!string.IsNullOrEmpty(viewResult.ViewIconResourceKey))
            //    try
            //    {
            //        var resource = Application.Current.FindResource(viewResult.ViewIconResourceKey);
            //        if (resource != null)
            //            iconBrush = (Brush) resource;
            //    }
            //    catch
            //    {
            //        iconBrush = Brushes.Transparent;
            //    }

            // If we respect local views and the view is in fact a local view, and we have a normal view already open, then we open it in a local way only.
            if (viewResult.ViewScope == ViewScope.Local && HandleLocalViewsSpecial && SelectedNormalView > -1)
            {
                var selectedView = NormalViews[SelectedNormalView];
                if (selectedView == null) return false;
                selectedView.LocalViews.Add(viewResult);
                if (viewResult.MakeViewVisibleOnLaunch)
                    selectedView.SelectedLocalViewIndex = selectedView.LocalViews.Count - 1;
                return true;
            }

            //Need to make sure we do not open more than allowed - Popups should not close underlying views.
            if (viewResult.ViewLevel != ViewLevel.Popup && MaximumTopLevelViewCount > -1)
            {
                var inplaceTopLevelviews = TopLevelViews.Where(v => v.TopLevelWindow == null).ToList();
                while (inplaceTopLevelviews.Count + 1 > MaximumTopLevelViewCount)
                {
                    CloseViewForModel(inplaceTopLevelviews[0].Model);
                    inplaceTopLevelviews.RemoveAt(0);
                }
            }

            TopLevelViews.Add(viewResult);

            if (viewResult.MakeViewVisibleOnLaunch && !(TopLevelViewLaunchMode == ViewLaunchMode.Popup || (TopLevelViewLaunchMode == ViewLaunchMode.InPlaceExceptPopups && viewResult.ViewLevel == ViewLevel.Popup)))
            {
                SelectedTopLevelView = TopLevelViews.Count - 1;
                SelectedTopLevelViewResult = SelectedTopLevelView > -1 ? TopLevelViews[SelectedTopLevelView] : null;
                if (viewResult.View != null)
                    if (!FocusHelper.FocusFirstControlDelayed(viewResult.View))
                        FocusHelper.FocusDelayed(viewResult.View);
            }
            TopLevelViewCount = TopLevelViews.Count;

            if (TopLevelViewLaunchMode == ViewLaunchMode.Popup || (TopLevelViewLaunchMode == ViewLaunchMode.InPlaceExceptPopups && viewResult.ViewLevel == ViewLevel.Popup))
            {
                var window = new Window
                    {
                        Title = viewResult.ViewTitle,
                        Content = viewResult.View,
                        DataContext = viewResult.Model,
                        WindowStartupLocation = WindowStartupLocation.CenterScreen,
                        Owner = this
                    };

                window.SetBinding(TitleProperty, new Binding("ViewTitle") { Source = viewResult });

                // Setting the size strategy
                var strategy = SimpleView.GetSizeStrategy(viewResult.View);
                switch (strategy)
                {
                    case ViewSizeStrategies.UseMinimumSizeRequired:
                        window.SizeToContent = SizeToContent.WidthAndHeight;
                        break;
                    case ViewSizeStrategies.UseMaximumSizeAvailable:
                        window.SizeToContent = SizeToContent.Manual;
                        window.Height = SystemParameters.WorkArea.Height;
                        window.Width = SystemParameters.WorkArea.Width;
                        break;
                    case ViewSizeStrategies.UseSuggestedSize:
                        window.SizeToContent = SizeToContent.Manual;
                        window.Height = SimpleView.GetSuggestedHeight(viewResult.View);
                        window.Width = SimpleView.GetSuggestedWidth(viewResult.View);
                        break;
                }

                viewResult.TopLevelWindow = window;

                if (context.Result is MessageBoxResult) window.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-TopLevelMessageBoxWindowStyle");
                else window.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-TopLevelWindowStyle");

                if (viewResult.View != null)
                    foreach (InputBinding binding in viewResult.View.InputBindings)
                        window.InputBindings.Add(binding);

                if (!FocusHelper.FocusFirstControlDelayed(window))
                    FocusHelper.FocusDelayed(window);
                
                if (viewResult.IsModal) window.ShowDialog();
                else window.Show();
            }


            //if (iconBrush != null)
            //{
            //    try
            //    {
            //        // TODO: Implement the icon logic
            //        //var iconRect = new Canvas {Height = 96, Width = 96, Background = iconBrush};
            //        //window.Icon = iconRect.ToIconSource();
            //    }
            //    catch
            //    {
            //    }
            //}

            return true;
        }
예제 #9
0
        /// <summary>
        /// Opens a normal view in a separate window.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="viewResult">The view result.</param>
        private static void OpenNormalViewInWindow(RequestContext context, ViewResult viewResult)
        {
            var window = new Window
                {
                    Title = viewResult.ViewTitle,
                    SizeToContent = SizeToContent.WidthAndHeight,
                    Content = viewResult.View,
                    DataContext = viewResult.Model,
                    WindowStartupLocation = WindowStartupLocation.CenterScreen
                };

            window.SetBinding(TitleProperty, new Binding("ViewTitle") {Source = viewResult});

            var simpleView = viewResult.View as SimpleView;
            if (simpleView != null)
                if (SimpleView.GetSizeStrategy(simpleView) == ViewSizeStrategies.UseMaximumSizeAvailable)
                    window.SizeToContent = SizeToContent.Manual;
            
            viewResult.TopLevelWindow = window;
            if (context.Result is MessageBoxResult) window.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-TopLevelMessageBoxWindowStyle");
            else window.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-NormalLevelWindowStyle");
            if (viewResult.IsModal) window.ShowDialog();
            else window.Show();
        }
예제 #10
0
        /// <summary>
        /// This method is invoked when a view is opened
        /// </summary>
        /// <param name="context">Request context (contains information about the view)</param>
        /// <returns>
        /// True if handled successfully
        /// </returns>
        public bool OpenView(RequestContext context)
        {
            if (context.Result is StatusMessageResult) return HandleStatusMessage(context);
            if (context.Result is NotificationMessageResult)
            {
                var result = context.Result as NotificationMessageResult;
                return HandleNotificationMessage(context, result.Model.OverrideTimeout);
            }

            var viewResult = context.Result as ViewResult;
            if (viewResult != null && viewResult.ForceNewShell)
                if ((viewResult.ViewLevel == ViewLevel.Normal && NormalViewCount > 0) || (viewResult.ViewLevel == ViewLevel.TopLevel && TopLevelViewCount > 0))
                {
                    // A new shell should be opened, so we try to create another shell and then hand off view opening duties to it, rather than handling it directly
                    var shellLauncher = Controller.GetShellLauncher() as WindowShellLauncher<Shell>;
                    if (shellLauncher != null)
                        if (shellLauncher.OpenAnotherShellInstance())
                            return Current.OpenView(context);
                }

            var messageBoxResult = context.Result as MessageBoxResult;
            if (messageBoxResult != null)
            {
                if (messageBoxResult.View == null)
                {
                    var messageBoxViewModel = messageBoxResult.Model as MessageBoxViewModel;
                    if (messageBoxViewModel != null)
                    {
                        var textBlock = new TextBlock {TextWrapping = TextWrapping.Wrap, Text = messageBoxViewModel.Text};
                        textBlock.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-MessageBox-Text");

                        if (!string.IsNullOrEmpty(messageBoxViewModel.IconResourceKey))
                        {
                            var grid = new Grid();
                            grid.ColumnDefinitions.Clear();
                            grid.ColumnDefinitions.Add(new ColumnDefinition {Width = GridLength.Auto});
                            grid.ColumnDefinitions.Add(new ColumnDefinition {Width = new GridLength(1, GridUnitType.Star)});
                            var rect = new Rectangle {Fill = messageBoxViewModel.IconBrush};
                            rect.SetResourceReference(StyleProperty, "CODE.Framework.Wpf.Mvvm.Shell-MessageBox-Image");
                            grid.Children.Add(rect);
                            grid.Children.Add(textBlock);
                            Grid.SetColumn(textBlock, 1);
                            SimpleView.SetSizeStrategy(grid, ViewSizeStrategies.UseMinimumSizeRequired);
                            messageBoxResult.View = grid;
                        }
                        else messageBoxResult.View = textBlock;
                    }
                }

                if (messageBoxResult.View != null)
                {
                    var messageBoxModelAction = messageBoxResult.Model as IHaveActions;
                    if (messageBoxModelAction != null)
                    {
                        messageBoxResult.View.InputBindings.Clear();
                        foreach (var action in messageBoxModelAction.Actions)
                            if (action.ShortcutKey != Key.None)
                                messageBoxResult.View.InputBindings.Add(new KeyBinding(action, action.ShortcutKey, action.ShortcutModifiers));
                    }
                }
            }

            if (viewResult != null && viewResult.View != null && !viewResult.IsPartial)
            {
                if (viewResult.ViewLevel == ViewLevel.Popup || viewResult.ViewLevel == ViewLevel.StandAlone || viewResult.ViewLevel == ViewLevel.TopLevel)
                    return OpenTopLevelView(context, messageBoxResult, viewResult);

                // This is an normal (main) view

                // Need to make sure we do not open more than allowed
                if (MaximumNormalViewCount > -1)
                {
                    var inplaceNormalViews = NormalViews.Where(v => v.TopLevelWindow == null).ToList();
                    while (inplaceNormalViews.Count + 1 > MaximumNormalViewCount)
                    {
                        CloseViewForModel(inplaceNormalViews[0].Model);
                        inplaceNormalViews.RemoveAt(0);
                    }
                }

                NormalViews.Add(viewResult);
                if (viewResult.MakeViewVisibleOnLaunch)
                {
                    FocusManager.SetFocusedElement(this, viewResult.View);
                    SelectedNormalView = NormalViews.Count - 1;
                    SelectedNormalViewResult = SelectedNormalView > -1 ? NormalViews[SelectedNormalView] : null;
                }
                NormalViewCount = NormalViews.Count;

                if (NormalViewLaunchMode == ViewLaunchMode.Popup)
                    OpenNormalViewInWindow(context, viewResult);

                return true;
            }

            return false;
        }
예제 #11
0
        /// <summary>Handles opening of views that are notification messages</summary>
        /// <param name="context">The request context.</param>
        /// <param name="overrideTimeout">Overrides the theme's default notification timeout.</param>
        /// <returns>True of view was handled</returns>
        protected virtual bool HandleNotificationMessage(RequestContext context, TimeSpan? overrideTimeout = null)
        {
            var notificationResult = context.Result as NotificationMessageResult;
            if (notificationResult == null) return false;

            var wrapper = new NotificationViewResultWrapper {Model = notificationResult.Model};

            if (notificationResult.View != null)
            {
                wrapper.View = notificationResult.View;
                notificationResult.View.DataContext = wrapper.Model;
            }
            else
            {
                wrapper.View = Controller.LoadView(StandardViews.Notification);
                if (wrapper.View != null)
                    wrapper.View.DataContext = wrapper.Model;
            }

            if (NotificationSort == NotificationSort.NewestFirst)
                CurrentNotifications.Add(wrapper);
            else
                CurrentNotifications.Insert(0, wrapper);

            while (CurrentNotifications.Count > MaximumNotificationCount)
            {
                // Handling this like a stack, popping the oldest one off
                if (NotificationSort == NotificationSort.NewestFirst)
                    CurrentNotifications.RemoveAt(0);
                else
                    CurrentNotifications.RemoveAt(CurrentNotifications.Count - 1);
            }
            CurrentNotificationsCount = CurrentNotifications.Count;

            RaiseEvent(new RoutedEventArgs(NotificationChangedEvent));

            var timeout = overrideTimeout ?? NotificationTimeout;
            wrapper.InternalTimer = new Timer(state => Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    CurrentNotifications.Remove(wrapper);
                    CurrentNotificationsCount = CurrentNotifications.Count;
                })), null, timeout, new TimeSpan(-1));

            return true;
        }
예제 #12
0
        /// <summary>Handles opening of views that are status messages</summary>
        /// <param name="context">The request context.</param>
        /// <returns>True of view was handled</returns>
        protected virtual bool HandleStatusMessage(RequestContext context)
        {
            var statusResult = context.Result as StatusMessageResult;
            if (statusResult == null) return false;

            if (Status == null) Status = new StatusViewResultWrapper();

            Status.Model = statusResult.Model;

            if (statusResult.View != null)
            {
                Status.View = statusResult.View;
                var element = Status.View as FrameworkElement;
                if (element != null)
                    element.DataContext = Status.Model;
            }
            else
            {
                var grid = new Grid();
                var text = new TextBlock();
                grid.Children.Add(text);
                var binding = new Binding("Message");
                text.SetBinding(TextBlock.TextProperty, binding);
                grid.DataContext = Status.Model;
                Status.View = grid;
            }

            CurrentStatusView = Status.View;
            CurrentApplicationStatus = Status.Model.Status;
            RaiseEvent(new RoutedEventArgs(StatusChangedEvent));

            return true;
        }