C# Workflow.NavigationContext类代码示例

 public bool CanEnterState(NavigationContext oldContext, NavigationContext newContext)
 {
     lock (syncObject)
     {
         return currentBackgroundTask == null;
     }
 }

 protected static ItemsList UpdateNavigationItems(NavigationContext context)
 {
   try
   {
     ItemsList navigationItems = GetOrCreateNavigationItems(context);
     Stack<NavigationContext> contextStack = ServiceRegistration.Get<IWorkflowManager>().NavigationContextStack;
     List<NavigationContext> contexts = new List<NavigationContext>(contextStack);
     contexts.Reverse();
     navigationItems.Clear();
     bool first = true;
     foreach (NavigationContext ctx in contexts)
     {
       ListItem item = new ListItem(KEY_NAME, ctx.DisplayLabel);
       item.AdditionalProperties[KEY_ISFIRST] = first;
       NavigationContext contextCopy = ctx;
       item.Command = new MethodDelegateCommand(() => WorkflowPopToState(contextCopy.WorkflowState.StateId));
       first = false;
       navigationItems.Add(item);
     }
     navigationItems.FireChange();
     return navigationItems;
   }
   catch (Exception e)
   {
     ServiceRegistration.Get<ILogger>().Warn("WorkflowNavigationBar: Error updating properties", e);
     return null;
   }
 }

 void closeDialog(NavigationContext context)
 {
     currentBackgroundTask = null;
     var screenMgr = ServiceRegistration.Get<IScreenManager>();
     if (screenMgr.TopmostDialogInstanceId == context.DialogInstanceId)
         screenMgr.CloseTopmostDialog();
 }

 public void EnterModelContext(NavigationContext oldContext, NavigationContext newContext)
 {
     // reset the properties
     UpdateInfo = string.Empty;
     UpdateProgress = 0;
     // start the update in a background thread
     RunUpdate(newContext);
 }

 bool getParameters(NavigationContext context)
 {
     game = null;
     object gameObject;
     if (!context.ContextVariables.TryGetValue(KEY_GAME, out gameObject))
         return false;
     game = gameObject as Game;
     return game != null;
 }

 protected static ItemsList GetOrCreateNavigationItems(NavigationContext context)
 {
   lock (context.SyncRoot)
   {
     ItemsList result = GetNavigationItems(context);
     if (result == null)
       context.ContextVariables[NAVIGATION_ITEMS_KEY] = result = new ItemsList();
     return result;
   }
 }

 protected override void DoTask(NavigationContext context)
 {
     if (!getParameters(context))
         return;
     SetProgress("Launching " + game.Title, 0);
     launcher = new GameLauncher(game);
     launcher.ExtractionProgress += (s, e) => SetProgress(string.Format("Extracting {0}%", e.Percent), e.Percent);
     launcher.Starting += (s, e) => SetProgress("Launching...", 50);
     launcher.Exited += launcher_Exited;
     launcher.Launch();
 }

 /// <summary>
 /// This constructor has to be called from the component managing the navigation context stack.
 /// </summary>
 public NavigationContext(WorkflowState workflowState, string displayLabel, NavigationContext predecessor,
     IWorkflowModel workflowModel)
 {
   _workflowState = workflowState;
   _displayLabel = displayLabel;
   _predecessor = predecessor;
   if (workflowModel != null)
   {
     _workflowModelId = workflowModel.ModelId;
     _models.Add(workflowModel.ModelId, workflowModel);
   }
 }

 public void ExitModelContext(NavigationContext oldContext, NavigationContext newContext)
 {
     // set a flag to stop the update if the thread is still running
     lock (syncObject)
     {
         if (currentBackgroundTask != null) currentBackgroundTask.State = WorkState.CANCELED;
     }
     // wait until the update background thread has ended
     while (currentBackgroundTask != null)
     {
         System.Threading.Thread.Sleep(20);
     }
 }

 public bool IsActionEnabled(NavigationContext context)
 {
     if (context.WorkflowModelId == Guids.WorkFlowModelOV)
     {
         if (!BackgroundTask.Instance.IsExecuting)
         {
             if (context.WorkflowState.Name == Guids.WorkflowStateCategoriesName || context.WorkflowState.StateId == Guids.WorkflowStateVideos)
             {
                 return ((OnlineVideosWorkflowModel)context.Models[context.WorkflowModelId.Value]).SelectedSite.Site.CanSearch;
             }
         }
     }
     return false;
 }

        protected override void DoTask(NavigationContext context)
        {
            if (!getParameters(context))
                return;

            SetProgress(string.Format("Looking up {0}", platformStr), 0);
            var platform = importer.GetPlatformByName(platformStr);
            if (platform != null)
            {
                SetProgress(string.Format("Retrieving info for {0}", platform.Name), 33);
                var platformInfo = importer.GetPlatformInfo(platform.Id);
                if (platformInfo != null)
                {
                    System.Threading.Thread.Sleep(2000);
                    SetProgress(string.Format("Updating {0}", emulator.Title), 67);
                    emulator.Title = platformInfo.Title;
                    emulator.Developer = platformInfo.Developer;
                    emulator.Description = platformInfo.GetDescription();

                    using (ThumbGroup thumbGroup = new ThumbGroup(emulator))
                    {
                        using (SafeImage image = ImageHandler.SafeImageFromWeb(platformInfo.LogoUrl))
                        {
                            if (image != null)
                            {
                                thumbGroup.Logo.SetSafeImage(image.Image);
                                thumbGroup.SaveThumb(ThumbType.Logo);
                            }
                        }
                        using (SafeImage image = ImageHandler.SafeImageFromWeb(platformInfo.FanartUrl))
                        {
                            if (image != null)
                            {
                                thumbGroup.Fanart.SetSafeImage(image.Image);
                                thumbGroup.SaveThumb(ThumbType.Fanart);
                            }
                        }
                    }
                    emulator.Commit();
                }
            }
        }

 private static void OnStateSlotChanged(DependencyObject targetObject, NavigationContext context, string contextVariable)
 {
   if (string.IsNullOrEmpty(contextVariable))
   {
     WorkflowSaveRestoreStateAction action = GetSaveRestoreAction(targetObject);
     if (action != null)
     {
       action.DetachFromObject();
       RemoveSaveRestoreAction(targetObject);
     }
   }
   else
   {
     if (GetSaveRestoreAction(targetObject) != null)
       // Action already attached to object
       return;
     UIElement uiElement = targetObject as UIElement;
     WorkflowSaveRestoreStateAction action = new WorkflowSaveRestoreStateAction(context, contextVariable);
     SetSaveRestoreAction(targetObject, action);
     action.AttachToObject(uiElement);
   }
 }

 public WorkflowSaveRestoreStateAction(NavigationContext context, string contextVariable)
 {
   _context = context;
   _contextVariable = contextVariable;
 }

    public const string CONTEXT = "Context"; // Type: NavigationContext

    /// <summary>
    /// Sends a <see cref="MessageType.StatePushed"/> message.
    /// </summary>
    /// <param name="context">Navigation context of the workflow state which was pushed onto the navigation context stack.</param>
    public static void SendStatePushedMessage(NavigationContext context)
    {
      SystemMessage msg = new SystemMessage(MessageType.StatePushed);
      msg.MessageData[CONTEXT] = context;
      ServiceRegistration.Get<IMessageBroker>().Send(CHANNEL, msg);
    }

 public void UpdateMenuActions(NavigationContext context, IDictionary<Guid, WorkflowAction> actions)
 {
 }