Ticket #4558: gtk3-4558-2-fixes.patch

File gtk3-4558-2-fixes.patch, 10.1 KB (added by dobey, 4 years ago)

Updated patch against gtk3-4558-2 branch

  • twisted/internet/_glibbase.py

    class GlibReactorBase(GlibSignalMixin, 
    9494    # callbacks queued from a thread:
    9595    _wakerFactory = GlibWaker
    9696
    97     def __init__(self):
     97    def __init__(self, glib_module, gtk_module, useGtk=False):
    9898        self._simtag = None
    9999        self._reads = set()
    100100        self._writes = set()
    101101        self._sources = {}
     102        self._glib = glib_module
     103        self._gtk = gtk_module
    102104        posixbase.PosixReactorBase.__init__(self)
    103105
     106        self._source_remove = self._glib.source_remove
     107        self._timeout_add = self._glib.timeout_add
    104108
     109        def _mainquit():
     110            if self._gtk.main_level():
     111                self._gtk.main_quit()
     112
     113        if useGtk:
     114            self._pending = self._gtk.events_pending
     115            self._iteration = self._gtk.main_iteration_do
     116            self._crash = _mainquit
     117            self._run = self._gtk.main
     118        else:
     119            self.context = self._glib.main_context_default()
     120            self._pending = self.context.pending
     121            self._iteration = self.context.iteration
     122            self.loop = self._glib.MainLoop()
     123            self._crash = lambda: self._glib.idle_add(self.loop.quit)
     124            self._run = self.loop.run
     125
     126    # The input_add function in pygtk1 checks for objects with a
     127    # 'fileno' method and, if present, uses the result of that method
     128    # as the input source. The pygtk2 input_add does not do this. The
     129    # function below replicates the pygtk1 functionality.
     130
     131    # In addition, pygtk maps gtk.input_add to _gobject.io_add_watch, and
     132    # g_io_add_watch() takes different condition bitfields than
     133    # gtk_input_add(). We use g_io_add_watch() here in case pygtk fixes this
     134    # bug.
    105135    def input_add(self, source, condition, callback):
    106         """
    107         This is a stub to be implemented by inheriting classes.
    108         """
    109         raise NotImplementedError()
     136        if hasattr(source, 'fileno'):
     137            # handle python objects
     138            def wrapper(source, condition, real_s=source, real_cb=callback):
     139                return real_cb(real_s, condition)
     140            return self._glib.io_add_watch(source.fileno(), condition, wrapper)
     141        else:
     142            return self._glib.io_add_watch(source, condition, callback)
    110143
    111144
    112145    def _ioEventCallback(self, source, condition):
    class PortableGlibReactorBase(GlibSignal 
    287320
    288321    Sockets aren't supported by GObject's input_add on Win32.
    289322    """
    290     def __init__(self):
     323    def __init__(self, glib_module, gtk_module, useGtk=False):
    291324        self._simtag = None
     325        self._glib = glib_module
     326        self._gtk = gtk_module
    292327        selectreactor.SelectReactor.__init__(self)
    293328
     329        self._source_remove = self._glib.source_remove
     330        self._timeout_add = self._glib.timeout_add
     331
     332        def _mainquit():
     333            if self._gtk.main_level():
     334                self._gtk.main_quit()
     335
     336        if useGtk:
     337            self._crash = _mainquit
     338            self._run = self._gtk.main
     339        else:
     340            self.loop = self._glib.MainLoop()
     341            self._crash = lambda: self._glib.idle_add(self.loop.quit)
     342            self._run = self.loop.run
     343
    294344
    295345    def crash(self):
    296346        selectreactor.SelectReactor.crash(self)
    class PortableGlibReactorBase(GlibSignal 
    313363        timeout = min(self.timeout(), 0.01)
    314364        if timeout is None:
    315365            timeout = 0.01
    316         self._simtag = self._timeout_add(int(timeout * 1000), self.simulate)
     366        self._simtag = self._timeout_add(int(timeout * 1010), self.simulate)
  • twisted/internet/gireactor.py

    class GIReactor(_glibbase.GlibReactorBas 
    5252    OUTFLAGS = _POLL_OUT | _POLL_DISCONNECTED
    5353
    5454    def __init__(self, useGtk=False):
    55         _glibbase.GlibReactorBase.__init__(self)
     55        _gtk = None
     56        if useGtk is True:
     57            from gi.repository import Gtk as _gtk
    5658
    57         self._source_remove = GLib.source_remove
    58         self._timeout_add = GLib.timeout_add
    59 
    60         if useGtk:
    61             from gi.repository import Gtk
    62 
    63             self._pending = Gtk.events_pending
    64             self._iteration = Gtk.main_iteration_do
    65             self._crash = Gtk.main_quit
    66             self._run = Gtk.main
    67         else:
    68             self.context = GLib.main_context_default()
    69             self._pending = self.context.pending
    70             self._iteration = self.context.iteration
    71             self.loop = GLib.MainLoop()
    72             self._crash = lambda: GLib.idle_add(self.loop.quit)
    73             self._run = self.loop.run
    74 
    75     # The input_add function in pygtk1 checks for objects with a
    76     # 'fileno' method and, if present, uses the result of that method
    77     # as the input source. The pygtk2 input_add does not do this. The
    78     # function below replicates the pygtk1 functionality.
    79 
    80     # In addition, pygtk maps gtk.input_add to _gobject.io_add_watch, and
    81     # g_io_add_watch() takes different condition bitfields than
    82     # gtk_input_add(). We use g_io_add_watch() here in case pygtk fixes this
    83     # bug.
    84     def input_add(self, source, condition, callback):
    85         if hasattr(source, 'fileno'):
    86             # handle python objects
    87             def wrapper(source, condition, real_s=source, real_cb=callback):
    88                 return real_cb(real_s, condition)
    89             return GLib.io_add_watch(source.fileno(), condition, wrapper)
    90         else:
    91             return GLib.io_add_watch(source, condition, callback)
     59        _glibbase.GlibReactorBase.__init__(self, GLib, _gtk, useGtk=useGtk)
    9260
    9361
    9462
    class PortableGIReactor(_glibbase.Portab 
    9765    Portable GObject Introspection event loop reactor.
    9866    """
    9967    def __init__(self, useGtk=False):
    100         _glibbase.PortableGlibReactorBase.__init__(self)
    101 
    102         self._source_remove = GLib.source_remove
    103         self._timeout_add = GLib.timeout_add
    104 
    105         if useGtk:
    106             from gi.repository import Gtk
    107 
    108             self._crash = Gtk.main_quit
    109             self._run = Gtk.main
    110         else:
    111             self.loop = GLib.MainLoop()
    112             self._crash = lambda: GLib.idle_add(self.loop.quit)
    113             self._run = self.loop.run
     68        _gtk = None
     69        if useGtk is True:
     70            from gi.repository import Gtk as _gtk
    11471
     72        _glibbase.PortableGlibReactorBase.__init__(self, GLib, _gtk,
     73                                                   useGtk=useGtk)
    11574
    11675
    11776def install(useGtk=False):
  • twisted/internet/gtk2reactor.py

    class Gtk2Reactor(_glibbase.GlibReactorB 
    6262    OUTFLAGS = _POLL_OUT | _POLL_DISCONNECTED
    6363
    6464    def __init__(self, useGtk=True):
    65         _glibbase.GlibReactorBase.__init__(self)
     65        _gtk = None
     66        if useGtk is True:
     67            import gtk as _gtk
    6668
    67         self._source_remove = gobject.source_remove
    68         self._timeout_add = gobject.timeout_add
    69 
    70         # pre 2.3.91 the glib iteration and mainloop functions didn't release
    71         # global interpreter lock, thus breaking thread and signal support.
    72         if getattr(gobject, "pygtk_version", ()) >= (2, 3, 91) and not useGtk:
    73             self.context = gobject.main_context_default()
    74             self._pending = self.context.pending
    75             self._iteration = self.context.iteration
    76             self.loop = gobject.MainLoop()
    77             self._crash = self.loop.quit
    78             self._run = self.loop.run
    79         else:
    80             import gtk
    81 
    82             def mainquit():
    83                 if gtk.main_level():
    84                     gtk.main_quit()
    85 
    86             self._pending = gtk.events_pending
    87             self._iteration = gtk.main_iteration
    88             self._crash = mainquit
    89             self._run = gtk.main
    90 
    91 
    92     # The input_add function in pygtk1 checks for objects with a
    93     # 'fileno' method and, if present, uses the result of that method
    94     # as the input source. The pygtk2 input_add does not do this. The
    95     # function below replicates the pygtk1 functionality.
    96 
    97     # In addition, pygtk maps gtk.input_add to _gobject.io_add_watch, and
    98     # g_io_add_watch() takes different condition bitfields than
    99     # gtk_input_add(). We use g_io_add_watch() here in case pygtk fixes this
    100     # bug.
    101     def input_add(self, source, condition, callback):
    102         if hasattr(source, 'fileno'):
    103             # handle python objects
    104             def wrapper(source, condition, real_s=source, real_cb=callback):
    105                 return real_cb(real_s, condition)
    106             return gobject.io_add_watch(source.fileno(), condition, wrapper)
    107         else:
    108             return gobject.io_add_watch(source, condition, callback)
     69        _glibbase.GlibReactorBase.__init__(self, gobject, _gtk, useGtk=useGtk)
    10970
    11071
    11172
    class PortableGtkReactor(_glibbase.Porta 
    11576
    11677    Sockets aren't supported by GTK+'s input_add on Win32.
    11778    """
    118     def __init__(self, useGtk=False):
    119         _glibbase.PortableGlibReactorBase.__init__(self)
    120 
    121         self._source_remove = gobject.source_remove
    122         self._timeout_add = gobject.timeout_add
    123 
    124         if useGtk:
    125             import gtk
     79    def __init__(self, useGtk=True):
     80        _gtk = None
     81        if useGtk is True:
     82            import gtk as _gtk
    12683
    127             def mainquit():
    128                 if gtk.main_level():
    129                     gtk.main_quit()
    130 
    131             self._crash = mainquit
    132             self._run = gtk.main
    133         else:
    134             self.loop = gobject.MainLoop()
    135             self._crash = lambda: gobject.idle_add(self.loop.quit)
    136             self._run = self.loop.run
     84        _glibbase.PortableGlibReactorBase.__init__(self, gobject, _gtk,
     85                                                   useGtk=useGtk)
    13786
    13887
    13988def install(useGtk=True):