docs: def qteBindKeyGlobal(self, keysequence, macroName: str):
          """
          Associate ``macroName`` with ``keysequence`` in all current
          applets.
  
          This method will bind ``macroName`` to ``keysequence`` in the
          global key map and **all** local key maps. This also applies
          for all applets (and their constituent widgets) yet to be
          instantiated because they will inherit a copy of the global
          keymap.
  
          .. note::  This binding is signature independent.
  
          If the ``macroName`` was not registered the method returns
          **False**.
  
          The ``keysequence`` can be specified either as a string (eg
          '<ctrl>+x <ctrl>+f'), or a list of tuples containing the
          constants from the ``QtCore.Qt`` name space
          (eg. [(ControlModifier, Key_X), (ControlModifier, Key_F)]), or
          as a ``QtmacsKeysequence`` object.
  
          |Args|
  
          * ``keysequence`` (**str**, **list** of **tuples**,
            **QtmacsKeysequence**): key sequence to activate ``macroName``
            for specified ``widgetSignature``.
          * ``macroName`` (**str**): name of macro to associate with
            ``keysequence``.
  
          |Returns|
  
          **bool**: **True** if the binding was successful.
  
          |Raises|
  
          * **QtmacsArgumentError** if at least one argument has an invalid type.
          * **QtmacsKeysequenceError** if the provided ``keysequence``
            could not be parsed.
          """
          # Convert the key sequence into a QtmacsKeysequence object, or
          # raise an QtmacsOtherError if the conversion is impossible.
          keysequence = QtmacsKeysequence(keysequence)
  
          # Sanity check: the macro must have been registered
          # beforehand.
          if not self.qteIsMacroRegistered(macroName):
              msg = 'Cannot globally bind key to unknown macro <b>{}</b>.'
              msg = msg.format(macroName)
              self.qteLogger.error(msg, stack_info=True)
              return False
  
          # Insert/overwrite the key sequence and associate it with the
          # new macro.
          self._qteGlobalKeyMap.qteInsertKey(keysequence, macroName)
  
          # Now update the local key map of every applet. Note that
          # globally bound macros apply to every applet (hence the loop
          # below) and every widget therein (hence the "*" parameter for
          # the widget signature).
          for app in self._qteAppletList:
              self.qteBindKeyApplet(keysequence, macroName, app)
          return True