Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""Utility for opening a file using the default application in a cross-platform

manner. Modified from http://code.activestate.com/recipes/511443/.

"""

__version__ = '1.1x'

__all__ = ['open']

import os

import sys

import webbrowser

import subprocess

_controllers = {}

_open = None

class BaseController(object):

    '''Base class for open program controllers.'''

    def __init__(self, name):

        self.name = name

    def open(self, filename):

        raise NotImplementedError

class Controller(BaseController):

    '''Controller for a generic open program.'''

    def __init__(self, *args):

        super(Controller, self).__init__(os.path.basename(args[0]))

        self.args = list(args)

    def _invoke(self, cmdline):

        if sys.platform[:3] == 'win':

            closefds = False

            startupinfo = subprocess.STARTUPINFO()

            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

        else:

            closefds = True

            startupinfo = None

        if (os.environ.get('DISPLAY') or sys.platform[:3] == 'win' or

                                                    sys.platform == 'darwin'):

            inout = file(os.devnull, 'r+')

        else:

            # for TTY programs, we need stdin/out

            inout = None

        # if possible, put the child precess in separate process group,

        # so keyboard interrupts don't affect child precess as well as

        # Python

        setsid = getattr(os, 'setsid', None)

        if not setsid:

            setsid = getattr(os, 'setpgrp', None)

        pipe = subprocess.Popen(cmdline, stdin=inout, stdout=inout,

                                stderr=inout, close_fds=closefds,

                                preexec_fn=setsid, startupinfo=startupinfo)

        # It is assumed that this kind of tools (gnome-open, kfmclient,

        # exo-open, xdg-open and open for OSX) immediately exit after launching

        # the specific application

        returncode = pipe.wait()

        if hasattr(self, 'fixreturncode'):

            returncode = self.fixreturncode(returncode)

        return not returncode

    def open(self, filename):

        if isinstance(filename, basestring):

            cmdline = self.args + [filename]

        else:

            # assume it is a sequence

            cmdline = self.args + filename

        try:

            return self._invoke(cmdline)

        except OSError:

            return False

# Platform support for Windows

if sys.platform[:3] == 'win':

    class Start(BaseController):

        '''Controller for the win32 start program through os.startfile.'''

        def open(self, filename):

            try:

                os.startfile(filename)

            except WindowsError:

                # [Error 22] No application is associated with the specified

                # file for this operation: '<URL>'

                return False

            else:

                return True

    _controllers['windows-default'] = Start('start')

    _open = _controllers['windows-default'].open

# Platform support for MacOS

elif sys.platform == 'darwin':

    _controllers['open']= Controller('open')

    _open = _controllers['open'].open

# Platform support for Unix

else:

    try:

        from commands import getoutput

    except ImportError:

        from subprocess import getoutput

    # @WARNING: use the private API of the webbrowser module

    from webbrowser import _iscommand

    class KfmClient(Controller):

        '''Controller for the KDE kfmclient program.'''

        def __init__(self, kfmclient='kfmclient'):

            super(KfmClient, self).__init__(kfmclient, 'exec')

            self.kde_version = self.detect_kde_version()

        def detect_kde_version(self):

            kde_version = None

            try:

                info = getoutput('kde-config --version')

                for line in info.splitlines():

                    if line.startswith('KDE'):

                        kde_version = line.split(':')[-1].strip()

                        break

            except (OSError, RuntimeError):

                pass

            return kde_version

        def fixreturncode(self, returncode):

            if returncode is not None and self.kde_version > '3.5.4':

                return returncode

            else:

                return os.EX_OK

    def detect_desktop_environment():

        '''Checks for known desktop environments

        Return the desktop environments name, lowercase (kde, gnome, xfce)

        or "generic"

        '''

        desktop_environment = 'generic'

        if os.environ.get('KDE_FULL_SESSION') == 'true':

            desktop_environment = 'kde'

        elif os.environ.get('GNOME_DESKTOP_SESSION_ID'):

            desktop_environment = 'gnome'

        else:

            try:

                info = getoutput('xprop -root _DT_SAVE_MODE')

                if ' = "xfce4"' in info:

                    desktop_environment = 'xfce'

            except (OSError, RuntimeError):

                pass

        return desktop_environment

    def register_X_controllers():

        if _iscommand('kfmclient'):

            _controllers['kde-open'] = KfmClient()

        for command in ('gnome-open', 'exo-open', 'xdg-open'):

            if _iscommand(command):

                _controllers[command] = Controller(command)

    def get():

        controllers_map = {

            'gnome': 'gnome-open',

            'kde': 'kde-open',

            'xfce': 'exo-open',

        }

        desktop_environment = detect_desktop_environment()

        try:

            controller_name = controllers_map[desktop_environment]

            return _controllers[controller_name].open

        except KeyError:

            if 'xdg-open' in _controllers:

                return _controllers['xdg-open'].open

            else:

                return webbrowser.open

    if os.environ.get("DISPLAY"):

        register_X_controllers()

    _open = get()

def open(filename):

    '''Open a file or a URL in the registered default application.'''

    return _open(filename)