def __start__(self,
port,
longpresstimeout,
prefix='X10-Mouse',
enduringevent=False,
logbytes=False,
longpressreset=0.075):
if enduringevent:
self.info.eventPrefix = prefix
else:
self.TriggerEvent = eg.TriggerEvent
try:
self.Serial = SerialThread(
eg.WinApi.serial.Serial(port,
baudrate=1200,
bytesize=7,
stopbits=1,
parity='N'),
win32event.CreateEvent(None, 1, 0, None), logbytes, prefix,
self.TriggerEvent, longpresstimeout, longpressreset)
except:
self.Serial = None
print self.Exceptions.SerialOpenFailed
eg.Print('X-10 Mouse Plugin Has Stopped')
else:
eg.Print('X-10 Mouse Plugin Has Started')
self.Serial.start()
def __stop__(self):
eg.Print('X-10 Mouse Plugin Has Stopped')
self.TriggerEvent = self.savedtriggerevent
if self.Serial:
self.Serial.EVENT.set()
self.Serial.join(1.0)
self.Serial = None
def OnCmdClearLog(self, dummyEvent=None):
self.SetItemCount(0)
self.DeleteAllItems()
self.data.clear()
eg.log.data.clear()
eg.Print(eg.text.MainFrame.Logger.welcomeText)
self.FocusLastItem()
self.Scroll()
self.Refresh()
def __start__(self,
port,
longpresstimeout,
prefix='X10-Mouse',
enduringevent=False,
logbytes=False,
longpressreset=0.075,
mousemove=True,
mouseevents=True,
mousemaxspeed=10,
mouseacceleration=1):
if enduringevent:
self.info.eventPrefix = prefix
else:
self.TriggerEvent = eg.TriggerEvent
try:
self.Serial = SerialThread(
eg.WinApi.serial.Serial(port,
baudrate=1200,
bytesize=7,
stopbits=1,
parity='N'),
win32event.CreateEvent(None, 1, 0, None),
logbytes,
mousemove,
mousemaxspeed,
mouseacceleration,
mouseevents,
prefix,
self.TriggerEvent,
longpresstimeout,
longpressreset,
)
except Exception as err:
self.Serial = None
eg.PrintError(str([err]))
eg.Print('X-10 Mouse Plugin Has Stopped')
else:
eg.Print('X-10 Mouse Plugin Has Started')
self.Serial.start()
def InitGui():
import __builtin__
__builtin__.raw_input = RawInput
__builtin__.input = Input
eg.scheduler.start()
eg.messageReceiver.Start()
eg.document = eg.Document()
if eg.config.showTrayIcon:
if not (eg.config.hideOnStartup or eg.startupArguments.hideOnStartup):
eg.document.ShowFrame()
else:
eg.document.ShowFrame()
if eg.config.hideOnStartup or eg.startupArguments.hideOnStartup:
eg.mainFrame.Iconize(True)
eg.actionThread.Start()
eg.eventThread.startupEvent = eg.startupArguments.startupEvent
config = eg.config
startupFile = eg.startupArguments.startupFile
if startupFile is None:
startupFile = config.autoloadFilePath
if startupFile and not exists(startupFile):
eg.PrintError(eg.text.Error.FileNotFound % startupFile)
startupFile = None
eg.eventThread.Start()
wx.CallAfter(
eg.eventThread.Call,
eg.eventThread.StartSession,
startupFile
)
if config.checkUpdate:
# avoid more than one check per day
today = gmtime()[:3]
if config.lastUpdateCheckDate != today:
config.lastUpdateCheckDate = today
wx.CallAfter(eg.CheckUpdate.Start)
# Register restart handler for easy crash recovery.
if eg.WindowsVersion >= 'Vista':
args = " ".join(eg.app.GetArguments())
windll.kernel32.RegisterApplicationRestart(args, 8)
eg.Print(eg.text.MainFrame.Logger.welcomeText)
import LoopbackSocket
eg.socketSever = LoopbackSocket.Start()
def InitGui():
#import eg.WinApi.COMServer
import __builtin__
__builtin__.raw_input = RawInput
__builtin__.input = Input
eg.scheduler.start()
eg.messageReceiver.Start()
eg.document = eg.Document()
if not (eg.config.hideOnStartup or eg.startupArguments.hideOnStartup):
eg.document.ShowFrame()
eg.actionThread.Start()
eg.eventThread.startupEvent = eg.startupArguments.startupEvent
config = eg.config
startupFile = eg.startupArguments.startupFile
if startupFile is None:
startupFile = config.autoloadFilePath
if startupFile and not os.path.exists(startupFile):
eg.PrintError(eg.text.Error.FileNotFound % startupFile)
startupFile = None
eg.eventThread.Start()
wx.CallAfter(
eg.eventThread.Call,
eg.eventThread.StartSession,
startupFile
)
# if config.checkUpdate:
# # avoid more than one check per day
# today = gmtime()[:3]
# if config.lastUpdateCheckDate != today:
# config.lastUpdateCheckDate = today
# wx.CallAfter(eg.CheckUpdate.Start)
eg.Print(eg.text.MainFrame.Logger.welcomeText)
def Print(self, *args, **kwargs):
kwargs.setdefault("source", self)
kwargs.setdefault("icon", self.icon)
eg.Print(*args, **kwargs)
def __call__(self):
eg.Print(eg.result)
return eg.result
def close(self):
self._poll_event.set()
self._poll_thread.join(3)
self.adapter.Close()
eg.Print('CEC: connection closed on ' + self.com_port)
def __init__(self, com_port, adapter_name, hdmi_port, use_avr,
poll_interval):
self.name = adapter_name
self.com_port = com_port
self._log_level = None
self._menu_state = False
self._key_event = None
self._last_key = 255
self._restart_params = (com_port, adapter_name, hdmi_port, use_avr)
self._poll_event = threading.Event()
self._poll_interval = poll_interval
self._poll_thread = threading.Thread(name='PulseEightCEC-' +
adapter_name,
target=self._run_poll)
self.cec_config = cec_config = cec.libcec_configuration()
cec_config.clientVersion = cec.LIBCEC_VERSION_CURRENT
cec_config.deviceTypes.Add(cec.CEC_DEVICE_TYPE_RECORDING_DEVICE)
cec_config.SetLogCallback(self._log_callback)
cec_config.SetKeyPressCallback(self._key_callback)
cec_config.iHDMIPort = hdmi_port
cec_config.strDeviceName = str(adapter_name)
cec_config.bActivateSource = 0
if use_avr:
cec_config.baseDevice = cec.CECDEVICE_AUDIOSYSTEM
else:
cec_config.baseDevice = cec.CECDEVICE_TV
self.adapter = adapter = cec.ICECAdapter.Create(cec_config)
if adapter.Open(com_port):
eg.Print('CEC: connection opened on ' + com_port)
else:
eg.PrintError('CEC Error: connection failed on ' + com_port)
raise AdapterError
self.tv = CECDevice(adapter, 'TV', cec.CECDEVICE_TV)
self.tuner1 = CECDevice(adapter, 'Tuner 1', cec.CECDEVICE_TUNER1)
self.tuner2 = CECDevice(adapter, 'Tuner 2', cec.CECDEVICE_TUNER2)
self.tuner3 = CECDevice(adapter, 'Tuner 3', cec.CECDEVICE_TUNER3)
self.tuner4 = CECDevice(adapter, 'Tuner 4', cec.CECDEVICE_TUNER4)
self.audiosystem = CECDevice(adapter, 'AVR', cec.CECDEVICE_AUDIOSYSTEM)
self.freeuse = CECDevice(adapter, 'Free Use', cec.CECDEVICE_FREEUSE)
self.unknown = CECDevice(adapter, 'Unknown', cec.CECDEVICE_UNKNOWN)
self.broadcast = CECDevice(adapter, 'Broadcast',
cec.CECDEVICE_BROADCAST)
self.reserved1 = CECDevice(adapter, 'Reserved 1',
cec.CECDEVICE_RESERVED1)
self.reserved2 = CECDevice(adapter, 'Reserved 2',
cec.CECDEVICE_RESERVED2)
self.recordingdevice1 = CECDevice(adapter, 'Recording Device 1',
cec.CECDEVICE_RECORDINGDEVICE1)
self.playbackdevice1 = CECDevice(adapter, 'Playback Device 1',
cec.CECDEVICE_PLAYBACKDEVICE1)
self.recordingdevice2 = CECDevice(adapter, 'Recording Device 2',
cec.CECDEVICE_RECORDINGDEVICE2)
self.playbackdevice2 = CECDevice(adapter, 'Playback Device 2',
cec.CECDEVICE_PLAYBACKDEVICE2)
self.recordingdevice3 = CECDevice(adapter, 'Recording Device 3',
cec.CECDEVICE_RECORDINGDEVICE3)
self.playbackdevice3 = CECDevice(adapter, 'Playback Device 3',
cec.CECDEVICE_PLAYBACKDEVICE3)
self.devices = [
self.tv,
self.audiosystem,
self.tuner1,
self.tuner2,
self.tuner3,
self.tuner4,
self.recordingdevice1,
self.recordingdevice2,
self.recordingdevice3,
self.playbackdevice1,
self.playbackdevice2,
self.playbackdevice3,
self.reserved1,
self.reserved2,
self.freeuse,
self.broadcast,
self.unknown,
]
self._poll_thread.start()
def run(self):
notice_ip = _validate_ip(self.host)
if notice_ip and notice_ip != self.host:
eg.Print('Is Connected: '
'Monitoring Started: '
'Name: %s, '
'Host Name: %s '
'IP Address: %s '
'MAC Address: %s' %
(self.client_name, self.host, notice_ip,
_get_mac_address(notice_ip)))
elif notice_ip == self.host:
eg.Print(
'Is Connected: '
'Monitoring Started: '
'Name: %s, '
'IP Address: %s '
'MAC Address: %s' %
(self.client_name, notice_ip, _get_mac_address(notice_ip)))
else:
eg.Print('Is Connected: '
'Monitoring Started: '
'Name: %s, '
'Host Name: %s' % (self.client_name, self.host))
while not self._interval_event.isSet():
ip = _validate_ip(self.host)
def send_arp():
self._lock.acquire()
new_connection = False
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(self.timeout)
while not self._timeout_event.isSet():
try:
sock.connect((ip, 56421))
except socket.timeout:
self._timeout_event.set()
except socket.error as err:
if err[0] == 10060:
new_connection = False
elif err[0] == 10061:
new_connection = True
self._timeout_event.set()
elif err[0] == 10022:
pass
else:
raise
else:
new_connection = True
self._timeout_event.set()
finally:
try:
sock.close()
except socket.error:
pass
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(self.timeout)
self._lock.release()
self.trigger_event(new_connection)
t = threading.Thread(target=send_arp)
t.start()
self._timeout_event.wait(self.timeout)
self._timeout_event.set()
try:
t.join(1)
except:
pass
self._lock.acquire()
self._lock.release()
self._interval_event.wait(self.interval)
self._timeout_event.clear()
self._thread = None
self._timeout_event.clear()
self._interval_event.clear()
eg.Print('Is Connected: '
'Monitoring Stopped: '
'Name: %s' % self.client_name)
