private void manager_NewFileTransfer(IFileTransfer transfer)
{
try {
// Add transfer to list
transferListStore.AppendValues(transfer);
// Watch a few other events
transfer.PeerAdded += (FileTransferPeerEventHandler)DispatchService.GuiDispatch(
new FileTransferPeerEventHandler(transfer_PeerAdded)
);
transfer.Error += (FileTransferErrorEventHandler)DispatchService.GuiDispatch(
new FileTransferErrorEventHandler(transfer_Error)
);
Gui.MainWindow.RefreshCounts();
} catch (Exception ex) {
LoggingService.LogError(ex);
Gui.ShowErrorDialog(ex.ToString(), Gui.MainWindow.Window);
}
}
IInteractiveSession SetupSession()
{
var ses = new CSharpInteractiveSession();
ses.TextReceived += t => DispatchService.GuiDispatch(() => view.WriteOutput(t));
ses.PromptReady += () => DispatchService.GuiDispatch(() => view.Prompt(true));
ses.Exited += () => DispatchService.GuiDispatch(() => {
if (kill == KillIntent.None)
{
view.WriteOutput("\nSession termination detected. Press Enter to restart.");
isPrompting = true;
}
else if (kill == KillIntent.Restart)
{
view.Clear();
}
kill = KillIntent.None;
});
ses.StartReceiving();
return(ses);
}
public IProgressMonitor BeginProgress(string title)
{
progressStarted = true;
logView.Clear();
monitor = logView.GetProgressMonitor();
asyncOperation = monitor.AsyncOperation;
DispatchService.GuiDispatch(delegate {
window.HasNewData = false;
window.HasErrors = false;
window.IsWorking = true;
buttonStop.Sensitive = true;
});
monitor.AsyncOperation.Completed += delegate {
EndProgress();
};
return(monitor);
}
} // GetSymbolsVisibleFrom
/// <summary>
/// Add results to a ValaCompletionDataList on the GUI thread
/// </summary>
private static void AddResults(IEnumerable <Afrodite.Symbol> list, ValaCompletionDataList results)
{
if (null == list || null == results)
{
LoggingService.LogDebug("AddResults: null list or results!");
return;
}
List <CompletionData> data = new List <CompletionData> ();
foreach (Afrodite.Symbol symbol in list)
{
data.Add(new CompletionData(symbol));
}
DispatchService.GuiDispatch(delegate {
results.IsChanging = true;
results.AddRange(data);
results.IsChanging = false;
});
} // AddResults
private void BuildChildNodesThreaded(object state)
{
BaseNode node = state as BaseNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
bool showSystemObjects = (bool)builder.Options["ShowSystemObjects"];
ProcedureSchemaCollection procedures = node.ConnectionContext.SchemaProvider.GetProcedures();
DispatchService.GuiDispatch(delegate {
foreach (ProcedureSchema procedure in procedures)
{
if (procedure.IsSystemProcedure && !showSystemObjects)
{
continue;
}
builder.AddChild(new ProcedureNode(node.ConnectionContext, procedure));
}
builder.Expanded = true;
});
}
private void BuildChildNodesThreaded(object state)
{
BaseNode node = state as BaseNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
bool showSystemObjects = (bool)builder.Options["ShowSystemObjects"];
ViewSchemaCollection views = node.ConnectionContext.SchemaProvider.GetViews();
DispatchService.GuiDispatch(delegate {
foreach (ViewSchema view in views)
{
if (view.IsSystemView && !showSystemObjects)
{
continue;
}
builder.AddChild(new ViewNode(node.ConnectionContext, view));
}
builder.Expanded = true;
});
}
protected override BuildResult Build(IProgressMonitor monitor, Solution solution, ConfigurationSelector configuration)
{
try {
buildingSolution = true;
BuildResult res = base.Build(monitor, solution, configuration);
if (res.ErrorCount == 0)
{
SolutionAddinData data = solution.GetAddinData();
if (data != null && data.Registry != null)
{
data.Registry.Update(new ProgressStatusMonitor(monitor));
DispatchService.GuiDispatch(delegate {
data.NotifyChanged();
});
}
}
return(res);
} finally {
buildingSolution = false;
}
}
void PerformSearch()
{
if (list == null)
{
return;
}
// userSelecting = false;
string toMatch = this.searchEntry.Text.ToUpper();
lock (matchLock) {
matchString = toMatch;
}
lock (searchResults) {
// Clean the results list
searchResults.Clear();
}
if (searchThread != null)
{
searchThread.Abort();
searchThread = null;
}
// Queuing this seems to prevent things getting
// added from queued events after the clear.
DispatchService.GuiDispatch(list.Clear);
ThreadStart start = new ThreadStart(SearchThread);
searchThread = new Thread(start)
{
Name = "Class pad search",
IsBackground = true,
Priority = ThreadPriority.Lowest,
};
searchThread.Start();
}
static CSharpSyntaxMode()
{
MonoDevelop.Debugger.DebuggingService.DisableConditionalCompilation += DispatchService.GuiDispatch(new EventHandler <DocumentEventArgs> (OnDisableConditionalCompilation));
if (IdeApp.Workspace != null)
{
IdeApp.Workspace.ActiveConfigurationChanged += delegate {
foreach (var doc in IdeApp.Workbench.Documents)
{
TextEditorData data = doc.Editor;
if (data == null)
{
continue;
}
// Force syntax mode reparse (required for #if directives)
var editor = doc.Editor;
if (editor != null)
{
if (data.Document.SyntaxMode is SyntaxMode)
{
((SyntaxMode)data.Document.SyntaxMode).UpdateDocumentHighlighting();
SyntaxModeService.WaitUpdate(data.Document);
}
editor.Parent.TextViewMargin.PurgeLayoutCache();
doc.ReparseDocument();
editor.Parent.QueueDraw();
}
}
};
}
CommentTag.SpecialCommentTagsChanged += (sender, e) => {
UpdateCommentRule();
var actDoc = IdeApp.Workbench.ActiveDocument;
if (actDoc != null && actDoc.Editor != null)
{
actDoc.UpdateParseDocument();
actDoc.Editor.Parent.TextViewMargin.PurgeLayoutCache();
actDoc.Editor.Parent.QueueDraw();
}
};
}
protected override void Run()
{
vc.Checkout(path, null, true, Monitor);
if (Monitor.IsCancelRequested)
{
Monitor.ReportSuccess(GettextCatalog.GetString("Checkout operation cancelled"));
return;
}
if (!System.IO.Directory.Exists(path))
{
Monitor.ReportError(GettextCatalog.GetString("Checkout folder does not exist"), null);
return;
}
string projectFn = null;
string[] list = System.IO.Directory.GetFiles(path);
if (projectFn == null)
{
foreach (string str in list)
{
if (MonoDevelop.Projects.Services.ProjectService.IsWorkspaceItemFile(str))
{
projectFn = str;
break;
}
}
}
if (projectFn != null)
{
DispatchService.GuiDispatch(delegate {
IdeApp.Workspace.OpenWorkspaceItem(projectFn);
});
}
Monitor.ReportSuccess(GettextCatalog.GetString("Solution checked out"));
}
protected virtual void RefreshClickedThreaded(object state)
{
DatabaseConnectionSettings settings = state as DatabaseConnectionSettings;
DatabaseConnectionContext context = new DatabaseConnectionContext(settings);
IDbFactory fac = DbFactoryService.GetDbFactory(settings.ProviderIdentifier);
try {
FakeConnectionPool pool = new FakeConnectionPool(fac, fac.ConnectionProvider, context);
pool.Initialize();
ISchemaProvider prov = fac.CreateSchemaProvider(pool);
DatabaseSchemaCollection databases = prov.GetDatabases();
foreach (DatabaseSchema db in databases)
{
DispatchService.GuiDispatch(delegate() {
storeDatabases.AppendValues(db.Name);
});
}
isDatabaseListEmpty = databases.Count == 0;
} catch {}
if (isDatabaseListEmpty)
{
DispatchService.GuiDispatch(delegate() {
storeDatabases.AppendValues(GettextCatalog.GetString("No databases found!"));
});
}
else
{
DispatchService.GuiDispatch(delegate() {
TreeIter iter;
if (storeDatabases.GetIterFirst(out iter))
{
comboDatabase.SetActiveIter(iter);
}
});
}
}
NSToolbarItem CreateStatusBarToolbarItem()
{
var bar = new StatusBar();
viewCache.Add(bar);
var item = new NSToolbarItem(StatusBarId)
{
View = bar,
// Place some temporary values in there.
MinSize = new CGSize(360, 22),
MaxSize = new CGSize(360, 22),
};
Action <NSNotification> resizeAction = notif => DispatchService.GuiDispatch(() => {
// Skip updates with a null Window. Only crashes on Mavericks.
// The View gets updated once again when the window resize finishes.
if (bar.Window == null)
{
return;
}
// We're getting notified about all windows in the application (for example, NSPopovers) that change size when really we only care about
// the window the bar is in.
if (notif.Object != bar.Window)
{
return;
}
double maxSize = Math.Round(bar.Window.Frame.Width * 0.30f);
double minSize = Math.Round(bar.Window.Frame.Width * 0.25f);
item.MinSize = new CGSize((nfloat)Math.Max(220, minSize), 22);
item.MaxSize = new CGSize((nfloat)Math.Min(700, maxSize), 22);
bar.RepositionStatusLayers();
});
NSNotificationCenter.DefaultCenter.AddObserver(NSWindow.DidResizeNotification, resizeAction);
NSNotificationCenter.DefaultCenter.AddObserver(NSWindow.DidEndLiveResizeNotification, resizeAction);
return(item);
}
public void Refresh(UnityProjectState state)
{
bool updated = folderUpdater.Update(state);
DispatchService.GuiDispatch(() =>
{
if (updated)
{
// Updated folder structure, refresh tree
TreeView.RefreshNode(TreeView.GetRootNode());
}
else
{
// Created a new folder structure, replace old tree
TreeView.Clear();
foreach (var child in folderUpdater.RootFolder.Children)
{
TreeView.AddChild(child);
}
}
});
}
public void EndProgress()
{
DispatchService.GuiDispatch(delegate {
if (window != null)
{
window.IsWorking = false;
if (!asyncOperation.Success)
{
window.HasErrors = true;
}
else
{
window.HasNewData = true;
}
}
buttonStop.Sensitive = false;
progressStarted = false;
if (window == null)
{
buttonClear.Sensitive = false;
}
if (monitor.Errors.Length > 0)
{
IdeApp.Workbench.StatusBar.ShowMessage(Stock.Error, monitor.Errors [monitor.Errors.Length - 1].Message);
IdeApp.Workbench.StatusBar.SetMessageSourcePad(statusSourcePad);
}
else if (monitor.Messages.Length > 0)
{
IdeApp.Workbench.StatusBar.ShowMessage(monitor.Messages [monitor.Messages.Length - 1]);
IdeApp.Workbench.StatusBar.SetMessageSourcePad(statusSourcePad);
}
else if (monitor.Warnings.Length > 0)
{
IdeApp.Workbench.StatusBar.ShowMessage(Stock.Warning, monitor.Warnings [monitor.Warnings.Length - 1]);
IdeApp.Workbench.StatusBar.SetMessageSourcePad(statusSourcePad);
}
});
}
public XmlEditorViewContent()
{
xmlEditorWindow = new XmlEditorWindow(this);
view = xmlEditorWindow.View;
buffer = (SourceBuffer)view.Buffer;
buffer.Changed += BufferChanged;
view.SchemaCompletionDataItems = XmlSchemaManager.SchemaCompletionDataItems;
SetInitialValues();
// Watch for changes to the source editor properties.
propertyChangedHandler = (EventHandler <PropertyChangedEventArgs>)DispatchService.GuiDispatch(new EventHandler <PropertyChangedEventArgs>(SourceEditorPropertyChanged));
TextEditorProperties.Properties.PropertyChanged += propertyChangedHandler;
buffer.ModifiedChanged += new EventHandler(OnModifiedChanged);
XmlEditorAddInOptions.PropertyChanged += new EventHandler <PropertyChangedEventArgs>(XmlEditorPropertyChanged);
XmlSchemaManager.UserSchemaAdded += new EventHandler(UserSchemaAdded);
XmlSchemaManager.UserSchemaRemoved += new EventHandler(UserSchemaRemoved);
xmlEditorWindow.ShowAll();
}
private void AddNetwork(Network network)
{
lock (this) {
if (debug)
{
Console.Out.WriteLine("*** Adding network {0}.", network.NetworkName);
}
PointD position = new PointD(rng.Next(200), rng.Next(200));
Hashtable nodegroups = Hashtable.Synchronized(new Hashtable());
Hashtable node2nodegroup = Hashtable.Synchronized(new Hashtable());
network.Properties["nodegroups"] = nodegroups;
network.Properties["node2nodegroup"] = node2nodegroup;
network.Properties["rect"] = new Rectangle(position.X, position.Y, 0, 0);
networkZOrder.Add(network);
foreach (Node node in network.Nodes.Values)
{
AddNode(node, network);
}
network.NewIncomingConnection += delegate(Network eNetwork, LocalNodeConnection connection) { Gtk.Application.Invoke(delegate { this.QueueDraw(); }); };
network.ConnectingTo += delegate(Network eNetwork, LocalNodeConnection connection) { Gtk.Application.Invoke(delegate { this.QueueDraw(); }); };
network.UserOnline += (NodeOnlineOfflineEventHandler)DispatchService.GuiDispatch(new NodeOnlineOfflineEventHandler(network_UserOnline));
network.UserOffline += (NodeOnlineOfflineEventHandler)DispatchService.GuiDispatch(new NodeOnlineOfflineEventHandler(network_UserOffline));
network.UpdateNodeInfo += (UpdateNodeInfoEventHandler)DispatchService.GuiDispatch(new UpdateNodeInfoEventHandler(network_UpdateNodeInfo));
network.ConnectionUp += delegate(INodeConnection connection) { Gtk.Application.Invoke(delegate { this.QueueDraw(); }); };
network.ConnectionDown += delegate(INodeConnection connection) { Gtk.Application.Invoke(delegate { this.QueueDraw(); }); };
network.CleanupFinished += delegate(object sender, EventArgs e) { Gtk.Application.Invoke(delegate { this.QueueDraw(); }); };
}
this.QueueDraw();
}
void RunTest(ITreeNavigator nav, IExecutionHandler mode)
{
if (nav == null)
{
return;
}
UnitTest test = nav.DataItem as UnitTest;
if (test == null)
{
return;
}
TestSession.ResetResult(test.RootTest);
this.buttonRun.Sensitive = false;
this.buttonRunAll.Sensitive = false;
this.buttonStop.Sensitive = true;
IdeApp.Workbench.GetPad <TestPad> ().BringToFront();
runningTestOperation = testService.RunTest(test, mode);
runningTestOperation.Completed += (OperationHandler)DispatchService.GuiDispatch(new OperationHandler(TestSessionCompleted));
}
public void TakeScreenshot(string screenshotPath)
{
#if MAC
DispatchService.GuiDispatch(delegate {
try {
IntPtr handle = CGDisplayCreateImage(MainDisplayID());
CoreGraphics.CGImage screenshot = ObjCRuntime.Runtime.GetINativeObject <CoreGraphics.CGImage> (handle, true);
AppKit.NSBitmapImageRep imgRep = new AppKit.NSBitmapImageRep(screenshot);
var imageData = imgRep.RepresentationUsingTypeProperties(AppKit.NSBitmapImageFileType.Png);
imageData.Save(screenshotPath, true);
} catch (Exception e) {
Console.WriteLine(e);
throw;
}
});
#else
Sync(delegate {
try {
using (var bmp = new System.Drawing.Bitmap(System.Windows.Forms.Screen.PrimaryScreen.Bounds.Width,
System.Windows.Forms.Screen.PrimaryScreen.Bounds.Height)) {
using (var g = System.Drawing.Graphics.FromImage(bmp))
{
g.CopyFromScreen(System.Windows.Forms.Screen.PrimaryScreen.Bounds.X,
System.Windows.Forms.Screen.PrimaryScreen.Bounds.Y,
0, 0,
bmp.Size,
System.Drawing.CopyPixelOperation.SourceCopy);
}
bmp.Save(screenshotPath);
}
return(null);
} catch (Exception e) {
Console.WriteLine(e);
throw;
}
});
#endif
}
protected override void Run(object dataItem)
{
MessageHandler guiRun = delegate
{
var project = IdeApp.ProjectOperations.CurrentSelectedProject as DProject;
if (project == null)
{
return;
}
DProjectConfiguration conf = project.Configurations["Unittest"] as DProjectConfiguration;
if (conf == null)
{
return;
}
ProjectFile file = IdeApp.ProjectOperations.CurrentSelectedItem as ProjectFile;
if (file == null)
{
return;
}
string filePath = file.FilePath.FullPath;
IdeApp.Workbench.SaveAll();
if ((string)commandInfo.Command.Id == "MonoDevelop.D.Unittest.Commands.UnittestCommands.RunExternal")
{
UnittestCore.RunExternal(filePath, project, conf);
}
else
{
UnittestCore.Run(filePath, project, conf);
}
};
DispatchService.GuiDispatch(guiRun);
}
public static void ReportStashResult(IProgressMonitor monitor, MergeCommandResult result)
{
if (result.GetMergeStatus() == NGit.Api.MergeStatus.FAILED)
{
string msg = GettextCatalog.GetString("Stash operation failed.");
DispatchService.GuiDispatch(delegate
{
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
string txt = msg + "\n\n" + GetMergeResultErrorDetail(result);
monitor.ReportError(txt, null);
}
else if (result.GetMergeStatus() == NGit.Api.MergeStatus.NOT_SUPPORTED)
{
string msg = GettextCatalog.GetString("Operation not supported");
monitor.ReportError(msg, null);
DispatchService.GuiDispatch(delegate
{
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
}
else if (result.GetMergeStatus() == NGit.Api.MergeStatus.CONFLICTING)
{
string msg = GettextCatalog.GetString("Stash applied with conflicts");
DispatchService.GuiDispatch(delegate
{
IdeApp.Workbench.StatusBar.ShowWarning(msg);
});
}
else
{
string msg = GettextCatalog.GetString("Stash successfully applied");
DispatchService.GuiDispatch(delegate
{
IdeApp.Workbench.StatusBar.ShowMessage(msg);
});
}
}
public void Start(bool rerun = false)
{
if (!rerun && alreadyStarted)
{
return;
}
alreadyStarted = true;
ThreadPool.QueueUserWorkItem(delegate {
lock (updateLock) {
try {
History = Item.Repository.GetHistory(Item.Path, null);
VersionInfo = Item.Repository.GetVersionInfo(Item.Path, VersionInfoQueryFlags.IgnoreCache);
} catch (Exception ex) {
LoggingService.LogError("Error retrieving history", ex);
}
DispatchService.GuiDispatch(delegate {
OnUpdated(EventArgs.Empty);
});
isUpdated = true;
}
});
}
void UpdateReferences(IList <WebReferenceItem> items)
{
try {
UpdateReferenceContext = IdeApp.Workbench.StatusBar.CreateContext();
UpdateReferenceContext.BeginProgress(GettextCatalog.GetPluralString("Updating web reference", "Updating web references", items.Count));
DispatchService.ThreadDispatch(() => {
for (int i = 0; i < items.Count; i++)
{
DispatchService.GuiDispatch(() => UpdateReferenceContext.SetProgressFraction(Math.Max(0.1, (double)i / items.Count)));
try {
items [i].Update();
} catch (Exception ex) {
DispatchService.GuiSyncDispatch(() => {
MessageService.ShowException(ex, GettextCatalog.GetString("Failed to update Web Reference '{0}'", items [i].Name));
DisposeUpdateContext();
});
return;
}
}
DispatchService.GuiDispatch(() => {
// Make sure that we save all relevant projects, there should only be 1 though
foreach (var project in items.Select(i => i.Project).Distinct())
{
IdeApp.ProjectOperations.Save(project);
}
IdeApp.Workbench.StatusBar.ShowMessage(GettextCatalog.GetPluralString("Updated Web Reference {0}", "Updated Web References", items.Count, items[0].Name));
DisposeUpdateContext();
});
});
} catch {
DisposeUpdateContext();
throw;
}
}
void RunInstall(Gtk.Alignment commandBox, Update update)
{
installing = true;
ProgressBarMonitor monitorBar = new ProgressBarMonitor();
monitorBar.ShowErrorsDialog = true;
monitorBar.Show();
commandBox.Child.Destroy();
commandBox.Add(monitorBar);
IAsyncOperation oper = update.InstallAction(monitorBar.CreateProgressMonitor());
oper.Completed += delegate {
DispatchService.GuiDispatch(delegate {
monitorBar.Hide();
Gtk.Label result = new Gtk.Label();
if (oper.Success)
{
result.Text = GettextCatalog.GetString("Completed");
}
else
{
result.Text = GettextCatalog.GetString("Failed");
}
commandBox.Child.Destroy();
commandBox.Add(result);
result.Show();
installing = false;
if (installQueue.Count > 0)
{
installQueue.Dequeue()();
}
});
};
}
void AddFolderOverlay(Repository rep, string folder, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon, object dataObject)
{
Gdk.Pixbuf overlay = null;
VersionInfo vinfo = GetVersionInfo(rep, folder, dataObject, false);
if (vinfo == null)
{
ThreadPool.QueueUserWorkItem(x => {
VersionInfo info = GetVersionInfo(rep, folder, dataObject, true);
if (info != null)
{
DispatchService.GuiDispatch(() => UpdatePath(folder));
}
});
vinfo = VersionInfo.CreateUnversioned(folder, true);
}
else if (!vinfo.IsVersioned)
{
overlay = VersionControlService.LoadOverlayIconForStatus(VersionStatus.Unversioned);
}
else if (vinfo.IsVersioned && !vinfo.HasLocalChanges)
{
overlay = VersionControlService.overlay_controled;
}
else
{
overlay = VersionControlService.LoadOverlayIconForStatus(vinfo.Status);
}
if (overlay != null)
{
AddOverlay(ref icon, overlay);
if (closedIcon != null)
{
AddOverlay(ref closedIcon, overlay);
}
}
}
private void BuildChildNodesThreaded(object state)
{
TableNode node = state as TableNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
IDbFactory fac = node.ConnectionContext.DbFactory;
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.Columns))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ColumnsNode(node.ConnectionContext, node.Table));
});
}
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.PrimaryKeyConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.ForeignKeyConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.CheckConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.UniqueConstraint)
)
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ConstraintsNode(node.ConnectionContext, node.Table));
});
}
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.Trigger))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new TriggersNode(node.ConnectionContext));
});
}
//TODO: rules
DispatchService.GuiDispatch(delegate {
builder.Expanded = true;
});
}
protected void OnGetOutgoing()
{
VersionControlItem vcitem = GetItems()[0];
MercurialRepository repo = ((MercurialRepository)vcitem.Repository);
Dictionary <string, BranchType> branches = repo.GetKnownBranches(vcitem.Path);
string defaultBranch = string.Empty,
localPath = vcitem.IsDirectory? (string)vcitem.Path.FullPath: Path.GetDirectoryName(vcitem.Path.FullPath);
foreach (KeyValuePair <string, BranchType> branch in branches)
{
if (BranchType.Parent == branch.Value)
{
defaultBranch = branch.Key;
break;
}
} // check for parent branch
Dialogs.BranchSelectionDialog bsd = new Dialogs.BranchSelectionDialog(branches.Keys, defaultBranch, localPath, false, false, false, false);
try {
if ((int)Gtk.ResponseType.Ok == bsd.Run())
{
MercurialTask worker = new MercurialTask();
worker.Description = string.Format("Outgoing to {0}", bsd.SelectedLocation);
worker.Operation = delegate {
repo.LocalBasePath = MercurialRepository.GetLocalBasePath(localPath);
Revision[] history = repo.GetOutgoing(bsd.SelectedLocation);
DispatchService.GuiDispatch(() => {
var view = new MonoDevelop.VersionControl.Views.LogView(localPath, true, history, repo);
IdeApp.Workbench.OpenDocument(view, true);
});
};
worker.Start();
}
} finally {
bsd.Destroy();
}
} // OnGetOutgoing
private void RenameItemThreaded(object state)
{
object[] objs = state as object[];
TableNode node = objs[0] as TableNode;
string newName = objs[1] as string;
ISchemaProvider provider = node.Table.SchemaProvider;
if (provider.IsValidName(newName))
{
provider.RenameTable(node.Table, newName);
node.Refresh();
}
else
{
DispatchService.GuiDispatch(delegate() {
Services.MessageService.ShowError(String.Format(
"Unable to rename table '{0}' to '{1}'!",
node.Table.Name, newName
));
});
}
node.Refresh();
}
public void AddNodeBefore(object data)
{
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
Extension en = GetExtension();
ExtensionNodeType ntype = (ExtensionNodeType)data;
ExtensionNodeDescription newNode = new ExtensionNodeDescription(ntype.NodeName);
en.ExtensionNodes.Add(newNode);
CurrentNode.Expanded = true;
adata.SaveAddinManifest();
adata.NotifyChanged(false);
DispatchService.GuiDispatch(delegate {
ITreeNavigator nav = Tree.GetNodeAtObject(new ExtensionNodeInfo(newNode, false));
if (nav != null)
{
nav.Selected = true;
}
});
}
private void RenameItemThreaded(object state)
{
object[] objs = state as object[];
ViewNode node = objs[0] as ViewNode;
string newName = objs[1] as string;
IEditSchemaProvider provider = (IEditSchemaProvider)node.View.SchemaProvider;
if (provider.IsValidName(newName))
{
provider.RenameView(node.View, newName);
node.Refresh();
}
else
{
DispatchService.GuiDispatch(delegate() {
MessageService.ShowError(String.Format(
"Unable to rename view '{0}' to '{1}'!",
node.View.Name, newName
));
});
}
node.Refresh();
}
protected override void Run()
{
MessageHandler guiRun = delegate
{
var project = IdeApp.ProjectOperations.CurrentSelectedProject as DProject;
if (project == null)
{
return;
}
Pad pad = IdeApp.Workbench.GetPad <DProfilerPad>();
if (pad == null || !(pad.Content is DProfilerPad))
{
return;
}
DProfilerPad profilerPad = (DProfilerPad)pad.Content;
pad.Visible = true;
profilerPad.AnalyseTraceFile(project);
};
DispatchService.GuiDispatch(guiRun);
}
