Example #1
0
        /// <summary>
        /// Performs an action and send back a Disposable which will perform another action once it is disposed. Typically used to make temporary changes through
        /// the "using" pattern.
        /// </summary>
        /// <param name="push">The action to perform right now</param>
        /// <param name="pop">The action to perform once the returned object will be disposed</param>
        /// <returns>An object implementing IDisposable</returns>
        /// <exception cref="System.ArgumentNullException">push</exception>
        public static IDisposable Begin(Action push, Action pop)
        {
            push.ThrowIfNull(nameof(push));

            push();
            return new DisposableWithCallback(pop);
        }
        public MessageInputHandler(WorldInstance worldInstance, MessageRendererState messageRendererState, TimeSpan totalTime, Action<IXnaGameTime> messageClosingDelegate)
        {
            worldInstance.ThrowIfNull("worldInstance");
            messageRendererState.ThrowIfNull("messageRendererState");
            messageClosingDelegate.ThrowIfNull("messageClosingDelegate");

            _worldInstance = worldInstance;
            _messageRendererState = messageRendererState;
            _messageClosingDelegate = messageClosingDelegate;
            _answerKeyboardStateHelper = new KeyboardStateHelper(
                KeyDown,
                null,
                null,
                TextAdventure.Xna.Constants.MessageRenderer.Input.AcceptKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.NextAnswerKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PreviousAnswerKey);
            _scrollKeyboardStateHelper = new KeyboardStateHelper(
                _scrollKeyboardRepeatHelper,
                TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollUpKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollDownKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.HomeKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.EndKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PageUpKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PageDownKey);
            _scrollKeyboardRepeatHelper.InitialInterval = TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollKeyboardInterval;
            _scrollKeyboardRepeatHelper.RepeatingInterval = TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollKeyboardInterval;
        }
Example #3
0
        /// <summary>
        /// Invokes asynchronously the specified action for this control.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="action">The action.</param>
        public static void BeginInvoke(Control control, Action action)
        {
            control.ThrowIfNull("control");
            action.ThrowIfNull("action");
            if (!control.Created || control.IsDisposed || !control.IsHandleCreated) return;

            control.BeginInvoke(action);
        }
        public CssCommentaryInterpreter(Action<Int32, Int32> onOpen, Action<String, Int32, Int32> onClose)
        {
            onOpen.ThrowIfNull("onOpen");
            onClose.ThrowIfNull("onClose");

            this.onOpen = onOpen;
            this.onClose = onClose;
        }
        public ReactiveCommand(
			Action<object> execute,
			Func<object, bool> canExecute,
			params INotifyPropertyChanged[] canExecuteNotifiers)
        {
            _execute = execute.ThrowIfNull();
            _canExecute = canExecute.ThrowIfNull();
            _canExecuteNotifiers = canExecuteNotifiers;

            _canExecuteNotifiers.ForEach(x => x.SubscribeWeakly(this, (c, s, e) => c.NotifyCanExecuteChanged()));
        }
 public WeakAction(Action action)
 {
     action.ThrowIfNull("action");
     _method = action.GetMethodInfo();
     if (action.GetMethodInfo().IsStatic)
     {
         _staticAction = action;
     }
     if (action.Target != null)
     {
         _actionTargetReference = new WeakReference(action.Target);
     }
 }
        public MessageFadeOutAndScaleUpdater(MessageRendererState messageRendererState, TimeSpan totalTime, Action completeDelegate)
        {
            messageRendererState.ThrowIfNull("messageRendererState");
            completeDelegate.ThrowIfNull("completeDelegate");
            if (totalTime < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("totalTime");
            }

            _messageRendererState = messageRendererState;
            _completeDelegate = completeDelegate;
            _timedLerpHelper = new TimedLerpHelper(totalTime, TextAdventure.Xna.Constants.MessageRenderer.FadeOutDuration, 1f, 0f);
        }
Example #8
0
        public TimerHelper(TimeSpan startTotalTime, TimeSpan duration, Action completedDelegate)
        {
            completedDelegate.ThrowIfNull("completedDelegate");
            if (startTotalTime < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("startTotalTime");
            }
            if (duration < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("duration");
            }

            _duration = duration;
            _startTotalTime = startTotalTime;
            _completedDelegate = completedDelegate;
        }
Example #9
0
        /// <summary>
        /// Invokes the specified action for this control.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="action">The action.</param>
        public static void Invoke(Control control, Action action)
        {
            control.ThrowIfNull("control");
            action.ThrowIfNull("action");
            if (!control.Created || control.IsDisposed || !control.IsHandleCreated) return;

            try
            {
                control.Invoke(action);
            }
            catch (ObjectDisposedException ex)
            {
                logger.LogError("Control {0} disposed while trying to process an Invoke on it".InvariantFormat(control.Name));
                logger.LogException(ex);
            }
            catch (InvalidOperationException ioe)
            {
                logger.LogError("Invalid operation exception triggered by {0} control while trying to invoke".InvariantFormat(control.Name));
                logger.LogException(ioe);
            }
        }
Example #10
0
 private void Transaction(Action<IDbConnection, IDbTransaction> action)
 {
     action.ThrowIfNull("action");
     using(var conn = this.GetConnection()) {
         using(var tx = conn.BeginTransaction()) {
             try {
                 action(conn, tx);
                 tx.Commit();
             } catch {
                 tx.Rollback();
                 throw;
             }
         }
     }
 }
Example #11
0
        /// <summary>
        /// Saves the blank character.
        /// </summary>
        /// <param name="callback">The callback.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">callback</exception>
        public static async Task SaveAsync(Action callback)
        {
            callback.ThrowIfNull(nameof(callback));

            SerializableCCPCharacter serial = CreateCharacter();

            using (SaveFileDialog fileDialog = new SaveFileDialog())
            {
                fileDialog.Title = @"Save Blank Character";
                fileDialog.Filter = @"Blank Character CCPXML (*.xml) | *.xml";
                fileDialog.FileName = $"{serial.Name}.xml";
                fileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);

                DialogResult result = fileDialog.ShowDialog();
                if (result != DialogResult.OK)
                    return;

                XmlDocument xmlDoc = (XmlDocument)Util.SerializeToXmlDocument(serial);
                string content = Util.GetXmlStringRepresentation(xmlDoc);
                await FileHelper.OverwriteOrWarnTheUserAsync(fileDialog.FileName,
                    async fs =>
                    {
                        using (StreamWriter writer = new StreamWriter(fs, Encoding.UTF8))
                        {
                            await writer.WriteAsync(content);
                            await writer.FlushAsync();
                            await fs.FlushAsync();
                        }
                        return true;
                    });

                s_filename = fileDialog.FileName;
                callback.Invoke();
            }
        }
Example #12
0
 public RelayCommand(Action<object> execute, Predicate<object> canExecute)
 {
     this.execute = execute.ThrowIfNull();
     this.canExecute = canExecute;
 }
Example #13
0
 public RelayCommand(Action<object> execute, Predicate<object> canExecute)
 {
     execute.ThrowIfNull("execute");
     _execute = execute; _canExecute = canExecute;
 }
Example #14
0
        /// <summary>
        /// Adds the plans as toolstrip items to the list.
        /// </summary>
        /// <param name="plans">The plans.</param>
        /// <param name="list">The list.</param>
        /// <param name="initialize">The initialize.</param>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static void AddTo(this IEnumerable<Plan> plans, ToolStripItemCollection list,
                                 Action<ToolStripMenuItem, Plan> initialize)
        {
            plans.ThrowIfNull(nameof(plans));

            list.ThrowIfNull(nameof(list));

            initialize.ThrowIfNull(nameof(initialize));

            //Scroll through plans
            foreach (Plan plan in plans)
            {
                ToolStripMenuItem item;
                using (ToolStripMenuItem planItem = new ToolStripMenuItem(plan.Name))
                {
                    initialize(planItem, plan);
                    item = planItem;
                }
                list.Add(item);
            }
        }
 /// <summary>
 /// Creates a new DelegateAuthenticator.
 /// </summary>
 /// <param name="modifyRequest">Delegate used to modify the webrequest.</param>
 public DelegateAuthenticator(Action<HttpWebRequest> modifyRequest)
 {
     modifyRequest.ThrowIfNull("modifyRequest");
     ModifyRequestDelegate = modifyRequest;
 }
Example #16
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Disposable"/> class.
        /// </summary>
        /// <param name="action">The action.</param>
        public OnDisposeAction(Action action)
        {
            action.ThrowIfNull("action");

            Action = action;
        }
Example #17
0
 public Command(Action<object> action, Predicate<object> canExecute)
 {
     this.action = action.ThrowIfNull("Command : action null");
     this.canExecute = canExecute.ThrowIfNull("Command : canExecute null");
 }
Example #18
0
 public Command(Action<object> action, Predicate<object> canExecute = null)
 {
     this.action = action.ThrowIfNull("Command : action null");
     this.canExecute = canExecute;
     this.isEnabled = true;
 }