public Shell(IUnityContainer container, IEventAggregator evtAggregator)
 {
     InitializeComponent();
     container.RegisterInstance<Panel>("MainRegion", m_MainRegionPanel);
     container.RegisterInstance<Panel>("SecondRegion", m_SecondRegionPanel);
     evtAggregator.GetEvent<ProductSavedEvent>().Subscribe(OnProductSaved,ThreadOption.SubscriberAffinityThread);
 }

        public GeoRegionMaintenanceViewModel(IModuleController moduleController, IDataRepository repository, IEventAggregator eventAggregator)
        {
            _moduleController = moduleController;
            _repository = repository;
            _eventAggregator = eventAggregator;

            ShowView = _moduleController.ShowViewCommand;
            NavigationDetails = _moduleController.NavigationDetails;

            ChangeMetaPanel = new DelegateCommand<bool?>(ChangeMetaViewPanel);
            ChangeGeoPanel = new DelegateCommand<bool?>(ChangeGeoViewPanel);

            DeleteMetaRegionCommand = new DelegateCommand(DeleteMetaRegion);
            EditMetaRegionCommand = new DelegateCommand(EditMetaRegion);
            AddNewMetaRegionCommand = new DelegateCommand(AddNewMetaRegion);
            DeleteMetaRegionMappingCommand = new DelegateCommand(DeleteMetaRegionMapping);
            AddMetaRegionMappingCommand = new DelegateCommand(AddMetaRegionMapping);
            DeleteGeoRegionCommand = new DelegateCommand(DeleteGeoRegion);
            EditGeoRegionCommand = new DelegateCommand(EditGeoRegion);
            CreateNewGeoRegionCommand = new DelegateCommand(CreateNewGeoRegion);

            _metaRegions = new ObservableCollection<t033_meta_region>();
            _metaRegionMappings = new ObservableCollection<t031_geo_code>();
            _geoRegions = new ObservableCollection<GeoRegionViewModel>();

            _moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionRegion, MaintenanceViewNames.MetaRegionView);
            _moduleController.SwitchPanel(MaintenanceRegionNames.GeoRegionRegion, MaintenanceViewNames.GeoRegionView);
            _moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionMappingRegion, MaintenanceViewNames.MetaRegionMappingView);

            _eventAggregator.GetEvent<RefreshRegionsEvent>().Subscribe(InitializeData);
        }

  public EntityListPageViewModel(IEntityRepository entityRepository, INavigationService navService, IEventAggregator eventAggregator) {
      _entityRepository = entityRepository;
      _navService = navService;
      _eventAggregator = eventAggregator;
      NavCommand = new DelegateCommand<Entity>(OnNavCommand);
      EntityDetailNavCommand = new DelegateCommand(() => _navService.Navigate("EntityDetail", 0));
 }

 public EditCollectionTemplateViewModel(IServer server, IEventAggregator events,
                                        IDocumentTemplateProvider templateProvider)
 {
     this.server = server;
     this.events = events;
     this.templateProvider = templateProvider;
 }

 public DebugWindowViewModel(IEventAggregator eventAggregator) {
   _eventAggregator = eventAggregator;
   DebugStrings = new ObservableCollection<string>();
   _eventAggregator.GetEvent<SetDebugMessageEvent>().Subscribe(SetMessage);
   SendCloseMessageCommand = new DelegateCommand(SendCloseMessage);
   ExportListCommand = new DelegateCommand(ExportList);
 }

 public PivotRunTimeCalculatorViewModel(INavigationService navigationService, IEventAggregator eventAggregator, string title)
     : base(navigationService, eventAggregator, title)
 {
     _navigationService = navigationService;
     _eventAggregator = eventAggregator;
     initializePivotRunTimeCalculatorViewModel();
 }

 public ModuleInit(IRegionManager regionManager, IUnityContainer container, IEventAggregator eventAggregator, IModuleManager moduleManager)
 {
     this.regionManager = regionManager;
     this.container = container;
     this.eventAggregator = eventAggregator;
     this.moduleManager = moduleManager;
 }

 public SalesModule(IEventAggregator eventAggregator, INavigationService navigationService, IUnityContainer container, IRegionManager regionManager)
 {
     _container = container;
     _regionManager = regionManager;
     _navigationService = navigationService;
     _eventAggregator = eventAggregator;
 }

        public ViewModelBase(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService)
        {
            if (personService == null)
            {
                throw new ArgumentNullException("personService");
            }

            if (dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }

            if (aggregator == null)
            {
                throw new ArgumentNullException("aggregator");
            }

            if (dialogService == null)
            {
                throw new ArgumentNullException("dialogService");
            }

            this.personService = personService;
            this.dispatcher = dispatcher;
            this.aggregator = aggregator;
            this.dialogService = dialogService;

            isBusy = false;
        }

 public MenuRegionController(IUnityContainer container,
     [Dependency(ShellRegionNames.MenuRegion)] IRegion menuRegion)
 {
     _container = container;
     _eventAggregator = _container.Resolve<IEventAggregator>();
     _menuRegion = menuRegion;
 }

		public MainMenuViewModel()
		{
			Groups = new BindableCollection<MenuGroup>();

			if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
			{
				_running = IoC.Get<RunExperimentViewModel>();
				_runThresholdTest = IoC.Get<RunThresholdTestViewModel>();
				_permutations = IoC.Get<PermutationViewModel>();
				_nbsmConfig = IoC.Get<NBSmConfigViewModel>();

				_eventAggregator = IoC.Get<IEventAggregator>();
				_navService = IoC.Get<INavigationService>();
				_regionService = IoC.Get<IRegionService>();
				_subjectService = IoC.Get<ISubjectDataService>();
				_subjectFilterService = IoC.Get<ISubjectFilterService>();
				_computeService = IoC.Get<IComputeService>();

				var regionsVM = IoC.Get<RegionsViewModel>();

				Groups.Add(new MenuGroup { Title = "Source", Items = { regionsVM, IoC.Get<SubjectsViewModel>(), IoC.Get<GroupsViewModel>() } });
				Groups.Add(new MenuGroup { Title = "Config", Items = { _permutations, _nbsmConfig } });
				Groups.Add(new MenuGroup { Title = "Compute", Items = { _runThresholdTest, _running } });
				Groups.Add(new MenuGroup { Title = "Global", Items = { IoC.Get<GlobalStrengthViewModel>() } });
				Groups.Add(new MenuGroup { Title = "Component", Items = { IoC.Get<IntermodalViewModel>(), IoC.Get<IntraSummaryViewModel>()/*, new MenuItem { Title = "Associations" },*/ } });
				Groups.Add(new MenuGroup { Title = "Nodal", Items = { IoC.Get<NodalStrengthDataTypeViewModel>() } });
				Groups.Add(new MenuGroup { Title = "Edge", Items = { IoC.Get<EdgeSignificanceViewModel>() } });
			}
		}

 public UpdaterModuleBootstraper(IUpdater updater, RegionManager regionManager,IEventAggregator eventAggregator)
 {
     // use injected services from Nomad, instead of using IServiceLocator mechanism
     _updater = updater;
     _regionManager = regionManager;
     _eventAggregator = eventAggregator;
 }

        public WatchListViewModel(IWatchListService watchListService, IMarketFeedService marketFeedService, IRegionManager regionManager, IEventAggregator eventAggregator)
        {
            if (watchListService == null)
            {
                throw new ArgumentNullException("watchListService");
            }

            if (eventAggregator == null)
            {
                throw new ArgumentNullException("eventAggregator");
            }

            this.HeaderInfo = Resources.WatchListTitle;
            this.WatchListItems = new ObservableCollection<WatchItem>();

            this.marketFeedService = marketFeedService;
            this.regionManager = regionManager;

            this.watchList = watchListService.RetrieveWatchList();
            this.watchList.CollectionChanged += delegate { this.PopulateWatchItemsList(this.watchList); };
            this.PopulateWatchItemsList(this.watchList);

            this.eventAggregator = eventAggregator;
            this.eventAggregator.GetEvent<MarketPricesUpdatedEvent>().Subscribe(this.MarketPricesUpdated, ThreadOption.UIThread);

            this.removeWatchCommand = new DelegateCommand<string>(this.RemoveWatch);

            this.watchListItems.CollectionChanged += this.WatchListItems_CollectionChanged;
        }       

 public PasswordGeneratorViewModel(IPasswordGenerator passwordGenerator, IEventAggregator events)
 {
     this.events = events;
     this.passwordGenerator = passwordGenerator;
     this.DisplayName = "Generator";
     this.Length = 6;
 }

 public DownloadService(IProvideDownloadClient downloadClientProvider,
     IEventAggregator eventAggregator, Logger logger)
 {
     _downloadClientProvider = downloadClientProvider;
     _eventAggregator = eventAggregator;
     _logger = logger;
 }

 /// <summary>
 /// See 8.2.4 Tokenization
 /// </summary>
 /// <param name="source">The source code manager.</param>
 /// <param name="events">The event aggregator to use.</param>
 public HtmlTokenizer(TextSource source, IEventAggregator events)
     : base(source, events)
 {
     _state = HtmlParseMode.PCData;
     _acceptsCharacterData = false;
     _lastStartTag = String.Empty;
 }

 public GroupWidget()
 {
     this.InitializeComponent();
     _eventAggregator = App.Current.Container.Resolve<IEventAggregator>();
     this.Tapped += OnTapped;
     this.DataContextChanged += OnDataContextChanged;
 }

 public GettingStartedViewModel(IEventAggregator eventAggregator, INavigate navigator )
 {
     this.eventAggregator = eventAggregator;
     this.navigator = navigator;
     
     ReturnToLoginScreenCommand = new DelegateCommand<object>(ReturnToLoginScreen, CanReturnToLoginScreen);
 }

        public WCFClient(IEventAggregator eventBus) {
            _eventBus = eventBus;
            _pipeFactory = new ChannelFactory<IUpdaterWCF>(new NetNamedPipeBinding(), new EndpointAddress(
                "net.pipe://localhost/UpdaterWCF_Pipe"));

            _pipeProxy = _pipeFactory.CreateChannel();
        }

 public TrendLinePresentationModel(ITrendLineView view, IMarketHistoryService marketHistoryService, IEventAggregator eventAggregator)
 {
     this.View = view;
     this.View.Model = this;
     this._marketHistoryService = marketHistoryService;
     eventAggregator.GetEvent<TickerSymbolSelectedEvent>().Subscribe(this.TickerSymbolChanged);
 }