Example #1
0
        public void SendCommand(RxCommand cmd, byte channel = 0)
        {
            var data = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

            data[1] = (byte)cmd;
            data[2] = channel;

            device.WriteFeatureData(data);
            System.Threading.Thread.Sleep(200);
        }
Example #2
0
        public MainWindow()
        {
            escape         = RxCommand.Create(EscapeImpl);
            ViewDispatcher = new MainWindowViewDispatcher(this);

            Title = "Craft";
            WindowStartupLocation = WindowStartupLocation.CenterScreen;

            InitializeComponent();

            ViewDispatcher.RegisterLast <MainWindowState>(SetState);
            // trigger ^ with anything set up already
            ViewDispatcher.Dispatch(ViewDispatcher.LastState);
        }
Example #3
0
        public MainWindowViewDispatcher(IMainWindowDependencies viewDependencies) : base()
        {
            BlessedEmoji = ParseEmoji();

            // initialize starting state
            Dispatch(new MainWindowState(
                         save: RxCommand.Create(SaveImpl),
                         help: RxCommand.Create(viewDependencies.OpenHelp),
                         settings: RxCommand.Create(viewDependencies.OpenSettings),
                         suggestions: BlessedEmoji
                         ));

            RegisterLast <CommitMessageEditOperation>(UpdateCommitMessage);
            RegisterLast <SuggestionSelectedOperation>(UseSuggestion);
            Curfew.Curfew.Dispatcher.RegisterLast <LoadFileOperation>(Load);
        }
Example #4
0
        public ApiModel(MainWindowModel mainWindow, ApiCollectionModel parent, Api api) : base(mainWindow, parent, api)
        {
            Inputs  = new RxList <ApiInputModel>();
            Outputs = new RxList <ApiOutputModel>();
            Headers = new RxList <ApiHeaderModel>();

            SubscribeForInputs(this.ObservePropertyChange(x => x.Model.Url), () => Model.Url, ApiInputType.Url);
            SubscribeForInputs(this.ObservePropertyChange(x => x.Model.Body).Where(x => ContentTypes.IsText(ContentType)), () => Model.Body, ApiInputType.Body);
            SubscribeForInputs(this.ObservePropertyChange(x => x.Headers).SelectMany(x => x.ObserveElementProperty(y => y.Name)).Merge(this.ObservePropertyChange(x => x.Headers).SelectMany(x => x.ObserveElementProperty(y => y.Value))), () => string.Join("\n", Headers.Select(x => x.Name + "=" + x.Value)), ApiInputType.Header);

            Model = api;
            if (api.Inputs != null)
            {
                Inputs.AddRange(api.Inputs.Select(x => new ApiInputModel
                {
                    Id           = x.Id,
                    Name         = x.Name,
                    DefaultValue = x.DefaultValue,
                    InputType    = x.InputType
                }));
            }
            if (api.Outputs != null)
            {
                Outputs.AddRange(api.Outputs.Select(x => new ApiOutputModel
                {
                    Id         = x.Id,
                    Name       = x.Name,
                    Expression = x.Expression,
                    Type       = x.Type
                }));
            }
            if (api.Headers != null)
            {
                Headers.AddRange(api.Headers.Select(x => new ApiHeaderModel
                {
                    Id    = x.Id,
                    Name  = x.Name,
                    Value = x.Value
                }));
            }
            Send  = RxCommand.CreateAsync(OnSend);
            Reset = RxCommand.Create(OnReset);

            Inputs.SetUpSync(
                MainWindow.Repository,
                Model.Inputs,
                x => new ApiInput {
                Name = x.Name, DefaultValue = "", InputType = x.InputType
            });
            Outputs.SetUpSync(
                MainWindow.Repository,
                Model.Outputs,
                x => new ApiOutput {
                Name = x.Name, Expression = ""
            });
            Headers.SetUpSync(
                MainWindow.Repository,
                Model.Headers,
                _ => new ApiHeader {
                Name = "", Value = ""
            });
        }
Example #5
0
        public MainWindowModel(Func <SelectFileType, string, string, string> selectFile)
        {
            this.selectFile = selectFile;

            var canAddChild = this.ObserveProperty(x => x.SelectedItem).Select(x => x is ApiCollectionModel);

            AddApi                = RxFunction.CreateAsync(async() => await OnAddApi(null));
            AddApiCollection      = RxFunction.CreateAsync(async() => await OnAddApiCollection(null));
            AddChildApi           = RxFunction.CreateAsync(async() => await OnAddApi((ApiCollectionModel)SelectedItem), canAddChild);
            AddChildApiCollection = RxFunction.CreateAsync(async() => await OnAddApiCollection((ApiCollectionModel)SelectedItem), canAddChild);
            Export                = RxCommand.Create(OnExport);
            Import                = RxCommand.CreateAsync(OnImport);
            Title       = "Restless";
            Items       = new RxList <ApiItemModel>();
            Methods     = httpMethods.ToList();
            OutputTypes = outputTypes.ToList();

            SplitterPosition    = Settings.Default.MainWindowSplitterPosition;
            ApiSplitterPosition = Settings.Default.ApiPanelSplitterPosition;
            this.ObservePropertyChange(x => x.SplitterPosition).Throttle(TimeSpan.FromSeconds(1)).Subscribe(x =>
            {
                Settings.Default.MainWindowSplitterPosition = x;
                Settings.Default.Save();
            });
            this.ObservePropertyChange(x => x.ApiSplitterPosition).Throttle(TimeSpan.FromSeconds(1)).Subscribe(x =>
            {
                Settings.Default.ApiPanelSplitterPosition = x;
                Settings.Default.Save();
            });

            ApiItemModel selectedItem = null;

            this.ObservePropertyChange(x => x.SelectedItem).Subscribe(x =>
            {
                if (selectedItem != null)
                {
                    selectedItem.IsSelected = false;
                }
                selectedItem = x;
                if (selectedItem != null)
                {
                    selectedItem.IsSelected = true;
                }
            });

            Repository = new DbRepository(new RestlessDb());

            Task.Run(async() =>
            {
                await Repository.Initialize();
                await Repository.Load();
                foreach (var apiItem in Repository.Items)
                {
                    if (apiItem is Api)
                    {
                        Items.Add(new ApiModel(this, null, (Api)apiItem));
                    }
                    else
                    {
                        Items.Add(new ApiCollectionModel(this, null, (ApiCollection)apiItem));
                    }
                }
            });

            DeleteSelectedItem = RxCommand.CreateAsync(OnDeleteSelectedItem);
        }
Example #6
0
        public MetroMessage(string message, MessageBoxButton button, MessageBoxImage icon = MessageBoxImage.Information)
        {
            InitializeComponent();

            DataContext = this;

            OKVisibility     = new Observable <Visibility>(Visibility.Collapsed);
            CancelVisibility = new Observable <Visibility>(Visibility.Collapsed);
            YesVisibility    = new Observable <Visibility>(Visibility.Collapsed);
            NoVisibility     = new Observable <Visibility>(Visibility.Collapsed);

            QuestionVisibility    = new Observable <Visibility>(Visibility.Collapsed);
            InformationVisibility = new Observable <Visibility>(Visibility.Collapsed);
            ErrorVisibility       = new Observable <Visibility>(Visibility.Collapsed);
            WarningVisibility     = new Observable <Visibility>(Visibility.Collapsed);

            OKCommand     = new RxCommand();
            CancelCommand = new RxCommand();
            YesCommand    = new RxCommand();
            NoCommand     = new RxCommand();

            Result  = new Observable <MessageBoxResult>();
            Caption = new Observable <string>(MVVMConfiguration.Configuration.MessageBoxTitle);
            Message = new Observable <string>(message);

            OKCommand.Subscribe(x =>
            {
                Result.Value = MessageBoxResult.OK;
                DialogResult = true;
            });

            CancelCommand.Subscribe(x =>
            {
                Result.Value = MessageBoxResult.Cancel;
                DialogResult = true;
            });

            YesCommand.Subscribe(x =>
            {
                Result.Value = MessageBoxResult.Yes;
                DialogResult = true;
            });

            NoCommand.Subscribe(x =>
            {
                Result.Value = MessageBoxResult.No;
                DialogResult = true;
            });



            switch (button)
            {
            case MessageBoxButton.OK:
                OKVisibility.Value     = Visibility.Visible;
                CancelVisibility.Value = Visibility.Collapsed;
                YesVisibility.Value    = Visibility.Collapsed;
                NoVisibility.Value     = Visibility.Collapsed;
                break;

            case MessageBoxButton.OKCancel:
                OKVisibility.Value     = Visibility.Visible;
                CancelVisibility.Value = Visibility.Visible;
                YesVisibility.Value    = Visibility.Collapsed;
                NoVisibility.Value     = Visibility.Collapsed;
                break;

            case MessageBoxButton.YesNoCancel:
                OKVisibility.Value     = Visibility.Collapsed;
                CancelVisibility.Value = Visibility.Visible;
                YesVisibility.Value    = Visibility.Visible;
                NoVisibility.Value     = Visibility.Visible;
                break;

            case MessageBoxButton.YesNo:
                OKVisibility.Value     = Visibility.Collapsed;
                CancelVisibility.Value = Visibility.Collapsed;
                YesVisibility.Value    = Visibility.Visible;
                NoVisibility.Value     = Visibility.Visible;
                break;

            default:
                break;
            }

            switch (icon)
            {
            case MessageBoxImage.Error:
                QuestionVisibility.Value    = Visibility.Collapsed;
                InformationVisibility.Value = Visibility.Collapsed;
                ErrorVisibility.Value       = Visibility.Visible;
                WarningVisibility.Value     = Visibility.Collapsed;
                break;

            case MessageBoxImage.Question:
                QuestionVisibility.Value    = Visibility.Visible;
                InformationVisibility.Value = Visibility.Collapsed;
                ErrorVisibility.Value       = Visibility.Collapsed;
                WarningVisibility.Value     = Visibility.Collapsed;
                break;

            case MessageBoxImage.Warning:
                QuestionVisibility.Value    = Visibility.Collapsed;
                InformationVisibility.Value = Visibility.Collapsed;
                ErrorVisibility.Value       = Visibility.Collapsed;
                WarningVisibility.Value     = Visibility.Visible;
                break;

            case MessageBoxImage.Information:
                QuestionVisibility.Value    = Visibility.Collapsed;
                InformationVisibility.Value = Visibility.Visible;
                ErrorVisibility.Value       = Visibility.Collapsed;
                WarningVisibility.Value     = Visibility.Collapsed;
                break;

            case MessageBoxImage.None:
            default:
                QuestionVisibility.Value    = Visibility.Collapsed;
                InformationVisibility.Value = Visibility.Collapsed;
                ErrorVisibility.Value       = Visibility.Collapsed;
                WarningVisibility.Value     = Visibility.Collapsed;
                break;
            }
        }