def register(classobj):
import winreg
subKeyCLSID = "SOFTWARE\\Microsoft\\Internet Explorer\\Extensions\\%38s" % classobj._reg_clsid_
try:
hKey = winreg.CreateKey( winreg.HKEY_LOCAL_MACHINE, subKeyCLSID )
subKey = winreg.SetValueEx( hKey, "ButtonText", 0, winreg.REG_SZ, classobj._button_text_ )
winreg.SetValueEx( hKey, "ClsidExtension", 0, winreg.REG_SZ, classobj._reg_clsid_ ) # reg value for calling COM object
winreg.SetValueEx( hKey, "CLSID", 0, winreg.REG_SZ, "{1FBA04EE-3024-11D2-8F1F-0000F87ABD16}" ) # CLSID for button that sends command to COM object
winreg.SetValueEx( hKey, "Default Visible", 0, winreg.REG_SZ, "Yes" )
winreg.SetValueEx( hKey, "ToolTip", 0, winreg.REG_SZ, classobj._tool_tip_ )
winreg.SetValueEx( hKey, "Icon", 0, winreg.REG_SZ, classobj._icon_)
winreg.SetValueEx( hKey, "HotIcon", 0, winreg.REG_SZ, classobj._hot_icon_)
except WindowsError:
print("Couldn't set standard toolbar reg keys.")
else:
print("Set standard toolbar reg keys.")
python类REG_SZ的实例源码
def is_autostart_enabled(self):
if os.name == 'nt':
with winreg.OpenKey(winreg.HKEY_CURRENT_USER, self._windows_run_reg_key, 0, winreg.KEY_ALL_ACCESS) as key:
try:
reg_value, reg_type = winreg.QueryValueEx(key, const.APP_NAME)
if reg_type == winreg.REG_SZ and reg_value == self._get_executable_path():
return True
else:
try:
winreg.DeleteValue(key, self.WIN_REG_AUTORUN_KEY)
except OSError:
pass # key does not exist
except:
return False
else:
return os.path.exists(self._linux_autostart_file)
def config_win():
try:
import winreg as reg
key = reg.CreateKey(reg.HKEY_CURRENT_USER, 'SOFTWARE\\Classes\\nzblnk')
reg.SetValue(key, '', reg.REG_SZ, 'URL:nzblnk')
reg.SetValueEx(key, 'URL Protocol', 0, reg.REG_SZ, '')
reg.CloseKey(key)
key = reg.CreateKey(reg.HKEY_CURRENT_USER, 'SOFTWARE\\Classes\\nzblnk\\shell\\open\\command')
reg.SetValue(key, '', reg.REG_SZ, '"{0}" "%1"'.format(op.normpath(os.path.abspath(sys.executable))))
reg.CloseKey(key)
except (OSError, ImportError):
print(Col.FAIL + ' FAILED to setup registry link for NZBLNK scheme!' + Col.OFF)
sleep(wait_time)
sys.exit(2)
def DllRegisterServer():
import winreg
key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\" \
"Explorer\\Desktop\\Namespace\\" + \
ShellFolderRoot._reg_clsid_)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, ShellFolderRoot._reg_desc_)
# And special shell keys under our CLSID
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"CLSID\\" + ShellFolderRoot._reg_clsid_ + "\\ShellFolder")
# 'Attributes' is an int stored as a binary! use struct
attr = shellcon.SFGAO_FOLDER | shellcon.SFGAO_HASSUBFOLDER | \
shellcon.SFGAO_BROWSABLE
import struct
s = struct.pack("i", attr)
winreg.SetValueEx(key, "Attributes", 0, winreg.REG_BINARY, s)
print(ShellFolderRoot._reg_desc_, "registration complete.")
def addActionToShell(self, name, descr, cmd):
"""
add action in windows explorer on top of file & dir
"""
if descr == "":
descr = name
import winreg as winreg
for item in ["*", "Directory"]:
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, r'%s\shell\%s' % (item, name))
key2 = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, r'%s\shell\%s\Command' % (item, name))
winreg.SetValueEx(key, "", None, winreg.REG_SZ, "%s " % descr)
winreg.SetValueEx(key, "Icon", None, winreg.REG_SZ, "")
winreg.SetValueEx(key, "Position", None, winreg.REG_SZ, "Top")
winreg.SetValueEx(key, "", None, winreg.REG_SZ, "%s " % descr)
#winreg.SetValueEx(key2,"",None,winreg.REG_SZ,r'cmd.exe /s /k pushd "%V"')
winreg.SetValueEx(key2, "", None, winreg.REG_SZ, cmd)
winreg.CloseKey(key)
def _save_autostart_win(self, on):
with winreg.OpenKey(winreg.HKEY_CURRENT_USER, self._windows_run_reg_key, 0, winreg.KEY_ALL_ACCESS) as key:
if on:
winreg.SetValueEx(key, const.APP_NAME, 0, winreg.REG_SZ, self._get_executable_path())
else:
try:
winreg.DeleteValue(key, const.APP_NAME)
except OSError:
pass # key does not exist
def read_windows_registry(self, strict=True):
"""
Load the MIME types database from Windows registry.
If strict is true, information will be added to
list of standard types, else to the list of non-standard
types.
"""
# Windows only
if not _winreg:
return
def enum_types(mimedb):
i = 0
while True:
try:
ctype = _winreg.EnumKey(mimedb, i)
except EnvironmentError:
break
else:
yield ctype
i += 1
default_encoding = sys.getdefaultencoding()
with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT,
r'MIME\Database\Content Type') as mimedb:
for ctype in enum_types(mimedb):
try:
with _winreg.OpenKey(mimedb, ctype) as key:
suffix, datatype = _winreg.QueryValueEx(key,
'Extension')
except EnvironmentError:
continue
if datatype != _winreg.REG_SZ:
continue
self.add_type(ctype, suffix, strict)
def DllRegisterServer():
# Also need to register specially in:
# HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Explorer\VolumeCaches
# See link at top of file.
import winreg
kn = r"Software\Microsoft\Windows\CurrentVersion\Explorer\VolumeCaches\%s" \
% (EmptyVolumeCache._reg_desc_,)
key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, kn)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, EmptyVolumeCache._reg_clsid_)
def DllRegisterServer():
import winreg
if sys.getwindowsversion()[0] < 6:
print("This sample only works on Vista")
sys.exit(1)
key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\" \
"Explorer\\Desktop\\Namespace\\" + \
ShellFolder._reg_clsid_)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, ShellFolder._reg_desc_)
# And special shell keys under our CLSID
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"CLSID\\" + ShellFolder._reg_clsid_ + "\\ShellFolder")
# 'Attributes' is an int stored as a binary! use struct
attr = shellcon.SFGAO_FOLDER | shellcon.SFGAO_HASSUBFOLDER | \
shellcon.SFGAO_BROWSABLE
import struct
s = struct.pack("i", attr)
winreg.SetValueEx(key, "Attributes", 0, winreg.REG_BINARY, s)
# register the context menu handler under the FolderViewSampleType type.
keypath = "%s\\shellex\\ContextMenuHandlers\\%s" % (ContextMenu._context_menu_type_, ContextMenu._reg_desc_)
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, keypath)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, ContextMenu._reg_clsid_)
propsys.PSRegisterPropertySchema(get_schema_fname())
print(ShellFolder._reg_desc_, "registration complete.")
def DllRegisterServer():
import winreg
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"Python.File\\shellex")
subkey = winreg.CreateKey(key, "IconHandler")
winreg.SetValueEx(subkey, None, 0, winreg.REG_SZ, ShellExtension._reg_clsid_)
print(ShellExtension._reg_desc_, "registration complete.")
def DllRegisterServer():
import winreg
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"directory\\shellex\\CopyHookHandlers\\" +
ShellExtension._reg_desc_)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, ShellExtension._reg_clsid_)
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"*\\shellex\\CopyHookHandlers\\" +
ShellExtension._reg_desc_)
winreg.SetValueEx(key, None, 0, winreg.REG_SZ, ShellExtension._reg_clsid_)
print(ShellExtension._reg_desc_, "registration complete.")
def DllRegisterServer():
import winreg
key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT,
"Python.File\\shellex")
subkey = winreg.CreateKey(key, "ContextMenuHandlers")
subkey2 = winreg.CreateKey(subkey, "PythonSample")
winreg.SetValueEx(subkey2, None, 0, winreg.REG_SZ, ShellExtension._reg_clsid_)
print(ShellExtension._reg_desc_, "registration complete.")
def _doregister(mod_name, dll_name):
assert os.path.isfile(dll_name), "Shouldn't get here if the file doesn't exist!"
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "Software\\Python\\PythonCore\\%s\\Modules\\%s" % (sys.winver, mod_name))
except winreg.error:
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "Software\\Python\\PythonCore\\%s\\Modules\\%s" % (sys.winver, mod_name))
except winreg.error:
print("Could not find the existing '%s' module registered in the registry" % (mod_name,))
usage_and_die(4)
# Create the debug key.
sub_key = winreg.CreateKey(key, "Debug")
winreg.SetValue(sub_key, None, winreg.REG_SZ, dll_name)
print("Registered '%s' in the registry" % (dll_name,))
def RegisterAddin(klass):
import winreg
key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Office\\Excel\\Addins")
subkey = winreg.CreateKey(key, klass._reg_progid_)
winreg.SetValueEx(subkey, "CommandLineSafe", 0, winreg.REG_DWORD, 0)
winreg.SetValueEx(subkey, "LoadBehavior", 0, winreg.REG_DWORD, 3)
winreg.SetValueEx(subkey, "Description", 0, winreg.REG_SZ, "Excel Addin")
winreg.SetValueEx(subkey, "FriendlyName", 0, winreg.REG_SZ, "A Simple Excel Addin")
def RegisterAddin(klass):
import winreg
key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Office\\Outlook\\Addins")
subkey = winreg.CreateKey(key, klass._reg_progid_)
winreg.SetValueEx(subkey, "CommandLineSafe", 0, winreg.REG_DWORD, 0)
winreg.SetValueEx(subkey, "LoadBehavior", 0, winreg.REG_DWORD, 3)
winreg.SetValueEx(subkey, "Description", 0, winreg.REG_SZ, klass._reg_progid_)
winreg.SetValueEx(subkey, "FriendlyName", 0, winreg.REG_SZ, klass._reg_progid_)
def add_to_startup(filename='"{}" --silent'.format(sys.argv[0])):
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'SOFTWARE\Microsoft\Windows\CurrentVersion\Run', 0, winreg.KEY_SET_VALUE)
winreg.SetValueEx(key, REGISTRY_NAME, 0, winreg.REG_SZ, filename)
key.Close()
def read_windows_registry(self, strict=True):
"""
Load the MIME types database from Windows registry.
If strict is true, information will be added to
list of standard types, else to the list of non-standard
types.
"""
# Windows only
if not _winreg:
return
def enum_types(mimedb):
i = 0
while True:
try:
ctype = _winreg.EnumKey(mimedb, i)
except EnvironmentError:
break
else:
if '\0' not in ctype:
yield ctype
i += 1
with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, '') as hkcr:
for subkeyname in enum_types(hkcr):
try:
with _winreg.OpenKey(hkcr, subkeyname) as subkey:
# Only check file extensions
if not subkeyname.startswith("."):
continue
# raises EnvironmentError if no 'Content Type' value
mimetype, datatype = _winreg.QueryValueEx(
subkey, 'Content Type')
if datatype != _winreg.REG_SZ:
continue
self.add_type(mimetype, subkeyname, strict)
except EnvironmentError:
continue
get_toolchain_if_necessary.py 文件源码
项目：Chromium_DepotTools
作者: p07r0457
项目源码
文件源码
阅读 20
收藏 0
点赞 0
评论 0
def GetInstallerName():
"""Return the name of the Windows 10 Universal C Runtime installer for the
current platform, or None if installer is not needed or not applicable.
The registry has to be used instead of sys.getwindowsversion() because
Python 2.7 is only manifested as being compatible up to Windows 8, so the
version APIs helpfully return a maximum of 6.2 (Windows 8).
"""
key_name = r'Software\Microsoft\Windows NT\CurrentVersion'
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_name)
value, keytype = winreg.QueryValueEx(key, "CurrentVersion")
key.Close()
if keytype != winreg.REG_SZ:
raise Exception("Unexpected type in registry")
if value == '6.1':
# Windows 7 and Windows Server 2008 R2
return 'Windows6.1-KB2999226-x64.msu'
elif value == '6.2':
# Windows 8 and Windows Server 2012
return 'Windows8-RT-KB2999226-x64.msu'
elif value == '6.3':
# Windows 8.1, Windows Server 2012 R2, and Windows 10.
# The Windows 8.1 installer doesn't work on Windows 10, but it will never
# be used because the UCRT is always installed on Windows 10.
return 'Windows8.1-KB2999226-x64.msu'
else:
# Some future OS.
return None
def GetInstallerName():
"""Return the name of the Windows 10 Universal C Runtime installer for the
current platform, or None if installer is not needed or not applicable.
The registry has to be used instead of sys.getwindowsversion() because
Python 2.7 is only manifested as being compatible up to Windows 8, so the
version APIs helpfully return a maximum of 6.2 (Windows 8).
"""
key_name = r'Software\Microsoft\Windows NT\CurrentVersion'
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_name)
value, keytype = winreg.QueryValueEx(key, "CurrentVersion")
key.Close()
if keytype != winreg.REG_SZ:
raise Exception("Unexpected type in registry")
if value == '6.1':
# Windows 7 and Windows Server 2008 R2
return 'Windows6.1-KB2999226-x64.msu'
elif value == '6.2':
# Windows 8 and Windows Server 2012
return 'Windows8-RT-KB2999226-x64.msu'
elif value == '6.3':
# Windows 8.1, Windows Server 2012 R2, and Windows 10.
# The Windows 8.1 installer doesn't work on Windows 10, but it will never
# be used because the UCRT is always installed on Windows 10.
return 'Windows8.1-KB2999226-x64.msu'
else:
# Some future OS.
return None
def read_windows_registry(self, strict=True):
"""
Load the MIME types database from Windows registry.
If strict is true, information will be added to
list of standard types, else to the list of non-standard
types.
"""
# Windows only
if not _winreg:
return
def enum_types(mimedb):
i = 0
while True:
try:
ctype = _winreg.EnumKey(mimedb, i)
except EnvironmentError:
break
else:
yield ctype
i += 1
with _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, '') as hkcr:
for subkeyname in enum_types(hkcr):
try:
with _winreg.OpenKey(hkcr, subkeyname) as subkey:
# Only check file extensions
if not subkeyname.startswith("."):
continue
# raises EnvironmentError if no 'Content Type' value
mimetype, datatype = _winreg.QueryValueEx(
subkey, 'Content Type')
if datatype != _winreg.REG_SZ:
continue
self.add_type(mimetype, subkeyname, strict)
except EnvironmentError:
continue
def refresh_proxy_state(enable=None):
if enable:
try:
ProxyOverride, reg_type = winreg.QueryValueEx(SETTINGS, 'ProxyOverride')
except:
ProxyOverride =None
#??????????
if not ProxyOverride:
winreg.SetValueEx(SETTINGS, 'ProxyOverride', 0, winreg.REG_SZ, ProxyOverride)
Popen((py_exe, refresh_proxy))
def disable_x_proxy(type):
proxy_state = proxy_state_menu
proxy_state.__delattr__(type)
#?? AutoConfigURL ??????????
#??????? Server
proxy_state.type = 2
ProxyServer = proxy_state.str
if ProxyServer == '':
winreg.SetValueEx(SETTINGS, 'ProxyEnable', 0, winreg.REG_DWORD, 0)
else:
winreg.SetValueEx(SETTINGS, 'ProxyServer', 0, winreg.REG_SZ, ProxyServer)
refresh_proxy_state()
def enable_proxy(ProxyServer):
proxy_state = proxy_state_menu
#?? AutoConfigURL ???? ProxyServer
if proxy_state.pac:
winreg.DeleteValue(SETTINGS, 'AutoConfigURL')
if not proxy_state.type & 2:
winreg.SetValueEx(SETTINGS, 'ProxyEnable', 0, winreg.REG_DWORD, 1)
proxy_state.type = 2
proxy_state.http = ProxyServer.http
proxy_state.https = ProxyServer.https
winreg.SetValueEx(SETTINGS, 'ProxyServer', 0, winreg.REG_SZ, proxy_state.str)
refresh_proxy_state(1)
def set_password(self, service, username, password):
"""Write the password to the registry
"""
# encrypt the password
password_encrypted = _win_crypto.encrypt(password.encode('utf-8'))
# encode with base64
password_base64 = base64.encodestring(password_encrypted)
# encode again to unicode
password_saved = password_base64.decode('ascii')
# store the password
key_name = r'Software\%s\Keyring' % service
hkey = winreg.CreateKey(winreg.HKEY_CURRENT_USER, key_name)
winreg.SetValueEx(hkey, username, 0, winreg.REG_SZ, password_saved)
def add(name, application):
"""add a new autostart entry"""
key = get_runonce()
try:
winreg.SetValueEx(key, name, 0, winreg.REG_SZ, application)
except WindowsError as e:
print(e)
winreg.CloseKey(key)
def _win32_is_nic_enabled(self, lm, guid, interface_key):
# Look in the Windows Registry to determine whether the network
# interface corresponding to the given guid is enabled.
#
# (Code contributed by Paul Marks, thanks!)
#
try:
# This hard-coded location seems to be consistent, at least
# from Windows 2000 through Vista.
connection_key = _winreg.OpenKey(
lm,
r'SYSTEM\CurrentControlSet\Control\Network'
r'\{4D36E972-E325-11CE-BFC1-08002BE10318}'
r'\%s\Connection' % guid)
try:
# The PnpInstanceID points to a key inside Enum
(pnp_id, ttype) = _winreg.QueryValueEx(
connection_key, 'PnpInstanceID')
if ttype != _winreg.REG_SZ:
raise ValueError
device_key = _winreg.OpenKey(
lm, r'SYSTEM\CurrentControlSet\Enum\%s' % pnp_id)
try:
# Get ConfigFlags for this device
(flags, ttype) = _winreg.QueryValueEx(
device_key, 'ConfigFlags')
if ttype != _winreg.REG_DWORD:
raise ValueError
# Based on experimentation, bit 0x1 indicates that the
# device is disabled.
return not (flags & 0x1)
finally:
device_key.Close()
finally:
connection_key.Close()
except (EnvironmentError, ValueError):
# Pre-vista, enabled interfaces seem to have a non-empty
# NTEContextList; this was how dnspython detected enabled
# nics before the code above was contributed. We've retained
# the old method since we don't know if the code above works
# on Windows 95/98/ME.
try:
(nte, ttype) = _winreg.QueryValueEx(interface_key,
'NTEContextList')
return nte is not None
except WindowsError:
return False
def load(self, data):
"""
Prepare the content for display
"""
self.type = data["type"]
if self.type == "powerpoint":
if not self.pptregistry: return False
# https://mail.python.org/pipermail/python-win32/2012-July/012471.html
self.PPTapplication = win32com.client.DispatchWithEvents("PowerPoint.Application", self.PPTevents)
try:
self.PPTpresentation = self.PPTapplication.Presentations.Open(data["path"].replace("/", "\\"),
WithWindow=False)
# Change PowerPoint output monitor setting (Touch and revert)
reset = []
try:
reset.append((winreg.QueryValueEx(self.pptregistry, "UseAutoMonSelection")[0],
lambda value: winreg.SetValueEx(self.pptregistry, "UseAutoMonSelection", 0,
winreg.REG_DWORD,
value)))
except WindowsError:
reset.append((None, lambda _: winreg.DeleteValue(self.pptregistry, "UseAutoMonSelection")))
try:
reset.append((winreg.QueryValueEx(self.pptregistry, "DisplayMonitor")[0],
lambda value: winreg.SetValueEx(self.pptregistry, "DisplayMonitor", 0, winreg.REG_SZ,
value)))
except WindowsError:
reset.append((None, lambda _: winreg.DeleteValue(self.pptregistry, "DisplayMonitor")))
winreg.SetValueEx(self.pptregistry, "DisplayMonitor", 0, winreg.REG_SZ,
self.states["screens"][self.states["display"]["outputID"]]["physical"])
winreg.SetValueEx(self.pptregistry, "UseAutoMonSelection", 0, winreg.REG_DWORD, 0)
self.PPTpresentation.SlideShowSettings.ShowPresenterView = False
self.PPTpresentation.SlideShowSettings.Run()
self.PPTpresentation.SlideShowWindow.View.AcceleratorsEnabled = False
self.overlay.setGeometry(self.screen)
self.overlay.showFullScreen()
[action(value) for value, action in reset]
except Exception as e:
print(e)
else:
# Play with VLC
self.player.set_hwnd(int(self.foreground.winId()))
self.VLCmedia = self.vlc.media_new(data["path"])
self.player.set_media(self.VLCmedia)
def _win32_is_nic_enabled(self, lm, guid, interface_key):
# Look in the Windows Registry to determine whether the network
# interface corresponding to the given guid is enabled.
#
# (Code contributed by Paul Marks, thanks!)
#
try:
# This hard-coded location seems to be consistent, at least
# from Windows 2000 through Vista.
connection_key = _winreg.OpenKey(
lm,
r'SYSTEM\CurrentControlSet\Control\Network'
r'\{4D36E972-E325-11CE-BFC1-08002BE10318}'
r'\%s\Connection' % guid)
try:
# The PnpInstanceID points to a key inside Enum
(pnp_id, ttype) = _winreg.QueryValueEx(
connection_key, 'PnpInstanceID')
if ttype != _winreg.REG_SZ:
raise ValueError
device_key = _winreg.OpenKey(
lm, r'SYSTEM\CurrentControlSet\Enum\%s' % pnp_id)
try:
# Get ConfigFlags for this device
(flags, ttype) = _winreg.QueryValueEx(
device_key, 'ConfigFlags')
if ttype != _winreg.REG_DWORD:
raise ValueError
# Based on experimentation, bit 0x1 indicates that the
# device is disabled.
return not (flags & 0x1)
finally:
device_key.Close()
finally:
connection_key.Close()
except (EnvironmentError, ValueError):
# Pre-vista, enabled interfaces seem to have a non-empty
# NTEContextList; this was how dnspython detected enabled
# nics before the code above was contributed. We've retained
# the old method since we don't know if the code above works
# on Windows 95/98/ME.
try:
(nte, ttype) = _winreg.QueryValueEx(interface_key,
'NTEContextList')
return nte is not None
except WindowsError:
return False
def fixed_install_font(src_path):
# copy the font to the Windows Fonts folder
dst_path = os.path.join(
os.environ['SystemRoot'], 'Fonts', os.path.basename(src_path)
)
shutil.copy(src_path, dst_path)
# load the font in the current session
if not gdi32.AddFontResourceW(dst_path):
os.remove(dst_path)
raise WindowsError('AddFontResource failed to load "%s"' % src_path)
# notify running programs
user32.SendMessageTimeoutW(
HWND_BROADCAST, WM_FONTCHANGE, 0, 0, SMTO_ABORTIFHUNG, 1000, None
)
# store the fontname/filename in the registry
filename = os.path.basename(dst_path)
fontname = os.path.splitext(filename)[0]
# try to get the font's real name
cb = wintypes.DWORD()
if gdi32.GetFontResourceInfoW(
filename, ctypes.byref(cb), None, GFRI_DESCRIPTION
):
buf = (ctypes.c_wchar * cb.value)()
if gdi32.GetFontResourceInfoW(
filename, ctypes.byref(cb), buf, GFRI_DESCRIPTION
):
fontname = buf.value
is_truetype = wintypes.BOOL()
cb.value = ctypes.sizeof(is_truetype)
gdi32.GetFontResourceInfoW(
filename, ctypes.byref(cb), ctypes.byref(is_truetype), GFRI_ISTRUETYPE
)
if is_truetype:
fontname += ' (TrueType)'
with winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE, FONTS_REG_PATH, 0, winreg.KEY_SET_VALUE
) as key:
winreg.SetValueEx(key, fontname, 0, winreg.REG_SZ, filename)
def jit(vdb, line):
'''
Enable/Disable the current VDB location as the current Just-In-Time
debugger for windows applications.
Usage: jitenable [-D]
-E Enable VDB JIT debugging
-D Disable JIT debugging
'''
argv = e_cli.splitargs(line)
try:
opts, args = getopt.getopt(argv, "ED")
except Exception as e:
return vdb.do_help('jit')
try:
import winreg
except Exception as e:
vdb.vprint('Error Importing _winreg: %s' % e)
return
HKLM = winreg.HKEY_LOCAL_MACHINE
HKCU = winreg.HKEY_CURRENT_USER
REG_SZ = winreg.REG_SZ
regpath = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug'
# wow64path = r'SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\AeDebug'
# regkey = _winreg.CreateKey(HKLM, regpath)
regkey = winreg.CreateKey(HKLM, regpath)
vdb.vprint('JIT Currently: %s' % winreg.QueryValueEx(regkey, 'Debugger')[0])
setval = None
for opt, optarg in opts:
if opt == '-D':
setval = ''
elif opt == '-E':
vdbpath = os.path.abspath(sys.argv[0])
setval = '%s %s -r -p %%ld -e %%Id' % (sys.executable, vdbpath)
# _winreg.SetValue(HKLM
if setval != None:
vdb.vprint('Setting JIT: %s' % (setval,))
winreg.SetValueEx(regkey, 'Debugger', None, REG_SZ, setval)
