def do_get_resources_dir():
    rsc = None
    RESOURCES = "/Resources/"
    #FUGLY warning: importing gtkosx_application causes the dock to appear,
    #and in some cases we don't want that.. so use the env var XPRA_SKIP_UI as workaround for such cases:
    if os.environ.get("XPRA_SKIP_UI", "0")=="0":
        try:
            import gtkosx_application        #@UnresolvedImport
            try:
                rsc = gtkosx_application.gtkosx_application_get_resource_path()
                debug("get_resources_dir() gtkosx_application_get_resource_path=%s", rsc)
            except:
                #maybe we're not running from an app bundle?
                pass
        except:
            #delayed import to prevent cycles:
            from xpra.log import Logger
            log = Logger("util")
            log.error("ERROR: gtkosx_application module is missing - trying to continue anyway")
    else:
        debug("XPRA_SKIP_UI is set, not importing gtkosx_application")
    if rsc is None:
        #try using the path to this file to find the resource path:
        rsc = __file__
    i = rsc.rfind(RESOURCES)
    if i<=0:
        #last fallback: try the default app dir
        from xpra.platform.paths import default_get_app_dir
        rsc = default_get_app_dir()
        debug("get_resources_dir() default_get_app_dir()=%s", rsc)
    i = rsc.rfind(RESOURCES)
    if i>0:
        rsc = rsc[:i+len(RESOURCES)]
    debug("get_resources_dir()=%s", rsc)
    return rsc

def log_screen_sizes(root_w, root_h, sizes):
    try:
        do_log_screen_sizes(root_w, root_h, sizes)
    except Exception as e:
        from xpra.log import Logger
        log = Logger("screen")
        log.warn("failed to parse screen size information: %s", e, exc_info=True)

def log_screen_sizes(root_w, root_h, sizes):
    try:
        do_log_screen_sizes(root_w, root_h, sizes)
    except Exception:
        from xpra.log import Logger
        log = Logger("util")
        log.warn("failed to parse screen size information: %s", sys.exc_info()[1])

def start_children(child_reaper, commands, fake_xinerama):
    assert os.name=="posix"
    from xpra.log import Logger
    log = Logger()
    env = os.environ.copy()
    #add fake xinerama:
    if fake_xinerama:
        #locate the fakeXinerama lib:
        #it would be better to rely on dlopen to find the paths
        #but I cannot find a way of getting ctypes to tell us the path
        #it found the library in
        libpaths = os.environ.get("LD_LIBRARY_PATH", "").split(":")
        libpaths.append("/usr/lib64")
        libpaths.append("/usr/lib")
        for libpath in libpaths:
            if not libpath or not os.path.exists(libpath):
                continue
            libfakeXinerama_so = "%s/%s" % (libpath, "libfakeXinerama.so.1")
            if os.path.exists(libfakeXinerama_so):
                env["LD_PRELOAD"] = libfakeXinerama_so
    #disable ubuntu's global menu using env vars:
    env.update({
        "UBUNTU_MENUPROXY"          : "",
        "QT_X11_NO_NATIVE_MENUBAR"  : "1"})
    for child_cmd in commands:
        if not child_cmd:
            continue
        try:
            proc = subprocess.Popen(child_cmd, stdin=subprocess.PIPE, env=env, shell=True, close_fds=True)
            child_reaper.add_process(proc, child_cmd)
            log.info("started child '%s' with pid %s", child_cmd, proc.pid)
        except OSError, e:
            sys.stderr.write("Error spawning child '%s': %s\n" % (child_cmd, e))

def PIL_logging_workaround():
    import logging

    PIL_DEBUG = os.environ.get("XPRA_PIL_DEBUG", "0") == "1"
    if PIL_DEBUG:
        from xpra.log import Logger

        log = Logger("util")
        log.info("enabling PIL.DEBUG")
        level = logging.DEBUG
    else:
        level = logging.INFO

    # newer versions use this logger,
    # we must initialize it before we load the class:
    for x in ("Image", "PngImagePlugin", "WebPImagePlugin", "JpegImagePlugin"):
        logger = logging.getLogger("PIL.%s" % x)
        logger.setLevel(level)
    import PIL
    from PIL import Image

    assert PIL and Image
    if hasattr(Image, "DEBUG"):
        # for older versions (pre 3.0), use Image.DEBUG flag:
        Image.DEBUG = int(PIL_DEBUG)

def get_sys_info():
    info = {}
    try:
        import resource
        for k, constant in {"server"   : "RUSAGE_SELF",
                         "children" : "RUSAGE_CHILDREN",
                         "total"    : "RUSAGE_BOTH"}.items():
            try:
                v = getattr(resource, constant)
            except (NameError, AttributeError):
                continue
            stats = resource.getrusage(v)
            prefix = "memory.%s." % k
            for var in ("utime", "stime", "maxrss",
                        "ixrss", "idrss", "isrss",
                        "minflt", "majflt", "nswap",
                        "inblock", "oublock",
                        "msgsnd", "msgrcv",
                        "nsignals", "nvcsw", "nivcsw"):
                value = getattr(stats, "ru_%s" % var)
                if type(value)==float:
                    value = int(value)
                info[prefix+var] = value
    except:
        from xpra.log import Logger
        log = Logger()
        log.error("error getting memory usage info", exc_info=True)
    return info

class ChildReaper(object):
    def __init__(self, quit_cb, children_pids={}):
        self._quit = quit_cb
        self._children_pids = children_pids
        self._dead_pids = set()
        from xpra.log import Logger
        self._logger = Logger()

    def check(self):
        if self._children_pids:
            pids = set(self._children_pids.keys())
            if pids.issubset(self._dead_pids):
                self._quit()

    def sigchld(self, signum, frame):
        self.reap()

    def add_dead_pid(self, pid):
        if pid not in self._dead_pids:
            cmd = self._children_pids.get(pid)
            if cmd:
                self._logger.info("child '%s' with pid %s has terminated", cmd, pid)
            self._dead_pids.add(pid)
            self.check()

    def reap(self):
        while True:
            try:
                pid, _ = os.waitpid(-1, os.WNOHANG)
            except OSError:
                break
            if pid == 0:
                break
            self.add_dead_pid(pid)

def log_screen_sizes(root_w, root_h, ss):
    try:
        do_log_screen_sizes(root_w, root_h, ss)
    except Exception, e:
        from xpra.log import Logger
        log = Logger()
        log.warn("failed to parse screen size information: %s", e)

    def err(*msg):
        """ log an error message and return None """
        from xpra.log import Logger

        log = Logger("icon")
        log.error(*msg)
        return None

def start_children(child_reaper, cwd, commands, fake_xinerama):
    assert os.name == "posix"
    from xpra.log import Logger

    log = Logger("server")
    env = os.environ.copy()
    # add fake xinerama:
    if fake_xinerama:
        libfakeXinerama_so = find_fakeXinerama()
        if libfakeXinerama_so:
            env["LD_PRELOAD"] = libfakeXinerama_so
    # disable ubuntu's global menu using env vars:
    env.update(
        {
            "UBUNTU_MENUPROXY": "",
            "QT_X11_NO_NATIVE_MENUBAR": "1",
            "MWNOCAPTURE": "true",
            "MWNO_RIT": "true",
            "MWWM": "allwm",
        }
    )
    for child_cmd in commands:
        if not child_cmd:
            continue
        try:
            proc = subprocess.Popen(child_cmd, stdin=subprocess.PIPE, env=env, cwd=cwd, shell=True, close_fds=True)
            child_reaper.add_process(proc, child_cmd)
            log.info("started child '%s' with pid %s", child_cmd, proc.pid)
        except OSError, e:
            sys.stderr.write("Error spawning child '%s': %s\n" % (child_cmd, e))

def get_sys_info():
    try:
        from xpra.platform.xposix.info import get_sys_info as xposix_get_sys_info
        return xposix_get_sys_info()
    except:
        from xpra.log import Logger
        log = Logger("osx")
        log.error("error getting memory usage info", exc_info=True)
    return  {}

def setbinarymode(fd):
    if WIN32:
        #turn on binary mode:
        try:
            import msvcrt
            msvcrt.setmode(fd, os.O_BINARY)         #@UndefinedVariable
        except:
            from xpra.log import Logger
            log = Logger("util")
            log.error("setting stdin to binary mode failed", exc_info=True)

def get_icc_info():
    from xpra.log import Logger

    log = Logger("platform")
    info = {}
    try:
        from PIL.ImageCms import (
            get_display_profile,
            getProfileName,
            getProfileInfo,
            getProfileCopyright,
            getProfileManufacturer,
            getProfileModel,
            getProfileDescription,
            getDefaultIntent,
            INTENT_PERCEPTUAL,
            INTENT_RELATIVE_COLORIMETRIC,
            INTENT_SATURATION,
            INTENT_ABSOLUTE_COLORIMETRIC,
        )

        INTENT_STR = {
            INTENT_PERCEPTUAL: "perceptual",
            INTENT_RELATIVE_COLORIMETRIC: "relative-colorimetric",
            INTENT_SATURATION: "saturation",
            INTENT_ABSOLUTE_COLORIMETRIC: "absolute-colorimetric",
        }

        def getDefaultIntentStr(_p):
            return INTENT_STR.get(getDefaultIntent(_p), "unknown")

        def getData(_p):
            return _p.tobytes()

        p = get_display_profile()
        if p:
            for (k, fn) in {
                "name": getProfileName,
                "info": getProfileInfo,
                "copyright": getProfileCopyright,
                "manufacturer": getProfileManufacturer,
                "model": getProfileModel,
                "description": getProfileDescription,
                "default-intent": getDefaultIntentStr,
                "data": getData,
            }.items():
                try:
                    v = fn(p)
                    info[k] = v
                except Exception as e:
                    log("ICC profile error on %s using %s: %s", k, fn, e)
    except Exception as e:
        log.warn("Warning: cannot query ICC profiles:")
        log.warn(" %s", e)
    return info

def mdns_publish(display_name, mode, listen_on, text_dict={}):
    try:
        from xpra.net.avahi_publisher import AvahiPublishers
    except Exception, e:
        global MDNS_WARNING
        if not MDNS_WARNING:
            MDNS_WARNING = True
            from xpra.log import Logger
            log = Logger("mdns")
            log.error("failed to load the mdns avahi publisher: %s", e)
            log.error("either fix your installation or use the '--no-mdns' flag")
        return

def do_log_screen_sizes(root_w, root_h, sizes):
    from xpra.log import Logger

    log = Logger()
    # old format, used by some clients (android):
    if type(sizes) not in (tuple, list):
        return
    if any(True for x in sizes if type(x) not in (tuple, list)):
        return

    def dpi(size_pixels, size_mm):
        if size_mm == 0:
            return 0
        return int(size_pixels * 254 / size_mm / 10)

    for s in sizes:
        if len(s) < 10:
            log.info(" %s", s)
            continue
        # more detailed output:
        display_name, width, height, width_mm, height_mm, monitors, work_x, work_y, work_width, work_height = s[:10]
        # always log plug name:
        info = ["'%s'" % prettify_plug_name(display_name)]
        if width != root_w or height != root_h:
            # log plug dimensions if not the same as display (root):
            info.append("%sx%s" % (width, height))
        info.append("(%sx%s mm - DPI: %sx%s)" % (width_mm, height_mm, dpi(width, width_mm), dpi(height, height_mm)))

        def add_workarea(wx, wy, ww, wh):
            info.append("workarea: %sx%s" % (ww, wh))
            if wx != 0 or wy != 0:
                # log position if not (0, 0)
                info.append("at %sx%s" % (wx, wy))

        if work_width != width or work_height != height or work_x != 0 or work_y != 0:
            add_workarea(work_x, work_y, work_width, work_height)
        log.info("  " + " ".join(info))
        for i, m in enumerate(monitors, start=1):
            if len(m) < 7:
                log.info("    %s", m)
                continue
            plug_name, plug_x, plug_y, plug_width, plug_height, plug_width_mm, plug_height_mm = m[:7]
            info = ["%s" % prettify_plug_name(plug_name, "monitor %s" % i)]
            if plug_width != width or plug_height != height or plug_x != 0 or plug_y != 0:
                info.append("%sx%s" % (plug_width, plug_height))
                if plug_x != 0 or plug_y != 0:
                    info.append("at %sx%s" % (plug_x, plug_y))
            if (plug_width_mm != width_mm or plug_height_mm != height_mm) and (plug_width_mm > 0 or plug_height_mm > 0):
                info.append(
                    "(%sx%s mm - DPI: %sx%s)"
                    % (plug_width_mm, plug_height_mm, dpi(plug_width, plug_width_mm), dpi(plug_height, plug_height_mm))
                )
            if len(m) >= 11:
                work_x, work_y, work_width, work_height = m[7:11]
                add_workarea(work_x, work_y, work_width, work_height)
            log.info("    " + " ".join(info))

def get_icc_info():
    from xpra.log import Logger
    log = Logger("platform")
    ENV_ICC_DATA = os.environ.get("XPRA_ICC_DATA")
    if ENV_ICC_DATA:
        import binascii
        return {
                "source"    : "environment-override",
                "data"      : binascii.unhexlify(ENV_ICC_DATA),
                }
    info = {}
    try:
        from PIL import ImageCms
        from PIL.ImageCms import get_display_profile, getDefaultIntent
        INTENT_STR = {}
        for x in ("PERCEPTUAL", "RELATIVE_COLORIMETRIC", "SATURATION", "ABSOLUTE_COLORIMETRIC"):
            v = getattr(ImageCms, "INTENT_%s" % x, None)
            if v:
                INTENT_STR[v] = x.lower().replace("_", "-")
        log("get_icc_info() intents=%s", INTENT_STR)
        def getDefaultIntentStr(_p):
            return INTENT_STR.get(getDefaultIntent(_p), "unknown")
        def getData(_p):
            return _p.tobytes()
        p = get_display_profile()
        log("get_icc_info() display_profile=%s", p)
        if p:
            for (k, fn) in {
                            "name"          : "getProfileName",
                            "info"          : "getProfileInfo",
                            "copyright"     : "getProfileCopyright",
                            "manufacturer"  : "getProfileManufacturer",
                            "model"         : "getProfileModel",
                            "description"   : "getProfileDescription",
                            "default-intent": "getDefaultIntentStr",
                            "data"          : "getData",
                            }.items():
                m = getattr(ImageCms, fn, None)
                if not m:
                    log("%s lacks %s", ImageCms, fn)
                    continue
                try:
                    v = m(p)
                    info[k] = v
                except Exception as e:
                    log("ICC profile error on %s using %s: %s", k, fn, e)
    except Exception as e:
        log("get_icc_info()", exc_info=True)
        log.warn("Warning: cannot query ICC profiles:")
        log.warn(" %s", e)
    return info

def ival(key, default, minv=0, maxv=None):
    try:
        v = os.environ.get("XPRA_BATCH_%s" % key)
        if v is None:
            return default
        iv = int(v)
        assert minv is None or minv<=iv, "value for %s is too small: %s (minimum is %s)" % (key, iv, minv)
        assert maxv is None or maxv>=iv, "value for %s is too high: %s (maximum is %s)" % (key, iv, maxv)
        return iv
    except Exception as e:
        from xpra.log import Logger
        log = Logger("util")
        log.warn("failed to parse value '%s' for %s: %s", v, key, e)
        return default

def parse_simple_dict(s="", sep=","):
    #parse the options string and add the pairs:
    d = {}
    for s in s.split(sep):
        if not s:
            continue
        try:
            k,v = s.split("=", 1)
            d[k] = v
        except Exception as e:
            from xpra.log import Logger
            log = Logger("util")
            log.warn("Warning: failed to parse dictionary option '%s':", s)
            log.warn(" %s", e)
    return d

def set_application_name(name):
    global NAME_SET
    if NAME_SET:
        return
    NAME_SET = True
    from xpra.log import Logger
    log = Logger()
    if sys.version_info[:2]<(2,5):
        log.warn("Python %s is too old!", sys.version_info)
        return
    try:
        import glib
        glib.set_application_name(name or "Xpra")
    except ImportError, e:
        log.warn("glib is missing, cannot set the application name, please install glib's python bindings: %s", e)

    def __init__(self, event_cb, events=CONSOLE_EXIT_EVENTS):
        self.event_cb = event_cb
        self.events = events
        self.result = 0
        from xpra.log import Logger

        self.log = Logger("win32")