public TrackInfoPoller(NowPlayingTrackInfoProvider Provider, CoverManager CoverManager, Window window)
{
this.nowPlayingProvider = Provider;
this.coverManager = CoverManager;
this.window = window;
this.dispatcher = App.Current.Dispatcher;
}
public void StartListen()
{
_dispatcher = Dispatcher.CurrentDispatcher;
_presenceListener.StartListen();
_onPresence = _dispatcher.Wrap<Client, Presence>(OnPresence);
_presenceListener.PresenceReceived += _onPresence.Exec;
}
private void ChangeThemeCmd_Executed(object s, ExecutedRoutedEventArgs e, System.Windows.Threading.Dispatcher disp)
{
ThemesVM.EnTheme oldTheme = ThemesVM.EnTheme.Generic;
try
{
if (e == null)
{
return;
}
if (e.Parameter == null)
{
return;
}
// Check if request is available
if (e.Parameter is Themes.ThemesVM.EnTheme == false)
{
return;
}
Themes.ThemesVM.EnTheme t = (Themes.ThemesVM.EnTheme)e.Parameter;
oldTheme = this.Config.CurrentTheme;
// The Work to perform on another thread
ThreadStart start = delegate
{
// This works in the UI tread using the dispatcher with highest Priority
disp.Invoke(DispatcherPriority.Send,
(Action)(() =>
{
try
{
this.Config.CurrentTheme = t;
}
catch (Exception exp)
{
logger.ErrorException(exp.Message, exp);
Edi.Msg.Box.Show(exp, App.IssueTrackerText, MsgBoxButtons.OK, MsgBoxImage.Error, MsgBoxResult.NoDefaultButton,
App.IssueTrackerLink, App.IssueTrackerLink, App.IssueTrackerText, null, true);
}
}));
};
// Create the thread and kick it started!
Thread thread = new Thread(start);
thread.Start();
}
catch (Exception exp)
{
this.Config.CurrentTheme = oldTheme;
logger.ErrorException(exp.Message, exp);
Edi.Msg.Box.Show(exp, App.IssueTrackerText, MsgBoxButtons.OK, MsgBoxImage.Error, MsgBoxResult.NoDefaultButton,
App.IssueTrackerLink, App.IssueTrackerLink, App.IssueTrackerText, null, true);
}
}
private static void Show(Action action)
{
var startedEvent = new ManualResetEventSlim(initialState: false);
System.Windows.Threading.Dispatcher dispatcher = null;
var uiThread = new Thread(() =>
{
// Create and install a new dispatcher context
SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
dispatcher = Dispatcher.CurrentDispatcher;
// Signal that it is initialized
startedEvent.Set();
// Start the dispatcher processing
Dispatcher.Run();
});
// Set the apartment state
uiThread.SetApartmentState(ApartmentState.STA);
// Make the thread a background thread
uiThread.IsBackground = true;
// Start the thread
uiThread.Start();
startedEvent.Wait();
dispatcher.Invoke(action);
dispatcher.InvokeShutdown();
uiThread.Join(1000);
startedEvent.Dispose();
}
/// <summary>Called when the bootstrap application is run.</summary>
protected override void Run()
{
_mainWindow = GetApplicationUI();
UIDispatcher = Threading.Dispatcher.CurrentDispatcher;
if (_mainWindow != null)
{
try
{
if (Command.Display == Wix.Display.Full ||
Command.Display == Wix.Display.Passive)
{
UIDispatcher = _mainWindow.Dispatcher;
_mainWindow.Closed += OnWindowClosed;
_mainWindow.Show();
}
Engine.Detect();
Threading.Dispatcher.Run();
Engine.Quit(_mainWindow.Result);
}
catch (Exception ex)
{
LogError(ex);
Engine.Quit(400);
}
}
else
{
LogError("Failed to get an UI implementation.");
Engine.Quit(404);
}
}
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 Servidor(
string tag,
string link,
int bytesPacote,
int tempoResposta,
int pingMS,
Rectangle indicador1,
System.Windows.Controls.Label labelTempo,
System.Windows.Controls.Label labelnome,
System.Windows.Controls.Label labelsemResposta,
System.Windows.Controls.Label labelpacotes,
System.Windows.Controls.Label labelbytes,
Dispatcher dispatcher)
{
this.tag = tag;
this.link = link;
this.packetSize = bytesPacote;
this.tempoResposta = tempoResposta;
this.pingMS = pingMS;
this.indicador = indicador1;
this.labelTempo = labelTempo;
this.labelnome = labelnome;
this.labelsemResposta = labelsemResposta;
this.labelpacotes = labelpacotes;
this.labelbytes = labelbytes;
this.Dispatcher = dispatcher;
this.listaTempo = new System.Collections.Generic.List <int>();
}
// Dequeue the next file, load it as a BitmapImage, and return it. If there is no file, store the callback and dispatcher, to be called when the next file is enqueued.
// If a file is under review, it will NOT be passed to the next module; it will silently exit the workflow.
public ImageSource NextImage(NextImageCallback callback, System.Windows.Threading.Dispatcher dispatcher)
{
// TODO Consider reusing the dispatcher from BasicModule, which was added as part of logging.
ImageSource returnValue = null;
bool gotLock = false;
while (!gotLock)
{
fileLock.Enter(ref gotLock);
}
// We have the lock.
// Clear any saved callbacks; this request overrides them.
nextImageCallback = null;
nextImageCallbackDispatcher = null;
if (files.Count > 0)
{
// Great! We can dequeue.
FileInfo file;
// Get the next file to process.
file = files.Dequeue();
log($"ImageReviewer.NextImage: Dequeued file: {file.FullName}");
// Save the file so we have it when the decision to accept/reject comes back.
fileUnderReview = file;
fileLock.Exit();
// Load the image, AFTER exiting.
try
{
returnValue = makeImage(file);
}
catch (Exception e)
{
log($"ImageReviewer.NextImage: makeImage threw exception: {e.Message}");
log("ImageReviewer.NextImage: Ignoring this image and recursing.");
returnValue = NextImage(callback, dispatcher);
}
}
else
{
// Nothing to dequeue. Save a callback.
nextImageCallback = callback;
nextImageCallbackDispatcher = dispatcher;
fileLock.Exit();
// And clear the current saved file.
fileUnderReview = null;
log($"ImageReviewer.NextImage: Nothing to dequeue. Saved callback.");
}
return(returnValue);
}
public void GetAndRunWpfDispatcher_invokeAndShutdown_invocationInDispatcherDone()
{
System.Windows.Threading.Dispatcher disp = null;
var created = new ManualResetEvent(false);
var t = new Thread(x =>
{
disp = System.Windows.Threading.Dispatcher.CurrentDispatcher;
created.Set();
System.Windows.Threading.Dispatcher.Run();
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
created.WaitOne();
int threadId = -1;
bool wasAct = false;
Action act = () =>
{
wasAct = true;
threadId = Thread.CurrentThread.ManagedThreadId;
};
disp.Invoke(act);
disp.InvokeShutdown();
Assert.AreEqual(threadId, t.ManagedThreadId);
Assert.That(wasAct, Is.True);
}
public MainViewModel()
{
_Dispatcher = Dispatcher.CurrentDispatcher;
Items = new ObservableCollection<string>();
Items.Add("Messages go here");
}
public ContactWatcher(Dispatcher dispatcher, ContactLoader loader, string directory, ContactWatcherEventCallback callback)
{
// Assert here rather than dynamically generate these arrays. This class should include all the supported types.
Assert.AreEqual(Contact.GetExtensionsFromType(ContactTypes.All).Split('|').Length, _Types.Length);
var watchers = new ContactWatcherSingular[_Types.Length];
try
{
for (int i = 0; i < _Types.Length; ++i)
{
watchers[i] = new ContactWatcherSingular(dispatcher, loader, directory, _Types[i], callback);
}
_watchers = watchers;
watchers = null;
}
finally
{
if (null != watchers)
{
foreach (ContactWatcherSingular watcher in watchers)
{
if (null != watcher)
{
watcher.Dispose();
}
}
}
}
}
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);
}
//Constructor
public SignalCollection(MainWindow uiWindow)
{
brushes = new List<SolidColorBrush>();
brushes.Add(Brushes.MediumVioletRed);
brushes.Add(Brushes.LightBlue);
brushes.Add(Brushes.BurlyWood);
brushes.Add(Brushes.LightPink);
brushes.Add(Brushes.Yellow);
brushes.Add(Brushes.LightGreen);
brushes.Add(Brushes.Gold);
window = uiWindow;
dataDispatcher = window.Dispatcher;
signals = new List<Signal>(0);
this.view = uiWindow.view; //set initial view params
//view.XMAX = 2000;
view.YMIN = 0;
view.YMAX = 1024;
view.XMIN = 0;
view.LINESCALE = 1;
horizontals = new List<gridLine>(10);
verticals = new List<gridLine>(10);
plotlineH = createHLine(0,false);
plotlineH.hideLabel();
plotlineV = createVLine(0,false);
plotlineV.hideLabel();
preparePlot();
drawWorkerDelegate w = drawWorker;
w.BeginInvoke(null, null);
//addSignal(true);
}
public SpeechMod(System.Windows.Shapes.Ellipse circle, System.Windows.Threading.Dispatcher dispatcher)
{
this.circle = circle;
this.Dispatcher = dispatcher;
//init LifeCycleEvents..
lce = new LifeCycleEvents("ASR", "FUSION", "speech-1", "acoustic", "command"); // LifeCycleEvents(string source, string target, string id, string medium, string mode)
//mmic = new MmiCommunication("localhost",9876,"User1", "ASR"); //PORT TO FUSION - uncomment this line to work with fusion later
mmic = new MmiCommunication("localhost", 8000, "User1", "ASR"); // MmiCommunication(string IMhost, int portIM, string UserOD, string thisModalityName)
mmic.Send(lce.NewContextRequest());
//load pt recognizer
sre = new SpeechRecognitionEngine(new System.Globalization.CultureInfo("pt-PT"));
gr = new Grammar(Environment.CurrentDirectory + "\\ptG.grxml", "rootRule");
sre.LoadGrammar(gr);
sre.SetInputToDefaultAudioDevice();
sre.RecognizeAsync(RecognizeMode.Multiple);
sre.SpeechRecognized += Sre_SpeechRecognized;
sre.SpeechHypothesized += Sre_SpeechHypothesized;
// load speech synthetizer
tts = new Tts();
// introduce assistant
Speak("Olá, eu sou o teu assistente de viagens. Tenho todo o gosto em ajudar-te a planear as tuas férias de sonho. Podes saber mais sobre mim dizendo: preciso de ajuda.", 12);
}
public SplashWindow()
{
InitializeComponent();
//create our background worker and support cancellation
worker = new BackgroundWorker();
worker.DoWork += delegate(object s, DoWorkEventArgs doWorkArgs)
{
// try
// {
System.Threading.Thread.Sleep(5000);
//And ask the WPF thread to open the next (OpenFile) Window
System.Windows.Threading.Dispatcher winDispatcher = this.Dispatcher;
OpenFilePageDelegate winDelegate = new OpenFilePageDelegate(this.close_click);
//invoke the dispatcher and pass the percentage and max record count
winDispatcher.BeginInvoke(winDelegate);
// }
// catch (Exception ex)
// {
// ;
// }
};
worker.RunWorkerAsync();
}
public TvVideoPage()
{
this.InitializeComponent();
this.dispatcher = System.Windows.Threading.Dispatcher.CurrentDispatcher;
base.Loaded += new RoutedEventHandler(this.TvVideoPage_Loaded);
base.Unloaded += new RoutedEventHandler(this.TvVideoPage_Unloaded);
}
/// <summary>
/// Creates a timer that is bound to the specified dispatcher and
/// will be processed at the specified priority, after the
/// specified timeout.
/// </summary>
/// <param name="interval">
/// The interval to tick the timer after.
/// </param>
/// <param name="priority">
/// The priority to process the timer at.
/// </param>
/// <param name="callback">
/// The callback to call when the timer ticks.
/// </param>
/// <param name="dispatcher">
/// The dispatcher to use to process the timer.
/// </param>
public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback, Dispatcher dispatcher) // NOTE: should be Priority
{
//
if(callback == null)
{
throw new ArgumentNullException("callback");
}
if(dispatcher == null)
{
throw new ArgumentNullException("dispatcher");
}
if (interval.TotalMilliseconds < 0)
throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooSmall));
if (interval.TotalMilliseconds > Int32.MaxValue)
throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooLarge));
Initialize(dispatcher, priority, interval);
Tick += callback;
Start();
}
public CachedBitmap()
{
dispatcher = Dispatcher.CurrentDispatcher;
_url = "";
_source = null;
_workItem = null;
}
public DispatcherTimer(Dispatcher dispatcher, ITaskScheduler scheduler, TimeSpan interval, DispatcherPriority priority)
{
this.dispatcher = dispatcher;
this.scheduler = scheduler;
this.Interval = interval;
this.Priority = priority;
}
public VirtualPageManager( Dispatcher dispatcher,
int pageSize, int maxRealizedItemCount, double preemptivePageQueryRatio )
{
if( dispatcher == null )
throw new ArgumentNullException( "dispatcher" );
if( pageSize < 1 )
throw new ArgumentOutOfRangeException( "pageSize", pageSize, "pageSize must be greater than zero." );
if( maxRealizedItemCount < pageSize )
throw new ArgumentOutOfRangeException( "maxRealizedItemCount", maxRealizedItemCount, "maxRealizedItemCount must be greater than or equal to pageSize." );
m_managedLists = new List<VirtualList>();
m_pageNodes = new LinkedList<VirtualPage>();
this.Dispatcher = dispatcher;
m_pageSize = pageSize;
m_maxRealizedItemCount = maxRealizedItemCount;
m_maxRemovablePageCount = ( m_maxRealizedItemCount / m_pageSize );
m_preemptivePageQueryRatio = preemptivePageQueryRatio;
this.IsConnected = true;
}
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");
});
}
public InstituteAdminViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, InstituteAdminDTO instituteAdmin)
: base(userInterop, controllerInterop, dispatcher)
{
institutes = new List<InstituteDTO>();
originalEntity = instituteAdmin;
}
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 DialogManager(
ContentControl parent,
Dispatcher dispatcher)
{
_dispatcher = dispatcher;
_dialogHost = new DialogLayeringHelper(parent);
}
public InstituteAdminViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher)
: base(userInterop, controllerInterop, dispatcher)
{
institutes = new List<InstituteDTO>();
originalEntity = new InstituteAdminDTO() { Role = UserRoles.InstituteAdmin };
}
public Presenter(string[] startupArgs)
{
// Initialize logging system.
Log.InitLogging();
// Keep a handle to the current main GUI thread, so that we can have proper object
// ownership when it comes time for this presenter to present new GUI objects.
m_dispatcher = Dispatcher.CurrentDispatcher;
// Create and initialize the controller for all the internal logic.
m_controller = new SenescoController();
m_controller.ProgressUpdated += progressUpdated;
m_controller.Connected += connected;
m_controller.Disconnected += disconnected;
m_controller.ChatReceived += chatReceived;
m_controller.UserListUpdate += userListUpdate;
m_controller.PmReceived += pmReceived;
m_controller.UserInfoReceived += userInfoReceived;
m_controller.NewVersionAvailable += newVersionAvailable;
// Create and show the main chat window.
// Note that this creator is run in the main GUI thread, so this chat window is properly owned,
// but other windows we create may be in different threads so we'll have to take extra care.
m_chatWindow = new ChatWindow(this, m_controller);
m_chatWindow.Show();
// Process the command-line arguments.
ProcessStartup(startupArgs);
}
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);
}
internal FileOpenModalDialog(Dispatcher dispatcher, Window parentWindow)
: base(dispatcher, parentWindow)
{
Dialog = new CommonOpenFileDialog { EnsureFileExists = true };
Filters = new List<FileDialogFilter>();
FilePaths = new List<string>();
}
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;
}
public CathedraViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, CathedraDTO cathedra)
: base(userInterop, controllerInterop, dispatcher)
{
faculties = new List<FacultyDTO>();
originalEntity = cathedra;
}
/// <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 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();
}
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 DispatcherSynchronizationContext (Dispatcher dispatcher)
{
if (dispatcher == null)
throw new ArgumentNullException ("dispatcher");
this.dispatcher = dispatcher;
}
/// <summary>
/// Thread entry point for WiX Toolset Bootstrapper Application.
/// </summary>
protected override void Run()
{
this.Engine.Log(LogLevel.Verbose, "Running the WiX BA.");
WixBA.Model = new Model(this);
WixBA.Dispatcher = Threading.Dispatcher.CurrentDispatcher;
RootViewModel viewModel = new RootViewModel();
WixBA.View = new RootView(viewModel);
// Create a Window to show UI.
if (WixBA.Model.Command.Display == Display.Passive ||
WixBA.Model.Command.Display == Display.Full)
{
this.Engine.Log(LogLevel.Verbose, "Creating a UI.");
WixBA.View.Show();
}
// Kick off detect which will populate the view models.
this.Engine.Detect();
Threading.Dispatcher.Run();
this.PostTelemetry();
this.Engine.Quit(WixBA.Model.Result);
}
public MarketDataObservable(CurrencyPair currencyPair, Dispatcher dispatcher)
{
var spread = currencyPair.DefaultSpread;
var midRate = currencyPair.InitialPrice;
var bid = midRate - (spread * currencyPair.PipSize);
var offer = midRate + (spread * currencyPair.PipSize);
var initial = new MarketData(currencyPair.Code, bid, offer);
var currentPrice = initial;
Value = currentPrice;
var random = new Random();
//for a given period, move prices by up to 5 pips
_recurringAction = new RecurringAction(() =>
{
int pips = random.Next(1, 5);
//move up or down between 1 and 5 pips
var adjustment = Math.Round(pips * currencyPair.PipSize, currencyPair.DecimalPlaces);
MarketData marketData = random.NextDouble() > 0.5
? currentPrice + adjustment
: currentPrice - adjustment;
dispatcher.Invoke(() =>
Value = marketData, DispatcherPriority.Background);
}, () => TimeSpan.FromSeconds(1 / (double)currencyPair.TickFrequency));
}
/// <summary>
/// This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="disposing">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_xmlModel != null)
{
try
{
_xmlModel.Dispose();
}
finally
{
_xmlModel = null;
}
}
}
_dispatcher = null;
}
finally
{
base.Dispose(disposing);
}
}
public RemoveClientFromUserListTask(Dispatcher disp, TaskHandler handler, ClientConnectionList list, ClientConnection client, ObservableCollection<UserLocation> locs)
: base(disp, handler)
{
ClientConnectionList = list;
ClientConnection = client;
UserLocations = locs;
}
public MainWindow(MyExtMainWrapper extMainWrapper, MainWindowWrapper mainWindowWrapper, Dispatcher theSodAccessDispatcher)
{
this.Closing += MainWindow_Closing;
this.Topmost = true;
InitializeComponent();
CustomEventsInit();
}
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");
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskEvents"/> class with the specified <see
/// cref="SysDispatcher"/>.</summary>
/// <param name="dispatcher">
/// The <see cref="SysDispatcher"/> used to marshal calls to the foreground thread. This
/// argument may be a null reference.</param>
public TaskEvents(SysDispatcher dispatcher)
{
Dispatcher = dispatcher;
// create & start timer
Timer = new Stopwatch();
Timer.Start();
}
private void ProcessSingleFile(string filename)
{
_rowsProcessed = 0;
_inputFileStreamLength = 0;
_jaggedLines = 0;
// get the salt from the text box, which may or may not be visible..
_salt = txtSalt.Text;
System.Windows.Threading.Dispatcher dispatcher = Dispatcher;
worker = new BackgroundWorker();
worker.WorkerSupportsCancellation = true;
bool wasCancelled = false;
int columnIndexSelectedAsNHSNumber = cmbNHSNumber.SelectedIndex;
// anonymous delegate, this could be moved out for readability?
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
if (MainWork(filename, columnIndexSelectedAsNHSNumber, dispatcher, ref wasCancelled))
{
return;
}
};
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
string configWriteLine = "";
if (!wasCancelled)
{
configWriteLine = "Processing Finished At: " + DateTime.Now;
UpdateProgressDelegate update = new UpdateProgressDelegate(UpdateProgressText);
dispatcher.BeginInvoke(update, _inputFileStreamLength, _inputFileStreamLength, _rowsProcessed, _validNHSNumCount, _inValidNHSNumCount, _missingNHSNumCount);
}
else
{
configWriteLine = "Processing Cancelled At: " + DateTime.Now;
}
var writeConfigStream = new FileStream(_outputRunLogFileName, FileMode.Append, FileAccess.Write);
using (StreamWriter streamConfigWriter = new StreamWriter(writeConfigStream))
{
streamConfigWriter.WriteLine(configWriteLine);
streamConfigWriter.WriteLine("Lines Processed: " + _rowsProcessed);
streamConfigWriter.WriteLine("Jagged Lines: " + _jaggedLines);
if (_performNHSNumberValidation)
{
streamConfigWriter.WriteLine("Valid NHSNumbers (10 character number found and passed checksum) : " + _validNHSNumCount);
streamConfigWriter.WriteLine("Invalid NHSNumbers (data was present but failed the checksum) : " + _inValidNHSNumCount);
streamConfigWriter.WriteLine("Missing NHSNumbers (blank string or space) : " + _missingNHSNumCount);
}
}
SignRunLogFile();
};
worker.RunWorkerAsync();
}
public MarketDataService(IStaticData staticData, Dispatcher dispatcher)
{
_dispatcher = dispatcher;
foreach (var item in staticData.CurrencyPairs)
{
_marketDataObservables[item.Code] = CreateObservableMarketData(item);
}
}
public SuggestionInput()
{
m_uiDispatcher = t.Dispatcher.CurrentDispatcher;
m_timer = new t.DispatcherTimer
{
Interval = TimeSpan.FromMilliseconds(300),
IsEnabled = false
};
m_timer.Tick += OnFetch;
}
private List <EncryptedSaltDTO> SaltCollectMainWork(System.Windows.Threading.Dispatcher dispatcher, string address, string username, string password)
{
// try and connect to the KeyServer to get the public key
var client = new RestClient(address);
// call the API and get a list of files they own
client.Authenticator = new HttpBasicAuthenticator(username, password);
var request = new RestRequest("Salt", Method.GET);
List <EncryptedSaltDTO> myDtos = new List <EncryptedSaltDTO>();
List <EncryptedSaltDTO> shareddtos = new List <EncryptedSaltDTO>();
IRestResponse <List <EncryptedSaltDTO> > response = client.Execute <List <EncryptedSaltDTO> >(request);
// the restclient throws an exeception when trying to automatically deserialise our object, so we use Newtonsoft instead:
using (Stream ms = new MemoryStream(Encoding.UTF8.GetBytes(response.Content)))
{
myDtos = JsonConvert.DeserializeObject <List <EncryptedSaltDTO> >(new StreamReader(ms).ReadToEnd());
}
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
// OK bind
}
else
{
//return errro;
}
// call the API and get a list of files they can acess via shares
request = new RestRequest("ShareSalt", Method.GET);
response = client.Execute <List <EncryptedSaltDTO> >(request);
// the restclient throws an exeception when trying to automatically deserialise our object, so we use Newtonsoft instead:
using (Stream ms = new MemoryStream(Encoding.UTF8.GetBytes(response.Content)))
{
shareddtos = JsonConvert.DeserializeObject <List <EncryptedSaltDTO> >(new StreamReader(ms).ReadToEnd());
}
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
// OK bind
}
else
{
//return errro;
}
// concatenate and return
return(myDtos.Union(shareddtos).ToList());
}
public static void DoEvents(this System.Windows.Threading.Dispatcher dispatcher)
{
var frame = new DispatcherFrame();
Action <DispatcherFrame> action = _ => { frame.Continue = false; };
dispatcher.BeginInvoke(
DispatcherPriority.SystemIdle,
action,
frame);
Dispatcher.PushFrame(frame);
}
/// <summary>
/// Invoke or execute
/// </summary>
/// <param name="dispatcher">The dispatcher</param>
/// <param name="action">Action object</param>
public static void InvokeOrExecute(this System.Windows.Threading.Dispatcher dispatcher, Action action)
{
if (dispatcher.CheckAccess())
{
action();
}
else
{
dispatcher.BeginInvoke(DispatcherPriority.Normal, action);
}
}
public DirectoryTreeWatcher(DirectoryTree target, int side, string path, System.Windows.Threading.Dispatcher disp, ChangeHandler Change,
HashSet <string> fullTextExtensions,
PleaseWait initProgress)
{
this.target = target;
this.side = side;
this.path = path;
this.Change += Change;
this.disp = disp;
this.fullTextExtensions = fullTextExtensions;
init(initProgress);
}
private void Form1_Load(object sender, EventArgs e)
{
//this.pictureBox1.Visible = true;
this.backgroundWorker1.RunWorkerAsync();
_dispatcher = Dispatcher.CurrentDispatcher;
ShowColumnGraph(GetTableData());
ShowLineGraph();
}
/// <summary>Sets the main window to the specified <paramref name="window"/>.</summary>
/// <param name="window">The new main window.</param>
public void SetMainWindow(BaseBAWindow window)
{
if (window == null)
{
Exception error = new ArgumentNullException("window");
LogError(error);
throw error;
}
_mainWindow.Closed -= OnWindowClosed;
_mainWindow = window;
_mainWindow.Closed += OnWindowClosed;
UIDispatcher = _mainWindow.Dispatcher;
}
/// <summary>
/// Starts the dispatcher on the main thread.
/// </summary>
/// <param name="thread">The thread.</param>
/// <remarks>
/// If the method has already been called previously, this new call will silently fail.
/// </remarks>
internal static void Run(Thread thread)
{
if (s_mainThreadDispather != null)
{
return;
}
s_mainThreadDispather = ThreadDispatcher.FromThread(thread) ?? ThreadDispatcher.CurrentDispatcher;
s_oneSecondTimer = new DispatcherTimer(TimeSpan.FromSeconds(1),
DispatcherPriority.Background,
OneSecondTickTimer_Tick,
s_mainThreadDispather);
}
public static void Wait(System.Windows.Threading.Dispatcher Dispatcher, int Milliseconds)
{
var Frame = new DispatcherFrame();
ThreadPool.QueueUserWorkItem(State =>
{
Thread.Sleep(Milliseconds);
Frame.Continue = false;
});
MessageBox.Show("Complete!");
Dispatcher.PushFrame(Frame);
MessageBox.Show("Complete 2!");
}
/// <summary>
/// Initializes a new instance of the <see cref="Microsoft.Research.Science.Data.Utilities.DataSetReplicator"/> class.
/// </summary>
/// <param name="source">Source.</param>
/// <param name="wpfDispatcher">Wpf dispatcher.</param>
public DataSetReplicator(DataSet source, WPFDispatcher wpfDispatcher)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (wpfDispatcher == null)
{
throw new ArgumentNullException("wpfDispatcher");
}
this.source = source;
this.wpfDispatcher = wpfDispatcher;
DataSetCommittedEventManager.AddListener(source, this);
}
public MainForm()
{
InitializeComponent();
_dispatcher = Dispatcher.CurrentDispatcher;
CreateHeader();
this.ItemLinkLabel.Enabled = false;
this.PathText.Text = Environment.GetFolderPath(Environment.SpecialFolder.MyVideos);
#if DEBUG
this.PathText.Text = @"C:\Users\078134995";
#endif
}
/// <summary>
/// Initializes a new instance of the DelayInvoker class.
/// </summary>
/// <param name="dispatcher">The Dispatcher to execute the action.</param>
/// <param name="action">The action to execute with delay. Null is allowed.</param>
/// <param name="delayTime">Time to wait before executing the action.</param>
/// <param name="dispatcherPriority">The priority at which execute the action.</param>
/// <param name="delegatePriority">The dispatcher priority to use for methods and properties of this class if the caller is not in the thread for dispatcher.</param>
public DelayInvoker(TheDispatcher dispatcher, Action action, TimeSpan delayTime, TheDispatcherPriority dispatcherPriority, TheDispatcherPriority delegatePriority)
{
if (dispatcher == null)
{
throw new ArgumentNullException(nameof(dispatcher));
}
_dispatcher = dispatcher;
_action = action;
_delegatePriority = delegatePriority;
// Creates a timer.
_dispatcherTimer = new TheDispatcherTimer(dispatcherPriority, dispatcher);
_dispatcherTimer.Interval = delayTime;
_dispatcherTimer.Tick += DispatcherTimer_Tick;
}
/************************************************************************************************************************************/
/* Constructors */
/************************************************************************************************************************************/
/// <summary>
/// Initializes a shared virtual bus to act as a communication channel between modules.
/// </summary>
/// <param name="dispatcher">A dispatcher used to run event notifications on the GUI thread.</param>
public VirtualBus(System.Windows.Threading.Dispatcher dispatcher)
{
Debug.Write("Initializing the virtual bus...\n");
_updatedNodes = Queue.Synchronized(new Queue());
_nodes = new ConcurrentDictionary <BusNode, NodeEntry>();
_dispatcher = dispatcher;
foreach (BusNode node in BusNode.Values)
{
if (!IsValidType(node.NodeType))
{
throw new ArgumentException("Cannot initialize a node of type '" + node.NodeType.Name + "' as the type is not serializable.");
}
_nodes[node] = new NodeEntry(node, null, new List <VirtualBus.OnValueChangedCallback>());
}
}
private void FitToBounds(System.Windows.Threading.Dispatcher dispatcher, ZoomControl zoom)
{
if (dispatcher != null)
{
dispatcher.BeginInvoke(new Action(()
=>
{
zoom.ZoomToFill();
zoom.Mode = ZoomControlModes.Custom;
//zoom.FitToBounds();
}), DispatcherPriority.Loaded);
}
else
{
zoom.ZoomToFill();
zoom.Mode = ZoomControlModes.Custom;
}
}
public DispatcherQueue(System.Windows.Threading.Dispatcher dispatcher)
{
InitializeComponent();
// set data context to enable binding
DataContext = this;
// start a timer that is used to update the input field every second
perSecondTimer = new DispatcherTimer(DispatcherPriority.Normal);
perSecondTimer.Tick += new EventHandler(perSecondTimer_Tick);
perSecondTimer.Interval = new TimeSpan(0, 0, 1);
perSecondTimer.Start();
// remember the dispatcher that should be monitored
this.dispatcher = dispatcher;
// add a hook to the dispatcher that is monitored
dispatcher.Hooks.OperationPosted += new System.Windows.Threading.DispatcherHookEventHandler(Hooks_OperationPosted);
}
public PythonScriptRunner(string scriptDirectory, string exeLocation)
{
_scriptDirectory = scriptDirectory;
_fileToRun = @"\run_no_gui.py";
_programArguments = _scriptDirectory + @"\config.txt";
_exeLocation = exeLocation;
_isRunning = false;
_jsonDirectory = _scriptDirectory + @"\json\";
_jsonReader = PythonScriptRunnerFactory.Instance.CreateJsonReader();
// hopefully nobody creates this guy outside of the main thread
_threadDispatcherOnConstruction = System.Windows.Threading.Dispatcher.CurrentDispatcher;
// later I want to use c# processes instead of python proceses:
// branchList = run_cmd(pythonScriptDirectory+"\run_get_branches.py", "");
// for branchList:
// run_cmd(pythonScriptDirectory+"\run_no_gui.py", "branchName");
// for processList:
// if process.processHasFinished:
// send back data to parent (the view) that it needs to update that branch's visualisation
}