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()
