Пример #1
0
        public MainForm()
        {
            InitializeComponent();

            m_uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();

            var newAtom = Win32A.GlobalAddAtom("RTSS_time_reader");

            if (newAtom != 0)
            {
                m_globalHotkeyAtom = newAtom;
            }

            m_flushTimerPeriod = new TimeSpan(0, 0, 1);

            m_flushFileTimer           = new System.Timers.Timer();
            m_flushFileTimer.AutoReset = true;
            m_flushFileTimer.Interval  = m_flushTimerPeriod.TotalMilliseconds;
            m_flushFileTimer.Elapsed  += OnFlushFileTimerElapsed;

            m_stopWritingTimer           = new System.Timers.Timer();
            m_stopWritingTimer.AutoReset = false;
            m_stopWritingTimer.Elapsed  += StopWritingFileOnTimer;

            txtFolder.Text = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

            m_pipeReader = new PipeReader();
            m_pipeReader.StateChanged += (p_sender, p_args) => UpdateStatus();
        }
Пример #2
0
        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            var hotkey = new Hotkey(Win32A.KeyModifiers.Alt | Win32A.KeyModifiers.Ctrl, Keys.NumLock);

            var registered = RegisterHotkey(m_globalHotkeyAtom.Value, hotkey);

            if (registered)
            {
                RegistredHotkey = hotkey;
            }
            else
            {
                txtHotkeyEditor.Text = Win32A.KeyModifiers.None.ToString();
                if (m_globalHotkeyAtom.HasValue)
                {
                    Win32A.GlobalDeleteAtom(m_globalHotkeyAtom.Value);
                    m_globalHotkeyAtom = null;
                }
            }

            UpdateStatus();
            StartListening();
        }
Пример #3
0
        private void txtHotkeyEditor_Enter(object sender, EventArgs e)
        {
            var dialog = new HotkeyEditorDialog();

            dialog.RegistredHotkey = RegistredHotkey;

            dialog.HotkeyProcessor = this;
            if (dialog.ShowDialog(this) == DialogResult.OK)
            {
                if (m_globalHotkeyAtom.HasValue)
                {
                    Win32A.UnregisterHotKey(this.Handle, m_globalHotkeyAtom.Value);

                    var win32Error = Marshal.GetLastWin32Error();
                    if (win32Error != Win32A.ERROR_SUCCESS)
                    {
                        var ex = new Win32Exception();
                        MessageBox.Show(this, ex.Message, "Cannot regitster hotkey", MessageBoxButtons.OK,
                                        MessageBoxIcon.Warning);
                    }
                }

                RegistredHotkey    = dialog.NewHotkey;
                m_globalHotkeyAtom = dialog.NewHotkeyAtom;
            }

            this.ActiveControl = null;
        }
Пример #4
0
        public void UnregisterHotkey(ushort?p_atom)
        {
            if (p_atom.HasValue)
            {
                var atom = p_atom.Value;

                Win32A.UnregisterHotKey(this.Handle, atom);
                Win32A.GlobalDeleteAtom(atom);
            }
        }
Пример #5
0
        private bool CreatePipe()
        {
            var result = false;

            try
            {
                string fullPath = PipeFullName;

                var handle = Win32A.CreateNamedPipe(fullPath
                                                    , (uint)Win32A.PipeOpenModeFlags.PIPE_ACCESS_DUPLEX
                                                    ,
                                                    (uint)
                                                    (Win32A.PipeModeFlags.PIPE_TYPE_MESSAGE | Win32A.PipeModeFlags.PIPE_READMODE_MESSAGE |
                                                     Win32A.PipeModeFlags.PIPE_WAIT)
                                                    , 1
                                                    , 1024, 1024
                                                    , 0, IntPtr.Zero);

                if (handle.ToInt32() == -1)
                {
                    var win32Error = Marshal.GetLastWin32Error();
                    if (win32Error != Win32A.ERROR_SUCCESS)
                    {
                        throw new Win32Exception(win32Error);
                    }
                }

                var safePipeHandle = new SafePipeHandle(handle, true);
                m_pipeStream = new NamedPipeServerStream(PipeDirection.InOut, false, false, safePipeHandle);
                SetFlag(PipeReaderState.PipeCreated, true);

                m_lastException = null;

                result = true;
                WaitForConnection();
            }
            catch (TimeoutException exception)
            {
                m_lastException = exception;
                SetFlag(PipeReaderState.Error, true);
            }
            catch (System.OperationCanceledException)
            {
            }
            catch (Exception exception)
            {
                m_lastException = exception;
                ClosePipe();
                SetFlag(PipeReaderState.Error, true);
            }

            return(result);
        }
Пример #6
0
        private void btnOk_Click(object sender, EventArgs e)
        {
            NewHotkeyAtom = Win32A.GlobalAddAtom("RTSS_time_reader" + GetHashCode().ToString());

            var registred = HotkeyProcessor.RegisterHotkey(NewHotkeyAtom, NewHotkey);

            if (false == registred)
            {
                DialogResult = DialogResult.None;
            }
            else
            {
                DialogResult = DialogResult.OK;
            }
        }
Пример #7
0
        public void DropConnection()
        {
            if (false == IsConnectionAccepted)
            {
                throw new InvalidOperationException("Invalid object state");
            }

            m_stopReadWriteLoops = true;
            lock (m_threadHandleLocker)
            {
                if (ReadFlag(PipeReaderState.PipeIO) && m_taskThreadHandle != Win32A.INVALID_HANDLE_PTR)
                {
                    Win32A.CancelSynchronousIo(m_taskThreadHandle);
                }
            }
        }
Пример #8
0
        public bool RegisterHotkey(ushort p_atom, Hotkey p_hotkey)
        {
            var result = Win32A.RegisterHotKey(this.Handle, p_atom, p_hotkey.Modifiers, (int)p_hotkey.Key);

            if (false == result)
            {
                var win32Error = Marshal.GetLastWin32Error();
                if (win32Error != Win32A.ERROR_SUCCESS)
                {
                    var ex = new Win32Exception();
                    MessageBox.Show(this, ex.Message, "Cannot regitster hotkey", MessageBoxButtons.OK,
                                    MessageBoxIcon.Warning);
                }
            }

            return(result);
        }
Пример #9
0
        protected void ClosePipe()
        {
            ContinueAcceptingConnections = false;

            lock (m_threadHandleLocker)
            {
                if (ReadFlag(PipeReaderState.PipeIO) && m_taskThreadHandle != Win32A.INVALID_HANDLE_PTR)
                {
                    Win32A.CancelSynchronousIo(m_taskThreadHandle);
                }
            }

            lock (m_pipeStreamLocker)
            {
                if (m_pipeStream != null)
                {
                    m_pipeStream.Dispose();
                    m_pipeStream = null;
                }
            }

            SetFlag(PipeReaderState.ConnectionAccepted, false);
            SetFlag(PipeReaderState.PipeCreated, false);
        }
Пример #10
0
        private void WaitForConnection()
        {
            SetFlag(PipeReaderState.PipeIO, true);
            try
            {
                m_pipeStream.WaitForConnection();

                uint processId;
                if (Win32A.GetNamedPipeClientProcessId(m_pipeStream.SafePipeHandle.DangerousGetHandle(), out processId))
                {
                    ClientProcessId = processId;

                    using (var process = Process.GetProcessById((int)ClientProcessId))
                    {
                        ProcessName = process.ProcessName;
                    }
                }
            }
            finally
            {
                SetFlag(PipeReaderState.PipeIO, false);
            }
            SetFlag(PipeReaderState.ConnectionAccepted, true);
        }
Пример #11
0
        public void StartAcceptingConnections()
        {
            SetFlag(PipeReaderState.Started, true);
            ClientProcessId = Win32A.INVALID_HANDLE_VALUE;

            var previousTask = m_task;

            m_stopReadWriteLoops = false;

            m_task = Task.Factory.StartNew(
                () =>
            {
                lock (m_threadHandleLocker)
                {
                    var threadId       = Win32A.GetCurrentThreadId();
                    m_taskThreadHandle = Win32A.OpenThread(0x40000000, false, threadId);
                }

                try
                {
                    if (previousTask != null)
                    {
                        try
                        {
                            previousTask.Wait();
                        }
                        catch (Exception)
                        {
                            ;     //do nothing
                        }
                    }

                    if (false == CreatePipe())
                    {
                        return;
                    }

                    if (false == OpenFile())
                    {
                        ClosePipe();
                        return;
                    }

                    SetFlag(PipeReaderState.FileOpened, true);

                    MainLoop();
                }
                finally
                {
                    lock (m_threadHandleLocker)
                    {
                        if (m_taskThreadHandle != Win32A.INVALID_HANDLE_PTR)
                        {
                            Win32A.CloseHandle(m_taskThreadHandle);
                        }
                        m_taskThreadHandle = Win32A.INVALID_HANDLE_PTR;
                        m_task             = null;
                    }

                    State = PipeReaderState.None;
                }
            }
                , CancellationToken.None
                , TaskCreationOptions.LongRunning
                , TaskScheduler.Default
                );
        }