Example #1
0
        protected override void InstantiationFinished()
        {
            base.InstantiationFinished();
            Users = CreateObservableCollection(m_users);

            AddNewUserCommand  = new RelayCommand(AddNewUser);
        }
Example #2
0
 public AlphaDocument()
 {
     DataContext = this;
     BackCommand = new RelayCommand(ExecuteBack, _o => true);
     ForwardCommand = new RelayCommand(ExecuteForward, _o => true);
     CloseCommand = new RelayCommand(ExecuteClose, _o => true);
 }
Example #3
0
        protected override void InstantiationFinished()
        {
            base.InstantiationFinished();
            Users = CreateObservableCollection(m_users);

            AddNewUserCommand = new RelayCommand(AddNewUser);
            DeleteUserCommand = new RelayCommand(DeleteUser, _o => SelectedItem!=null);
            OpenCommand = new RelayCommand(ExecuteOpen);
        }
Example #4
0
		public MainVM()
		{
			SaveCommand = new RelayCommand(_o => Manager.Instance.Save(), CanExecuteSave);
			ShrinkCommand = new RelayCommand(_o => Manager.Instance.Shrink());
			Tabs = new ObservableCollection<AbstractViewModel>
				       {
					       new TilesTabVM(),
						   new TerrainsTabVM(),
				       };
		}
        public AlphaSpecificDocumentVM(IAlphaDocumentDescriptor _descriptor, Guid _uid)
        {
            m_uid = _uid;
            Descriptor = _descriptor;

            InputGestureText = Utils.InputGestureText(_descriptor.ModifierKeys, _descriptor.Key);
            OpenCommand = new RelayCommand(OpenExecute);
            OpenInNewTabCommand = new RelayCommand(OpenInNewTabExecute);
            AddToFavoritsCommand = new RelayCommand(AddToFavoritsExecute);
        }
Example #6
0
		public TextureVM(XTileInfoVM _xTileInfoVM)
		{
			m_xTileInfoVM = _xTileInfoVM;
			Texture = _xTileInfoVM.Texture;
			CursorX = _xTileInfoVM.X;
			CursorY = _xTileInfoVM.Y;
			Sets = new ObservableCollection<ETextureSet>(Enum.GetValues(typeof(ETextureSet)).Cast<ETextureSet>().OrderBy(_set => _set.ToString()));
			TextureClick = new RelayCommand(ExecuteTextureClick);
			SetCommand = new RelayCommand(ExecuteSetCommand, CanSetCommand);
			AddCommand = new RelayCommand(ExecuteAddCommand, CanAddCommand);
			Subscribe(m_xTileInfoVM, info => info.PlusHalfX, _changed => OnPropertyChanged(() => ScreenCursorX));
			Subscribe(m_xTileInfoVM, info => info.PlusHalfY, _changed => OnPropertyChanged(() => ScreenCursorY));
		}
        public AlphaRootTool(IAlphaRootToolDescriptor _descriptor)
        {
            InitializeComponent();

            Name = _descriptor.RootToolIdentifier;
            var element = _descriptor.Generate(out m_vm);
            m_body.DataContext = m_vm;
            m_body.Content = element;
            Title = _descriptor.Name;
            Descriptor = _descriptor;
            DataContext = this;
            RevertCommand = new RelayCommand(ExecuteRevert, _o => AlphaClient.Instance.GetIsRevertEnabled(m_vm.Uid));
            UndoCommand = new RelayCommand(ExecuteUndo, _o => AlphaClient.Instance.GetIsUndoEnabled(m_vm.Uid));
            RedoCommand = new RelayCommand(ExecuteRedo, _o => AlphaClient.Instance.GetIsRedoEnabled(m_vm.Uid));
            SaveCommand = new RelayCommand(ExecuteSave, _o => m_vm.IsDirty);
            CloseCommand = new RelayCommand(_o => Close());

            UiManager.UIMessage += UiManagerOnUiMessage;
        }
Example #8
0
        public MainWindow()
        {
            m_moduleRegistrator = new ModuleRegistrator();
            m_moduleRegistrator.LoadAssembliesNamesContains("ClientModule");
            m_moduleRegistrator.RegisterModules();

            Documents = new ObservableCollection<AlphaPage>();

            Tools = new ObservableCollection<AlphaToolDescriptorVM>();

            foreach (var alphaToolDescriptor in UiManager.ToolDescriptors)
            {
                var item = new AlphaToolDescriptorVM(alphaToolDescriptor);
                InputBindings.Add(new InputBinding(item.OpenCommand, new KeyGesture(item.Descriptor.Key, item.Descriptor.ModifierKeys)));
                Tools.Add(item);
            }

            RootTools = new ObservableCollection<AlphaRootToolDescriptorVM>();
            foreach (var alphaToolDescriptor in UiManager.GetRootToolDescriptors())
            {
                var item = new AlphaRootToolDescriptorVM(alphaToolDescriptor);
                InputBindings.Add(new InputBinding(item.OpenCommand, new KeyGesture(item.Descriptor.Key, item.Descriptor.ModifierKeys)));
                RootTools.Add(item);
            }

            UiManager.ShowToolWindow += UiManagerOnShowToolWindow;
            UiManager.ShowRootToolWindow += UiManagerOnShowRootToolWindow;
            UiManager.DocumentEvent += UiManagerOnDocumentEvent;

            NewPageCommand = new RelayCommand(NewPageExecute, NewPageCanExecute);

            InitializeComponent();
            DataContext = this;
            m_manager.Loaded += ManagerOnLoaded;
            m_manager.ActiveContentChanged += MManagerOnActiveContentChanged;
            m_manager.DeserializationCallback = DeserializationCallback;
            Closing += MainWindowClosing;
        }
Example #9
0
        public AlphaPage()
        {
            BlankDescriptor = new AlphaDocumentDescriptor<BlankVM>("New page", EAlphaKind.NONE, EAlphaDocumentKind.BLANK, ModifierKeys.None, Key.None, _blank => null);
            InitializeComponent();

            IsCloseable = true;
            Background = Brushes.White;

            SeeAlso = new ObservableCollection<AlphaSpecificDocumentVM>();

            DataContext = this;
            BackCommand = new RelayCommand(ExecuteBack, _o => m_history.Count > 1 && m_current > 0);
            ForwardCommand = new RelayCommand(ExecuteForward, _o => m_current < (m_history.Count - 1));
            CloseCommand = new RelayCommand(_o => Close());

            RevertCommand = new RelayCommand(ExecuteRevert, _o => IsNotBlank() && AlphaClient.Instance.GetIsRevertEnabled(ViewModel.Uid));
            UndoCommand = new RelayCommand(ExecuteUndo, _o => IsNotBlank() && AlphaClient.Instance.GetIsUndoEnabled(ViewModel.Uid));
            RedoCommand = new RelayCommand(ExecuteRedo, _o => IsNotBlank() && AlphaClient.Instance.GetIsRedoEnabled(ViewModel.Uid));

            SaveCommand = new RelayCommand(ExecuteSave, _o => IsNotBlank() && ViewModel.IsDirty);

            UiManager.UIMessage += UiManagerOnUiMessage;
        }
Example #10
0
        protected override void InstantiationFinished()
        {
            base.InstantiationFinished();
            var gnrl = AlphaClient.Instance.GetRoot<GeneralVM>();

            Instruments = gnrl.DerivativeVMs;
            Slots = CreateObservableCollection(m_slots);

            CollectionViewSource.GetDefaultView(Instruments).Filter = InstrumentsFilter;
            CollectionViewSource.GetDefaultView(Slots).Filter = SlotsFilter;

            CollectionViewSource.GetDefaultView(Slots).CollectionChanged += SlotsCollectionChanged;

            AddCommand = new RelayCommand(ExecuteAdd, _o => Instruments.Any(_vm => _vm.Selected && InstrumentsFilter(_vm)));
            RemoveCommand = new RelayCommand(ExecuteRemove, _o => Slots.Any(_vm => _vm.Selected && SlotsFilter(_vm)));
        }
Example #11
0
 protected SetTabVM()
 {
     AddCommand = new RelayCommand(ExecuteAdd, CanExecuteAdd);
 }
Example #12
0
 public ModuleBrowserVM()
 {
     UiManager.UIMessage += UiMangerUIMessage;
     OpenCommand = new RelayCommand(ExecuteOpen);
 }
Example #13
0
 public PortfolioLinkVM()
 {
     OpenCommand = new RelayCommand(OpenExecute, _o => true);
 }
Example #14
0
 public XColorVM()
 {
     SelectColorCommand = new RelayCommand(ExecuteSelectColorCommand);
 }
Example #15
0
 protected override void InstantiationFinished()
 {
     base.InstantiationFinished();
     SpecificDocumentVMs = DocumentDescriptors.Select(_descriptor => new AlphaSpecificDocumentVM(_descriptor, Uid)).ToArray();
     OpenCommand = new RelayCommand(OpenExecute, _o => true);
 }
 public AlphaRootToolDescriptorVM(IAlphaRootToolDescriptor _descriptor)
 {
     Descriptor = _descriptor;
     InputGestureText = Utils.InputGestureText(_descriptor.ModifierKeys, _descriptor.Key);
     OpenCommand = new RelayCommand(ExecuteOpen);
 }