public OrdersViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IEventAggregator eventAggregator,
ITradingServiceAsync tradingService,
UserContext userContext,
ReferenceData referenceData)
{
logger.Log("PositionsViewModel.PositionsViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_eventAggregator = eventAggregator;
_tradingService = tradingService;
this.UserContext = userContext;
this.Orders = new ObservableCollection<Order>();
this.ReferenceData = referenceData;
this.UpdateOrdersCommand = new DelegateCommand<object>(this.UpdateOrdersExecute);
this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute);
this.CancelOrderCommand = new DelegateCommand<object>(this.CancelOrderExecute);
_tradingService.GetOrdersCompleted +=
new EventHandler<GetOrdersCompletedEventArgs>(GetOrdersCallback);
_tradingService.CancelOrderCompleted +=
new EventHandler<AsyncCompletedEventArgs>(CancelOrderCallback);
this.UserContext.PropertyChanged +=
new PropertyChangedEventHandler(OnUserContextPropertyChanged);
ResetFilter();
SubscribeToEvents();
}
public AccountsViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IRegionManager regionManager,
IEventAggregator eventAggregator,
ITradingServiceAsync tradingService,
UserContext userContext)
{
logger.Log("AccountsViewModel.AccountsViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_tradingService = tradingService;
this.UserContext = userContext;
_tradingService.OpenNewAccountCompleted += new EventHandler<OpenNewAccountCompletedEventArgs>(OpenNewAccountCallback);
_tradingService.ChangeAccountNameCompleted += new EventHandler<AsyncCompletedEventArgs>(ChangeAccountNameCallback);
CreateAccountCommand = new DelegateCommand<object>(this.CreateAccountExecute);
EditAccountCommand = new DelegateCommand<object>(this.EditAccountExecute);
UpdateAccountsCommand = new DelegateCommand<object>(this.UpdateAccountsExecute);
SelectAccountCommand = new DelegateCommand<object>(this.SelectAccountExecute);
SubscribeToEvents();
}
public TransferViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IRegionManager regionManager,
IEventAggregator eventAggregator,
ITradingServiceAsync tradingService,
Bullsfirst.InterfaceOut.Oms.MarketDataServiceReference.IMarketDataServiceAsync marketDataService,
UserContext userContext,
ReferenceData referenceData)
{
logger.Log("TransferViewModel.TransferViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_tradingService = tradingService;
_marketDataService = marketDataService;
this.UserContext = userContext;
this.ReferenceData = referenceData;
_tradingService.TransferCashCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
_tradingService.TransferSecuritiesCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
_tradingService.AddExternalAccountCompleted += new EventHandler<AddExternalAccountCompletedEventArgs>(AddExternalAccountCallback);
_marketDataService.GetMarketPriceCompleted +=
new EventHandler<InterfaceOut.Oms.MarketDataServiceReference.GetMarketPriceCompletedEventArgs>(GetMarketPriceCallback);
TransferCommand = new DelegateCommand<object>(this.TransferExecute, this.CanTransferExecute);
AddExternalAccountCommand = new DelegateCommand<object>(this.AddExternalAccountExecute);
this.PropertyChanged += this.OnPropertyChanged;
this.ValidateAll();
SubscribeToEvents();
}
public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflow interactiveWorkflow) {
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_interactiveWorkflow = interactiveWorkflow;
_shell = interactiveWorkflow.Shell;
_securityService = _shell.Services.Security;
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell);
_hostLoadIndicatorViewModel = new HostLoadIndicatorViewModel(_sessionProvider, interactiveWorkflow.Shell);
_disposableBag = DisposableBag.Create<ConnectionManager>()
.Add(_statusBarViewModel)
.Add(_hostLoadIndicatorViewModel)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged)
.Add(() => _interactiveWorkflow.ActiveWindowChanged -= ActiveWindowChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
_interactiveWorkflow.ActiveWindowChanged += ActiveWindowChanged;
// Get initial values
var connections = CreateConnectionList();
_connections = new ConcurrentDictionary<string, IConnection>(connections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
public TransactionHistoryViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IEventAggregator eventAggregator,
ITradingServiceAsync tradingService,
UserContext userContext)
{
logger.Log("TransactionHistoryViewModel.TransactionHistoryViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_eventAggregator = eventAggregator;
_tradingService = tradingService;
this.UserContext = userContext;
this.Transactions = new ObservableCollection<TransactionSummary>();
this.UpdateTransactionsCommand = new DelegateCommand<object>(this.UpdateTransactionsExecute);
this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute);
_tradingService.GetTransactionSummariesCompleted +=
new EventHandler<GetTransactionSummariesCompletedEventArgs>(GetTransactionSummariesCallback);
this.UserContext.PropertyChanged +=
new PropertyChangedEventHandler(OnUserContextPropertyChanged);
ResetFilter();
SubscribeToEvents();
}
public HostWindow(Window window, IStatusBar statusBar = null, System.Action<CloseResult> onClosed = null)
{
_statusBar = statusBar;
_window = window;
_onClosed = onClosed;
if (_statusBar == null)
_statusBar = window as IStatusBar;
}
public ReportServerProgress(
ITypedRequestProcessProxy typedRequestProcessProxy,
ISynchronizationContextProvider synchronizationContextProvider,
IStatusBar statusBar) {
_typedRequestProcessProxy = typedRequestProcessProxy;
_synchronizationContextProvider = synchronizationContextProvider;
_statusBar = statusBar;
}
/// <summary>
/// Link navigator used for navigating to links from within
/// an editing session
/// </summary>
/// <param name="editorControl">presentation editor context</param>
public EditorLinkNavigator(HtmlEditorControl editorControl, IMainFrameWindow editorFrame, IStatusBar statusBar, IMshtmlDocumentEvents events)
{
// save references
_htmlEditorContext = editorControl as IHtmlEditorComponentContext;
_htmlEditorControl = editorControl;
_editorFrame = editorFrame;
_statusBar = statusBar;
_documentEvents = events;
// sign up for editor events
_editorFrame.Deactivate += new EventHandler(_editorFrame_Deactivate);
_htmlEditorContext.PreHandleEvent += new HtmlEditDesignerEventHandler(presentationEditor_PreHandleEvent);
_htmlEditorContext.TranslateAccelerator += new HtmlEditDesignerEventHandler(presentationEditor_TranslateAccelerator);
_documentEvents.LostFocus += new EventHandler(_documentEvents_LostFocus);
}
/// <summary>
/// Link navigator used for navigating to links from within
/// an editing session
/// </summary>
/// <param name="editorControl">presentation editor context</param>
public EditorLinkNavigator(HtmlEditorControl editorControl, IMainFrameWindow editorFrame, IStatusBar statusBar, IMshtmlDocumentEvents events)
{
// save references
_htmlEditorContext = editorControl as IHtmlEditorComponentContext;
_htmlEditorControl = editorControl;
_editorFrame = editorFrame;
_statusBar = statusBar;
_documentEvents = events;
// sign up for editor events
_editorFrame.Deactivate += new EventHandler(_editorFrame_Deactivate);
_htmlEditorContext.PreHandleEvent += new HtmlEditDesignerEventHandler(presentationEditor_PreHandleEvent);
_htmlEditorContext.TranslateAccelerator += new HtmlEditDesignerEventHandler(presentationEditor_TranslateAccelerator);
_documentEvents.LostFocus += new EventHandler(_documentEvents_LostFocus);
}
public CoverageWidget(ILoggingService loggingService, IStatusBar statusBar)
{
this.statusBar = statusBar;
Build();
SetupCoverageLabels();
presenter = new CoveragePadPresenter(this, loggingService);
void SetupCoverageLabels()
{
var font = Pango.FontDescription.FromString("Courier 30");
lineCoverageLabel.ModifyFont(font);
branchCoverageLabel.ModifyFont(font);
}
}
public SqlEditorViewModel(IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
IDatabaseProvider databaseProvider,
ITaskRunner taskRunner,
ISolutionItemSqlGeneratorRegistry sqlGeneratorsRegistry,
INativeTextDocument sql,
MetaSolutionSQL item) : this(mySqlExecutor, statusBar, databaseProvider, taskRunner, sql)
{
IsLoading = true;
taskRunner.ScheduleTask("Generating SQL",
async() =>
{
string sql = await sqlGeneratorsRegistry.GenerateSql(item.ItemToGenerate);
Code.FromString(sql);
IsLoading = false;
});
}
public SolutionTasksService(ITaskRunner taskRunner,
ISolutionItemSqlGeneratorRegistry sqlGenerator,
ISolutionItemRemoteCommandGeneratorRegistry remoteCommandGenerator,
IMySqlExecutor sqlExecutor,
ISolutionItemNameRegistry solutionItemNameRegistry,
IRemoteConnectorService remoteConnectorService,
IDatabaseProvider databaseProvider,
IStatusBar statusBar)
{
this.taskRunner = taskRunner;
this.sqlGenerator = sqlGenerator;
this.remoteCommandGenerator = remoteCommandGenerator;
this.sqlExecutor = sqlExecutor;
this.solutionItemNameRegistry = solutionItemNameRegistry;
this.remoteConnectorService = remoteConnectorService;
this.databaseProvider = databaseProvider;
this.statusBar = statusBar;
}
private void SetProgress(bool play)
{
IStatusBar statusBar = ArcMap.Application.StatusBar as IStatusBar;
IAnimationProgressor animationProgressor = statusBar.ProgressAnimation;
if (play)
{
animationProgressor.Show();
animationProgressor.Play(0, -1, -1);
statusBar.set_Message(0, "Processing Related Tables");
}
else
{
animationProgressor.Stop();
animationProgressor.Hide();
statusBar.set_Message(0, null);
}
}
public TextEditorViewModel(ITextDocument document, ISourceFile file) : base(file)
{
_lastLineNumber = -1;
_visualFontSize = _fontSize = 14;
_zoomLevel = 1;
if (_studio != null)
{
ZoomLevel = _studio.GlobalZoomLevel;
}
_document = document;
_inputHelpers = new List <ITextEditorInputHelper>();
_inputHelpers.Add(new DefaultIndentationInputHelper());
this.WhenAnyValue(x => x.Line).Subscribe(lineNumber =>
{
if (lineNumber != _lastLineNumber && lineNumber > 0)
{
var line = Document.Lines[Line];
var text = Document.GetText(line);
if (string.IsNullOrWhiteSpace(text))
{
foreach (var helper in InputHelpers)
{
helper.CaretMovedToEmptyLine(this);
}
}
_lastLineNumber = lineNumber;
}
});
this.WhenAnyValue(x => x.Offset).ObserveOn(RxApp.MainThreadScheduler).Subscribe(x =>
{
_statusBar?.SetTextPosition(Offset, Line, Column);
});
_statusBar = IoC.Get <IStatusBar>();
}
public QuickCommands(Lazy <IQuickAccessService> service,
Lazy <IQuickAccessViewModel> viewModel,
IClipboardService clipboardService,
IStatusBar statusBar)
{
CopyCommand = new DelegateCommand <object>(o =>
{
var text = o.ToString() ?? "";
clipboardService.SetText(text);
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Copied " + text));
viewModel.Value.CloseSearch();
});
SetSearchCommand = new DelegateCommand <object>(o =>
{
viewModel.Value.OpenSearch(o.ToString());
});
NoCommand = new DelegateCommand(() => { });
}
// Try really hard to get the instance of the status bar from the application.
public static IStatusBar StatusBarInstance(int retryCount = MaximumRetries)
{
if (_StatusInstance != null)
{
return(_StatusInstance);
}
try
{
// Ran out of retries
if (retryCount == 0)
{
return(new NullStatusBar());
}
// Normal status bar access
try
{
_StatusInstance = new StatusBar();
return(_StatusInstance);
}
catch (COMException e)
{
// The excel RPC server is busy. We need to wait and then retry (RPC_E_SERVERCALL_RETRYLATER)
if (e.HResult == Shared.Excel.Exception.RPC_E_SERVERCALL_RETRYLATER || e.HResult == Shared.Excel.Exception.VBA_E_IGNORE)
{
Thread.Sleep(RetryWaitTimeMs);
_StatusInstance = StatusBarInstance(retryCount - 1);
return(_StatusInstance);
}
Logger.log(e, null, Logger.LogType.NOSENTRY);
return(new NullStatusBar());
}
}
catch (System.Exception e)
{
Logger.log(e, null, Logger.LogType.NOSENTRY);
return(new NullStatusBar());
}
}
public SqlEditorViewModel(IMySqlExecutor mySqlExecutor,
IStatusBar statusBar,
ITaskRunner taskRunner,
INativeTextDocument sql)
{
Code = sql;
ExecuteSql = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
async() =>
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
await mySqlExecutor.ExecuteSql(Code.ToString());
statusBar.PublishNotification(new PlainNotification(NotificationType.Success, "Query executed"));
});
});
Save = new DelegateCommand(() =>
{
ExecuteSql.Execute(null);
});
}
public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflowVisual interactiveWorkflow)
{
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_interactiveWorkflow = interactiveWorkflow;
_shell = interactiveWorkflow.Shell;
_securityService = _shell.GetService <ISecurityService>();
_log = _shell.GetService <IActionLog>();
_installationService = _shell.GetService <IRInstallationService>();
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell.Services);
if (settings.ShowHostLoadMeter)
{
_hostLoadIndicatorViewModel =
new HostLoadIndicatorViewModel(_sessionProvider, interactiveWorkflow.Shell.MainThread());
}
_disposableBag = DisposableBag.Create <ConnectionManager>()
.Add(_statusBarViewModel)
.Add(_hostLoadIndicatorViewModel ?? Disposable.Empty)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged)
.Add(() => _interactiveWorkflow.RSession.Connected -= SessionConnected)
.Add(() => _interactiveWorkflow.RSession.Disconnected -= SessionDisconnected)
.Add(() => _interactiveWorkflow.ActiveWindowChanged -= ActiveWindowChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
_interactiveWorkflow.RSession.Connected += SessionConnected;
_interactiveWorkflow.RSession.Disconnected += SessionDisconnected;
_interactiveWorkflow.ActiveWindowChanged += ActiveWindowChanged;
// Get initial values
var connections = CreateConnectionList();
_connections = new ConcurrentDictionary <string, IConnection>(connections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
public void OnToolWindowCreated(IServiceProvider serviceProvider)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
_uiRequestProcessor = componentModel.DefaultExportProvider.GetExportedValue <IUIRequestProcessor>();
_statusBar = componentModel.DefaultExportProvider.GetExportedValue <IStatusBar>();
_typedRequestProcessProxy = componentModel.DefaultExportProvider.GetExportedValue <ITypedRequestProcessProxy>();
_typedRequestProcessProxy.EventReceived += TypedRequestProcessProxy_EventReceived;
var standarImageSourceFactory = componentModel.DefaultExportProvider.GetExportedValue <IStandarImageSourceFactory>();
var clipboard = componentModel.DefaultExportProvider.GetExportedValue <IClipboard>();
var windowsExplorer = componentModel.DefaultExportProvider.GetExportedValue <IWindowsExplorer>();
var openDocumentHelper = componentModel.DefaultExportProvider.GetExportedValue <IOpenDocumentHelper>();
var synchronizationContextProvider = componentModel.DefaultExportProvider.GetExportedValue <ISynchronizationContextProvider>();
var host = new SourceExplorerViewModelHost(this, _uiRequestProcessor, standarImageSourceFactory, windowsExplorer, clipboard, synchronizationContextProvider, openDocumentHelper);
ViewModel.SetHost(host);
ViewModel.OnToolWindowCreated(serviceProvider);
FetchFilesystemTree();
}
//ToDo: OLW Spell Checker
//public BlogPostHtmlEditorControl(IMainFrameWindow mainFrameWindow, IStatusBar statusBar, MshtmlOptions options, IBlogPostImageEditingContext imageEditingContext, IBlogPostSidebarContext sidebarContext, IContentSourceSidebarContext sourceContext, SmartContentResizedListener resizedListener, IBlogPostSpellCheckingContext spellingContext, IImageReferenceFixer referenceFixer, IInternetSecurityManager internetSecurityManager, CommandManager commandManager, TemplateStrategy strategy, IEditingMode editingModeContext) : base(mainFrameWindow, statusBar, options, internetSecurityManager, commandManager)
public BlogPostHtmlEditorControl(IMainFrameWindow mainFrameWindow, IStatusBar statusBar, MshtmlOptions options, IBlogPostImageEditingContext imageEditingContext, IBlogPostSidebarContext sidebarContext, IContentSourceSidebarContext sourceContext, SmartContentResizedListener resizedListener, IImageReferenceFixer referenceFixer, IInternetSecurityManager internetSecurityManager, CommandManager commandManager, TemplateStrategy strategy, IEditingMode editingModeContext)
: base(mainFrameWindow, statusBar, options, internetSecurityManager, commandManager)
{
_strategy = strategy;
_imageEditingContext = imageEditingContext;
_sidebarContext = sidebarContext;
_sourceContext = sourceContext;
_resizedListener = resizedListener;
//ToDo: OLW Spell Checker
//_spellingContext = spellingContext;
//_spellingManager = new SpellingManager(CommandManager);
_keyBoardHandler = new PostEditorKeyboardHandler(this, imageEditingContext, editingModeContext);
_referenceFixer = referenceFixer;
InitializeTableEditingManager();
InitializeElementBehaviors();
SelectionChanged += BlogPostHtmlEditorControl_SelectionChanged;
KeyPress += new HtmlEventHandler(BlogPostHtmlEditorControl_KeyPress);
}
public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflow interactiveWorkflow)
{
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_shell = interactiveWorkflow.Shell;
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell);
_disposableBag = DisposableBag.Create <ConnectionManager>()
.Add(_statusBarViewModel)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
// Get initial values
var userConnections = CreateConnectionList();
_userConnections = new ConcurrentDictionary <Uri, IConnection>(userConnections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
public LoggedInUserViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IRegionManager regionManager,
IEventAggregator eventAggregator,
ITradingServiceAsync tradingService,
UserContext userContext)
{
logger.Log("LoggedInUserViewModel.LoggedInUserViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_tradingService = tradingService;
this.UserContext = userContext;
this.SignOutCommand = new DelegateCommand<object>(this.SignOutExecute);
_tradingService.GetBrokerageAccountSummariesCompleted +=
new EventHandler<GetBrokerageAccountSummariesCompletedEventArgs>(GetBrokerageAccountSummariesCallback);
_tradingService.GetExternalAccountSummariesCompleted +=
new EventHandler<GetExternalAccountSummariesCompletedEventArgs>(GetExternalAccountSummariesCallback);
SubscribeToEvents();
}
public LoginViewModel(
ILoggerFacade logger,
IStatusBar statusBar,
IRegionManager regionManager,
IEventAggregator eventAggregator,
ISecurityServiceAsync securityService,
UserContext userContext)
{
logger.Log("LoginViewModel.LoginViewModel()", Category.Debug, Priority.Low);
_logger = logger;
_statusBar = statusBar;
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_securityService = securityService;
_securityService.AuthenticateUserCompleted += new EventHandler<AuthenticateUserCompletedEventArgs>(AuthenticateUserCallback);
this.UserContext = userContext;
LoginCommand = new DelegateCommand<object>(this.LoginExecute, this.CanLoginExecute);
OpenAccountCommand = new DelegateCommand<object>(this.OpenAccountExecute);
#if !SILVERLIGHT
PasswordChangedCommand = new DelegateCommand<object>(this.PasswordChangedExecute);
#endif
this.PropertyChanged += this.OnPropertyChanged;
this.ValidateAll();
}
public static void InstallNuGetPackage(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName, string targetNsbVersion)
{
string packageId;
int? majorVersion;
GetPackageIdAndMajorVersion(packageName, targetNsbVersion, out packageId, out majorVersion);
try
{
var version = NugetPackageVersionManager.GetVersionFromCacheForPackage(packageId, majorVersion);
if (!String.IsNullOrEmpty(version))
{
StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageId, version));
try
{
InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageId, version);
}
catch (Exception installException)
{
StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageId, installException.Message));
// There was a problem installing the specified version of the package. Try the installing the latest available package from the source.
InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageId, majorVersion);
}
}
else
{
StatusBar.DisplayMessage(String.Format("Installing the latest version of Package: {0}...", packageId));
InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageId, majorVersion);
}
}
catch (Exception ex)
{
throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageId, ex.Message), ex);
}
finally
{
StatusBar.DisplayMessage("");
}
}
internal virtual void PerformSearch(TypeSearchTask searchTask)
{
if (this._searchTask != null)
{
TypeSearchTask task = this._searchTask;
this._searchTask = null;
task.Cancel();
}
this._listView.Items.Clear();
base.Activate();
this._searchTask = searchTask;
this._listView.WatermarkText = "Searching...";
this.Mode = ClassViewToolWindowMode.Search;
if (this._statusBar == null)
{
this._statusBar = (IStatusBar) this.GetService(typeof(IStatusBar));
}
if (this._statusBar != null)
{
this._statusBar.SetProgress(10);
this._statusBar.SetText("Searching...");
}
this.UpdateCommands();
this._searchTask.Start(new AsyncTaskResultPostedEventHandler(this.OnSearchResultsPosted));
}
public TextDocumentViewModel(IWindowManager windowManager,
ITaskRunner taskRunner,
IStatusBar statusBar,
IMySqlExecutor mySqlExecutor,
IDatabaseProvider databaseProvider,
INativeTextDocument nativeTextDocument,
IQueryParserService queryParserService,
ISessionService sessionService,
IMessageBoxService messageBoxService)
{
Extension = "txt";
Title = "New file";
this.statusBar = statusBar;
document = nativeTextDocument;
SaveCommand = new AsyncAutoCommand(async() =>
{
var path = await windowManager.ShowSaveFileDialog($"{Extension} file|{Extension}|All files|*");
if (path != null)
{
await File.WriteAllTextAsync(path, document.ToString());
}
});
ExecuteSqlSaveSession = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
() => WrapStatusbar(async() =>
{
var query = Document.ToString();
IList <ISolutionItem>?solutionItems = null;
IList <string>?errors = null;
if (inspectQuery && sessionService.IsOpened && !sessionService.IsPaused)
{
(solutionItems, errors) = await queryParserService.GenerateItemsForQuery(query);
}
await mySqlExecutor.ExecuteSql(query);
if (solutionItems != null)
{
foreach (var item in solutionItems)
{
await sessionService.UpdateQuery(item);
}
if (errors !.Count > 0)
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Apply query")
.SetMainInstruction("Some queries couldn't be transformed into session items")
.SetContent("Details:\n\n" + string.Join("\n", errors.Select(s => " - " + s)))
.WithOkButton(true)
.Build());
}
}
}));
}, () => databaseProvider.IsConnected);
ExecuteSql = new DelegateCommand(() =>
{
taskRunner.ScheduleTask("Executing query",
() => WrapStatusbar(() => mySqlExecutor.ExecuteSql(Document.ToString())));
}, () => databaseProvider.IsConnected);
}
private void AddToStatusBar(IStatusBar statusBar, FrameworkElement item, object dataContext)
{
item.DataContext = dataContext;
Disposables.TryAdd(statusBar.AddItem(item));
}
public CustomGCCToolchain(IStatusBar statusBar)
: base(statusBar)
{
}
public StatusManager()
{
_statusBar = IoC.Get <IStatusBar>();
_timeoutTimer = new Timer();
_timeoutTimer.Elapsed += OnTimerExpired;
}
public StatusManager()
{
_statusBar = IoC.Get<IStatusBar>();
_timeoutTimer = new Timer();
_timeoutTimer.Elapsed += OnTimerExpired;
}
public HtmlEditorControl(IMainFrameWindow mainFrameWindow, IStatusBar statusBar, MshtmlOptions options, ISpellingChecker spellingChecker, IInternetSecurityManager internetSecurityManager, CommandManager commandManager)
{
_commandManager = commandManager;
// save reference to main frame window
_mainFrameWindow = mainFrameWindow;
_statusBar = statusBar;
_spellingChecker = spellingChecker;
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
//initialize the data format handlers for this control
DataFormatHandlerFactory = new HtmlEditorMarshallingHandler(this);
MarshalImagesSupported = true;
MarshalFilesSupported = true;
MarshalUrlSupported = true;
MarshalHtmlSupported = true;
MarshalTextSupported = true;
// The version host service provider tells MSHTML what feature versions are available (e.g. VML 1.0).
VersionHostServiceProvider = new VersionHostServiceProvider(new DisableVmlVersionHost());
// initialize the html editor
if (_editorCache == null)
{
_internetSecurityManager = new InternetSecurityManagerShim(internetSecurityManager);
// If mainFrameWindow == null, then we are pre-caching mshtml and don't want it to steal focus
_mshtmlEditor = new MshtmlEditor(this, options, (mainFrameWindow == null));
}
else
{
_mshtmlEditor = _editorCache.Editor;
_internetSecurityManager = _editorCache.SecurityManager;
_internetSecurityManager.SecurityManager = internetSecurityManager;
_editorCache = null;
_mshtmlEditor.Active = true;
_mshtmlEditor.MshtmlControl.ProtectFocus = false;
_mshtmlEditor.ClearContextMenuHandlers();
_mshtmlEditor.SetServiceProvider(this);
_mshtmlEditor.UpdateOptions(options, true);
}
_mshtmlOptions = options;
this.DefaultBlockElement = _mshtmlOptions.UseDivForCarriageReturn
? (DefaultBlockElement)new DivDefaultBlockElement()
: new ParagraphDefaultBlockElement();
PostEditorEvent += new MshtmlEditor.EditDesignerEventHandler(HtmlEditorControl_PostEditorEvent);
HandleClear += new HtmlEditorSelectionOperationEventHandler(TryMoveIntoNextTable);
// Hook the editor into the stream of the security manager so we
// can allow our own objects (smart content, image resizing) to load in the editor
_internetSecurityManager.HandleProcessUrlAction = HandleProcessUrlAction;
// Automation uses this to find the editor to automate it
_mshtmlEditor.Name = "BorderControl";
// subscribe to key events
_mshtmlEditor.DocumentComplete += new EventHandler(_mshtmlEditor_DocumentComplete);
_mshtmlEditor.DocumentEvents.GotFocus += htmlEditor_GotFocus;
_mshtmlEditor.DocumentEvents.LostFocus += htmlEditor_LostFocus;
_mshtmlEditor.DocumentEvents.KeyDown += new HtmlEventHandler(DocumentEvents_KeyDown);
_mshtmlEditor.DocumentEvents.KeyUp += new HtmlEventHandler(DocumentEvents_KeyUp);
_mshtmlEditor.DocumentEvents.KeyPress += new HtmlEventHandler(DocumentEvents_KeyPress);
_mshtmlEditor.DocumentEvents.MouseDown += new HtmlEventHandler(DocumentEvents_MouseDown);
_mshtmlEditor.DocumentEvents.MouseUp += new HtmlEventHandler(DocumentEvents_MouseUp);
_mshtmlEditor.DocumentEvents.SelectionChanged += new EventHandler(DocumentEvents_SelectionChanged);
_mshtmlEditor.DisplayChanged += new EventHandler(_mshtmlEditor_DisplayChanged);
_mshtmlEditor.DocumentEvents.Click += new HtmlEventHandler(DocumentEvents_Click);
_mshtmlEditor.CommandKey += new KeyEventHandler(_mshtmlEditor_CommandKey);
_mshtmlEditor.DropTargetHandler = new MshtmlEditor.DropTargetUIHandler(_mshtmlEditor_GetDropTarget);
_mshtmlEditor.BeforeShowContextMenu += new EventHandler(_mshtmlEditor_BeforeShowContextMenu);
_mshtmlEditor.MshtmlControl.DLControlFlagsChanged += new EventHandler(_mshtmlControl_DLControlFlagsChanged);
_mshtmlEditor.TranslateAccelerator += new HtmlEditDesignerEventHandler(_mshtmlEditor_TranslateAccelerator);
InitDamageServices();
// notify subclasses that the editor has been created
OnEditorCreated();
}
public SolutionExplorerViewModel(ISolutionItemNameRegistry itemNameRegistry,
ISolutionManager solutionManager,
IEventAggregator ea,
ISolutionSqlService solutionSqlService,
INewItemService newItemService,
ISolutionTasksService solutionTasksService,
IStatusBar statusBar,
ISolutionItemIconRegistry solutionItemIconRegistry,
ISolutionItemProvideService provider)
{
this.itemNameRegistry = itemNameRegistry;
this.solutionManager = solutionManager;
this.ea = ea;
this.statusBar = statusBar;
this.solutionItemIconRegistry = solutionItemIconRegistry;
Root = new ObservableCollection <SolutionItemViewModel>();
itemToViewmodel = new Dictionary <ISolutionItem, SolutionItemViewModel>();
foreach (ISolutionItem item in this.solutionManager.Items)
{
AddItemToRoot(item);
}
this.solutionManager.Items.CollectionChanged += (sender, args) =>
{
if (args.NewItems != null)
{
var i = 0;
foreach (ISolutionItem obj in args.NewItems)
{
AddItemToRoot(obj, args.NewStartingIndex + i);
i++;
}
}
if (args.OldItems != null)
{
foreach (ISolutionItem obj in args.OldItems)
{
ISolutionItem solutionItem = obj;
Root.Remove(itemToViewmodel[solutionItem]);
itemToViewmodel.Remove(solutionItem);
}
}
};
solutionManager.RefreshRequest += item =>
{
foreach (var root in Root)
{
root.Refresh();
}
};
Dictionary <string, AddItemCategoryMenuViewModel> byNameCategories = new();
Func <ISolutionItemProvider, Task> insertItemCommand = async provider =>
{
var item = await provider.CreateSolutionItem();
if (item != null)
{
DoAddItem(item);
}
};
foreach (var item in provider.AllCompatible)
{
if (item is INamedSolutionItemProvider)
{
continue;
}
if (!byNameCategories.TryGetValue(item.GetGroupName(), out var category))
{
category = new AddItemCategoryMenuViewModel(item.GetGroupName());
byNameCategories.Add(category.Name, category);
AddItems.Add(category);
}
category.Items.Add(new SolutionItemMenuViewModel(item, insertItemCommand));
}
AddItem = new DelegateCommand(async() =>
{
ISolutionItem?item = await newItemService.GetNewSolutionItem();
if (item != null)
{
DoAddItem(item);
}
}, () => (SelectedItem == null || SelectedItem.IsContainer) && SelectedItems.Count <= 1)
.ObservesProperty(() => SelectedItem)
.ObservesProperty(() => SelectedItems.Count);
RemoveItem = new DelegateCommand(() =>
{
if (SelectedItems.Count > 0)
{
foreach (var item in SelectedItems.ToList())
{
DeleteSolutionItem(item);
}
SelectedItems.Clear();
}
else if (selected != null)
{
DeleteSolutionItem(selected);
}
}, () => SelectedItem != null || SelectedItems.Count > 0)
.ObservesProperty(() => SelectedItem)
.ObservesProperty(() => SelectedItems.Count);
SelectedItemChangedCommand = new DelegateCommand <SolutionItemViewModel>(ob => { selected = ob; });
RequestOpenItem = new DelegateCommand <SolutionItemViewModel>(item =>
{
if (item != null && !item.IsContainer)
{
this.ea.GetEvent <EventRequestOpenItem>().Publish(item.Item);
}
});
GenerateSQL = new DelegateCommand(() =>
{
if (selected != null)
{
solutionSqlService.OpenDocumentWithSqlFor(selected.Item);
}
});
UpdateDatabase = new DelegateCommand(() =>
{
if (selected != null)
{
solutionTasksService.SaveSolutionToDatabaseTask(selected.Item);
}
}, () => solutionTasksService.CanSaveToDatabase);
ExportToServer = new DelegateCommand(() =>
{
if (selected != null)
{
solutionTasksService.SaveAndReloadSolutionTask(selected.Item);
}
}, () => solutionTasksService.CanSaveAndReloadRemotely);
ExportToServerItem = new DelegateCommand <SolutionItemViewModel>(item =>
{
if (item != null)
{
solutionTasksService.SaveAndReloadSolutionTask(item.Item);
}
}, item => solutionTasksService.CanSaveAndReloadRemotely);
}
private static StatusBarModule CreateStatusBarModule(IStatusBar statusBar)
{
return new StatusBarModule(statusBar);
}
public Task <bool> Restore(IConsole console, IStatusBar statusBar = null, bool checkLock = false)
{
bool restore = !checkLock;
if (checkLock)
{
lock (_restoreLock)
{
restore = !IsRestored;
if (restore)
{
IsRestored = true;
_restoreTaskCompletionSource = new TaskCompletionSource <bool>();
}
}
}
if (restore)
{
return(Task.Factory.StartNew(() =>
{
statusBar.SetText($"Restoring Packages for solution: {Name}");
var exitCode = PlatformSupport.ExecuteShellCommand(DotNetCliService.Instance.DotNetPath, $"restore /m {Path.GetFileName(Location)}", (s, e) =>
{
if (statusBar != null)
{
if (!string.IsNullOrWhiteSpace(e.Data))
{
Dispatcher.UIThread.InvokeAsync(() =>
{
statusBar.SetText(e.Data.Trim());
});
}
}
console?.WriteLine(e.Data);
}, (s, e) =>
{
if (e.Data != null)
{
if (console != null)
{
console.WriteLine();
console.WriteLine(e.Data);
}
}
},
false, CurrentDirectory, false);
IsRestored = true;
var result = exitCode == 0;
_restoreTaskCompletionSource?.SetResult(result);
lock (_restoreLock)
{
_restoreTaskCompletionSource = null;
}
return result;
}));
}
else
{
lock (_restoreLock)
{
if (_restoreTaskCompletionSource != null)
{
return(_restoreTaskCompletionSource.Task);
}
else
{
return(Task.FromResult(true));
}
}
}
}
public SolutionExplorerViewModel(ISolutionItemNameRegistry itemNameRegistry,
ISolutionManager solutionManager,
IEventAggregator ea,
INewItemService newItemService,
IStatusBar statusBar,
ISolutionItemSqlGeneratorRegistry sqlGeneratorRegistry)
{
this.itemNameRegistry = itemNameRegistry;
_solutionManager = solutionManager;
_ea = ea;
_statusBar = statusBar;
_firstGeneration = new ObservableCollection <SolutionItemViewModel>();
_itemToViewmodel = new Dictionary <ISolutionItem, SolutionItemViewModel>();
foreach (var item in _solutionManager.Items)
{
AddItemToRoot(item);
}
_solutionManager.Items.CollectionChanged += (sender, args) =>
{
if (args.NewItems != null)
{
int i = 0;
foreach (var obj in args.NewItems)
{
AddItemToRoot(obj as ISolutionItem, args.NewStartingIndex + i);
i++;
}
}
if (args.OldItems != null)
{
foreach (var obj in args.OldItems)
{
var solutionItem = obj as ISolutionItem;
Root.Remove(_itemToViewmodel[solutionItem]);
_itemToViewmodel.Remove(solutionItem);
}
}
};
AddItem = new DelegateCommand(() =>
{
ISolutionItem item = newItemService.GetNewSolutionItem();
if (item != null)
{
if (_selected == null)
{
solutionManager.Items.Add(item);
}
else
{
_selected.Item.Items.Add(item);
}
}
});
RemoveItem = new DelegateCommand(() =>
{
if (_selected != null)
{
if (_selected.Parent == null)
{
_solutionManager.Items.Remove(_selected.Item);
}
else
{
_selected.Parent.Item.Items.Remove(_selected.Item);
}
}
});
SelectedItemChangedCommand = new DelegateCommand <SolutionItemViewModel>((ob) =>
{
_selected = ob;
});
RequestOpenItem = new DelegateCommand <SolutionItemViewModel>((item) =>
{
if (item != null && !item.IsContainer)
{
_ea.GetEvent <EventRequestOpenItem>().Publish(item.Item);
}
});
GenerateSQL = new DelegateCommand(() =>
{
if (_selected != null)
{
MetaSolutionSQL solution = new MetaSolutionSQL(sqlGeneratorRegistry.GenerateSql(_selected.Item));
_ea.GetEvent <EventRequestOpenItem>().Publish(solution);
}
});
}
public static void InstallNugetPackageForSpecifiedVersion(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName, string version)
{
try
{
StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageName, version));
try
{
InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageName, version);
}
catch (Exception installException)
{
StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageName, installException.Message));
}
}
catch (Exception ex)
{
throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageName, ex.Message), ex);
}
finally
{
StatusBar.DisplayMessage("");
}
}
/*
* private void InsertNodeElementsTask(object parameters)
* {
* TreeNode treenode = (TreeNode)((object[])parameters)[0];
* IExplorerObject exObject = (IExplorerObject)((object[])parameters)[1];
*
* IStatusBar statusbar = (_app != null) ? _app.StatusBar : null;
* List<ExplorerObjectNode> treeNodes = new List<ExplorerObjectNode>();
*
* List<IExplorerObject> childObjects = ((IExplorerParentObject)exObject).ChildObjects;
* if (childObjects == null) return;
* int pos = 0, count = childObjects.Count;
* if (statusbar != null) statusbar.ProgressVisible = true;
*
* foreach (IExplorerObject exObj in childObjects)
* {
* if (exObj == null ||
* exObj is IExplorerObjectDoubleClick) continue;
*
* if (statusbar != null)
* {
* statusbar.ProgressValue = (int)(((double)pos++ / (double)count) * 100.0);
* statusbar.Text = exObj.Name;
* statusbar.Refresh();
* }
*
* if (_filter != null)
* {
* if (_filter.Match(exObj))
* continue;
* else if (!(exObj is IExplorerParentObject)) continue;
* }
* int imageIndex = FormExplorer.ImageIndex(exObj);
* treeNodes.Add(new ExplorerObjectNode(exObj, imageIndex));
*
* if (exObj is IExplorerObjectDeletable)
* ((IExplorerObjectDeletable)exObj).ExplorerObjectDeleted += new ExplorerObjectDeletedEvent(CatalogTreeControl_ExplorerObjectDeleted);
* if (exObj is IExplorerObjectRenamable)
* ((IExplorerObjectRenamable)exObj).ExplorerObjectRenamed += new ExplorerObjectRenamedEvent(CatalogTreeControl_ExplorerObjectRenamed);
* if (exObj is IRefreshedEventHandler)
* ((IRefreshedEventHandler)exObj).Refreshed += new RefreshedEventHandler(CatalogTreeControl_Refreshed);
* }
*
* if (treenode.Nodes.Count == 0)
* {
* treenode.Nodes.Add(new DummyNode());
* return;
* }
* }
*
* private delegate void InsertNodeElementsCallback(TreeNode treeNode, List<ExplorerObjectNode> childNodes);
* private void InsertNodeElements(TreeNode treeNode, List<ExplorerObjectNode> childNodes)
* {
* if (this.InvokeRequired)
* {
* this.Invoke(new InsertNodeElementsCallback(InsertNodeElements), new object[] { treeNode, childNodes });
* }
* else
* {
* foreach (ExplorerObjectNode childNode in childNodes)
* {
* treeNode.Nodes.Add(childNode);
* }
* }
* }
*/
async private Task <bool> InsertNodeElements(TreeNode treenode)
{
if (!(treenode is ExplorerObjectNode))
{
return(true);
}
ExplorerObjectNode node = (ExplorerObjectNode)treenode;
IExplorerObject exObject = node.ExplorerObject;
if (exObject == null)
{
return(true);
}
try
{
Cursor = Cursors.WaitCursor;
if (exObject is IExplorerParentObject)
{
//System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(InsertNodeElementsTask));
//thread.Start(new object[] { treenode, exObject });
treenode.Nodes.Clear();
IStatusBar statusbar = (_app != null) ? _app.StatusBar : null;
List <IExplorerObject> childObjects = await((IExplorerParentObject)exObject).ChildObjects();
if (childObjects == null)
{
return(false);
}
int pos = 0, count = childObjects.Count;
if (statusbar != null)
{
statusbar.ProgressVisible = true;
}
foreach (IExplorerObject exObj in childObjects)
{
if (exObj == null ||
exObj is IExplorerObjectDoubleClick)
{
continue;
}
if (statusbar != null)
{
statusbar.ProgressValue = (int)((pos++ / (double)count) * 100.0);
statusbar.Text = exObj.Name;
statusbar.Refresh();
}
if (_filter != null)
{
if (await _filter.Match(exObj))
{
continue;
}
else if (!(exObj is IExplorerParentObject))
{
continue;
}
}
int imageIndex = gView.Explorer.UI.Framework.UI.ExplorerIcons.ImageIndex(exObj);
treenode.Nodes.Add(new ExplorerObjectNode(exObj, imageIndex));
if (exObj is IExplorerObjectDeletable)
{
((IExplorerObjectDeletable)exObj).ExplorerObjectDeleted += new ExplorerObjectDeletedEvent(CatalogTreeControl_ExplorerObjectDeleted);
}
if (exObj is IExplorerObjectRenamable)
{
((IExplorerObjectRenamable)exObj).ExplorerObjectRenamed += new ExplorerObjectRenamedEvent(CatalogTreeControl_ExplorerObjectRenamed);
}
if (exObj is IRefreshedEventHandler)
{
((IRefreshedEventHandler)exObj).Refreshed += new RefreshedEventHandler(CatalogTreeControl_Refreshed);
}
}
if (statusbar != null)
{
statusbar.ProgressVisible = false;
statusbar.Text = String.Empty;
statusbar.Refresh();
}
}
if (treenode.Nodes.Count == 0)
{
treenode.Nodes.Add(new DummyNode());
return(false);
}
return(true);
}
catch (Exception ex)
{
Cursor = Cursors.Default;
MessageBox.Show(ex.Message);
treenode.Nodes.Add(new DummyNode());
return(false);
}
finally
{
Cursor = Cursors.Default;
}
}
public void Activation()
{
//throw new NotImplementedException();
_statusBar = IoC.Get <IStatusBar>();
}
public ConnectionManagerProvider(IStatusBar statusBar, IRSettings settings) {
_statusBar = statusBar;
_settings = settings;
}
public ExplorerApplication(gView.Explorer.UI.Framework.UI.IFormExplorer appWindow)
: base()
{
_appWindow = appWindow;
_statusBar = new ExplorerStatusBar(_appWindow);
}
public WizardStyleViewModelBase(
IMessageBoxService messageBoxService,
ICoreSourceSettings coreSourceSettings,
ISourceSqlUpdateService sqlUpdateService,
IAuthMySqlExecutor authExecutor,
IMySqlExecutor worldExecutor,
IWindowManager windowManager,
ITaskRunner taskRunner,
IStatusBar statusBar,
INativeTextDocument resultCode)
{
ResultCode = resultCode;
CoreSourceFolder = coreSourceSettings.CurrentCorePath;
if (!string.IsNullOrEmpty(coreSourceSettings.CurrentCorePath))
{
Dispatcher.UIThread.Post(() => WizardStep++);
}
CommandPreviousStep = new DelegateCommand(() => WizardStep--, () => !IsLoading && WizardStep > 0)
.ObservesProperty(() => IsLoading)
.ObservesProperty(() => WizardStep);
CommandNextStep = new DelegateCommand(() => WizardStep++, () => !IsLoading && WizardStep < TotalSteps - 1)
.ObservesProperty(() => IsLoading)
.ObservesProperty(() => WizardStep);
PickCoreSourceFolder = new AsyncAutoCommand(async() =>
{
var selectedPath = await windowManager.ShowFolderPickerDialog(coreSourceFolder);
if (selectedPath != null)
{
if (!coreSourceSettings.SetCorePath(selectedPath))
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Invalid folder")
.SetMainInstruction("Invalid wow source folder")
.SetContent(
"It looks like it is not an valid wow server source folder.\n\nThe folder should contain src/ and sql/ subfolders")
.WithOkButton(true)
.Build());
}
CoreSourceFolder = coreSourceSettings.CurrentCorePath;
}
});
ExecuteSqlCommand = new AsyncAutoCommand(async() =>
{
var(auth, world) = GenerateSql();
try
{
await taskRunner.ScheduleTask("Executing commands update", async() =>
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
if (auth != null)
{
if (authExecutor.IsConnected)
{
await authExecutor.ExecuteSql(auth);
}
else
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Auth database not connected")
.SetIcon(MessageBoxIcon.Warning)
.SetMainInstruction("Auth database not connected")
.SetContent(
"You are trying to execute auth query, but auth database is not connected.\n\nEnsure you have correct auth database data in settings.")
.WithOkButton(true)
.Build());
}
}
if (world != null)
{
if (worldExecutor.IsConnected)
{
await worldExecutor.ExecuteSql(world);
}
else
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("World database not connected")
.SetIcon(MessageBoxIcon.Warning)
.SetMainInstruction("World database not connected")
.SetContent(
"You are trying to execute world query, but world database is not connected.\n\nEnsure you have correct world database data in settings.")
.WithOkButton(true)
.Build());
}
}
statusBar.PublishNotification(new PlainNotification(NotificationType.Success,
"Executed query"));
});
}
catch (Exception)
{
statusBar.PublishNotification(new PlainNotification(NotificationType.Error, "Error while executing query. Check Database Query Debug window"));
}
}, _ => worldExecutor.IsConnected || authExecutor.IsConnected);
SaveSqlCommand = new AsyncAutoCommand(async() =>
{
var(auth, world) = GenerateSql();
if (auth != null)
{
sqlUpdateService.SaveAuthUpdate(SqlSuffixName, auth);
}
if (world != null)
{
sqlUpdateService.SaveWorldUpdate(SqlSuffixName, world);
}
if (auth != null || world != null)
{
await messageBoxService.ShowDialog(new MessageBoxFactory <bool>()
.SetTitle("Done!")
.SetContent("SQL files saved to sql/updates/")
.SetIcon(MessageBoxIcon.Information)
.WithOkButton(true)
.Build());
}
});
}
public ClangToolchain(IStatusBar statusBar)
: base(statusBar)
{
}
public static void InstallNuGetPackage(this IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, IStatusBar StatusBar, string packageName)
{
try
{
var version = NugetPackageVersionManager.GetVersionFromCacheForPackage(packageName);
if (!String.IsNullOrEmpty(version))
{
StatusBar.DisplayMessage(String.Format("Installing Package: {0} {1}...", packageName, version));
try
{
InstallNugetPackageForSpecifiedVersion(project, vsPackageInstaller, packageName, version);
}
catch (Exception installException)
{
StatusBar.DisplayMessage(String.Format("When attempting to install version {0} of the package {1}, the following error occured: {2}.. Going to now try installing the latest version of Package ...", version, packageName, installException.Message));
// There was a problem installing the specified version of the package. Try the installing the latest available package from the source.
InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageName);
}
}
else
{
StatusBar.DisplayMessage(String.Format("Installing the latest version of Package: {0}...", packageName));
InstallLatestNugetPackage(project, vsPackageInstallerServices, vsPackageInstaller, packageName);
}
StatusBar.DisplayMessage("");
}
catch (Exception ex)
{
throw new Exception(String.Format("NuGet Package {0} cannot be installed ({1}).", packageName, ex.Message), ex);
}
}
public STM32GCCToolchain(IStatusBar statusBar)
: base(statusBar)
{
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (this._searchTask != null)
{
this._searchTask.Cancel();
this._searchTask = null;
}
this._statusBar = null;
IProjectManager service = (IProjectManager) this.GetService(typeof(IProjectManager));
}
base.Dispose(disposing);
}
public ConnectionManagerProvider(IStatusBar statusBar, ICoreShell coreShell)
{
_statusBar = statusBar;
_settings = coreShell.GetService <IRSettings>();
}
private static StatusBarModule CreateStatusBarModule(IStatusBar statusBar)
{
return(new StatusBarModule(statusBar));
}
public PublishedGCCToolchain(IStatusBar statusBar)
: base(statusBar)
{
}
public ConnectionManagerProvider(IStatusBar statusBar, IRSessionProvider sessionProvider, IRSettings settings)
{
_statusBar = statusBar;
_sessionProvider = sessionProvider;
_settings = settings;
}
