public TrackInfoPoller(NowPlayingTrackInfoProvider Provider, CoverManager CoverManager, Window window)
 {
     this.nowPlayingProvider = Provider;
     this.coverManager = CoverManager;
     this.window = window;
     this.dispatcher = App.Current.Dispatcher;
 }

 public TaskViewModel(Dispatcher disp)
 {
     this._dispatcher = disp;
     AnnulerCommand = new GenericCommand<object>(ExecuteAnnulerCommand, CanExecuteAnnulerCommand);
     EffectuerCommand = new GenericCommand<object>(ExecuteEffectuerCommand, CanExecuteEffectuerCommand);
     DeclarerProbleme = new GenericCommand<object>(ExecuteDeclarerProblemeCommand, CanExecuteDeclarerProblemeCommand);
 }

 public UserRateListViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, BaseEntityDTO entity)
     : base(userInterop, controllerInterop, dispatcher)
 {
     this.entity = entity;
     rates = new ObservableCollection<UserRateItemDTO>();
     Rates = new ReadOnlyObservableCollection<UserRateItemDTO>(rates);
 }

        public MainViewModel()
        {
            _Dispatcher = Dispatcher.CurrentDispatcher;

            Items = new ObservableCollection<string>();
            Items.Add("Messages go here");
        }

        private static void RequireInstance()
        {
            // Design-time is more of a no-op, won't be able to resolve the
            // dispatcher if it isn't already set in these situations.
            if (_designer || Application.Current == null)
            {
                return;
            }

            // Attempt to use the RootVisual of the plugin to retrieve a
            // dispatcher instance. This call will only succeed if the current
            // thread is the UI thread.
            try
            {
                _instance = Application.Current.Dispatcher;
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("The first time SmartDispatcher is used must be from a user interface thread. Consider having the application call Initialize, with or without an instance.", e);
            }

            if (_instance == null)
            {
                throw new InvalidOperationException("Unable to find a suitable Dispatcher instance.");
            }
        }

 public CachedBitmap()
 {
     dispatcher = Dispatcher.CurrentDispatcher;
     _url = "";
     _source = null;
     _workItem = null;
 }

		public DispatcherSynchronizationContext (Dispatcher dispatcher)
		{
			if (dispatcher == null)
				throw new ArgumentNullException ("dispatcher");

			this.dispatcher = dispatcher;
		}

 private static void GuardUiaServerInvocation(Action invocation, Dispatcher dispatcher)
 {
     if (dispatcher == null)
         throw new ElementNotAvailableException();
     Exception remoteException = null;
     bool completed = false;
     dispatcher.Invoke(DispatcherPriority.Send, TimeSpan.FromMinutes(3.0), (Action)(() =>
     {
         try
         {
             invocation();
         }
         catch (Exception e)
         {
             remoteException = e;
         }
         catch
         {
             remoteException = null;
         }
         finally
         {
             completed = true;
         }
     }));
     if (completed)
     {
         if (remoteException != null)
             throw remoteException;
     }
     else if (dispatcher.HasShutdownStarted)
         throw new InvalidOperationException("AutomationDispatcherShutdown");
     else
         throw new TimeoutException("AutomationTimeout");
 }

		public DialogManager(
			ContentControl parent,
			Dispatcher dispatcher)
		{
			_dispatcher = dispatcher;
			_dialogHost = new DialogLayeringHelper(parent);
		}

        protected override void Run()
        {
            this.Engine.Log(LogLevel.Verbose, "Launching Sparrow.Chart.Installer");
            BootstrapperDispatcher = Dispatcher.CurrentDispatcher;
            MainViewModel viewModel = new MainViewModel(this);
            viewModel.Bootstrapper.Engine.Detect();

            if (viewModel.Bootstrapper.Command.Action == LaunchAction.Install && !isInstalled)
            {
                MainView view = new MainView();
                view.DataContext = viewModel;
                view.Closed += (sender, e) => BootstrapperDispatcher.InvokeShutdown();
                view.Show();
                isInstalled = true;
            }

            if (viewModel.Bootstrapper.Command.Action == LaunchAction.Uninstall && !isUninstalled)
            {
                MainView view = new MainView();
                view.DataContext = viewModel;
                view.Closed += (sender, e) => BootstrapperDispatcher.InvokeShutdown();
                view.Show();
                isUninstalled = true;
            }

            Dispatcher.Run();

            this.Engine.Quit(0);
        }

		private void Application_Startup (object sender, StartupEventArgs e)
		{
			Panel root = new TestElement { Name = "Root" };
			root.Children.Add (CreateTemplated ("Button1"));
			d = root.Dispatcher;
			RootVisual = root;
			Delay (() => {
				Console.WriteLine ("Actual");
				Console.Write (sb.ToString ());

				Console.WriteLine ();
				Console.WriteLine ();
				Console.WriteLine (@"Expected
Button1: Loaded
Root: Loaded
Button2: Loaded
Button1: OnApplyTemplate
Button1: MeasureOverride
Button2: OnApplyTemplate
Button2: MeasureOverride
Button1: ArrangeOverride
Button2: ArrangeOverride
Root: LayoutUpdated
Button1: LayoutUpdated
Button2: LayoutUpdated");
			});
		}

 internal FileOpenModalDialog(Dispatcher dispatcher, Window parentWindow)
     : base(dispatcher, parentWindow)
 {
     Dialog = new CommonOpenFileDialog { EnsureFileExists = true };
     Filters = new List<FileDialogFilter>();
     FilePaths = new List<string>();
 }

        /// <summary>
        /// Creates a square image and attaches an event handler to the layout changed event that
        /// adds the the square in the upper right-hand corner of the TextView via the adornment layer
        /// </summary>
        /// <param name="view">The <see cref="IWpfTextView"/> upon which the adornment will be drawn</param>
        /// <param name="imageProvider">The <see cref="IImageProvider"/> which provides bitmaps to draw</param>
        /// <param name="setting">The <see cref="Setting"/> contains user image preferences</param>
        public ClaudiaIDE(IWpfTextView view, List<IImageProvider> imageProvider, Setting setting)
		{
		    try
		    {
		        _dispacher = Dispatcher.CurrentDispatcher;
                _imageProviders = imageProvider;
                _imageProvider = imageProvider.FirstOrDefault(x=>x.ProviderType == setting.ImageBackgroundType);
                _setting = setting;
                if (_imageProvider == null)
                {
                    _imageProvider = new SingleImageProvider(_setting);
                }
                _view = view;
                _image = new Image
                {
                    Opacity = setting.Opacity,
                    IsHitTestVisible = false
                };
                _adornmentLayer = view.GetAdornmentLayer("ClaudiaIDE");
				_view.ViewportHeightChanged += delegate { RepositionImage(); };
				_view.ViewportWidthChanged += delegate { RepositionImage(); };     
                _view.ViewportLeftChanged += delegate { RepositionImage(); };
                _setting.OnChanged += delegate { ReloadSettings(); };

                _imageProviders.ForEach(x => x.NewImageAvaliable += delegate { InvokeChangeImage(); });

                ChangeImage();
            }
			catch
			{
			}
		}

        public CathedraViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, CathedraDTO cathedra)
            : base(userInterop, controllerInterop, dispatcher)
        {
            faculties = new List<FacultyDTO>();

            originalEntity = cathedra;
        }

        public BackgroundDispatcher(string name)
        {
            AutoResetEvent are = new AutoResetEvent(false);

            Thread thread = new Thread((ThreadStart)delegate
            {
                _dispatcher = Dispatcher.CurrentDispatcher;
                _dispatcher.UnhandledException +=
                delegate(
                     object sender,
                     DispatcherUnhandledExceptionEventArgs e)
                {
                    e.Handled = true;
                };
                are.Set();
                Dispatcher.Run();
            });

            thread.Name = string.Format("BackgroundStaDispatcher({0})", name);
            thread.SetApartmentState(ApartmentState.MTA);
            thread.IsBackground = true;
            thread.Start();

            are.WaitOne();
            are.Close();
            are.Dispose();
        }

 public RemoveClientFromUserListTask(Dispatcher disp, TaskHandler handler, ClientConnectionList list, ClientConnection client, ObservableCollection<UserLocation> locs)
     : base(disp, handler)
 {
     ClientConnectionList = list;
     ClientConnection = client;
     UserLocations = locs;
 }

        public OrgStructureViewModel(string siteUrl,string subSiteUrl, StringBuilder log, string mainCheckListName)
        {
            _log = log;
            _dispatcher = Deployment.Current.Dispatcher;
            _OrgStructureServiceAgent = new OrgStructureServiceAgent(siteUrl, log);
            _mainCheckListName = mainCheckListName;
            _subSiteUrl = subSiteUrl;
            Levels = new ObservableCollection<OrgStructureEntityModel>();


            AddCommand = new RelayCommand(AddAction);
            AddCommand.IsEnabled = false;

            EditCommand = new RelayCommand(EditAction);
            EditCommand.IsEnabled = false;

            DeleteCommand = new RelayCommand(DeleteAction);
            DeleteCommand.IsEnabled = false;

            AddGlobalCommand = new RelayCommand(AddGlobalAction);
            AddGlobalCommand.IsEnabled = true;

            CancelCommand = new RelayCommand(CancelAction);
            CancelCommand.IsEnabled = true;

            _confirmDialog = new DialogService(340, 120);
            
            LoadOrgStructureEntityModel();

        }

        public InstituteAdminViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher)
            : base(userInterop, controllerInterop, dispatcher)
        {
            institutes = new List<InstituteDTO>();

            originalEntity = new InstituteAdminDTO() { Role = UserRoles.InstituteAdmin };
        }

		internal DispatcherOperation (Dispatcher dis, DispatcherPriority prio, Delegate d, object arg)
			: this (dis, prio)
		{
			delegate_method = d;
			delegate_args = new object [1];
			delegate_args [0] = arg;
		}

        public FileWatcher(string directory, string filter)
        {
            _dispatcher = Dispatcher.CurrentDispatcher;

            _watcher = new FileSystemWatcher();
            _watcher.BeginInit();
            _watcher.Path = directory;
            _watcher.Filter = filter;
            _watcher.IncludeSubdirectories = false;
            _watcher.InternalBufferSize = InitialBufferSize;

            _watcher.NotifyFilter
                = NotifyFilters.DirectoryName
                | NotifyFilters.FileName
                | NotifyFilters.LastWrite
                | NotifyFilters.Attributes
                | NotifyFilters.Security
                | NotifyFilters.Size;

            // note: all events are on threadpool threads!
            _watcher.Created += onCreated;
            _watcher.Deleted += onDeleted;
            _watcher.Changed += onChanged;
            _watcher.Renamed += onRenamed;
            _watcher.Error += onError;

            _watcher.EndInit();

            _watcher.EnableRaisingEvents = true;
        }