def _show_toast(self, title, msg, duration): message_map = { WM_DESTROY: self.on_destroy, } self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str("PythonTaskbar") self.wc.lpfnWndProc = message_map try: self.classAtom = RegisterClass(self.wc) except: pass style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) hicon = LoadIcon(0, IDI_APPLICATION) flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, "Tooltip") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, "Balloon Tooltip", msg, 200, title)) sleep(duration) DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, None) return None
def __init__(self): # Current bubble data self._bubble = None self.logger = logging.getLogger("zroya") # Event mapping. Keys is event type and value callback function. self._event_map = { WM_DESTROY: self.quit, } # Create window self._window_class = WNDCLASS() self._window_class.lpszClassName = str("Notification") self._window_class.lpfnWndProc = self._eventLoop self._class = RegisterClass(self._window_class) self._handle = GetModuleHandle(None) self._window = CreateWindow(self._class, "Notification", 0, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self._handle, None) # Draw window UpdateWindow(self._window) self.logger.debug("TrayIcon created.")
def __init__(self, icon_path, msg_q): """Initialize.""" self.visible = 0 self.log = [] self._thread = None self.msg_q = msg_q self.message_box = Mbox() message_map = { WM_DESTROY: self.onDestroy, WM_USER + 20: self.onTaskbarNotify, } wc = WNDCLASS() hinst = wc.hInstance = GetModuleHandle(None) icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: self.hicon = LoadImage(hinst, os.path.realpath(icon_path), IMAGE_ICON, 0, 0, icon_flags) except Exception as e: print(str(e)) self.hicon = LoadIcon(0, IDI_APPLICATION) wc.lpszClassName = str("Trustbase_notification") #lol wc.style = CS_VREDRAW | CS_HREDRAW #wc.hCursor = win32gui.LoadCursor( 0, win32con.IDC_ARROW ) wc.hbrBackground = COLOR_WINDOW wc.lpfnWndProc = message_map # could also specify a wndproc. classAtom = RegisterClass(wc) # Create the Window. style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow( classAtom, "MITM_alert", style, \ 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, \ 0, 0, hinst, None) UpdateWindow(self.hwnd) self.notification_id = 1 self.show()
def __init__(self): # List of all notifications. Each notification is represented by its ID (key) and thread (value). self._notifications = {} # Notification ID counter self._current_id = 0 self.logger = logging.getLogger("zroya") # Event mapping. Keys is event type and value callback function. self._event_map = { WM_DESTROY: self.quit, } # Create window self._window_class = WNDCLASS() self._window_class.lpszClassName = str("Notification") self._window_class.lpfnWndProc = self._eventLoop self._class = RegisterClass(self._window_class) self._handle = GetModuleHandle(None) self._window = CreateWindow(self._class, "Notification", WS_OVERLAPPED | WS_SYSMENU, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self._handle, None ) # Draw window UpdateWindow(self._window) self.logger.info("NotificationCenter created.")
def show_toast(self, title="Notification", msg="Here comes the message", icon_path=None, duration=5): """Notification settings. :title: notification title :msg: notification message :icon_path: path to the .ico file to custom notification :duration: delay in seconds before notification self-destruction """ message_map = { WM_DESTROY: self.on_destroy, } # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str("PythonTaskbar") # must be a string self.wc.lpfnWndProc = message_map # could also specify a wndproc. try: self.classAtom = RegisterClass(self.wc) except: pass #not sure of this style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) # icon if icon_path is not None: icon_path = path.realpath(icon_path) else: icon_path = resource_filename(Requirement.parse("win10toast"), "win10toast/data/python.ico") icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: hicon = LoadImage(self.hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) except Exception as e: logging.error("Some trouble with the icon ({}): {}".format( icon_path, e)) hicon = LoadIcon(0, IDI_APPLICATION) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, "Tooltip") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, "Balloon Tooltip", msg, 200, title)) # take a rest then destroy sleep(duration) DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, None) return None
def show_windows_notification(title, msg, icon_path): global tool_window, tool_icon from win32api import GetModuleHandle from win32con import ( CW_USEDEFAULT, IMAGE_ICON, LR_DEFAULTSIZE, LR_LOADFROMFILE, WM_USER, WS_OVERLAPPED, WS_SYSMENU, ) from win32gui import ( NIF_ICON, NIF_INFO, NIF_MESSAGE, NIF_TIP, NIM_ADD, NIM_MODIFY, WNDCLASS, CreateWindow, LoadImage, RegisterClass, Shell_NotifyIcon, UpdateWindow, ) wc = WNDCLASS() hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = "FastFlix" if not tool_window: tool_window = CreateWindow( RegisterClass(wc), "Taskbar", WS_OVERLAPPED | WS_SYSMENU, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hinst, None, ) UpdateWindow(tool_window) icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE tool_icon = LoadImage(hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (tool_window, 0, flags, WM_USER + 20, tool_icon, "FastFlix Notifications") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (tool_window, 0, NIF_INFO, WM_USER + 20, tool_icon, "Balloon Tooltip", msg, 200, title, 4))
def __init__(self): # Register window class; it's okay to do this multiple times wc = WNDCLASS() wc.lpszClassName = 'ServoTaskbarNotification' wc.lpfnWndProc = { win32con.WM_DESTROY: self.OnDestroy, } self.classAtom = RegisterClass(wc) self.hinst = wc.hInstance = GetModuleHandle(None)
def _show_toast(self, title, msg, icon_path, duration, callback_on_click): """Notification settings. :title: notification title :msg: notification message :icon_path: path to the .ico file to custom notification :duration: delay in seconds before notification self-destruction, None for no-self-destruction """ # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str(self) # must be a string # callback_on_click = self._destroy_wrap(callback_on_click) self.wc.lpfnWndProc = self._decorator( self.wnd_proc, callback_on_click) # could instead specify simple mapping try: self.classAtom = RegisterClass(self.wc) except Exception as e: logging.error("Some trouble with classAtom ({})".format(e)) style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) # icon if icon_path is not None: icon_path = path.realpath(icon_path) else: icon_path = resource_filename(Requirement.parse("win10toast"), "win10toast/data/python.ico") icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: hicon = LoadImage(self.hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) except Exception as e: logging.error("Some trouble with the icon ({}): {}".format( icon_path, e)) hicon = LoadIcon(0, IDI_APPLICATION) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, "Tooltip") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, "Balloon Tooltip", msg, 200, title)) PumpMessages() # take a rest then destroy if duration is not None and duration > 0: sleep(duration) self._destroy_window() return None
def __init__(self): """Initialize.""" message_map = {WM_DESTROY: self.on_destroy, } # Register the window class. wc = WNDCLASS() self.hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = str("PythonTaskbar") # must be a string wc.lpfnWndProc = message_map # could also specify a wndproc. self.classAtom = RegisterClass(wc)
def __init__(self, auto_destroy=True): """Initialize.""" self._thread = None self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str("PythonTaskbar") # must be a string if auto_destroy: # could also specify a wndproc. self.wc.lpfnWndProc = { WM_DESTROY: self.on_destroy, }
def __init__(self, message, title): message_map = {win32con.WM_DESTROY: self.OnDestroy} # Register the Window class. wc = WNDCLASS() hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = "PythonTaskbar" wc.lpfnWndProc = message_map # could also specify a wndproc. classAtom = RegisterClass(wc) # Create the Window. style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU self.hwnd = CreateWindow( classAtom, "Taskbar", style, 0, 0, win32con.CW_USEDEFAULT, win32con.CW_USEDEFAULT, 0, 0, hinst, None, ) UpdateWindow(self.hwnd) iconPathName = os.path.abspath( os.path.join(sys.path[0], "balloontip.ico")) icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE try: hicon = LoadImage(hinst, iconPathName, win32con.IMAGE_ICON, 0, 0, icon_flags) except: hicon = LoadIcon(0, win32con.IDI_APPLICATION) flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, win32con.WM_USER + 20, hicon, "tooltip") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon( NIM_MODIFY, ( self.hwnd, 0, NIF_INFO, win32con.WM_USER + 20, hicon, "Balloon tooltip", message, 200, title, ), ) time.sleep(10) DestroyWindow(self.hwnd) UnregisterClass(classAtom, hinst)
def anti(): #SbieDll.dll => To Bypass SandBoxie #api_log.dll => To Bypass SunBelt #dir_watch.dll => To Bypass SunBelt SandBox #dbghelp.dll => To Bypass vmware x = ["sbiedll.dll", "api_log.dll", "dir_watch.dll", "dbghelp.dll"] for i in x: try: GetModuleHandle(x) return True except: return False
def __init__(self, title='Waitbar', can_abort=True, max_val=100): Thread.__init__(self) # Initialize thread self.title = title self.can_abort = can_abort self.max_val = max_val InitCommonControls() self.hinst = GetModuleHandle(None) self.started = False self.position = 0 self.do_update = False self.start() # Run the thread while not self.started: sleep(0.1) # Wait until the dialog is ready
def windows_notify(self, title, message, config): config = self.prepare_config(config) try: from win32api import GetModuleHandle, PostQuitMessage from win32con import (CW_USEDEFAULT, IMAGE_ICON, IDI_APPLICATION, LR_DEFAULTSIZE, LR_LOADFROMFILE, WM_DESTROY, WS_OVERLAPPED, WS_SYSMENU, WM_USER) from win32gui import (CreateWindow, DestroyWindow, LoadIcon, LoadImage, NIF_ICON, NIF_INFO, NIF_MESSAGE, NIF_TIP, NIM_ADD, NIM_DELETE, NIM_MODIFY, RegisterClass, Shell_NotifyIcon, UpdateWindow, WNDCLASS) except ImportError: raise DependencyError( __name__, 'pypiwin32', 'pywin32 module is required for desktop notifications on ' 'windows. You can install it with `pip install pypiwin32`') # Register the window class. wc = WNDCLASS() hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = "FlexGetTaskbar" if not self.windows_classAtom: self.windows_classAtom = RegisterClass(wc) style = WS_OVERLAPPED | WS_SYSMENU hwnd = CreateWindow(self.windows_classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hinst, None) UpdateWindow(hwnd) hicon = LoadIcon(0, IDI_APPLICATION) # Hackily grab the icon from the webui if possible icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: import flexget.ui icon_path = os.path.join(flexget.ui.__path__[0], 'src', 'favicon.ico') hicon = LoadImage(hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) except Exception as e: log.debug('Error trying to get flexget icon from webui folder: %s', e) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO nid = (hwnd, 0, flags, WM_USER + 20, hicon, "FlexGet Notification", message, config['timeout'] * 1000, title) Shell_NotifyIcon(NIM_ADD, nid)
def GetRemoteProcAddress(hProcess, module, proc): """Get the base address, in the remote address space, at which the procedure of the given module is mapped. XXX in the current implementation we just get the base address in *our* address space. This suppose: - the remote process include the given module - the system maps the module at the same address for every process This just works for MSVCR71 for Python processes; if this is not the case (*no* check are done) the remote process degrade to undefined behavior. XXX TODO implement this function in the right way, rename to GetProvAddressEx? """ handle = GetModuleHandle(module) return GetProcAddress(handle, proc)
def _show_toast(self, title, msg, icon_path, duration): """Notification settings. :title: notification title :msg: notification message :icon_path: path to the .ico file to custom notification :duration: delay in seconds before notification self-destruction """ message_map = { WM_DESTROY: self.on_destroy, } # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str("PythonTaskbar") # must be a string self.wc.style = self.wc.cbWndExtra = 0 # self.wc.lpfnWndProc = message_map # could also specify a wndproc. try: self.classAtom = RegisterClass(self.wc) except: pass # not sure of this style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindowEx(0, "PythonTaskbar", "555", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) hicon = LoadIcon(0, IDI_APPLICATION) # Taskbar icon flags = NIF_ICON | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, "66666") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, "289347293874", msg, 0, title)) # # take a rest then destroy sleep(duration) DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, None) return None
def __init__(self, title, msg, timeout=2): message_map = { win32con.WM_DESTROY: self.OnDestroy, } # Register the Window class. wc = win32gui.WNDCLASS() self.destroyed = False hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = "PythonTaskbar" wc.lpfnWndProc = message_map # could also specify a wndproc. class_atom = win32gui.RegisterClass(wc) # Create the Window. style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU self.hwnd = win32gui.CreateWindow(class_atom, "Taskbar", style, 0, 0, win32con.CW_USEDEFAULT, win32con.CW_USEDEFAULT, 0, 0, hinst, None) win32gui.UpdateWindow(self.hwnd) icon_path_name = ospath.abspath( ospath.join(syspath[0], "balloontip.ico")) icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE try: hicon = win32gui.LoadImage(hinst, icon_path_name, win32con.IMAGE_ICON, 0, 0, icon_flags) except: hicon = win32gui.LoadIcon(0, win32con.IDI_APPLICATION) flags = win32gui.NIF_ICON | win32gui.NIF_MESSAGE | win32gui.NIF_TIP nid = (self.hwnd, 0, flags, win32con.WM_USER + 20, hicon, "tooltip") win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, nid) win32gui.Shell_NotifyIcon( win32gui.NIM_MODIFY, (self.hwnd, 0, win32gui.NIF_INFO, win32con.WM_USER + 20, hicon, "Balloon tooltip", msg, 200, title)) sleep(timeout) win32gui.DestroyWindow(self.hwnd) win32gui.UnregisterClass(class_atom, hinst) self.destroyed = True
def getSignalProcedure(pid): """Get the base address, in the remote address space, at which the 'raise' procedure of the C Runtime Library module is mapped. XXX in the current implementation we just get the base address in *our* address space. This suppose: - the remote process include the given module - the system maps the module at the same address for every process This just works for 'msvcrt.dll' and virtually every Windows program include this library. XXX we first retrieve all the C Runtime modules loaded in the process and use the most recent version """ libc = list(findCRTModules(pid)) if not libc: raise OSError("C Runtime not found", pid) # use the most recent version libc.sort(lambda i, j: cmp(i[2], j[2])) module, version, baseAddress = libc[-1] # find the map address of the procedure in the local process handle = GetModuleHandle(module) address = GetProcAddress(handle, "raise") if baseAddress != handle: # the module is mapped at a different address # XXX TODO the offset of the procedure should be the same, so # it should be still possible to obtain the proc address # address = baseAddress + (address - handle) raise AssertionError("module address mismatch", module) return address
def __init__(self): title = 'wxCommander' #style = wx.DEFAULT_FRAME_STYLE & ~ (wx.FRAME_NO_TASKBAR) & wx.STAY_ON_TOP & ~ (wx.RESIZE_BORDER) style = wx.DEFAULT_FRAME_STYLE & ~ (wx.RESIZE_BORDER) wx.Frame.__init__(self,parent=None, title=title, style=style, size = (1920,1080)) self.Maximize(True) #self.SetSize(1920, 1080) self.panelHijo = MyPanel(self) self.frame_number = 1 #self.Maximize(True) self.SizerPrincipal = wx.BoxSizer(wx.VERTICAL) self.SizerPrincipal.Add(self.panelHijo, 1, wx.EXPAND) self.Bind(wx.EVT_SIZE, self.OnResizeWindow) # Evento de foco #self.Bind(wx.EVT_SET_FOCUS, self.onFocus) #self.panelHijo.Bind(wx.EVT_LEFT_UP, self.OnLeftClick) #self.panelHijo.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown) #self.panelHijo.Bind(wx.EVT_RIGHT_UP, self.OnRightClick) #self.Bind(wx.EVT_RIGHT_UP, self.OnRightClick) self.SetSizer(self.SizerPrincipal) try: if os.path.isfile('icono.ico'): icono = wx.Icon("icono.ico") else: exeName = GetModuleFileName(GetModuleHandle(None)) icono = wx.Icon(exeName, wx.BITMAP_TYPE_ICO) self.SetIcon(icono) except: pass self.__barraMenus() self.CreateStatusBar() self.SetStatusText("Copyright TOI") #self.Fit() self.Show()
def _show_toast( self, title: str, msg: str = "No msg", icon_path: Path = None, duration: float = None, sound_path=None, callback_on_click: callable = None, tooltip: Optional[str] = None, ) -> None: """Notification settings. :param title: notification title :param msg: notification message :param icon_path: path to the .ico file to custom notification :param duration: delay in seconds before notification self-destruction, None for no-self-destruction :param sound_path: path to the .wav file to custom notification """ self.duration = duration def callback(): """ """ self.duration = 0 if callback_on_click is not None: callback_on_click() if tooltip is None: tooltip = PROJECT_NAME # Register the window class. self.window_class = WNDCLASS() self.instance_handle = self.window_class.hInstance = GetModuleHandle( None) self.window_class.lpszClassName = f"{PROJECT_NAME}-{title}" # must be a string self.window_class.lpfnWndProc = self._decorator( self.wnd_proc, callback) # could instead specify simple mapping try: self.classAtom = RegisterClass(self.window_class) except Exception as e: logging.error("Some trouble with classAtom (%s)", e) style = WS_OVERLAPPED | WS_SYSMENU button_style = WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON # TODO: Unused for now self.window_handle = CreateWindow( self.classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.instance_handle, None, ) UpdateWindow(self.window_handle) # icon new_name = "" if icon_path is not None: icon_path = path.realpath(icon_path) converted = False if Image is not None and icon_path.split(".")[-1] != ".ico": img = Image.open(icon_path) new_name = f'{str(icon_path.split(".")[:-1])}.ico' img.save(new_name) icon_path = new_name converted = True else: icon_path = resource_filename( Requirement.parse(PROJECT_NAME), str(Path(PROJECT_NAME) / "data" / "python.ico"), ) converted = False try: hicon = LoadImage( self.instance_handle, icon_path, IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE, ) if Image and path.exists(new_name and converted): remove(new_name) except Exception as e: logging.error("Some trouble with the icon (%s): %s", icon_path, e) hicon = LoadIcon(0, IDI_APPLICATION) # Set the duration """ buff = create_unicode_buffer(10) windll.user32.SystemParametersInfoW(SPI_GETMESSAGEDURATION, 0, buff, 0) try: oldlength = int(buff.value.encode("unicode_escape").decode().replace("\\", "0"), 16) except ValueError: oldlength = 5 # Default notification length duration_output = windll.user32.SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, self.duration, SPIF_SENDCHANGE) windll.user32.SystemParametersInfoW(SPI_GETMESSAGEDURATION, 0, buff, 0) duration_error = False try: int(buff.value.encode("unicode_escape").decode().replace("\\", "0"), 16) except ValueError: duration_error = True if duration_output == 0 or self.duration > 255 or duration_error: windll.user32.SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, oldlength, SPIF_SENDCHANGE) self.active = False raise RuntimeError(f"Some trouble with the duration ({self.duration})" ": Invalid duration length") """ title += " " * randint(0, 63 - len(title)) msg += " " * randint(0, 128 - len(msg)) Shell_NotifyIcon( NIM_ADD, ( self.window_handle, 0, NIF_ICON | NIF_MESSAGE | NIF_TIP, WM_USER + 20, hicon, tooltip, ), ) Shell_NotifyIcon( NIM_MODIFY, ( self.window_handle, 0, NIF_INFO, WM_USER + 20, hicon, tooltip, msg, 200, title, 0 if sound_path is None else NIIF_NOSOUND, ), ) if sound_path is not None: # play the custom sound sound_path = path.realpath(sound_path) if not path.exists(sound_path): logging.error( f"Some trouble with the sound file ({sound_path}): [Errno 2] No such file" ) try: PlaySound(sound_path, SND_FILENAME) except Exception as e: logging.error( f"Some trouble with the sound file ({sound_path}): {e}") PumpMessages() """ # Put the notification duration back to normal SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, oldlength, SPIF_SENDCHANGE) """ if duration is not None: # take a rest then destroy # sleep(duration) while self.duration > 0: sleep(0.1) self.duration -= 0.1 DestroyWindow(self.window_handle) UnregisterClass(self.window_class.lpszClassName, self.instance_handle) try: # Sometimes the try icon sticks around until you click it - this should stop that Shell_NotifyIcon(NIM_DELETE, (self.window_handle, 0)) except WinTypesException: pass self.active = False
def antisandbox(): try: GetModuleHandle("sbiedll.dll") return True except: return False
from abc import ABC from typing import final from win32api import GetModuleHandle from win32con import CW_USEDEFAULT, IMAGE_ICON, LR_DEFAULTSIZE, LR_LOADFROMFILE, WM_USER, \ WS_OVERLAPPED, WS_SYSMENU from win32gui import CreateWindow, DestroyWindow, LoadImage, NIF_ICON, NIF_INFO, NIF_MESSAGE, NIF_TIP, NIM_ADD, \ NIM_MODIFY, NIM_DELETE, RegisterClass, Shell_NotifyIcon, UpdateWindow, WNDCLASS from i18n import I18N_RESOURCES _wnd_class = WNDCLASS() _wnd_class.hInstance = GetModuleHandle(None) _wnd_class.lpszClassName = 'Railway Station Simulator' _wnd_class.lpfnWndProc = {} _wnd_class_instance = RegisterClass(_wnd_class) class Notification(ABC): def __init__(self, logger, caption_key, message_key, current_locale, caption_args=(), message_args=()): self.logger = logger self.handler = CreateWindow(_wnd_class_instance, "Taskbar", WS_OVERLAPPED | WS_SYSMENU, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, _wnd_class.hInstance, None)
def _show_toast(self, title, msg, icon_path, duration, callback_on_click): '''Notification settings. :param title: notification title :param msg: notification message :param icon_path: path to the .ico file to custom notification :para mduration: delay in seconds before notification self-destruction, None for no-self-destruction ''' # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) # must be a string self.wc.lpszClassName = str(f"PythonTaskbar{title}") # could instead specify simple mapping self.wc.lpfnWndProc = self._decorator(self.wnd_proc, callback_on_click) try: self.classAtom = RegisterClass(self.wc) except Exception as e: #logging.error('Some trouble with classAtom (%s)', e) self.classAtom = self.wc style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, 'Taskbar', style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) # icon if icon_path is not None: icon_path = path.realpath(icon_path) converted = False if Image is not None and icon_path.split('.')[-1] != '.ico': img = Image.open(icon_path) new_name = icon_path.split('.')[:-1] + '.ico' img.save(new_name) icon_path = new_name converted = True else: icon_path = resource_filename(Requirement.parse('win10toast'), 'win10toast/data/python.ico') converted = False icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: hicon = LoadImage(self.hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) if Image and path.exists(new_name and converted): remove(new_name) except Exception as e: logging.error('Some trouble with the icon (%s): %s', icon_path, e) hicon = LoadIcon(0, IDI_APPLICATION) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = self.hwnd, 0, flags, WM_USER + 20, hicon, 'Tooltip' Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, 'Balloon Tooltip', msg, 200, title)) PumpMessages() # take a rest then destroy if duration is not None: sleep(duration) DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, None) return None
def _show_toast(self, title, msg, icon_path, delay, sound_path, tooltip, duration, callback_on_click, kill_without_click): """Notification settings. :title: notification title :msg: notification message :icon_path: path to the .ico file to custom notification :delay: delay in seconds before notification self-destruction, None for no-self-destruction :sound_path: path to the .wav file to custom notification :duration: how long the notification stays on the screen in seconds :callback_on_click: function to run on click :kill_without_click: Kill the tray icon after the notification goes away, even if it wasn't clicked """ self.delay = delay self.destroy_window = kill_without_click # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str( f"PythonTaskbar - {uuid4().hex}") # must be a string self.wc.lpfnWndProc = self._decorator( self.wnd_proc, callback_on_click) # could instead specify simple mapping try: self.classAtom = RegisterClass(self.wc) except Exception as e: raise type(e)(f"Some trouble with classAtom:\n{e}") from None style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, "Python Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) # icon if icon_path is not None: icon_path = path.realpath(icon_path) else: icon_path = resource_filename(Requirement.parse("win10toast"), "win10toast/data/python.ico") icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE try: hicon = LoadImage(self.hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) except Exception as e: raise type(e)( f"Some trouble with the icon ({icon_path}):\n{e}") from None hicon = LoadIcon(0, IDI_APPLICATION) # set the duration buff = create_unicode_buffer(10) SystemParametersInfoW(SPI_GETMESSAGEDURATION, 0, buff, 0) try: oldlength = int( buff.value.encode('unicode_escape').decode().replace( "\\", "0"), 16) except ValueError: oldlength = 5 # default notification length durationOutput = SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, duration, SPIF_SENDCHANGE) SystemParametersInfoW(SPI_GETMESSAGEDURATION, 0, buff, 0) durationError = False try: int( buff.value.encode('unicode_escape').decode().replace( "\\", "0"), 16) except ValueError: durationError = True if durationOutput == 0 or duration > 255 or durationError: SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, oldlength, SPIF_SENDCHANGE) raise RuntimeError( f"Some trouble with the duration ({duration}): Invalid duration length" ) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, tooltip) Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon( NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, tooltip, msg, 0, title, 0 if sound_path == None else NIIF_NOSOUND)) # play the custom sound if sound_path is not None: sound_path = path.realpath(sound_path) if not path.exists(sound_path): raise IOError( "Some trouble with the sound file ({sound_path}): [Errno 2] No such file" ) try: PlaySound(sound_path, SND_FILENAME) except Exception as e: raise type( e)(f"Some trouble with the sound file ({sound_path}): {e}" ) from None PumpMessages() # put the notification duration back to normal SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, oldlength, SPIF_SENDCHANGE) # take a rest then destroy if self.delay is not None and self.destroy_window: while self.delay > 0: sleep(0.1) self.delay -= 0.1 DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, self.hinst) try: # sometimes the tray icon sticks around until you click it - this should stop it self.remove_window(self.hwnd) except WinTypesException: pass return
def __call__(self, summary, message="", timeout=2000, **kwargs): tip = kwargs.get("tip", "Balloon tooltip") # Register the Window class. wc = WNDCLASS() hinst = wc.hInstance = GetModuleHandle(None) wc.lpszClassName = "PythonTaskbar" wc.lpfnWndProc = self.message_map # could also specify a wndproc. classAtom = RegisterClass(wc) # Create the Window. style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU self.hwnd = CreateWindow( classAtom, "Taskbar", style, 0, 0, win32con.CW_USEDEFAULT, win32con.CW_USEDEFAULT, 0, 0, hinst, None, ) UpdateWindow(self.hwnd) # Icons managment iconPathName = os.path.abspath( os.path.join(sys.path[0], "balloontip.ico")) icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE try: hicon = LoadImage(hinst, iconPathName, win32con.IMAGE_ICON, 0, 0, icon_flags) except Exception: hicon = LoadIcon(0, win32con.IDI_APPLICATION) flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, win32con.WM_USER + 20, hicon, "tooltip") # Notify Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon( NIM_MODIFY, ( self.hwnd, 0, NIF_INFO, win32con.WM_USER + 20, hicon, tip, message, timeout, summary, ), ) # Destroy DestroyWindow(self.hwnd) classAtom = UnregisterClass(classAtom, hinst) return True
def _show_toast(self, title, msg, icon_path, duration, cbFunc=None, cbArgs=None): """Notification settings. :title: notification title :msg: notification message :icon_path: path to the .ico file to custom notification :duration: delay in seconds before notification self-destruction """ self.user_cbFunc = cbFunc self.user_cbArgs = cbArgs # Register the window class. self.wc = WNDCLASS() self.hinst = self.wc.hInstance = GetModuleHandle(None) self.wc.lpszClassName = str("PythonTaskbar" + os.urandom(24).hex()) # must be a string self.wc.lpfnWndProc = self._decorator( self.wnd_proc, self.user_cbFunc) # could also specify a wndproc. try: self.classAtom = RegisterClass(self.wc) except: pass #not sure of this style = WS_OVERLAPPED | WS_SYSMENU self.hwnd = CreateWindow(self.classAtom, "Taskbar", style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.hinst, None) UpdateWindow(self.hwnd) # icon hicon = None if icon_path is not None: icon_path = path.realpath(icon_path) icon_flags = LR_LOADFROMFILE try: hicon = LoadImage(self.hinst, icon_path, IMAGE_ICON, 0, 0, icon_flags) except Exception as e: logging.error("Some trouble with the icon ({}): {}".format( icon_path, e)) hicon = LoadIcon(0, IDI_APPLICATION) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = (self.hwnd, 0, flags, WM_USER + 20, hicon, "Tooltip") Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon(NIM_MODIFY, (self.hwnd, 0, NIF_INFO, WM_USER + 20, hicon, "Balloon Tooltip", msg, 200, title)) PumpMessages() # take a rest then destroy sleep(duration) DestroyWindow(self.hwnd) UnregisterClass(self.wc.lpszClassName, None) return None
def _show_toast(self): """Internal function called by Toast#display to show the toast""" self.active = True self.destroy_window = self.toast_data["kill_without_click"] # Register the window class self.toast_data["wnd_class"] = WNDCLASS() self.toast_data["hinst"] = self.toast_data[ "wnd_class"].hInstance = GetModuleHandle(None) self.toast_data[ "wnd_class"].lpszClassName = f"PythonTaskbar{uuid4().hex}" self.toast_data["wnd_class"].lpfnWndProc = self._decorator( self._wnd_proc, self.toast_data["callback_on_click"]) self.toast_data["class_atom"] = RegisterClass( self.toast_data["wnd_class"]) style = WS_OVERLAPPED | WS_SYSMENU self.toast_data["hwnd"] = CreateWindow( self.toast_data["class_atom"], self.toast_data["wnd_class"].lpszClassName, style, 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, self.toast_data["hinst"], None, ) UpdateWindow(self.toast_data["hwnd"]) icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE hicon = LoadImage(self.toast_data["hinst"], self.toast_data['icon_path'], IMAGE_ICON, 0, 0, icon_flags) # Set the duration buff = create_unicode_buffer(10) SystemParametersInfoW(SPI_GETMESSAGEDURATION, 0, buff, 0) try: oldlength = int( buff.value.encode("unicode_escape").decode().replace( "\\", "0"), 16) except ValueError: oldlength = 5 # Default notification length SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, self.toast_data["duration"], SPIF_SENDCHANGE) # Taskbar icon flags = NIF_ICON | NIF_MESSAGE | NIF_TIP nid = ( self.toast_data["hwnd"], 0, flags, WM_USER + 20, hicon, self.toast_data["tooltip"], ) # Make it so that it won't replace another # notification with the same title and message title = self.toast_data["title"] + " " * randint( 0, 63 - len(self.toast_data["title"])) message = self.toast_data["msg"] + " " * randint( 0, 128 - len(self.toast_data["msg"])) # Add tray icon and queue message Shell_NotifyIcon(NIM_ADD, nid) Shell_NotifyIcon( NIM_MODIFY, ( self.toast_data["hwnd"], 0, NIF_INFO, WM_USER + 20, hicon, self.toast_data["tooltip"], message, 0, title, NIIF_NOSOUND if self.toast_data["sound_path"] else 0, ), ) # Play the custom sound if self.toast_data["sound_path"] is not None: sound_path = path.realpath(self.toast_data["sound_path"]) PlaySound(sound_path, SND_FILENAME) # Show the message PumpMessages() # Put the notification duration back to normal SystemParametersInfoW(SPI_SETMESSAGEDURATION, 0, oldlength, SPIF_SENDCHANGE) # Take a rest then destroy if not self.toast_data["keep_alive"] and self.destroy_window: self.destroy()