def __init__(self, *args, **kwargs): self.__alive = True self.__queue = deque() self.__setupFunc = partial(self.Setup, *args, **kwargs) self.__wakeEvent = CreateEvent(None, 0, 0, None) self.__dummyEvent = CreateEvent(None, 0, 0, None) self.__events = (HANDLE * 1)(self.__wakeEvent) self.__thread = Thread( group=None, target=self.__MainLoop, name=self.__class__.__name__, )
def ThreadLoop(self, startupEvent): try: hDir = CreateFile( self.path, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE, None, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, 0) if hDir == INVALID_HANDLE_VALUE: self.startException = FormatError() startupEvent.set() return overlapped = OVERLAPPED() overlapped.hEvent = CreateEvent(None, 1, 0, None) buffer = (c_byte * BUFSIZE)() events = (HANDLE * 2)(overlapped.hEvent, self.stopEvent) flags = (FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_SECURITY) includeSubdirs = self.includeSubdirs renamePath = None bytesReturned = DWORD() noneCallback = cast(None, LPOVERLAPPED_COMPLETION_ROUTINE) startupEvent.set() while 1: ReadDirectoryChangesW(hDir, buffer, BUFSIZE, includeSubdirs, flags, byref(bytesReturned), byref(overlapped), noneCallback) rc = MsgWaitForMultipleObjects(2, events, 0, INFINITE, QS_ALLINPUT) if rc == WAIT_OBJECT_0: res = GetOverlappedResult(hDir, byref(overlapped), byref(bytesReturned), 1) address = addressof(buffer) while True: fni = FILE_NOTIFY_INFORMATION.from_address(address) length = fni.FileNameLength / WCHAR_SIZE fileName = wstring_at(address + 12, length) action = fni.Action fullFilename = os.path.join(self.path, fileName) if action == FILE_ACTION_ADDED: self.TriggerEvent("Created", (fullFilename, )) elif action == FILE_ACTION_REMOVED: self.TriggerEvent("Deleted", (fullFilename, )) elif action == FILE_ACTION_MODIFIED: self.TriggerEvent("Updated", (fullFilename, )) elif action == FILE_ACTION_RENAMED_OLD_NAME: renamePath = fullFilename elif action == FILE_ACTION_RENAMED_NEW_NAME: self.TriggerEvent("Renamed", (renamePath, fullFilename)) renamePath = None if fni.NextEntryOffset == 0: break address += fni.NextEntryOffset elif rc == WAIT_OBJECT_0 + 1: break CloseHandle(hDir) except: self.thread = None raise
def __call__( self, osdText="", fontInfo=None, foregroundColour=(255, 255, 255), backgroundColour=(0, 0, 0), alignment=0, offset=(0, 0), displayNumber=0, timeout=3.0, skin=None ): if isinstance(skin, bool): skin = SKINS[0] if skin else None self.osdFrame.timer.cancel() osdText = eg.ParseString(osdText) event = CreateEvent(None, 0, 0, None) wx.CallAfter( self.osdFrame.ShowOSD, osdText, fontInfo, foregroundColour, backgroundColour, alignment, offset, displayNumber, timeout, event, skin ) eg.actionThread.WaitOnEvent(event)
def StatusCheckLoop(self): hComm = self.hFile waitingOnStatusHandle = False dwCommEvent = DWORD() dwOvRes = DWORD() commMask = ( EV_BREAK | EV_CTS | EV_DSR | EV_ERR | EV_RING | EV_RLSD | EV_RXCHAR | EV_RXFLAG | EV_TXEMPTY ) if not SetCommMask(self.hFile, commMask): raise SerialError("error setting communications mask") osStatus = OVERLAPPED(0) osStatus.hEvent = CreateEvent(None, 1, 0, None) if not osStatus.hEvent: raise SerialError("error creating event") while True: # Issue a status event check if one hasn't been issued already. if not waitingOnStatusHandle: if WaitCommEvent(hComm, byref(dwCommEvent), byref(osStatus)): # WaitCommEvent returned immediately. # Deal with status event as appropriate. self.ReportStatusEvent(dwCommEvent.value) else: if GetLastError() == ERROR_IO_PENDING: waitingOnStatusHandle = True else: raise SerialError("error in WaitCommEvent") # Check on overlapped operation if waitingOnStatusHandle: # Wait a little while for an event to occur. res = WaitForSingleObject(osStatus.hEvent, 1000) if res == WAIT_OBJECT_0: if GetOverlappedResult( hComm, byref(osStatus), byref(dwOvRes), 0 ): # Status event is stored in the event flag # specified in the original WaitCommEvent call. # Deal with the status event as appropriate. self.ReportStatusEvent(dwCommEvent.value) else: # An error occurred in the overlapped operation; # call GetLastError to find out what it was # and abort if it is fatal. raise SerialError() # Set waitingOnStatusHandle flag to indicate that a new # WaitCommEvent is to be issued. waitingOnStatusHandle = True elif res == WAIT_TIMEOUT: print "timeout" else: # This indicates a problem with the OVERLAPPED structure's # event handle. CloseHandle(osStatus.hEvent) raise SerialError("error in the WaitForSingleObject") CloseHandle(osStatus.hEvent)
def __call__(self, title="", body="", alias="", payload="", blocking=False, options=0, mbType=0, autoClose=0): title = eg.ParseString(title) body = eg.ParseString(body) alias = eg.ParseString(alias) payload = eg.ParseString(payload) if not isinstance(autoClose, int): try: autoClose = int(eg.ParseString(autoClose)) except: autoClose = 0 if mbType: event = CreateEvent(None, 0, 0, None) if blocking else None wx.CallAfter(self.showTweakedBox, None, title, body, alias, payload, options, autoClose, event) if blocking: #print "Waiting ..." eg.actionThread.WaitOnEvent(event, 999999999999) return self.retCode else: if blocking: return self.showMessageBox(title, body, alias, payload, options) else: Thread(target=self.showMessageBox, args=(title, body, alias, payload, options)).start() return None
def __init__(self, callback): Thread.__init__(self, target=self.ThreadLoop) self.timeout = INFINITE self.lock = Lock() self.callback = callback self.event = CreateEvent(None, 0, 0, None) self.start()
def GetToken(self): flag = True while flag: token = format(randrange(16777216), '06x') flag = token in self.queryData event = CreateEvent(None, 0, 0, None) self.queryData[token] = event return token
def __start__(self): self.stopEvent = CreateEvent(None, 1, 0, None) self.startException = None startupEvent = threading.Event() self.thread = threading.Thread(target=self.ThreadLoop, name="ProcessWatcherThread", args=(startupEvent, )) self.thread.start() startupEvent.wait(3) if self.startException is not None: raise self.Exception(self.startException)
def __start__(self, path, includeSubdirs): self.stopEvent = CreateEvent(None, 1, 0, None) self.path = path self.startException = None self.includeSubdirs = includeSubdirs startupEvent = threading.Event() self.thread = threading.Thread(target=self.ThreadLoop, name="DirectoryWatcherThread", args=(startupEvent, )) self.thread.start() startupEvent.wait(3) if self.startException is not None: raise self.Exception(self.startException)
def __init__(self, hFile=0): Thread.__init__(self, target=self.ReceiveThreadProc) self.hFile = int(hFile) self.osWriter = OVERLAPPED() self.osWriter.hEvent = CreateEvent(None, 0, 0, None) self.osReader = OVERLAPPED() self.osReader.hEvent = CreateEvent(None, 1, 0, None) self.dwRead = DWORD() self.comstat = COMSTAT() self.dcb = DCB() self.dcb.DCBlength = sizeof(DCB) self.oldCommTimeouts = COMMTIMEOUTS() self.readEventCallback = None self.readEventLock = Lock() self.readEventLock.acquire() self.readCondition = Condition() self.buffer = "" self.keepAlive = True self.stopEvent = CreateEvent(None, 1, 0, None) self.callbackThread = Thread(target=self.CallbackThreadProc, name="SerialReceiveThreadProc")
def SendCommand(self, cmd, room, value, wait=True): if wait: event = CreateEvent(None, 0, 0, None) self.event = (COMMANDS[cmd], event) hwnd = GetHwnd() if hwnd: SendMessage(hwnd, WM_COMMAND, COMMANDS[cmd] + room, value) if wait: eg.actionThread.WaitOnEvent(event) res = self.result self.result = None return res else: eg.PrintError(self.text.err1)
def onBurn(evt): if self.data == [cpy(EMPTY_CHAR)]: MessageBox(self.panel, text.message3, text.messBoxTit4, wx.ICON_EXCLAMATION, plugin=self, time=10) return if not self.GetConnected(): MessageBox(self.panel, text.message2, text.messBoxTit2, wx.ICON_EXCLAMATION, plugin=self, time=10) return max = 1 + len(self.data) dlg = wx.ProgressDialog(self.text.progress, self.text.wait, maximum=max, parent=self.panel, style=wx.PD_CAN_ABORT | wx.PD_APP_MODAL) dlg.SetIcon(self.info.icon.GetWxIcon()) keepGoing = True count = 0 for i, ch in enumerate(self.data): event = CreateEvent(None, 0, 0, None) item = list(ch[2]) item.append(i) item.append(ord(ch[1])) self.queue.put(((COMMANDS["Burn"], item), event)) eg.actionThread.WaitOnEvent(event) count += 1 (keepGoing, skip) = dlg.Update(count) self.queue.put(((COMMANDS["Burn"], (len(self.data), )), event)) count += 1 eg.actionThread.WaitOnEvent(event) (keepGoing, skip) = dlg.Update(count, self.text.done) self.eechars = len(self.data)