private async void OnRename(ShellOperationEventArgs e)
        {
            if (e.Item.IsFolder)
            {
                // rename a key
                using (var key = OpenKey(true))
                {
                    if (key != null)
                    {
                        var path = System.IO.Path.Combine(Path ?? string.Empty, e.Item.DisplayName);
                        RegRenameKey(key.Handle, path, e.NewName);
                        e.NewId = new StringKeyShellItemId(e.NewName);
                        e.Item.NotifyRename(e.NewId);
                        e.HResult = ShellUtilities.S_OK;
                    }
                }
                return;
            }

            // rename a value (delete + set)
            using (var key = OpenKey(true))
            {
                if (key != null)
                {
                    if (key.GetValueNames().Contains(e.NewName, StringComparer.OrdinalIgnoreCase))
                    {
                        await WindowsUtilities.DoModelessAsync(() =>
                        {
                            MessageBox.Show(new Win32Window(e.HwndOwner), "The Registry Folder cannot rename '" + e.Item.DisplayName + "'. The specified value name already exists. Type another name and try again.", "Registry Folder", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        });
                    }
                    else
                    {
                        var value = key.GetValue(e.Item.DisplayName);
                        if (value == null)
                        {
                            await WindowsUtilities.DoModelessAsync(() =>
                            {
                                MessageBox.Show(new Win32Window(e.HwndOwner), "The Registry Folder cannot rename '" + e.Item.DisplayName + "'. The specified value name does not exists. Refresh the view and try again.", "Registry Folder", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            });
                        }
                        else
                        {
                            key.SetValue(e.NewName, value);
                            key.DeleteValue(e.Item.DisplayName, false);
                            e.NewId   = new StringKeyShellItemId(e.NewName);
                            e.HResult = ShellUtilities.S_OK;
                            e.Item.Parent?.NotifyUpdate();
                        }
                    }
                }
            }
        }
        protected override async void HandleInformationBarMenu(InformationBar bar, IntPtr hwndOwner, int id)
        {
            if (id == 1) // first item has id 1, etc.
            {
                await WindowsUtilities.DoModelessAsync(() =>
                {
                    System.Windows.Forms.MessageBox.Show(new Win32Window(hwndOwner), "UAC level is " + DiagnosticsInformation.GetTokenElevationType(), "Registry Folder");
                });

                return;
            }
        }
        protected async override void OnDragDropTarget(DragDropTargetEventArgs e)
        {
            e.Effect = DragDropEffects.Copy;
            if (e.Type == DragDropTargetEventType.DragDrop)
            {
                // you can use other formats but this one is the only one that contains PIDLs
                var list = string.Join(Environment.NewLine, e.DataObject.ItemsIdLists.Select(id => id.GetName(Core.WindowsShell.SIGDN.SIGDN_NORMALDISPLAY)));

                await WindowsUtilities.DoModelessAsync(() =>
                {
                    MessageBox.Show(null, "UAC level is " + DiagnosticsInformation.GetTokenElevationType(), "Registry Folder");
                });
            }
        }
Exemplo n.º 4
0
        protected override void OnDragDropTarget(DragDropTargetEventArgs e)
        {
            e.HResult = ShellUtilities.S_OK;
            var paths = GetPaths(e);

            if (paths.Count > 0)
            {
                e.Effect = DragDropEffects.All;
            }

            if (e.Type == DragDropTargetEventType.DragDrop)
            {
                // file operation events need an STA thread
                WindowsUtilities.DoModelessAsync(() =>
                {
                    using (var fo = new FileOperation(true))
                    {
                        fo.PostCopyItem += (sender, e2) =>
                        {
                            // we could add some logic here
                        };

                        if (paths.Count == 1)
                        {
                            fo.CopyItem(paths[0], FileSystemPath, null);
                        }
                        else
                        {
                            fo.CopyItems(paths, FileSystemPath);
                        }
                        fo.SetOperationFlags(FOF.FOF_ALLOWUNDO | FOF.FOF_NOCONFIRMMKDIR | FOF.FOF_RENAMEONCOLLISION);
                        fo.PerformOperations();
                        NotifyUpdate();
                    }
                });
            }
        }
        private async void OnShellMenuItemInvoke(object sender, ShellMenuInvokeEventArgs e)
        {
            // e.MenuItem can be null for standard commands
            var menu = (ShellMenu)sender;

            // log something (if a logger is configured)
            menu.Server.Configuration?.Logger?.Log(TraceLevel.Info, "Shell Item '" + e.MenuItem + "' (cmd:" + e.Command + ") called.");

            var mc = Conversions.ChangeType(e.MenuItem?.Tag, MenuCommand.Unknown);

            switch (mc)
            {
            case MenuCommand.Modify:
                if (e.Items.Count == 1)                // we only support modification of one value at a time
                {
                    using (var form = new EditValue()) // note because of async + await, Dispose will happen in continuing task
                    {
                        var valueItem = (RegistryValueItem)e.Items[0];
                        form.LoadEditor(BaseParent.Hive, Path, valueItem.KeyName);
                        await WindowsUtilities.ShowModelessAsync(form, e.HwndOwner).ContinueWith((task) =>
                        {
                            if (task.Result == DialogResult.OK)
                            {
                                using (var key = OpenKey(true))
                                {
                                    key.SetValue(valueItem.KeyName, form.NewValue);
                                    valueItem.Parent?.NotifyUpdate();
                                }
                            }
                        });
                    }
                    return;
                }
                break;

            case MenuCommand.NewKey:
                using (var key = OpenKey(true))
                {
                    if (key != null)
                    {
                        var newName = GetNewName("New Key #", key.GetSubKeyNames());
                        try
                        {
                            key.CreateSubKey(newName);
                            e.Folder.RefreshShellViews();
                            await SelectAndEdit(newName);
                        }
                        catch (Exception ex)
                        {
                            // probably an access denied error
                            await WindowsUtilities.DoModelessAsync(() =>
                            {
                                MessageBox.Show(new Win32Window(e.HwndOwner), "The Registry Folder cannot set a value here: " + ex.Message, "Registry Folder", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            });
                        }
                    }
                }
                break;

            case MenuCommand.NewValueString:
            case MenuCommand.NewValueBinary:
            case MenuCommand.NewValueDWord:
            case MenuCommand.NewValueQWord:
            case MenuCommand.NewValueMultiString:
            case MenuCommand.NewValueExpandString:
                var kind = (RegistryValueKind)mc;
                using (var key = OpenKey(true))
                {
                    if (key != null)
                    {
                        var newName = GetNewName("New Value #", key.GetValueNames());
                        try
                        {
                            key.SetValue(newName, GetDefaultValue(kind), kind);
                            e.Folder.RefreshShellViews();
                            await SelectAndEdit(newName);
                        }
                        catch (Exception ex)
                        {
                            // probably an access denied error
                            await WindowsUtilities.DoModelessAsync(() =>
                            {
                                MessageBox.Show(new Win32Window(e.HwndOwner), "The Registry Folder cannot set a value here: " + ex.Message, "Registry Folder", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            });
                        }
                    }
                }
                break;
            }
        }