def __init__(self, quit_cb=None):
        log("ChildReaper(%s)", quit_cb)
        from xpra.gtk_common.gobject_compat import import_glib

        self.glib = import_glib()
        self._quit = quit_cb
        self._proc_info = []
        if USE_PROCESS_POLLING:
            log("using process polling every %s seconds", POLL_DELAY)
            self.glib.timeout_add(POLL_DELAY * 1000, self.poll)
        else:
            # with a less buggy python, we can just check the list of pids
            # whenever we get a SIGCHLD
            # however.. subprocess.Popen will no longer work as expected
            # see: http://bugs.python.org/issue9127
            # so we must ensure certain things that exec happen first:
            from xpra.version_util import get_platform_info

            get_platform_info()

            signal.signal(signal.SIGCHLD, self.sigchld)
            # Check once after the mainloop is running, just in case the exit
            # conditions are satisfied before we even enter the main loop.
            # (Programming with unix the signal API sure is annoying.)
            def check_once():
                self.check()
                return False  # Only call once

            self.glib.timeout_add(0, check_once)

 def __init__(self, codec):
     gobject.GObject.__init__(self)
     self.codec = codec
     self.codec_description = ""
     self.codec_mode = ""
     self.container_description = ""
     self.bus = None
     self.bus_message_handler_id = None
     self.bitrate = -1
     self.pipeline = None
     self.pipeline_str = ""
     self.start_time = 0
     self.state = "stopped"
     self.buffer_count = 0
     self.byte_count = 0
     self.emit_info_due = False
     self.info = {
                  "codec"        : self.codec,
                  "state"        : self.state,
                  }
     glib = import_glib()
     self.idle_add = glib.idle_add
     self.timeout_add = glib.timeout_add
     self.source_remove = glib.source_remove
     if gst_version[0]<1:
         #Gst 0.10: can handle both TAG and ELEMENT:
         self.parse_message = self.parse_message0
     else:
         #Gst 1.0: (does not have MESSAGE_ELEMENT):
         self.parse_message = self.parse_message1

def gtk_main_quit_really():
    # We used to call gtk.main_quit() repeatedly, but this doesn't actually
    # work -- gtk.main_quit() always marks the *current* level of main loop
    # for destruction, so it's actually idempotent. We have to call
    # gtk.main_quit once, and then return to the main loop, and then call it
    # again, and then return to the main loop, etc. So we use a trick: We
    # register a function that gtk should call 'forever' (i.e., as long as the
    # main loop is running!)
    def gtk_main_quit_forever():
        # We import gtk inside here, rather than at the top of the file,
        # because importing gtk has the side-effect of trying to connect to
        # the X server (and this process may block, may cause us to later be
        # killed if the X server goes away, etc.), and we don't want to impose
        # that on every user of this function.
        from xpra.gtk_common.gobject_compat import import_gtk
        gtk = import_gtk()
        gtk.main_quit()
        # So long as there are more nested main loops, re-register ourselves
        # to be called again:
        if gtk.main_level() > 1:
            return True
        else:
            # But when we've just quit the outermost main loop, then
            # unregister ourselves so that it's possible to start the
            # main-loop again if desired:
            return False
    from xpra.gtk_common.gobject_compat import import_glib
    glib = import_glib()
    glib.timeout_add(0, gtk_main_quit_forever)

def main():
    log.enable_debug()
    from xpra.gtk_common.gobject_compat import import_glib
    glib = import_glib()
    s = GTKStatusIconTray(None, "test", "xpra.png", None, None, None, gtk.main_quit)
    glib.timeout_add(1000*2, s.set_blinking, True)
    glib.timeout_add(1000*5, s.set_blinking, False)
    glib.timeout_add(1000*10, gtk.main_quit)
    gtk.main()

 def glib_init(self):
     try:
         glib = import_glib()
         try:
             glib.threads_init()
         except AttributeError:
             #old versions of glib may not have this method
             pass
     except ImportError:
         pass

def main():
    import random, signal
    port = int(20000*random.random())+10000
    host = "0.0.0.0"
    host_ports = [(host, port)]
    ID = "test_%s" % int(random.random()*100000)
    publisher = BonjourPublishers(host_ports, ID, XPRA_MDNS_TYPE, {"somename":"somevalue"})
    signal.signal(signal.SIGTERM, exit)
    from xpra.gtk_common.gobject_compat import import_glib
    glib = import_glib()
    glib.idle_add(publisher.start)
    loop = glib.MainLoop()
    loop.run()

 def __init__(self, description="wrapper"):
     self.process = None
     self.protocol = None
     self.command = None
     self.description = description
     self.send_queue = Queue()
     self.signal_callbacks = {}
     self.large_packets = []
     #hook a default packet handlers:
     self.connect(Protocol.CONNECTION_LOST, self.connection_lost)
     self.connect(Protocol.GIBBERISH, self.gibberish)
     glib = import_glib()
     self.idle_add = glib.idle_add
     self.timeout_add = glib.timeout_add
     self.source_remove = glib.source_remove

 def init_attributes(self, *args):
     FileTransferAttributes.init_attributes(self, *args)
     self.remote_file_transfer = False
     self.remote_printing = False
     self.remote_open_files = False
     self.remote_file_size_limit = 0
     self.remote_file_chunks = 0
     self.send_chunks_in_progress = {}
     self.receive_chunks_in_progress = {}
     self.file_descriptors = set()
     if not getattr(self, "timeout_add", None):
         from xpra.gtk_common.gobject_compat import import_glib
         glib = import_glib()
         self.timeout_add = glib.timeout_add
         self.idle_add = glib.idle_add
         self.source_remove = glib.source_remove

 def session_change_event(self, event, session):
     event_name = WTS_SESSION_EVENTS.get(event, event)
     log("WM_WTSSESSION_CHANGE: %s on session %#x", event_name, session)
     c = self.client
     if not c:
         return
     if event in (WTS_SESSION_LOGOFF, WTS_SESSION_LOCK):
         log("will freeze all the windows")
         c.freeze()
     elif event in (WTS_SESSION_LOGON, WTS_SESSION_UNLOCK):
         log("will unfreeze all the windows")
         #don't unfreeze directly from here,
         #as the system may not be fully usable yet (see #997)
         from xpra.gtk_common.gobject_compat import import_glib
         glib = import_glib()
         glib.idle_add(c.unfreeze)

def main():
	def mdns_found(*args):
		print("mdns_found: %s" % (args, ))
	def mdns_add(*args):
		print("mdns_add: %s" % (args, ))
	def mdns_remove(*args):
		print("mdns_remove: %s" % (args, ))

	from xpra.dbus.common import loop_init
	loop_init()
	listener = AvahiListener(XPRA_MDNS_TYPE, mdns_found, mdns_add, mdns_remove)
	try:
		from xpra.gtk_common.gobject_compat import import_glib
		glib = import_glib()
		glib.idle_add(listener.start)
		glib.MainLoop().run()
	finally:
		listener.stop()

 def __init__(self, codec):
     gobject.GObject.__init__(self)
     self.codec = codec
     self.codec_description = ""
     self.codec_mode = ""
     self.bus = None
     self.bus_message_handler_id = None
     self.bitrate = -1
     self.pipeline = None
     self.pipeline_str = ""
     self.start_time = 0
     self.state = "stopped"
     self.buffer_count = 0
     self.byte_count = 0
     self.emit_info_due = False
     glib = import_glib()
     self.idle_add = glib.idle_add
     self.timeout_add = glib.timeout_add
     self.source_remove = glib.source_remove

def main():
    import sys
    if "-v" in sys.argv or "--verbose" in sys.argv:
        from xpra.log import add_debug_category
        add_debug_category("webcam")
    run = "-r" in sys.argv or "--run" in sys.argv
    if run:
        from xpra.gtk_common.gobject_compat import import_glib, import_gobject
        glib = import_glib()
        gobject = import_gobject()
        gobject.threads_init()

    from xpra.util import engs, print_nested_dict
    from xpra.platform import program_context
    with program_context("Webcam Info", "Webcam Info"):
        devices = get_virtual_video_devices() or {}
        log.info("Found %i virtual video device%s:", len(devices), engs(devices))
        print_nested_dict(devices)
        all_devices = get_all_video_devices() or {}
        log.info("Found %i video device%s in total:", len(all_devices), engs(all_devices))
        print_nested_dict(all_devices)

        if run:
            log.info("add watch for video device changes")
            def callback(added=None, device=None):
                if added is not None or device:
                    log.info("video device %s: %s", ["removed", "added"][added], device)
                else:
                    log.info("device change")
            log.info("starting main loop")
            main_loop = glib.MainLoop()
            glib.idle_add(add_video_device_change_callback, callback)
            try:
                main_loop.run()
            except KeyboardInterrupt:
                pass
            log.info("terminating, removing callback")
            remove_video_device_change_callback(callback)

def main():
    from xpra.platform import init, clean
    init("Sound-Record")
    try:
        from xpra.gtk_common.gobject_compat import import_glib
        glib = import_glib()
        args = sys.argv
        log.enable_debug()
        import os.path
        if len(args) not in (2, 3):
            print("usage: %s [-v|--verbose] filename [codec]" % sys.argv[0])
            return 1
        filename = args[1]
        if not os.path.exists(filename):
            print("file %s does not exist" % filename)
            return 2
        codecs = get_codecs()
        if len(args)==3:
            codec = args[2]
            if codec not in codecs:
                print("invalid codec: %s" % codec)
                print("only supported: %s" % str(codecs.keys()))
                return 2
            codecs = [codec]
        else:
            codec = None
            parts = filename.split(".")
            if len(parts)>1:
                extension = parts[-1]
                if extension.lower() in codecs:
                    codec = extension.lower()
                    print("guessed codec %s from file extension %s" % (codec, extension))
            if codec is None:
                print("assuming this is an mp3 file...")
                codec = MP3
            codecs = [codec]

        log.enable_debug()
        with open(filename, "rb") as f:
            data = f.read()
        print("loaded %s bytes from %s" % (len(data), filename))
        #force no leak since we push all the data at once
        global QUEUE_LEAK, QUEUE_SILENT
        QUEUE_LEAK = GST_QUEUE_NO_LEAK
        QUEUE_SILENT = 1
        ss = SoundSink(codecs=codecs)
        def eos(*args):
            print("eos")
            glib.idle_add(glib_mainloop.quit)
        ss.connect("eos", eos)
        ss.start()

        glib_mainloop = glib.MainLoop()

        import signal
        def deadly_signal(*args):
            glib.idle_add(ss.stop)
            glib.idle_add(glib_mainloop.quit)
            def force_quit(sig, frame):
                sys.exit()
            signal.signal(signal.SIGINT, force_quit)
            signal.signal(signal.SIGTERM, force_quit)
        from xpra.gtk_common.gobject_compat import is_gtk3
        if not is_gtk3():
            signal.signal(signal.SIGINT, deadly_signal)
        signal.signal(signal.SIGTERM, deadly_signal)

        def check_for_end(*args):
            qtime = ss.queue.get_property("current-level-time")//MS_TO_NS
            if qtime<=0:
                log.info("underrun (end of stream)")
                thread.start_new_thread(ss.stop, ())
                glib.timeout_add(500, glib_mainloop.quit)
                return False
            return True
        glib.timeout_add(1000, check_for_end)
        glib.idle_add(ss.add_data, data)

        glib_mainloop.run()
        return 0
    finally:
        clean()

 def setup_mainloop(self):
     glib = import_glib()
     self.mainloop = glib.MainLoop()
     self.idle_add = glib.idle_add
     self.timeout_add = glib.timeout_add
     self.source_remove = glib.source_remove

def main():
    from xpra.platform import program_context
    with program_context("Xpra-Sound-Source"):
        import os.path
        if "-v" in sys.argv:
            log.enable_debug()
            sys.argv.remove("-v")

        if len(sys.argv) not in (2, 3):
            log.error("usage: %s filename [codec] [--encoder=rencode]", sys.argv[0])
            return 1
        filename = sys.argv[1]
        if filename=="-":
            from xpra.os_util import disable_stdout_buffering
            disable_stdout_buffering()
        elif os.path.exists(filename):
            log.error("file %s already exists", filename)
            return 1
        codec = None

        codecs = get_codecs()
        if len(sys.argv)==3:
            codec = sys.argv[2]
            if codec not in codecs:
                log.error("invalid codec: %s, codecs supported: %s", codec, codecs)
                return 1
        else:
            parts = filename.split(".")
            if len(parts)>1:
                extension = parts[-1]
                if extension.lower() in codecs:
                    codec = extension.lower()
                    log.info("guessed codec %s from file extension %s", codec, extension)
            if codec is None:
                codec = MP3
                log.info("using default codec: %s", codec)

        #in case we're running against pulseaudio,
        #try to setup the env:
        try:
            from xpra.platform.paths import get_icon_filename
            f = get_icon_filename("xpra.png")
            from xpra.sound.pulseaudio.pulseaudio_util import add_audio_tagging_env
            add_audio_tagging_env(icon_path=f)
        except Exception as e:
            log.warn("failed to setup pulseaudio tagging: %s", e)

        from threading import Lock
        if filename=="-":
            f = sys.stdout
        else:
            f = open(filename, "wb")
        ss = SoundSource(codecs=[codec])
        lock = Lock()
        def new_buffer(ss, data, metadata):
            log.info("new buffer: %s bytes (%s), metadata=%s", len(data), type(data), metadata)
            with lock:
                if f:
                    f.write(data)
                    f.flush()

        from xpra.gtk_common.gobject_compat import import_glib
        glib = import_glib()
        glib_mainloop = glib.MainLoop()

        ss.connect("new-buffer", new_buffer)
        ss.start()

        import signal
        def deadly_signal(sig, frame):
            log.warn("got deadly signal %s", SIGNAMES.get(sig, sig))
            glib.idle_add(ss.stop)
            glib.idle_add(glib_mainloop.quit)
            def force_quit(sig, frame):
                sys.exit()
            signal.signal(signal.SIGINT, force_quit)
            signal.signal(signal.SIGTERM, force_quit)
        from xpra.gtk_common.gobject_compat import is_gtk3
        if not is_gtk3():
            signal.signal(signal.SIGINT, deadly_signal)
        signal.signal(signal.SIGTERM, deadly_signal)

        try:
            glib_mainloop.run()
        except Exception as e:
            log.error("main loop error: %s", e)
        ss.stop()

        f.flush()
        if f!=sys.stdout:
            log.info("wrote %s bytes to %s", f.tell(), filename)
        with lock:
            f.close()
            f = None
        return 0

# later version. See the file COPYING for details.

""" client_launcher.py

This is a simple GUI for starting the xpra client.

"""

import os.path
import sys
import shlex
import signal
import traceback

from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, import_gobject, import_pango, import_glib
glib = import_glib()
gobject = import_gobject()
gobject.threads_init()
gtk = import_gtk()
gdk = import_gdk()
try:
    gdk.threads_init()
except:
    pass
pango = import_pango()

from xpra.platform.gui import init as gui_init
gui_init()

from xpra.scripts.config import read_config, make_defaults_struct, validate_config, save_config
from xpra.codecs.loader import PREFERED_ENCODING_ORDER

def _glib():
    from xpra.gtk_common.gobject_compat import import_glib
    return import_glib()