Pen CreateNewPen(UBrush b, UStroke s) { // Link to invalidation of brush, once. // the cache of the pen is stored in the stroke. VoidAction inval = delegate { }; inval = () => { s.Invalidate(); b.changed -= inval; }; b.changed += inval; // FIXME advanced features not used! Pen ret; ret = new Pen(CreateBrush(b)); ret.DashCap = Translate1(s.dashCap); ret.EndCap = Translate2(s.endCap); ret.StartCap = Translate2(s.startCap); ret.LineJoin = Translate(s.lineJoin); ret.DashStyle = Translate(s.dashStyle); ret.MiterLimit = s.mitreLimit; ret.DashOffset = s.offset; // FIXME maybe not right for compatibility with other renderes? ret.Alignment = PenAlignment.Center; if (s.dashStyle == StrokeType.custom) { ret.DashPattern = s.custom; } return(ret); }
public void MapKey(string key, VoidAction action) { Guard.ArgumentNotNullNorEmpty("key", key); Guard.ArgumentNotNull("action", action); MapKey(key, Command.FromAction(action)); }
/// <summary> /// Initializes a new instance of the <see cref="ProcessForm"/> class. /// </summary> /// <param name="stopDelegate">The stop delegate.</param> /// <param name="startDelegate">The start delegate.</param> /// <param name="startArguments">The start arguments.</param> public ProcessForm( VoidAction stopDelegate, VoidStringArgsAction startDelegate, string[] startArguments ) { //this.allo //this.serviceHost = serviceHost; this.stopDelegate = stopDelegate; this.startDelegate = startDelegate; this.startArguments = startArguments; InitializeComponent(); setupPropertyGrid.SelectedObject = AppDomain.CurrentDomain.SetupInformation; //SetProcessControlButtons(true); try { Console.SetOut(new TextControlTextWriter(this.logRichTextBox)); //Trace.Listeners.Add(new ConsoleTraceListener(false)); } catch (SecurityException ex) { ShowErrorMessage(MessagesResource.CannotLogToTestConsole + Environment.NewLine + ex.ToString()); } }
public void StartContinuingAction(string name, float time, VoidAction action) { progress = 0f; goal = time; actionName = name; StartCoroutine(StartContinuingAction_IE(action)); }
public override void WriteLine(string value) { VoidAction action = delegate { if (!string.IsNullOrEmpty(searchKey) && !value.Contains(searchKey)) { return; } if (tbox.Lines.Length > 200) { tbox.Clear(); } tbox.AppendText(value + "\r\n"); if (value.Contains("MessageBox|")) { MessageBox.Show(value.Replace("MessageBox|", "")); } }; try { tbox.BeginInvoke(action); } catch (Exception) { } }
public override void Write(string str) { CheckFull(); VoidAction action = () => _txtBox.AppendText(str); _txtBox.BeginInvoke(action); }
public override void Write(string fmt, params object[] args) { CheckFull(); VoidAction action = () => _txtBox.AppendText(string.Format(fmt, args)); _txtBox.BeginInvoke(action); }
public virtual void Run(VoidAction tickCallback) { m_tickCallback = tickCallback; while (!IsDone) m_tickCallback(); }
public override void Write(char value) { CheckFull(); VoidAction action = () => _txtBox.AppendText(value.ToString()); _txtBox.BeginInvoke(action); }
private void TestTree( string label, IRangeList tree, IEnumerable <Op> sequence, VoidAction action) { try { BuildTree(tree, sequence); } catch (Exception exception) { Console.WriteLine("{0} [setup]: Unexpected exception occurred: {1}", label, exception); throw new UnitTestFailureException(label, exception); } try { action(); } catch (Exception exception) { Console.WriteLine("{0} [action]: Unexpected exception occurred: {1}", label, exception); throw new UnitTestFailureException(label, exception); } ValidateRanges(((INonInvasiveRange2MapInspection)tree).GetRanges()); }
/// <summary> /// Initializes a new instance of the <see cref="ProcessForm"/> class. /// </summary> /// <param name="stopDelegate">The StopInternal delegate.</param> /// <param name="startDelegate">The StartInternal delegate.</param> /// <param name="startArguments">The StartInternal arguments.</param> public ProcessForm( VoidAction stopDelegate, VoidStringArgsAction startDelegate, string[] startArguments ) { //this.allo //this.serviceHost = serviceHost; this.stopDelegate = stopDelegate; this.startDelegate = startDelegate; this.startArguments = startArguments; InitializeComponent(); setupPropertyGrid.SelectedObject = AppDomain.CurrentDomain.SetupInformation; AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; //SetProcessControlButtons(true); try { logTextWriter = new TextControlTextWriter(outputListView, Settings.Default.DescriptionRegex); Console.SetOut(logTextWriter); //Trace.Listeners.Add(new ConsoleTraceListener(false)); } catch (SecurityException ex) { ShowErrorMessage(MessagesResource.CannotLogToTestConsole + Environment.NewLine + ex); } }
public override void Run(VoidAction tickCallback) { // 59.75 is sort of compensation long ticksPerFrame = (int)Math.Round(MyGameTimer.Frequency / 59.75f); long targetTicks = 0; MyLog.Default.WriteLine("Timer Frequency: " + MyGameTimer.Frequency); MyLog.Default.WriteLine("Ticks per frame: " + ticksPerFrame); ManualResetEventSlim waiter = new ManualResetEventSlim(false, 0); MyTimer.TimerEventHandler handler = new MyTimer.TimerEventHandler((a, b, c, d, e) => { waiter.Set(); }); base.Run(delegate { using (Stats.Generic.Measure("WaitForUpdate")) { var currentTicks = m_gameTimer.ElapsedTicks; // Wait for correct frame start targetTicks += ticksPerFrame; if (currentTicks > targetTicks + ticksPerFrame * 5) { // We're more behind than 5 frames, don't try to catch up targetTicks = currentTicks; } else { // For until correct tick comes if (MyFakes.ENABLE_UPDATE_WAIT) { var remaining = MyTimeSpan.FromTicks(targetTicks - currentTicks); int waitMs = (int)(remaining.Miliseconds - 0.1); // To handle up to 0.1ms inaccuracy of timer if (waitMs > 0) { waiter.Reset(); MyTimer.StartOneShot(waitMs, handler); waiter.Wait(17); // Never wait more than 17ms //Debug.Assert(MyPerformanceCounter.ElapsedTicks < targetTicks); //VRageRender.MyRenderStats.Write("WaitRemaining", (float)MyPerformanceCounter.TicksToMs(targetTicks - MyPerformanceCounter.ElapsedTicks), VRageRender.MyStatTypeEnum.MinMaxAvg, 300, 3); } } while (m_gameTimer.ElapsedTicks < targetTicks) { ; } } } //UpdateInternal(); tickCallback(); ProfilerShort.Commit(); }); }
public void VoidNoArgDelegate() { testVoidActionExecuted = false; VoidAction voidAction = MyAction; voidAction(); Assert.IsTrue(testVoidActionExecuted); }
private void InAssembly(VoidAction<ITypeOptions> create) { AssemblyBuilder.CreateNewDll(with => { with.Name(AssemblyName); create(with.Type); }); }
/// <summary> /// Runs the specified action in a thread. /// </summary> /// <param name="action">The action.</param> /// <param name="taskName">Name of the task.</param> public static void Run(VoidAction action, string taskName = "SharpDXTask") { #if W8CORE System.Threading.Tasks.Task.Factory.StartNew(() => action(), System.Threading.Tasks.TaskCreationOptions.LongRunning); #else var thread = new System.Threading.Thread(() => action()) { IsBackground = true, Name = taskName }; thread.Start(); #endif }
public override void WriteLine(string value) { VoidAction action = delegate { _listBox.Items.Insert(0, string.Format("[{0:HH:mm:ss}]{1}", DateTime.Now, value)); }; _listBox.BeginInvoke(action); }
public override bool Compile() { if (base.Compile()) { CompiledDelegate = Expression.Lambda <VoidAction>(ExpressionForThisRule).Compile(); } return(CompiledDelegate != null); }
public virtual void Run(VoidAction tickCallback) { m_tickCallback = tickCallback; while (!IsDone) { m_tickCallback(); } }
public override void WriteLine(string value) { VoidAction action = delegate { _textBox.AppendText(value); }; _textBox.BeginInvoke(action); }
private void DontCare(VoidAction action) { try { action(); } catch { } }
public override void Run(VoidAction tickCallback) { // 59.75 is sort of compensation long ticksPerFrame = (int)Math.Round(MyGameTimer.Frequency / 59.75f); long targetTicks = 0; MyLog.Default.WriteLine("Timer Frequency: " + MyGameTimer.Frequency); MyLog.Default.WriteLine("Ticks per frame: " + ticksPerFrame); ManualResetEventSlim waiter = new ManualResetEventSlim(false, 0); MyTimer.TimerEventHandler handler = new MyTimer.TimerEventHandler((a, b, c, d, e) => { waiter.Set(); }); base.Run(delegate { using (Stats.Generic.Measure("WaitForUpdate")) { var currentTicks = m_gameTimer.ElapsedTicks; // Wait for correct frame start targetTicks += ticksPerFrame; if (currentTicks > targetTicks + ticksPerFrame * 5) { // We're more behind than 5 frames, don't try to catch up targetTicks = currentTicks; } else { // For until correct tick comes if (MyFakes.ENABLE_UPDATE_WAIT) { var remaining = MyTimeSpan.FromTicks(targetTicks - currentTicks); int waitMs = (int)(remaining.Miliseconds - 0.1); // To handle up to 0.1ms inaccuracy of timer if (waitMs > 0) { waiter.Reset(); MyTimer.StartOneShot(waitMs, handler); waiter.Wait(17); // Never wait more than 17ms //Debug.Assert(MyPerformanceCounter.ElapsedTicks < targetTicks); //VRageRender.MyRenderStats.Write("WaitRemaining", (float)MyPerformanceCounter.TicksToMs(targetTicks - MyPerformanceCounter.ElapsedTicks), VRageRender.MyStatTypeEnum.MinMaxAvg, 300, 3); } } while (m_gameTimer.ElapsedTicks < targetTicks) ; } } //UpdateInternal(); tickCallback(); ProfilerShort.Commit(); }); }
public override void WriteLine(string value) { VoidAction action = delegate { List <string> temp = new List <string>(lstBox.Lines); temp.Insert(0, string.Format("[{0:HH:mm:ss}]{1}", DateTime.Now, value)); lstBox.Lines = temp.ToArray(); }; lstBox.BeginInvoke(action); }
public ClickableControl(VoidAction primary, VoidAction secondary = null) { Debug.Assert(primary != null, "At least one action must be given to a clickable control"); PrimaryAction = primary; if (secondary == null) SecondaryAction = () => { }; else SecondaryAction = secondary; }
public ConditionalStatement Else(VoidAction<List<IStatement>> code) { var blockStatements = new List<IStatement>(); code(blockStatements); var elseBranch = new BlockStatement(); elseBranch.Statements = blockStatements; ifStatement.FalseBranch = elseBranch; return ifStatement; }
public override void Run(object windowContext, VoidAction initCallback, VoidAction tickCallback) { // If window context is null under WinRT, then this is a non-XAML application IsBlockingRun = true; // Initialize the window Window.Initialize(windowContext); // Rendering to CoreWindow gameWindowWP8.RunDrawingSurfaceBackground(initCallback, tickCallback); }
public override void Write(string value) { VoidAction action = delegate { //lstBox.Items.Insert(0, string.Format("[{0:HH:mm:ss}]{1}", DateTime.Now, value)); lstBox.TopIndex = lstBox.Items.Count - 1; lstBox.Items.Add(value); }; lstBox.BeginInvoke(action); }
public static void Execute <TIgnoreException>(VoidAction operation) where TIgnoreException : Exception { try { operation(); } catch (TIgnoreException) { } }
private void DontCare( VoidAction action ) { try { action(); } catch { } }
public override void WriteLine(string value) { VoidAction action = delegate { if (logBox.Text.Count() > 10000) { this.logBox.Text = ""; } logBox.Text += (string.Format("[{0:yyyy-MM-dd HH:mm:ss.fff}]{1}", DateTime.Now, value) + "\r\n"); }; logBox.BeginInvoke(action); }
public override void Run(VoidAction tickCallback) { base.Run(delegate { using (StatGroup.Measure(StatName)) { m_waiter.Wait(); } //UpdateInternal(); tickCallback(); }); }
public override void Write(char value) { //base.Write(value);//still output to Console VoidAction action = delegate { txtBox.AppendText(value.ToString()); //if(txtBox.Visibility == Visibility.Visible) //{ // txtBox.ScrollToEnd(); //} }; txtBox.Dispatcher.BeginInvoke(action); }
public override void Run(VoidAction tickCallback) { long targetTicks = 0; ManualResetEventSlim waiter = new ManualResetEventSlim(false, 0); MyTimer.TimerEventHandler handler = new MyTimer.TimerEventHandler((a, b, c, d, e) => { waiter.Set(); }); base.Run(delegate { using (StatGroup.Measure(StatName)) { var currentTicks = m_gameTimer.ElapsedTicks; // Wait for correct frame start targetTicks += TickPerFrame; if (currentTicks > targetTicks + TickPerFrame * 5) { // We're more behind than 5 frames, don't try to catch up targetTicks = currentTicks; } else { // For until correct tick comes if (EnableUpdateWait) { var remaining = MyTimeSpan.FromTicks(targetTicks - currentTicks); int waitMs = (int)(remaining.Miliseconds - 0.1); // To handle up to 0.1ms inaccuracy of timer if (waitMs > 0) { waiter.Reset(); MyTimer.StartOneShot(waitMs, handler); waiter.Wait(17); // Never wait more than 17ms //Debug.Assert(MyPerformanceCounter.ElapsedTicks < targetTicks); //VRageRender.MyRenderStats.Write("WaitRemaining", (float)MyPerformanceCounter.TicksToMs(targetTicks - MyPerformanceCounter.ElapsedTicks), VRageRender.MyStatTypeEnum.MinMaxAvg, 300, 3); } } while (m_gameTimer.ElapsedTicks < targetTicks) { ; } } } //UpdateInternal(); tickCallback(); }); }
public IEnumerator StartContinuingAction_IE(VoidAction action) { while (progress < goal) { Debug.Log("Increase Progress"); ActionInProgress = true; yield return(new WaitForSeconds(0.03f)); progress += 0.03f; } ActionInProgress = false; action(); Debug.Log("coroutine ends"); }
public IExpression WithBody(VoidAction<ICodeBuilder> code) { method.Type = delegateType; method.CallingConvention = CallingConvention.HasThis; method.ReturnType = returnTypeReference; var codeBuilder = new CodeBuilder(host, method.Parameters); code(codeBuilder); var body = new BlockStatement(); foreach (var statement in codeBuilder.Statements) body.Statements.Add(statement); method.Body = body; return method; }
public override void Write(string value) { VoidAction action = delegate { tbox.AppendText(value); }; try { tbox.BeginInvoke(action); } catch (Exception) { } }
IEnumerator MovePanel(Vector2 endPos, VoidAction action) { Vector3 direction = ((Vector3)endPos - panel.transform.position).normalized; while (Vector2.Distance(panel.transform.position, endPos) > speed * Time.deltaTime) { panel.transform.position += direction * speed * Time.deltaTime; yield return(null); } if (action != null) { action(); } }
/// <summary> /// Subscribe the specified key with the given method. /// </summary> /// <param name="key">Key to subscribe to</param> /// <param name="d">The void action to run when published</param> public static void Subscribe(string key, VoidAction d) { //If the subscription already contains the key, //add this delegate to the existing delegate under the given key if (voidSubscriptions.ContainsKey(key)) { //Add delegate to existing delegate voidSubscriptions[key] += d; } else { //Create a new entry in the subscription dictonary voidSubscriptions.Add(key, d); } }
/// <summary> /// Subscribe the specified key with the given method. /// </summary> /// <param name="key">Key to subscribe to</param> /// <param name="d">The void action to run when published</param> public static void Subscribe(string key, VoidAction d) { //If the subscription already contains the key, //add this delegate to the existing delegate under the given key if(voidSubscriptions.ContainsKey(key)) { //Add delegate to existing delegate voidSubscriptions[key] += d; } else { //Create a new entry in the subscription dictonary voidSubscriptions.Add(key, d); } }
static void *WithExceptionsCatched(VoidAction action) { try { action(); return(ToPointer(new InvokationResult())); } catch (TargetInvocationException e) { return(ToPointer(new InvokationResult(e.InnerException, true))); } catch (Exception e) { return(ToPointer(new InvokationResult(e, true))); } }
public override void Run(VoidAction tickCallback) { long targetTicks = 0; ManualResetEventSlim waiter = new ManualResetEventSlim(false, 0); MyTimer.TimerEventHandler handler = new MyTimer.TimerEventHandler((a, b, c, d, e) => { waiter.Set(); }); base.Run(delegate { using (StatGroup.Measure(StatName)) { var currentTicks = m_gameTimer.ElapsedTicks; // Wait for correct frame start targetTicks += TickPerFrame; if (currentTicks > targetTicks + TickPerFrame * 5) { // We're more behind than 5 frames, don't try to catch up targetTicks = currentTicks; } else { // For until correct tick comes if (EnableUpdateWait) { var remaining = MyTimeSpan.FromTicks(targetTicks - currentTicks); int waitMs = (int)(remaining.Miliseconds - 0.1); // To handle up to 0.1ms inaccuracy of timer if (waitMs > 0) { waiter.Reset(); MyTimer.StartOneShot(waitMs, handler); waiter.Wait(17); // Never wait more than 17ms //Debug.Assert(MyPerformanceCounter.ElapsedTicks < targetTicks); //VRageRender.MyRenderStats.Write("WaitRemaining", (float)MyPerformanceCounter.TicksToMs(targetTicks - MyPerformanceCounter.ElapsedTicks), VRageRender.MyStatTypeEnum.MinMaxAvg, 300, 3); } } while (m_gameTimer.ElapsedTicks < targetTicks) ; } } //UpdateInternal(); tickCallback(); }); }
public Notification(string message, DrawingRectangleF screenArea, NotificationType type = NotificationType.Message) : base() { System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(message), "Notification message should not be null or empty."); this.IsVisible = true; this.IsActive = true; this.IsRounded = false; this.LayoutOption = LayoutType.Vertical; this.ResizeOption = ResizeOptions.WrapChildren; this.HorizontalAlignment = Controls.HorizontalAlignment.Center; this.VerticalAlignment = Controls.VerticalAlignment.Center; this.DrawBackground = true; this.DrawBorder = true; _buttonAction = () => { this.Close(); }; Position = screenArea.Position; Size = screenArea.Size; var label = new Label() { Text = message, VerticalAlignment = VerticalAlignment.Top, HorizontalAlignment = HorizontalAlignment.Center }; label.Size = Size; AddControl(label); switch (type) { case NotificationType.Message: var button = new Button(_buttonAction) { Text = "Ok", Size = new Vector2(this.Width / 4f, DEFAULT_BUTTON_HEIGHT), VerticalAlignment = VerticalAlignment.Top, HorizontalAlignment = HorizontalAlignment.Center }; AddControl(button); break; case NotificationType.Temporary: this.Expires = true; this.Duration = Notification.TemporaryNotificationDuration; break; } }
public ListTextWriter(ListBox box, long lastCount = 3000) { _listBox = box; System.Threading.Tasks.Task.Run(() => { while (true) { if (_listBox.Items.Count >= lastCount) { VoidAction action = delegate { _listBox.Items.Clear(); }; _listBox.BeginInvoke(action); } System.Threading.Thread.Sleep(3000); } }); }
public static void startJob(string key, VoidAction d, float time) { lock (dic) { if (dic.ContainsKey(key)) { dic.Remove(key); } else if (dic2.ContainsKey(key)) { dic2[key].cancel = true; dic2.Remove(key); } JobAction jobAction = new JobAction(); jobAction.key = key; jobAction.d = d; jobAction.time = time; jobAction.cancel = false; dic.Add(key, jobAction); } }
public override void Run(object windowContext, VoidAction initCallback, VoidAction tickCallback) { // Initialize the window Window.Initialize(windowContext); // Register on Activated Window.Activated += OnActivated; Window.Deactivated += OnDeactivated; // Initialize the init callback initCallback(); // Run the rendering loop try { RenderLoop.Run((Control)Window.NativeWindow, new RenderLoop.RenderCallback(tickCallback)); } finally { OnExiting(this, EventArgs.Empty); } }
public override void Run(object windowContext, VoidAction initCallback, VoidAction tickCallback) { // If window context is null under WinRT, then this is a non-XAML application IsBlockingRun = windowContext == null; // Initialize the window Window.Initialize(windowContext); this.tickCallback = tickCallback; if (windowContext == null) { // Rendering to CoreWindow gameWindowWinRT.RunCoreWindow(initCallback, tickCallback); } else { // Rendering to SwapChainBackgroundPanel initCallback(); CompositionTarget.Rendering += CompositionTarget_Rendering; } }
public Command(VoidAction action) { Guard.ArgumentNotNull("action", action); _action = action; }
public static ICommand FromAction(VoidAction action) { Guard.ArgumentNotNull("action", action); return new Command(action); }
public IModule CreateNewDll(VoidAction<IAssemblyConstructionOptions> with) { with(this); return CreateNewDll(model.Name); }
public abstract void Run(object windowContext, VoidAction initCallback, VoidAction tickCallback);
public override void Run(object windowContext, VoidAction initCallback, VoidAction tickCallback) { // Initialize the window Window.Initialize(windowContext); // Initialize the init callback initCallback(); // Run the rendering loop RenderLoop.Run((Control)Window.NativeWindow, new RenderLoop.RenderCallback(tickCallback)); }
public void UnwrapsTargetInvocationException() { if (SystemUtils.MonoRuntime) { #if DEBUG // TODO (EE): find solution for Mono return; #endif } MethodInfo mi = new VoidAction(ThrowDummyException).Method; try { try { mi.Invoke(null, null); Assert.Fail(); } catch (TargetInvocationException tie) { // Console.WriteLine(tie); throw ReflectionUtils.UnwrapTargetInvocationException(tie); } Assert.Fail(); } catch (DummyException e) { // Console.WriteLine(e); string[] stackFrames = e.StackTrace.Split('\n'); #if !MONO // TODO: mono includes the invoke() call in inner stackframe does not include the outer stackframes - either remove or document it string firstFrameMethodName = mi.DeclaringType.FullName + "." + mi.Name; AssertStringContains(firstFrameMethodName, stackFrames[0]); string lastFrameMethodName = MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + MethodBase.GetCurrentMethod().Name; AssertStringContains(lastFrameMethodName, stackFrames[stackFrames.Length - 1]); #endif } }
/// <summary> /// Subscribe to an event in the pub sub dictionaries. This will attach /// to the dictionary containing only VoidActions, which do not return values /// on execution. /// </summary> /// <param name="key">Name of Value in Dictionary</param> /// <param name="sub">Subscription of methods to Key</param> public void Subscribe(string key, VoidAction sub) { EventDispatcher.Subscribe(key, sub); }
public void RunCoreWindow(VoidAction initCallback, VoidAction tickCallback) { this.initCallback = initCallback; this.tickCallback = tickCallback; CoreApplication.Run(this); }
public override IAsyncResult BeginStop(object state, AsyncCallback callback) { // Very raw for a moment, just proof of concept (SD) VoidAction joinDelegate = new VoidAction(Stop); return joinDelegate.BeginInvoke ( new AsyncCallback ( callback ), new Descriptor(Name, Description) ); }
public Button(VoidAction leftClick, VoidAction rightClick = null) : base(leftClick, rightClick) { }
public void MapNoKey(VoidAction action) { Guard.ArgumentNotNull("action", action); MapKey(NoKey, action); }
public void RunDrawingSurfaceBackground(VoidAction initCallback, VoidAction tickCallback) { this.initCallback = initCallback; this.tickCallback = tickCallback; // Set the background to this drawingSurfaceBackgroundGrid.SetBackgroundContentProvider(this); }