public void Copy()
{
if (hexEditContainer.HasSomethingSelected)
{
ClipboardWrapper.SetText(hexEditContainer.Copy());
}
}
public override void Run()
{
string clipboardText = ClipboardWrapper.GetText();
if (string.IsNullOrEmpty(clipboardText))
{
return;
}
IViewContent viewContent = WorkbenchSingleton.Workbench.ActiveViewContent;
if (viewContent == null || !(viewContent is ITextEditorProvider))
{
return;
}
ITextEditor textEditor = ((ITextEditorProvider)viewContent).TextEditor;
if (textEditor == null)
{
return;
}
using (textEditor.Document.OpenUndoGroup())
Run(textEditor, clipboardText);
}
public void CopySelectionToClipboard()
{
StringBuilder b = new StringBuilder();
foreach (Task t in this.SelectedTasks)
{
if (b.Length > 0)
{
b.AppendLine();
}
b.Append(t.Description);
if (!string.IsNullOrEmpty(t.FileName))
{
b.Append(" - ");
b.Append(t.FileName);
if (t.Line >= 0)
{
b.Append(':');
b.Append(t.Line + 1);
if (t.Column > 0)
{
b.Append(',');
b.Append(t.Column + 1);
}
}
}
}
ClipboardWrapper.SetText(b.ToString());
}
private void ButtonCopyClick(object sender, EventArgs e)
{
StringBuilder versionInfo = new StringBuilder();
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
AssemblyName name = a.GetName();
versionInfo.Append(name.Name);
versionInfo.Append(",");
versionInfo.Append(name.Version.ToString());
versionInfo.Append(",");
try
{
versionInfo.Append(a.Location);
}
catch (NotSupportedException)
{
versionInfo.Append("dynamic");
}
versionInfo.Append(Environment.NewLine);
}
ClipboardWrapper.SetDataObject(versionInfo.ToString());
}
private void ClipChanged()
{
IDataObject iData = ClipboardWrapper.GetDataObject();
if (iData == null)
{
return;
}
ClipboardFormat?format = null;
foreach (var f in formats)
{
if (iData.GetDataPresent(f))
{
format = (ClipboardFormat)Enum.Parse(typeof(ClipboardFormat), f);
break;
}
}
object data = iData.GetData(format.ToString());
if (data == null || format == null)
{
return;
}
if (OnClipboardChange != null)
{
OnClipboardChange((ClipboardFormat)format, data);
}
}
public static bool DoEnablePaste(ISolutionFolderNode container)
{
IDataObject dataObject = ClipboardWrapper.GetDataObject();
if (dataObject == null)
{
return(false);
}
if (dataObject.GetDataPresent(typeof(ISolutionFolder).ToString()))
{
string guid = dataObject.GetData(typeof(ISolutionFolder).ToString()).ToString();
ISolutionFolder solutionFolder = container.Solution.GetSolutionFolder(guid);
if (solutionFolder == null || solutionFolder == container)
{
return(false);
}
if (solutionFolder is ISolutionFolderContainer)
{
return(solutionFolder.Parent != container &&
!((ISolutionFolderContainer)solutionFolder).IsAncestorOf(container.Folder));
}
else
{
return(solutionFolder.Parent != container);
}
}
return(false);
}
public static void DoPaste(ISolutionFolderNode folderNode)
{
if (!DoEnablePaste(folderNode))
{
LoggingService.Warn("SolutionFolderNode.DoPaste: Pasting was not enabled.");
return;
}
ExtTreeNode folderTreeNode = (ExtTreeNode)folderNode;
IDataObject dataObject = ClipboardWrapper.GetDataObject();
if (dataObject.GetDataPresent(typeof(ISolutionFolder).ToString()))
{
string guid = dataObject.GetData(typeof(ISolutionFolder).ToString()).ToString();
ISolutionFolder solutionFolder = folderNode.Solution.GetSolutionFolder(guid);
if (solutionFolder != null)
{
folderNode.Container.AddFolder(solutionFolder);
ExtTreeView treeView = (ExtTreeView)folderTreeNode.TreeView;
foreach (ExtTreeNode node in treeView.CutNodes)
{
ExtTreeNode oldParent = node.Parent as ExtTreeNode;
node.Remove();
node.AddTo(folderTreeNode);
if (oldParent != null)
{
oldParent.Refresh();
}
}
ProjectService.SaveSolution();
}
}
folderTreeNode.Expand();
}
public override void Run()
{
string clipboardText = ClipboardWrapper.GetText();
if (string.IsNullOrEmpty(clipboardText))
{
return;
}
//IViewContent viewContent = WorkbenchSingleton.Workbench.ActiveViewContent;
ITextEditorControlProvider viewContent = WorkbenchSingleton.ActiveControl as ITextEditorControlProvider;
if (viewContent == null || !(viewContent is ITextEditorControlProvider))
{
return;
}
TextEditorControl textEditor = ((ITextEditorControlProvider)viewContent).TextEditorControl;
if (textEditor == null)
{
return;
}
textEditor.BeginUpdate();
textEditor.Document.UndoStack.StartUndoGroup();
try {
Run(textEditor, clipboardText);
} finally {
textEditor.Document.UndoStack.EndUndoGroup();
textEditor.EndUpdate();
}
textEditor.Refresh();
}
void CopyButtonClick(object sender, EventArgs e)
{
StringBuilder versionInfo = new StringBuilder();
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
AssemblyName name = asm.GetName();
versionInfo.Append(name.Name);
versionInfo.Append(",");
versionInfo.Append(name.Version.ToString());
versionInfo.Append(",");
try
{
versionInfo.Append(asm.Location);
}
catch (NotSupportedException)
{
// assembly.Location throws NotSupportedException for assemblies emitted using
// Reflection.Emit by custom controls used in the forms designer
versionInfo.Append("dynamic");
}
versionInfo.Append(Environment.NewLine);
}
ClipboardWrapper.SetText(versionInfo.ToString());
}
private void CopyInfoToClipboard(bool copyToClipboard)
{
if (!copyToClipboard)
{
return;
}
// TODO: Replace ClipboardWrapper.SetText() with abstraction
string exceptionText = BuildExceptionText();
if (Application.OleRequired() == ApartmentState.STA)
{
ClipboardWrapper.SetText(exceptionText);
}
else
{
var thread = new Thread((ThreadStart) delegate
{
ClipboardWrapper.SetText(exceptionText);
});
thread.Name = nameof(CopyInfoToClipboard);
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
}
}
public override void Run()
{
ResourceEditorControl editor = ((ResourceEditWrapper)WorkbenchSingleton.Workbench.ActiveViewContent).ResourceEditor;
if (editor.ResourceList.SelectedItems.Count > 0)
{
ClipboardWrapper.SetText(editor.ResourceList.SelectedItems[0].Text);
}
}
/// <summary>
/// Starts the command
/// </summary>
public override void Run()
{
Editor editor = Owner as Editor;
if (editor != null)
{
ClipboardWrapper.SetText(editor.CopyAsHexString());
}
}
public override void Run()
{
IWorkbenchWindow window = Owner as IWorkbenchWindow;
if (window != null && window.ViewContent.FileName != null)
{
ClipboardWrapper.SetText(window.ViewContent.FileName);
}
}
public override void Paste()
{
IDataObject dataObject = ClipboardWrapper.GetDataObject();
if (dataObject == null)
{
return;
}
if (dataObject.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])dataObject.GetData(DataFormats.FileDrop);
foreach (string fileName in files)
{
if (System.IO.Directory.Exists(fileName))
{
if (!FileUtility.IsBaseDirectory(fileName, Directory))
{
CopyDirectoryHere(fileName, false);
}
}
else
{
CopyFileHere(fileName, false);
}
}
}
else if (dataObject.GetDataPresent(typeof(FileNode)))
{
FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(FileNode).ToString());
if (File.Exists(clipboardObject.FileName))
{
CopyFileHere(clipboardObject.FileName, clipboardObject.PerformMove);
if (clipboardObject.PerformMove)
{
Clipboard.Clear();
}
}
}
else if (dataObject.GetDataPresent(typeof(DirectoryNode)))
{
FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(DirectoryNode).ToString());
if (System.IO.Directory.Exists(clipboardObject.FileName))
{
CopyDirectoryHere(clipboardObject.FileName, clipboardObject.PerformMove);
if (clipboardObject.PerformMove)
{
Clipboard.Clear();
}
}
}
ProjectService.SaveSolution();
}
public void CopyPRCGToClipboardClicked()
{
if (Model.SelectedWorkUnitRow == null)
{
return;
}
string projectString = Model.SelectedWorkUnitRow.ToProjectString();
// TODO: Replace ClipboardWrapper.SetText() with abstraction
ClipboardWrapper.SetText(projectString);
}
public override void Run()
{
if (this.Owner is WatchPad)
{
WatchPad pad = (WatchPad)this.Owner;
var node = pad.WatchList.SelectedNode;
if (node != null && node.Node is ExpressionNode)
{
string text = ((ExpressionNode)node.Node).FullText;
ClipboardWrapper.SetText(text);
}
}
}
private void App_OnStartup(object sender, StartupEventArgs e)
{
WcfMutexSingleInstanceRunner instanceRunner = new WcfMutexSingleInstanceRunner("8E756836-F0DE-490E-AEA5-EDAADF9C5FF8");
if (!instanceRunner.Run(e))
{
instanceRunner.Dispose();
Shutdown(0);
}
m_dispatcher = new DispatcherWrapper(Dispatcher.CurrentDispatcher);
instanceRunner.SecondInstanceStarted += CreateSettingsWindow;
#region Upgrade settings
if (!HandMeAFile.Properties.Settings.Default.Updated)
{
HandMeAFile.Properties.Settings.Default.Updated = true;
HandMeAFile.Properties.Settings.Default.Upgrade();
HandMeAFile.Properties.Settings.Default.Save();
}
#endregion
IClipboard clipboard = new ClipboardWrapper();
m_packsRepository = new ClipboardFilesRepository(new ClipboardNotifier(), clipboard);
m_settings = new SettingsStorage(m_packsRepository, new FilePackSerializer(new XDocumentProvider()));
m_packsRepository.Init(m_settings.FilePacks.Select(p => p.SetCount((p.ClipboardCount + 1) / 2)).ToArray());
IProvideContextMenu contextMenuProvider = new ContextMenuProvider();
IContextMenu contextMenu = contextMenuProvider.Provide(new IMenuItem[0]);
IProvideMenuItem menuItemProvider = new MenuItemProvider();
IMenuItem settingsMenuItem = menuItemProvider.Provide("Settings");
IMenuItem exitMenuItem = menuItemProvider.Provide("Exit");
contextMenu.Add(menuItemProvider.Provide("-"));
contextMenu.Add(settingsMenuItem);
contextMenu.Add(exitMenuItem);
settingsMenuItem.Click += CreateSettingsWindow;
exitMenuItem.Click += (senderObj, args) => Shutdown(0);
m_contextUpdater = new ContextMenuUpdater(m_packsRepository, contextMenu, menuItemProvider, clipboard);
IRunTheTrayApp trayApplication = new TrayApplication(contextMenu,
new ApplicationWrapper(this),
new NotifyIconProvider(),
new StaticIconProvider(new IconWrapper(HandMeAFile.Properties.Resources.HandMeAFile)),
doubleClickAction: CreateSettingsWindow);
trayApplication.Run();
}
public void Copy()
{
if (resourceEditor.ResourceList.SelectedItems.Count < 1)
{
return;
}
Hashtable tmphash = new Hashtable();
foreach (ListViewItem item in resourceEditor.ResourceList.SelectedItems)
{
object resourceValue = GetClonedResource(resourceEditor.ResourceList.Resources[item.Text].ResourceValue);
tmphash.Add(item.Text, resourceValue); // copy a clone to clipboard
}
ClipboardWrapper.SetDataObject(tmphash);
}
private void CopyInfoToClipboard()
{
if (copyErrorCheckBox.Checked)
{
if (Application.OleRequired() == ApartmentState.STA)
{
ClipboardWrapper.SetText(GetExceptionDetailMessage());
}
else
{
Thread th = new Thread((ThreadStart) delegate { ClipboardWrapper.SetText(GetExceptionDetailMessage()); });
th.SetApartmentState(ApartmentState.STA);
th.Start();
}
}
}
public void Paste()
{
if (resourceEditor.ResourceList.WriteProtected)
{
return;
}
IDataObject dob = ClipboardWrapper.GetDataObject();
if (dob == null)
{
return;
}
if (dob.GetDataPresent(typeof(Hashtable).FullName))
{
Hashtable tmphash = (Hashtable)dob.GetData(typeof(Hashtable));
foreach (DictionaryEntry entry in tmphash)
{
object resourceValue = GetClonedResource(entry.Value);
ResourceItem item;
if (!resourceEditor.ResourceList.Resources.ContainsKey((string)entry.Key))
{
item = new ResourceItem(entry.Key.ToString(), resourceValue);
}
else
{
int count = 1;
string newNameBase = entry.Key.ToString() + " ";
string newName = newNameBase + count.ToString();
while (resourceEditor.ResourceList.Resources.ContainsKey(newName))
{
count++;
newName = newNameBase + count.ToString();
}
item = new ResourceItem(newName, resourceValue);
}
resourceEditor.ResourceList.Resources.Add(item.Name, item);
resourceEditor.ResourceList.OnChanged();
}
resourceEditor.ResourceList.InitializeListView();
}
}
public void Cut()
{
if (resourceEditor.ResourceList.WriteProtected || resourceEditor.ResourceList.SelectedItems.Count < 1)
{
return;
}
Hashtable tmphash = new Hashtable();
foreach (ListViewItem item in resourceEditor.ResourceList.SelectedItems)
{
tmphash.Add(item.Text, resourceEditor.ResourceList.Resources[item.Text].ResourceValue);
resourceEditor.ResourceList.Resources.Remove(item.Text);
resourceEditor.ResourceList.Items.Remove(item);
}
resourceEditor.ResourceList.OnChanged();
ClipboardWrapper.SetDataObject(tmphash);
}
void CopyInfoToClipboard()
{
if (copyErrorCheckBox.Checked)
{
if (Application.OleRequired() == ApartmentState.STA)
{
ClipboardWrapper.SetText(getClipboardString());
}
else
{
Thread th = new Thread((ThreadStart) delegate {
ClipboardWrapper.SetText(getClipboardString());
});
th.Name = "CopyInfoToClipboard";
th.SetApartmentState(ApartmentState.STA);
th.Start();
}
}
}
public ContextMenuStrip GetContextMenu()
{
ContextMenuStrip menu = new ContextMenuStrip();
ToolStripMenuItem copyItem;
copyItem = new ToolStripMenuItem();
copyItem.Text = ResourceService.GetString("MainWindow.Windows.Debug.LocalVariables.CopyToClipboard");
copyItem.Checked = false;
copyItem.Click += delegate {
ClipboardWrapper.SetText(fullText);
};
ToolStripMenuItem hexView;
hexView = new ToolStripMenuItem();
hexView.Text = ResourceService.GetString("MainWindow.Windows.Debug.LocalVariables.ShowInHexadecimal");
hexView.Checked = DebuggingOptions.Instance.ShowValuesInHexadecimal;
hexView.Click += delegate {
// refresh all pads that use ValueNode for display
DebuggingOptions.Instance.ShowValuesInHexadecimal = !DebuggingOptions.Instance.ShowValuesInHexadecimal;
// always check if instance is null, might be null if pad is not opened
if (LocalVarPad.Instance != null)
{
LocalVarPad.Instance.RefreshPad();
}
if (WatchPad.Instance != null)
{
WatchPad.Instance.RefreshPad();
}
};
menu.Items.AddRange(new ToolStripItem[] {
copyItem,
hexView
});
return(menu);
}
public static bool DoEnablePaste(ISolutionFolderNode container)
{
return(DoEnablePaste(container, ClipboardWrapper.GetDataObject()));
}
public override void Cut()
{
DoPerformCut = true;
ClipboardWrapper.SetDataObject(new DataObject(typeof(ISolutionFolder).ToString(), folder.IdGuid));
}
public override void Run()
{
IWorkbenchWindow window = Owner as IWorkbenchWindow;
ClipboardWrapper.SetText(window.ActiveViewContent.PrimaryFileName ?? "");
}
public override void Cut()
{
DoPerformCut = true;
ClipboardWrapper.SetDataObject(FileOperationClipboardObject.CreateDataObject(this, true));
}
public override void Copy()
{
ClipboardWrapper.SetDataObject(FileOperationClipboardObject.CreateDataObject(this, false));
}
void CopyInfoToClipboard()
{
ClipboardWrapper.SetText(GetClipboardString());
}
public void Paste()
{
hexEditContainer.Paste(ClipboardWrapper.GetText());
}
