コード例 #1
0
ファイル: EXOxtenderApp.cs プロジェクト: EXOPC/EXOxtender
 private void getBrightnessLevels()
 {
     if (brightnessLevels == null)
     {
         EXOxtenderLibrary.Brightness _bri0 = new EXOxtenderLibrary.Brightness();
         brightnessLevels = _bri0.GetBrightnessLevels();
     }
 }
コード例 #2
0
ファイル: EXOxtenderApp.cs プロジェクト: EXOPC/EXOxtender
        private void sendBrightness(int message)
        {
            EXOxtenderLibrary.Brightness _bri = new EXOxtenderLibrary.Brightness();
            int _returnValue = Convert.ToInt32(_bri.getBrightness());

            //textBox1.Text += "hWnd:" + m.HWnd.ToString() + " Msg:" + m.Msg.ToString() + " arg0:" + _arg0 + " arg1:" + _arg1 + " arg2:" + _arg2 + " arg3:" + _arg3 + "\r\n";
            //textBox1.Text += "ReturnCode:" + _returnValue + "\r\n";

            MessageHelper.PostMessage(_exoUI, EXOMsg.WM_APP + 5, MessageHelper.MakeWParam(message, 1), MessageHelper.MakeLParam(_returnValue, brightnessLevels.Length));
        }
コード例 #3
0
ファイル: EXOxtenderApp.cs プロジェクト: EXOPC/EXOxtender
        protected override void WndProc(ref Message m)
        {
            try
            {
                _exoUI = MessageHelper.FindWindow_INTPTR(null, _windowName);

                if (_exoUI != IntPtr.Zero && m.Msg == EXOMsg.WM_APP + 5)
                {

                    //SET UP VARIABLES
                    EXOxtenderLibrary.VolumeControl _vol;

                    int _hWnd = m.HWnd.ToInt32();
                    int _arg0 = MessageHelper.LoWord(m.WParam.ToInt32());
                    int _arg1 = MessageHelper.HiWord(m.WParam.ToInt32());
                    int _arg2 = MessageHelper.LoWord(m.LParam.ToInt32());
                    int _arg3 = MessageHelper.HiWord(m.LParam.ToInt32());
                    //EXO UI MessageID = 32773;

                    textBox1.Text += string.Format("WM_APP + 5 received: arg0:{0} arg1:{1} arg2:{2} arg3:{3}", _arg0, _arg1, _arg2, _arg3) + Environment.NewLine;

                    switch (_arg0)
                    {
                        case EXOMsg.EX_SHUTDOWN:
                            this.Close();
                            break;

                        case EXOMsg.EX_WIFI_GET:

                            lock (wifiMutex)
                            {
                                try
                                {
                                    bool setMonitoring;

                                    if (_arg1 == 1)
                                        setMonitoring = true;
                                    else if (_arg1 == 2)
                                        setMonitoring = false;
                                    else
                                        setMonitoring = isMonitoringWifi;

                                    setCurrentWlanInterface(setMonitoring);

                                    if (_arg1 == 0 || _arg1 == 1)
                                    {
                                        sendWifiStatus(EXOMsg.EX_WIFI_INFO);
                                    }
                                }
                                catch (Exception e)
                                {
                                    trace("wifi get exception: " + e.Message);
                                    trace(e.StackTrace);
                                }
                            }

                            break;

                        case EXOMsg.EX_WIFI_SET:

                            try
                            {
                                if (_arg1 == 1 || _arg1 == 2)
                                    wifiSet(_arg1);
                            }
                            catch (Exception e)
                            {
                                trace("wifi set exception: " + e.Message);
                                trace(e.StackTrace);
                            }

                            break;

                        case EXOMsg.EX_DISP_GET:

                            lock (brightnessMutex)
                            {
                                getBrightnessLevels();

                                if (_arg1 == 1)
                                    isMonitoringBrightness = true;
                                else if (_arg1 == 2)
                                    isMonitoringBrightness = false;

                                if (_arg1 == 0 || _arg1 == 1)
                                    sendBrightness(EXOMsg.EX_DISP_INFO);
                            }

                            break;

                        case EXOMsg.EX_DISP_SET:

                            lock (brightnessMutex)
                            {
                                if (_arg1 != 0) // 0 means ignore
                                {
                                    getBrightnessLevels();

                                    EXOxtenderLibrary.Brightness _bri0 = new EXOxtenderLibrary.Brightness();

                                    if (_arg1 == 2) // 2 means OFF
                                        _arg2 = 0;  // set it to minimum

                                    if (_arg2 < 0) _arg2 = 0;
                                    if (_arg2 >= brightnessLevels.Length)
                                        _arg2 = brightnessLevels.Length - 1;

                                    _bri0.BrightnessLevel = brightnessLevels[_arg2];
                                    _bri0.setBrightnessLevel();

                                    //int _returnValue0 = Convert.ToInt32(_bri0.getBrightness());

                                    //textBox1.Text += "EX_DISP_SET - New level:" + _arg2.ToString() + "\r\n";
                                    //textBox1.Text += "hWnd:" + m.HWnd.ToString() + " Msg:" + m.Msg.ToString() + " arg0:" + _arg0 + " arg1:" + _arg1 + " arg2:" + _arg2 + " arg3:" + _arg3 + "\r\n";
                                    //textBox1.Text += "ReturnCode:" + _arg2.ToString() + "\r\n";
                                }
                            }
                            break;

                        case EXOMsg.EX_SND_GET:
                            //GET THE VOLUME LEVEL
                            int _volumeLevel = EXOxtenderLibrary.VolumeControl.Instance.GetVolume();

                            EXOxtenderLibrary.VolumeControl.Instance.VolumeChanged -= Instance_VolumeChanged;

                            if (_arg1 == 0)
                            {
                                MessageHelper.PostMessage(_exoUI, EXOMsg.WM_APP + 5, MessageHelper.MakeWParam(EXOMsg.EX_SND_INFO, _volumeLevel), MessageHelper.MakeLParam(EXOxtenderLibrary.VolumeControl.Instance.isMute, 0));
                            }
                            else if (_arg1 == 1)
                            {
                                MessageHelper.PostMessage(_exoUI, EXOMsg.WM_APP + 5, MessageHelper.MakeWParam(EXOMsg.EX_SND_INFO, _volumeLevel), MessageHelper.MakeLParam(EXOxtenderLibrary.VolumeControl.Instance.isMute, 0));
                                EXOxtenderLibrary.VolumeControl.Instance.VolumeChanged += new EXOxtenderLibrary.VolumeControl.VolumeEventHandler(Instance_VolumeChanged);
                            }

                            //textBox1.Text += "UI_VOLUME_GET - Current level:" + _volumeLevel.ToString() + ", Mute:" + MessageHelper.HiWord(m.LParam.ToInt32()).ToString() + "\r\n";
                            //textBox1.Text += "hWnd:" + m.HWnd.ToString() + " Msg:" + m.Msg.ToString() + " arg0:" + _arg0 + " arg1:" + _arg1 + " arg2:" + _arg2 + " arg3:" + _arg3 + "\r\n";

                            break;

                        case EXOMsg.EX_SND_SET:
                            //SET THE VOLUME TO A SPECIFIED VALUE
                            int _newVolumeLevel = _arg1;
                            if (_newVolumeLevel > 0 && _newVolumeLevel < 101)
                            { EXOxtenderLibrary.VolumeControl.Instance.SetVolume(_newVolumeLevel); }

                            if (_arg2 == 1)
                            { EXOxtenderLibrary.VolumeControl.Instance.Mute = true; }
                            else if (_arg2 == 2)
                            { EXOxtenderLibrary.VolumeControl.Instance.Mute = false; }

                            //textBox1.Text += "UI_VOLUME_SET - New level:" + _newVolumeLevel.ToString() + ", Mute:" + MessageHelper.HiWord(m.LParam.ToInt32()).ToString() + "\r\n";
                            //textBox1.Text += "hWnd:" + m.HWnd.ToString() + " Msg:" + m.Msg.ToString() + " arg0:" + _arg0 + " arg1:" + _arg1 + " arg2:" + _arg2 + " arg3:" + _arg3 + "\r\n";
                            //try
                            //{
                            //    MessageHelper.PostMessage(_exoUI, WM_APP + 5, MessageHelper.MakeWParam(147, UI_VOLUME_SET), MessageHelper.MakeLParam(_vol.GetVolume(), _vol.isMute));
                            //}
                            //catch (Exception e)
                            //{ textBox1.Text = e.Message; }
                            break;
                        case EX_OK:
                            // Request Dispose of the timer object.
                            textBox1.Text += string.Format("EX_OK received! Stopping to send EX_READY message...{0}", Environment.NewLine);
                            _stateObj.TimerCanceled = true;
                            break;
                        case EXOMsg.EX_TOUCH_SET:
                            /*
                            using (StreamWriter writer = new StreamWriter(@"\patrice\patrice2.txt", true))
                            {
                                writer.WriteLine("EX_TOUCH_SET");
                            }
                            */
                            textBox1.Text += string.Format("EX_TOUCH_SET received!{0}", Environment.NewLine);
                            if (_arg1 == 1)
                            {
                                //Touch manager enabled in hook mode
                                textBox1.Text += string.Format("Initializing touch manager in hook mode...{0}", Environment.NewLine);

                                int keyboardHandle = MessageHelper.MakeWParam(_arg2, _arg3);
                                IntPtr keyboardIntPtr = new IntPtr(keyboardHandle);

                                //MessageBox.Show("keyboardptr: " + keyboardIntPtr.ToString() + "arg2: " + _arg2 + "arg3: " + _arg3);

                                if (InitializeTouch(_windowName, keyboardIntPtr))
                                {
                                    hookModeEnabled = true;
                                    textBox1.Text += string.Format("Touch manager successfully enabled!{0}", Environment.NewLine);
                                    /*
                                    using (StreamWriter writer = new StreamWriter(@"\patrice\patrice2.txt", true))
                                    {
                                        writer.WriteLine("InitTouch ok");
                                    }
                                    */
                                }
                                else
                                {
                                    textBox1.Text += string.Format("ERROR: Unable to initialize touch manager.{0}", Environment.NewLine);
                                    /*
                                    using (StreamWriter writer = new StreamWriter(@"\patrice\patrice2.txt", true))
                                    {
                                        writer.WriteLine("InitTouch failed");
                                    }
                                    */
                                }
                            }
                            else if (_arg1 == 2)
                            {
                                //Touch manager enabled in transparent layer mode
                                WindowWrapper wrapper = new WindowWrapper(_exoUI);

                                tw = new TransparentWindow();
                                tw.Touchdown += new EventHandler<EXOxtender.WMTouchEventArgs>(tw_Touchdown);
                                tw.Touchup += new EventHandler<EXOxtender.WMTouchEventArgs>(tw_Touchup);
                                tw.TouchMove += new EventHandler<EXOxtender.WMTouchEventArgs>(tw_TouchMove);

                                //tw.Show();
                                tw.Show(wrapper);
                                transparentLayerModeEnabled = true;

                                textBox1.Text += string.Format("Touch manager enabled in transparent layer mode.{0}", Environment.NewLine);
                            }
                            else if (_arg1 == 99)
                            {
                                //Touch manager disabled
                                textBox1.Text += string.Format("Disabling touch manager...{0}", Environment.NewLine);

                                if (hookModeEnabled)
                                {
                                    UninitializeTouch();
                                }

                                if (transparentLayerModeEnabled && tw != null)
                                {
                                    tw.Close();
                                }
                            }
                            break;
                        case EXOMsg.EX_TOUCH_AREA_POS:
                            if (tw != null)
                            {
                                string msg = string.Format("EX_TOUCH_AREA_POS received: X={0}, Y={1}{2}", _arg1, _arg2, Environment.NewLine);
                                textBox1.Text += msg;
                                tw.Location = new Point(_arg1, _arg2);
                            }
                            break;
                        case EXOMsg.EX_TOUCH_AREA_SIZE:
                            if (tw != null)
                            {
                                string msg = string.Format("EX_TOUCH_AREA_SIZE received: X={0}, Y={1}{2}", _arg1, _arg2, Environment.NewLine);
                                textBox1.Text += msg;
                                tw.Size = new Size(_arg1, _arg2);
                            }
                            break;
                        case EXOMsg.EX_GESTURE_ENABLE:
                            {
                                int windowHandle = MessageHelper.MakeWParam(_arg2, _arg3);
                                IntPtr windowIntPtr = new IntPtr(windowHandle);
                                GestureEnable(windowIntPtr);
                            }
                            break;
                        case EXOMsg.EX_TOUCH_ENABLE:
                            {
                                int windowHandle = MessageHelper.MakeWParam(_arg2, _arg3);
                                IntPtr windowIntPtr = new IntPtr(windowHandle);
                                TouchEnable(windowIntPtr);
                            }
                            break;
                        case EXOMsg.EX_TOUCH_IGNORE:
                            {
                                int windowHandle = MessageHelper.MakeWParam(_arg2, _arg3);
                                IntPtr windowIntPtr = new IntPtr(windowHandle);
                                TouchIgnore(windowIntPtr);
                            }
                            break;

                        case EXOMsg.EX_UDP_GET:
                            {
                                if (_arg1 == 1)
                                {
                                    if (!isListeningToUDP)
                                    {
                                        isListeningToUDP = true;
                                        udpJob = new ThreadStart(udpThreadProc);
                                        udpThread = new Thread(udpJob);
                                        udpThread.Start();
                                    }
                                }
                                else if (_arg1 == 2)
                                {
                                    if (isListeningToUDP)
                                    {
                                        isListeningToUDP = false;
                                        if (udpClient != null)
                                            udpClient.Close();
                                        udpThread.Abort();
                                    }
                                }
                            }
                            break;

                        case EXOMsg.EX_UDP_SEND:
                            {
                                try
                                {
                                    XmlTextReader reader = new XmlTextReader(_tempPath + "udp_send.xml");
                                    String ip = null;
                                    while (reader.Read())
                                    {
                                        if (reader.NodeType ==  XmlNodeType.Element && reader.Name == "message")
                                        {
                                             while (reader.MoveToNextAttribute())
                                             {
                                                 if (reader.Name == "ip")
                                                 {
                                                     ip = reader.Value;
                                                 }
                                             }
                                        }
                                        else if (reader.NodeType == XmlNodeType.Text && ip != null)
                                        {
                                            byte[] message = Encoding.ASCII.GetBytes(reader.Value);
                                            IPAddress ipAddress = IPAddress.Parse(ip);
                                            UdpClient socket = new UdpClient();
                                            socket.Connect(ipAddress, UDP_PORT);
                                            socket.Send(message, message.Length);
                                            socket.Close();
                                        }
                                    }
                                }
                                catch (IOException e)
                                {
                                    // ignore errors while sending UDP, anyway UDP is not reliable
                                }
                            }
                            break;
                        case EXOMsg.EX_HARDWARE_REPORT_GET:
                            hardwareReportGet();
                            break;
                        case EXOMsg.EX_TRANSP_LAYER_OPEN_XY:
                            transparentLayerX = _arg1;
                            transparentLayerY = _arg2;
                            break;
                        case EXOMsg.EX_TRANSP_LAYER_OPEN_WH:
                            exTranspLayerOpen(transparentLayerX, transparentLayerY, _arg1, _arg2);
                            break;
                        case EXOMsg.EX_DRAG_FEEDBACK:
                            exDragFeedback(_arg1);
                            break;
                        case EXOMsg.EX_TRANSP_LAYER_CLOSE:
                            exTranspLayerClose();
                            break;
                    }
                }
                base.WndProc(ref m);
            }
            catch (Exception e)
            {
                trace("EXOxtender WndProc Exception: " + e.Message);
                trace(e.StackTrace);
            }
        }