def cleanup(self):
     tw = self.tray_widget
     traylog("cleanup() tray_widget=%s", tw)
     if tw:
         self.tray_widget = None
         tw.cleanup()
     GTKServerBase.cleanup(self)

 def init(self, opts):
     self.fake_xinerama = opts.fake_xinerama
     self.current_xinerama_config = None
     if self.fake_xinerama:
         self.libfakeXinerama_so = find_libfakeXinerama()
     else:
         self.libfakeXinerama_so = None
     self.x11_init()
     GTKServerBase.init(self, opts)

 def __init__(self):
     import gtk.gdk
     ShadowServerBase.__init__(self, gtk.gdk.get_default_root_window())
     GTKServerBase.__init__(self)
     self.keycodes = {}
     from xpra.net.bytestreams import set_continue_wait
     #on win32, we want to wait just a little while,
     #to prevent servers spinning wildly on non-blocking sockets:
     set_continue_wait(5)

 def add_listen_socket(self, socktype, sock):
     log("add_listen_socket(%s, %s)", socktype, sock)
     if socktype=="named-pipe":
         #named pipe listener uses a thread:
         sock.new_connection_cb = self._new_connection
         self.socket_types[sock] = socktype
         sock.start()
     else:
         GTKServerBase.add_listen_socket(self, socktype, sock)

 def __init__(self):
     ShadowServerBase.__init__(self, gtk.gdk.get_default_root_window())
     GTKServerBase.__init__(self)
     #for managing the systray
     self.tray_menu = None
     self.tray_menu_shown = False
     self.tray_widget = None
     self.tray = False
     self.tray_icon = None

 def __init__(self):
     #sanity check:
     image = CG.CGWindowListCreateImage(CG.CGRectInfinite,
                 CG.kCGWindowListOptionOnScreenOnly,
                 CG.kCGNullWindowID,
                 CG.kCGWindowImageDefault)
     if image is None:
         raise Exception("cannot grab test screenshot - maybe you need to run this command whilst logged in via the UI")
     ShadowServerBase.__init__(self, gtk.gdk.get_default_root_window())
     GTKServerBase.__init__(self)

 def make_hello(self, source):
     capabilities = GTKServerBase.make_hello(self, source)
     capabilities["server_type"] = "Python/gtk/x11"
     if source.wants_features:
         capabilities["resize_screen"] = self.randr
         capabilities["force_ungrab"] = True
     return capabilities

 def do_get_info(self, proto, server_sources, window_ids):
     info = GTKServerBase.do_get_info(self, proto, server_sources, window_ids)
     info["server.type"] = "Python/gtk/x11"
     try:
         from xpra.x11.gtk_x11.composite import CompositeHelper
         info["server.XShm"] = CompositeHelper.XShmEnabled
     except:
         pass
     #randr:
     try:
         sizes = RandR.get_screen_sizes()
         if self.randr and len(sizes)>=0:
             info["server.randr.options"] = list(reversed(sorted(sizes)))
     except:
         pass
     try:
         from xpra.scripts.server import find_fakeXinerama
         fx = find_fakeXinerama()
     except:
         fx = None
     info["server.fakeXinerama"] = self.fake_xinerama and bool(fx)
     info["server.libfakeXinerama"] = fx or ""
     #this is added here because the server keyboard config doesn't know about "keys_pressed"..
     info["keyboard.state.keys_pressed"] = list(self.keys_pressed.keys())
     return info

 def do_get_info(self, proto, server_sources, window_ids):
     start = time.time()
     info = GTKServerBase.do_get_info(self, proto, server_sources, window_ids)
     if self.opengl_props:
         info["opengl"] = self.opengl_props
     #this is added here because the server keyboard config doesn't know about "keys_pressed"..
     info.setdefault("keyboard", {}).update({
                                             "state"           : {
                                                                  "keys_pressed"   : list(self.keys_pressed.keys())
                                                                  },
                                             "fast-switching"  : True,
                                             })
     sinfo = info.setdefault("server", {})
     sinfo.update({"type"                : "Python/gtk/x11",
                   "fakeXinerama"        : self.fake_xinerama and bool(self.libfakeXinerama_so),
                   "libfakeXinerama"     : self.libfakeXinerama_so or "",
                   "Xkb"                 : X11Keyboard.hasXkb(),
                   "XTest"               : X11Keyboard.hasXTest(),
                   })
     try:
         from xpra.x11.gtk2.composite import CompositeHelper
         sinfo["XShm"] = CompositeHelper.XShmEnabled
     except:
         pass
     #randr:
     try:
         sizes = RandR.get_screen_sizes()
         if self.randr and len(sizes)>=0:
             sinfo["randr"] = {"options" : list(reversed(sorted(sizes)))}
     except:
         pass
     log("X11ServerBase.do_get_info took %ims", (time.time()-start)*1000)
     return info

 def get_child_env(self):
     #adds fakexinerama:
     env = GTKServerBase.get_child_env(self)
     if self.fake_xinerama:
         libfakeXinerama_so = self.find_fakeXinerama()
         if libfakeXinerama_so:
             env["LD_PRELOAD"] = libfakeXinerama_so
     return env

 def get_info(self, proto):
     info = GTKServerBase.get_info(self, proto)
     info.setdefault("features", {})["shadow"] = True
     info.setdefault("server", {
                                "type"       : "Python/gtk2/win32-shadow",
                                "tray"       : self.tray,
                                "tray-icon"  :self.tray_icon or ""})
     return info

 def _new_connection(self, listener, *args):
     socktype = self.socket_types.get(listener)
     log("_new_connection(%s) socktype=%s", listener, socktype)
     if socktype!="named-pipe":
         return GTKServerBase._new_connection(self, listener)
     pipe_handle = args[0]
     conn = NamedPipeConnection(listener.pipe_name, pipe_handle)
     return self.make_protocol(socktype, conn, frominfo=" on %s" % conn.target)

 def do_get_info(self, proto, server_sources, window_ids):
     info = GTKServerBase.do_get_info(self, proto, server_sources, window_ids)
     info["server.type"] = "Python/gtk/x11"
     try:
         from xpra.x11.gtk_x11.composite import CompositeHelper
         info["server.XShm"] = CompositeHelper.XShmEnabled
     except:
         pass
     return info

 def make_hello(self, source):
     capabilities = GTKServerBase.make_hello(self, source)
     capabilities["server_type"] = "Python/gtk/x11"
     if source.wants_features:
         capabilities.update({
                 "resize_screen"             : self.randr,
                 "force_ungrab"              : True,
                 "keyboard.fast-switching"   : True,
                 })
     return capabilities

 def get_info(self, proto):
     info = GTKServerBase.get_info(self, proto)
     info.setdefault("features", {})["shadow"] = True
     info.setdefault("server", {})["type"] = "Python/gtk2/osx-shadow"
     info.setdefault("damage", {}).update({
                                           "notifications"   : self.refresh_registered,
                                           "count"           : self.refresh_count,
                                           "rectangles"      : self.refresh_rectangle_count,
                                           })
     return info

 def do_get_info(self, proto, server_sources, window_ids):
     info = GTKServerBase.do_get_info(self, proto, server_sources, window_ids)
     info["server.type"] = "Python/gtk/x11"
     try:
         from xpra.x11.gtk2.composite import CompositeHelper
         info["server.XShm"] = CompositeHelper.XShmEnabled
     except:
         pass
     #randr:
     try:
         sizes = RandR.get_screen_sizes()
         if self.randr and len(sizes)>=0:
             info["server.randr.options"] = list(reversed(sorted(sizes)))
     except:
         pass
     info["server.fakeXinerama"] = self.fake_xinerama and bool(self.libfakeXinerama_so)
     info["server.libfakeXinerama"] = self.libfakeXinerama_so or ""
     #this is added here because the server keyboard config doesn't know about "keys_pressed"..
     info["keyboard.state.keys_pressed"] = list(self.keys_pressed.keys())
     info["keyboard.fast-switching"] = True
     info["server.Xkb"] = X11Keyboard.hasXkb()
     info["server.XTest"] = X11Keyboard.hasXTest()
     return info

 def init(self, opts):
     GTKServerBase.init(self, opts)
     self.tray = opts.tray
     self.tray_icon = opts.tray_icon
     if self.tray:
         self.setup_tray()

 def init(self, opts):
     GTKServerBase.init(self, opts)
     self.keycodes = {}

 def init_keyboard(self):
     GTKServerBase.init_keyboard(self)
     #clear all modifiers
     clean_keyboard_state()

 def init_packet_handlers(self):
     GTKServerBase.init_packet_handlers(self)
     self._authenticated_ui_packet_handlers["force-ungrab"] = self._process_force_ungrab