home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_2846 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  13.2 KB  |  494 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import win32api
  6. import win32con
  7. import pythoncom
  8. import winerror
  9. import os
  10. CATID_PythonCOMServer = '{B3EF80D0-68E2-11D0-A689-00C04FD658FF}'
  11.  
  12. def _set_subkeys(keyName, valueDict, base = win32con.HKEY_CLASSES_ROOT):
  13.     hkey = win32api.RegCreateKey(base, keyName)
  14.     
  15.     try:
  16.         for key, value in valueDict.items():
  17.             win32api.RegSetValueEx(hkey, key, None, win32con.REG_SZ, value)
  18.     finally:
  19.         win32api.RegCloseKey(hkey)
  20.  
  21.  
  22.  
  23. def _set_string(path, value, base = win32con.HKEY_CLASSES_ROOT):
  24.     win32api.RegSetValue(base, path, win32con.REG_SZ, value)
  25.  
  26.  
  27. def _get_string(path, base = win32con.HKEY_CLASSES_ROOT):
  28.     
  29.     try:
  30.         return win32api.RegQueryValue(base, path)
  31.     except win32api.error:
  32.         return None
  33.  
  34.  
  35.  
  36. def _remove_key(path, base = win32con.HKEY_CLASSES_ROOT):
  37.     
  38.     try:
  39.         win32api.RegDeleteKey(base, path)
  40.     except win32api.error:
  41.         (code, fn, msg) = None
  42.         if code != winerror.ERROR_FILE_NOT_FOUND:
  43.             raise win32api.error, (code, fn, msg)
  44.         code != winerror.ERROR_FILE_NOT_FOUND
  45.  
  46.  
  47.  
  48. def recurse_delete_key(path, base = win32con.HKEY_CLASSES_ROOT):
  49.     
  50.     try:
  51.         h = win32api.RegOpenKey(base, path)
  52.     except win32api.error:
  53.         (code, fn, msg) = None
  54.         if code != winerror.ERROR_FILE_NOT_FOUND:
  55.             raise win32api.error, (code, fn, msg)
  56.         code != winerror.ERROR_FILE_NOT_FOUND
  57.  
  58.     
  59.     try:
  60.         while None:
  61.             
  62.             try:
  63.                 subkeyname = win32api.RegEnumKey(h, 0)
  64.             except win32api.error:
  65.                 (code, fn, msg) = None
  66.                 if code != winerror.ERROR_NO_MORE_ITEMS:
  67.                     raise win32api.error, (code, fn, msg)
  68.                 code != winerror.ERROR_NO_MORE_ITEMS
  69.                 break
  70.  
  71.             continue
  72.             _remove_key(path, base)
  73.         win32api.RegCloseKey(h)
  74.         return None
  75.  
  76.  
  77.  
  78. def _cat_registrar():
  79.     return pythoncom.CoCreateInstance(pythoncom.CLSID_StdComponentCategoriesMgr, None, pythoncom.CLSCTX_INPROC_SERVER, pythoncom.IID_ICatRegister)
  80.  
  81.  
  82. def _find_localserver_exe(mustfind):
  83.     if not sys.platform.startswith('win32'):
  84.         return sys.executable
  85.     if pythoncom.__file__.find('_d') < 0:
  86.         exeBaseName = 'pythonw.exe'
  87.     else:
  88.         exeBaseName = 'pythonw_d.exe'
  89.     exeName = os.path.join(os.path.split(sys.executable)[0], exeBaseName)
  90.     if not os.path.exists(exeName):
  91.         exeName = os.path.join(sys.prefix, exeBaseName)
  92.     
  93.     if not os.path.exists(exeName):
  94.         exeName = os.path.join(sys.prefix, 'PCbuild', exeBaseName)
  95.     
  96.     if not os.path.exists(exeName):
  97.         
  98.         try:
  99.             key = 'SOFTWARE\\Python\\PythonCore\\%s\\InstallPath' % sys.winver
  100.             path = win32api.RegQueryValue(win32con.HKEY_LOCAL_MACHINE, key)
  101.             exeName = os.path.join(path, exeBaseName)
  102.         except (AttributeError, win32api.error):
  103.             pass
  104.         except:
  105.             None<EXCEPTION MATCH>(AttributeError, win32api.error)
  106.         
  107.  
  108.     None<EXCEPTION MATCH>(AttributeError, win32api.error)
  109.     if not os.path.exists(exeName):
  110.         if mustfind:
  111.             raise RuntimeError, "Can not locate the program '%s'" % exeBaseName
  112.         mustfind
  113.         return None
  114.     return exeName
  115.  
  116.  
  117. def _find_localserver_module():
  118.     import win32com.server as win32com
  119.     path = win32com.server.__path__[0]
  120.     baseName = 'localserver'
  121.     pyfile = os.path.join(path, baseName + '.py')
  122.     
  123.     try:
  124.         os.stat(pyfile)
  125.     except os.error:
  126.         ext = '.pyo'
  127.         pyfile = os.path.join(path, baseName + ext)
  128.         
  129.         try:
  130.             os.stat(pyfile)
  131.         except os.error:
  132.             raise RuntimeError, "Can not locate the Python module 'win32com.server.%s'" % baseName
  133.         except:
  134.             None<EXCEPTION MATCH>os.error
  135.         
  136.  
  137.         None<EXCEPTION MATCH>os.error
  138.  
  139.     return pyfile
  140.  
  141.  
  142. def RegisterServer(clsid, pythonInstString = None, desc = None, progID = None, verProgID = None, defIcon = None, threadingModel = 'both', policy = None, catids = [], other = { }, addPyComCat = None, dispatcher = None, clsctx = None, addnPath = None):
  143.     if not pythonInstString and not policy:
  144.         raise TypeError, 'You must specify either the Python Class or Python Policy which implement the COM object.'
  145.     not policy
  146.     keyNameRoot = 'CLSID\\%s' % str(clsid)
  147.     _set_string(keyNameRoot, desc)
  148.     _set_string('AppID\\%s' % clsid, progID)
  149.     if not clsctx:
  150.         clsctx = pythoncom.CLSCTX_INPROC_SERVER | pythoncom.CLSCTX_LOCAL_SERVER
  151.     
  152.     if pythoncom.frozen:
  153.         if sys.frozen == 'dll':
  154.             clsctx = clsctx & pythoncom.CLSCTX_INPROC_SERVER
  155.         else:
  156.             clsctx = clsctx & pythoncom.CLSCTX_LOCAL_SERVER
  157.     
  158.     if clsctx & pythoncom.CLSCTX_INPROC_SERVER:
  159.         if pythoncom.frozen:
  160.             if hasattr(sys, 'frozendllhandle'):
  161.                 dllName = win32api.GetModuleFileName(sys.frozendllhandle)
  162.             else:
  163.                 raise RuntimeError, "We appear to have a frozen DLL, but I don't know the DLL to use"
  164.         hasattr(sys, 'frozendllhandle')
  165.         dllName = os.path.basename(pythoncom.__file__)
  166.         _set_subkeys(keyNameRoot + '\\InprocServer32', {
  167.             None: dllName,
  168.             'ThreadingModel': threadingModel })
  169.     else:
  170.         _remove_key(keyNameRoot + '\\InprocServer32')
  171.     if clsctx & pythoncom.CLSCTX_LOCAL_SERVER:
  172.         if pythoncom.frozen:
  173.             exeName = win32api.GetShortPathName(sys.executable)
  174.             command = '%s /Automate' % (exeName,)
  175.         else:
  176.             exeName = _find_localserver_exe(1)
  177.             exeName = win32api.GetShortPathName(exeName)
  178.             pyfile = _find_localserver_module()
  179.             command = '%s "%s" %s' % (exeName, pyfile, str(clsid))
  180.         _set_string(keyNameRoot + '\\LocalServer32', command)
  181.     else:
  182.         _remove_key(keyNameRoot + '\\LocalServer32')
  183.     if pythonInstString:
  184.         _set_string(keyNameRoot + '\\PythonCOM', pythonInstString)
  185.     else:
  186.         _remove_key(keyNameRoot + '\\PythonCOM')
  187.     if policy:
  188.         _set_string(keyNameRoot + '\\PythonCOMPolicy', policy)
  189.     else:
  190.         _remove_key(keyNameRoot + '\\PythonCOMPolicy')
  191.     if dispatcher:
  192.         _set_string(keyNameRoot + '\\PythonCOMDispatcher', dispatcher)
  193.     else:
  194.         _remove_key(keyNameRoot + '\\PythonCOMDispatcher')
  195.     if defIcon:
  196.         _set_string(keyNameRoot + '\\DefaultIcon', defIcon)
  197.     else:
  198.         _remove_key(keyNameRoot + '\\DefaultIcon')
  199.     if addnPath:
  200.         _set_string(keyNameRoot + '\\PythonCOMPath', addnPath)
  201.     else:
  202.         _remove_key(keyNameRoot + '\\PythonCOMPath')
  203.     if addPyComCat is None:
  204.         addPyComCat = pythoncom.frozen == 0
  205.     
  206.     if addPyComCat:
  207.         catids = catids + [
  208.             CATID_PythonCOMServer]
  209.     
  210.     if catids:
  211.         regCat = _cat_registrar()
  212.         regCat.RegisterClassImplCategories(clsid, catids)
  213.     
  214.     if other:
  215.         for key, value in other.items():
  216.             _set_string(keyNameRoot + '\\' + key, value)
  217.         
  218.     
  219.     if progID:
  220.         if verProgID:
  221.             _set_string(keyNameRoot + '\\ProgID', verProgID)
  222.         else:
  223.             _set_string(keyNameRoot + '\\ProgID', progID)
  224.         if desc:
  225.             _set_string(progID, desc)
  226.         
  227.         _set_string(progID + '\\CLSID', str(clsid))
  228.         if verProgID:
  229.             _set_string(progID + '\\CurVer', verProgID)
  230.             _set_string(keyNameRoot + '\\VersionIndependentProgID', progID)
  231.             if desc:
  232.                 _set_string(verProgID, desc)
  233.             
  234.             _set_string(verProgID + '\\CLSID', str(clsid))
  235.         
  236.     
  237.  
  238.  
  239. def GetUnregisterServerKeys(clsid, progID = None, verProgID = None, customKeys = None):
  240.     ret = [
  241.         ('CLSID\\%s' % str(clsid), win32con.HKEY_CLASSES_ROOT)]
  242.     if verProgID:
  243.         ret.append((verProgID, win32con.HKEY_CLASSES_ROOT))
  244.     
  245.     if progID:
  246.         ret.append((progID, win32con.HKEY_CLASSES_ROOT))
  247.     
  248.     ret.append(('AppID\\%s' % str(clsid), win32con.HKEY_CLASSES_ROOT))
  249.     if customKeys:
  250.         ret = ret + customKeys
  251.     
  252.     return ret
  253.  
  254.  
  255. def UnregisterServer(clsid, progID = None, verProgID = None, customKeys = None):
  256.     for args in GetUnregisterServerKeys(clsid, progID, verProgID, customKeys):
  257.         recurse_delete_key(*args)
  258.     
  259.  
  260.  
  261. def GetRegisteredServerOption(clsid, optionName):
  262.     keyNameRoot = 'CLSID\\%s\\%s' % (str(clsid), str(optionName))
  263.     return _get_string(keyNameRoot)
  264.  
  265.  
  266. def _get(ob, attr, default = None):
  267.     
  268.     try:
  269.         return getattr(ob, attr)
  270.     except AttributeError:
  271.         pass
  272.  
  273.     
  274.     try:
  275.         bases = ob.__bases__
  276.     except AttributeError:
  277.         return default
  278.  
  279.     for base in bases:
  280.         val = _get(base, attr, None)
  281.         if val is not None:
  282.             return val
  283.     
  284.     return default
  285.  
  286.  
  287. def RegisterClasses(*classes, **flags):
  288.     if flags.has_key('quiet'):
  289.         pass
  290.     quiet = flags['quiet']
  291.     if flags.has_key('debug'):
  292.         pass
  293.     debugging = flags['debug']
  294.     for cls in classes:
  295.         clsid = cls._reg_clsid_
  296.         progID = _get(cls, '_reg_progid_')
  297.         desc = _get(cls, '_reg_desc_', progID)
  298.         spec = _get(cls, '_reg_class_spec_')
  299.         verProgID = _get(cls, '_reg_verprogid_')
  300.         defIcon = _get(cls, '_reg_icon_')
  301.         threadingModel = _get(cls, '_reg_threading_', 'both')
  302.         catids = _get(cls, '_reg_catids_', [])
  303.         options = _get(cls, '_reg_options_', { })
  304.         policySpec = _get(cls, '_reg_policy_spec_')
  305.         clsctx = _get(cls, '_reg_clsctx_')
  306.         tlb_filename = _get(cls, '_reg_typelib_filename_')
  307.         addPyComCat = not _get(cls, '_reg_disable_pycomcat_', pythoncom.frozen != 0)
  308.         addnPath = None
  309.         if debugging:
  310.             dispatcherSpec = _get(cls, '_reg_debug_dispatcher_spec_')
  311.             if dispatcherSpec is None:
  312.                 dispatcherSpec = 'win32com.server.dispatcher.DefaultDebugDispatcher'
  313.             
  314.             debuggingDesc = '(for debugging)'
  315.             options['Debugging'] = '1'
  316.         else:
  317.             dispatcherSpec = _get(cls, '_reg_dispatcher_spec_')
  318.             debuggingDesc = ''
  319.             options['Debugging'] = '0'
  320.         if spec is None:
  321.             moduleName = cls.__module__
  322.             if moduleName == '__main__':
  323.                 
  324.                 try:
  325.                     moduleName = os.path.splitext(win32api.FindFiles(sys.argv[0])[0][8])[0]
  326.                 except (IndexError, win32api.error):
  327.                     raise TypeError, "Can't locate the script hosting the COM object - please set _reg_class_spec_ in your object"
  328.                 except:
  329.                     None<EXCEPTION MATCH>(IndexError, win32api.error)
  330.                 
  331.  
  332.             None<EXCEPTION MATCH>(IndexError, win32api.error)
  333.             spec = moduleName + '.' + cls.__name__
  334.             if not pythoncom.frozen:
  335.                 scriptDir = os.path.split(sys.argv[0])[0]
  336.                 if not scriptDir:
  337.                     scriptDir = '.'
  338.                 
  339.                 addnPath = win32api.GetFullPathName(scriptDir)
  340.             
  341.         
  342.         RegisterServer(clsid, spec, desc, progID, verProgID, defIcon, threadingModel, policySpec, catids, options, addPyComCat, dispatcherSpec, clsctx, addnPath)
  343.         if not quiet:
  344.             print 'Registered:',
  345.             if not progID:
  346.                 pass
  347.             print spec, debuggingDesc
  348.         
  349.         if tlb_filename:
  350.             tlb_filename = os.path.abspath(tlb_filename)
  351.             typelib = pythoncom.LoadTypeLib(tlb_filename)
  352.             pythoncom.RegisterTypeLib(typelib, tlb_filename)
  353.             if not quiet:
  354.                 print 'Registered type library:', tlb_filename
  355.             
  356.         quiet
  357.     
  358.     extra = flags.get('finalize_register')
  359.     if extra:
  360.         extra()
  361.     
  362.  
  363.  
  364. def UnregisterClasses(*classes, **flags):
  365.     if flags.has_key('quiet'):
  366.         pass
  367.     quiet = flags['quiet']
  368.     for cls in classes:
  369.         clsid = cls._reg_clsid_
  370.         progID = _get(cls, '_reg_progid_')
  371.         verProgID = _get(cls, '_reg_verprogid_')
  372.         customKeys = _get(cls, '_reg_remove_keys_')
  373.         unregister_typelib = _get(cls, '_reg_typelib_filename_') is not None
  374.         UnregisterServer(clsid, progID, verProgID, customKeys)
  375.         if not quiet:
  376.             print 'Unregistered:',
  377.             if not progID:
  378.                 pass
  379.             print str(clsid)
  380.         
  381.         if unregister_typelib:
  382.             tlb_guid = _get(cls, '_typelib_guid_')
  383.         None if tlb_guid is None else None<EXCEPTION MATCH>pythoncom.com_error
  384.     
  385.     extra = flags.get('finalize_unregister')
  386.     if extra:
  387.         extra()
  388.     
  389.  
  390.  
  391. def UnregisterInfoClasses(*classes, **flags):
  392.     ret = []
  393.     for cls in classes:
  394.         clsid = cls._reg_clsid_
  395.         progID = _get(cls, '_reg_progid_')
  396.         verProgID = _get(cls, '_reg_verprogid_')
  397.         customKeys = _get(cls, '_reg_remove_keys_')
  398.         ret = ret + GetUnregisterServerKeys(clsid, progID, verProgID, customKeys)
  399.     
  400.     return ret
  401.  
  402.  
  403. def UseCommandLine(*classes, **flags):
  404.     unregisterInfo = '--unregister_info' in sys.argv
  405.     unregister = '--unregister' in sys.argv
  406.     if not flags.get('quiet', 0):
  407.         pass
  408.     flags['quiet'] = '--quiet' in sys.argv
  409.     if not flags.get('debug', 0):
  410.         pass
  411.     flags['debug'] = '--debug' in sys.argv
  412.     if not flags.get('unattended', 0):
  413.         pass
  414.     flags['unattended'] = '--unattended' in sys.argv
  415.     if unregisterInfo:
  416.         return UnregisterInfoClasses(*classes, **flags)
  417.     
  418.     try:
  419.         if unregister:
  420.             UnregisterClasses(*classes, **flags)
  421.         else:
  422.             RegisterClasses(*classes, **flags)
  423.     except win32api.error:
  424.         unregisterInfo
  425.         exc = unregisterInfo
  426.         if flags['unattended'] and exc[0] != winerror.ERROR_ACCESS_DENIED or sys.getwindowsversion()[0] < 5:
  427.             raise 
  428.         sys.getwindowsversion()[0] < 5
  429.         ShellExecuteEx = ShellExecuteEx
  430.         import win32com.shell.shell
  431.         shellcon = shellcon
  432.         import win32com.shell
  433.         import win32process
  434.         import win32event
  435.         import winxpgui
  436.         if not flags['quiet']:
  437.             print 'Requesting elevation and retrying...'
  438.         
  439.         new_params = []([ '"' + a + '"' for a in sys.argv ])
  440.         hwnd = flags.get('hwnd', None)
  441.         if hwnd is None:
  442.             
  443.             try:
  444.                 hwnd = winxpgui.GetConsoleWindow()
  445.             except winxpgui.error:
  446.                 []
  447.                 []
  448.                 ' '.join
  449.                 hwnd = 0
  450.             except:
  451.                 []<EXCEPTION MATCH>winxpgui.error
  452.             
  453.  
  454.         []
  455.         rc = ShellExecuteEx(hwnd = hwnd, fMask = shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb = 'runas', lpFile = win32api.GetShortPathName(sys.executable), lpParameters = new_params, lpDirectory = os.getcwd(), nShow = win32con.SW_SHOW)
  456.         hproc = rc['hProcess']
  457.         win32event.WaitForSingleObject(hproc, win32event.INFINITE)
  458.         exit_code = win32process.GetExitCodeProcess(hproc)
  459.         if exit_code:
  460.             print 'Error: registration failed (exit code %s).' % exit_code
  461.             print 'Please re-execute this command from an elevated command-prompt'
  462.             print 'to see details about the error.'
  463.         elif not flags['quiet']:
  464.             print 'Elevated process succeeded.'
  465.         
  466.     except:
  467.         []
  468.  
  469.  
  470.  
  471. def RegisterPyComCategory():
  472.     regCat = _cat_registrar()
  473.     regCat.RegisterCategories([
  474.         (CATID_PythonCOMServer, 1033, 'Python COM Server')])
  475.  
  476. if not pythoncom.frozen:
  477.     
  478.     try:
  479.         win32api.RegQueryValue(win32con.HKEY_CLASSES_ROOT, 'Component Categories\\%s' % CATID_PythonCOMServer)
  480.     except win32api.error:
  481.         
  482.         try:
  483.             RegisterPyComCategory()
  484.         except pythoncom.error:
  485.             pass
  486.         except:
  487.             None<EXCEPTION MATCH>pythoncom.error
  488.         
  489.  
  490.         None<EXCEPTION MATCH>pythoncom.error
  491.     
  492.  
  493. None<EXCEPTION MATCH>win32api.error
  494.