mcplatform.py

"""Copyright (c) 2010-2012 David Rio Vierra

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."""
# -# Modified by D.C.-G. for translation purpose
# !# Tests for file chooser

"""
mcplatform.py

Platform-specific functions, folder paths, and the whole fixed/portable nonsense.
"""

import logging
log = logging.getLogger(__name__)

import directories
import os
from os.path import dirname, exists, join
import sys
import platform

enc = sys.getfilesystemencoding()

hasXlibDisplay = False
if sys.platform == "win32":
    if platform.architecture()[0] == "32bit":
        plat = "win32"
    if platform.architecture()[0] == "64bit":
        plat = "win-amd64"
    #sys.path.append(join(directories.getDataDir(), "pymclevel", "build", "lib." + plat + "-2.6").encode(enc))
    sys.path.append(directories.getDataFile('pymclevel', 'build', 'lib.{}-2.6'.format(plat)).encode(enc))
elif sys.platform in ['linux2', 'darwin']:
    try:
        import Xlib.display
        import Xlib.X
        import Xlib.protocol
        hasXlibDisplay = True
    except ImportError:
        hasXlibDisplay = None

#os.environ["YAML_ROOT"] = join(directories.getDataDir(), "pymclevel").encode(enc)
os.environ['YAML_ROOT'] = directories.getDataFile('pymclevel').encode(enc)

from pygame import display

from albow import request_new_filename, request_old_filename
from albow.translate import _
from pymclevel import minecraftSaveFileDir, getMinecraftProfileDirectory, getSelectedProfile
from datetime import datetime

import re
import subprocess

try:
    import pygtk
    pygtk.require('2.0')
    import gtk
    if gtk.pygtk_version < (2, 3, 90):
        raise ImportError
    hasGtk = True
except ImportError:
    hasGtk = False  # Using old method as fallback


texturePacksDir = os.path.join(getMinecraftProfileDirectory(getSelectedProfile()), "texturepacks")
# Compatibility layer for filters:
filtersDir = directories.filtersDir
schematicsDir = directories.schematicsDir

# !# Disabling platform specific file chooser:
# !# Please, don't touch these two lines and the 'platChooser' stuff. -- D.C.-G.
#platChooser = sys.platform in ('linux2', 'darwin')
platChooser = sys.platform == 'darwin'


def dynamic_arguments(func_to_replace, askFile_func):
    def wrapper(initialDir, displayName, fileFormat):
        if isinstance(fileFormat, tuple):
            return func_to_replace(initialDir, displayName, fileFormat)
        else:
            def old_askSaveSchematic(initialDir, displayName, fileFormat):
                dt = datetime.now().strftime("%Y-%m-%d--%H-%M-%S")
                return askFile_func(initialDir,
                                    title=_('Save this schematic...'),
                                    defaultName=displayName + "_" + dt + "." + fileFormat,
                                    filetype=_('Minecraft Schematics (*.{0})\0*.{0}\0\0').format(fileFormat),
                                    suffix=fileFormat,
                                    )
            return old_askSaveSchematic(initialDir, displayName, fileFormat)
    return wrapper


def getTexturePacks():
    try:
        return os.listdir(texturePacksDir)
    except:
        return []

if sys.platform == "win32":
    try:
        from win32 import win32gui
        from win32 import win32api

        from win32.lib import win32con
    except ImportError:
        import win32gui
        import win32api

        import win32con

    try:
        import win32com.client
        from win32com.shell import shell, shellcon  # @UnresolvedImport
    except:
        pass
    
    try:
        import pywintypes
    except:
        pass

if sys.platform == 'darwin':
    cmd_name = "Cmd"
    option_name = "Opt"
else:
    cmd_name = "Ctrl"
    option_name = "Alt"


def OSXVersionChecker(name, compare):
    """Rediculously complicated function to compare current System version to inputted version."""
    if compare != 'gt' and compare != 'lt' and compare != 'eq' and compare != 'gteq' and compare != 'lteq':
        print "Invalid version check {}".format(compare)
        return False
    if sys.platform == 'darwin':
        try:
            systemVersion = platform.mac_ver()[0].split('.')
            if len(systemVersion) == 2:
                systemVersion.append('0')

            major, minor, patch = 10, 0, 0

            if name.lower() == 'cheetah':
                minor = 0
                patch = 4
            elif name.lower() == 'puma':
                minor = 1
                patch = 5
            elif name.lower() == 'jaguar':
                minor = 2
                patch = 8
            elif name.lower() == 'panther':
                minor = 3
                patch = 9
            elif name.lower() == 'tiger':
                minor = 4
                patch = 11
            elif name.lower() == 'snow_leopard':
                minor = 5
                patch = 8
            elif name.lower() == 'snow_leopard':
                minor = 6
                patch = 8
            elif name.lower() == 'lion':
                minor = 7
                patch = 5
            elif name.lower() == 'mountain_lion':
                minor = 8
                patch = 5
            elif name.lower() == 'mavericks':
                minor = 9
                patch = 5
            elif name.lower() == 'yosemite':
                minor = 10
                patch = 0
            else:
                major = 0

            if int(systemVersion[0]) > int(major):
                ret_val = 1
            elif int(systemVersion[0]) < int(major):
                ret_val = -1
            else:
                if int(systemVersion[1]) > int(minor):
                    ret_val = 1
                elif int(systemVersion[1]) < int(minor):
                    ret_val = -1
                else:
                    if int(systemVersion[2]) > int(patch):
                        ret_val = 1
                    elif int(systemVersion[2]) < int(patch):
                        ret_val = -1
                    else:
                        ret_val = 0

            if ret_val == 0 and (compare == 'eq' or compare == 'gteq' or compare == 'lteq'):
                return True
            elif ret_val == -1 and (compare == 'lt' or compare == 'lteq'):
                return True
            elif ret_val == 1 and (compare == 'gt' or compare == 'gteq'):
                return True
        except:
            print "An error occured determining the system version"
            return False
    else:
        return False

lastSchematicsDir = None
lastSaveDir = None


def buildFileTypes(filetypes):
    result = ""
    for key in reversed(filetypes[0].keys()):
        ftypes = []
        result += key + " ("
        for ftype in filetypes[0][key]:
            ftypes.append("*." + ftype)
        result += ",".join(ftypes) + ")\0"
        result += ";".join(ftypes) + "\0"
    return result + "\0"


def askOpenFile(title='Select a Minecraft level....', schematics=False, suffixes=None):
    title = _(title)
    global lastSchematicsDir, lastSaveDir

    if not suffixes:
        suffixes = ["mclevel", "dat", "mine", "mine.gz", "mcworld"]
        suffixesChanged = False
    else:
        suffixesChanged = True
    initialDir = lastSaveDir or minecraftSaveFileDir
    if schematics:
        initialDir = lastSchematicsDir or directories.schematicsDir

    def _askOpen(_suffixes):
        if schematics:
            _suffixes.append("schematic")
            _suffixes.append("schematic.gz")
            _suffixes.append("zip")

            _suffixes.append("inv")
            
            _suffixes.append("nbt")

            # BO support
            _suffixes.append("bo2")
            _suffixes.append("bo3")
            _suffixes.sort()

        if sys.platform == "win32":  # !#
            if suffixesChanged:
                sendSuffixes = _suffixes
            else:
                sendSuffixes = None
            return askOpenFileWin32(title, schematics, initialDir, sendSuffixes)

        elif hasGtk and not platChooser:  # !# #Linux (When GTK 2.4 or newer is installed)
            return askOpenFileGtk(title, _suffixes, initialDir)

        else:
            log.debug("Calling internal file chooser.")
            log.debug("'initialDir' is %s (%s)" % (repr(initialDir), type(initialDir)))
            try:
                iDir = initialDir.encode(enc)
            except Exception as e:
                iDir = initialDir
                log.debug("Could not encode 'initialDir' %s" % repr(initialDir))
                log.debug("Encode function returned: %s" % e)
            if "All files (*.*)" not in _suffixes and "*.* (*.*)" not in _suffixes:
                _suffixes.append("All files (*.*)")
            return request_old_filename(suffixes=_suffixes, directory=iDir)

    filename = _askOpen(suffixes)
    if filename:
        if schematics:
            lastSchematicsDir = dirname(filename)
        else:
            lastSaveDir = dirname(filename)

    return filename


def askOpenFileWin32(title, schematics, initialDir, suffixes=None):
    try:
        if not suffixes:
            f = (_('Levels and Schematics') + '\0*.mclevel;*.dat;*.mine;*.mine.gz;*.schematic;*.zip;*.schematic.gz;*.inv;*.nbt;*.mcworld\0' +
                 '*.*\0*.*\0\0')
        else:
            f = "All\0"
            for suffix in suffixes:
                f += "*." + suffix + ";"
            f += "\0*.*\0\0"

        filename, customfilter, flags = win32gui.GetOpenFileNameW(
            hwndOwner=display.get_wm_info()['window'],
            InitialDir=initialDir,
            Flags=(win32con.OFN_EXPLORER
                   | win32con.OFN_NOCHANGEDIR
                   | win32con.OFN_FILEMUSTEXIST
                   | win32con.OFN_LONGNAMES
                   ),
            Title=title,
            Filter=f,
        )
    except Exception:
        pass
    else:
        return filename


def askOpenFileGtk(title, suffixes, initialDir):
    fls = []

    def run_dlg():
        chooser = gtk.FileChooserDialog(title,
                                        None, gtk.FILE_CHOOSER_ACTION_SAVE,
                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                                        gtk.STOCK_OPEN, gtk.RESPONSE_OK))
    
        chooser.set_default_response(gtk.RESPONSE_OK)
        chooser.set_current_folder(initialDir)
        chooser.set_current_name("world")  # For some reason the Windows isn't closing if this line ins missing or the parameter is ""

        # Add custom Filter
        file_filter = gtk.FileFilter()
        file_filter.set_name(_("Levels and Schematics"))
        for suffix in suffixes:
            file_filter.add_pattern("*." + suffix)
        chooser.add_filter(file_filter)

        # Add "All files" Filter
        file_filter = gtk.FileFilter()
        file_filter.set_name("All files")
        file_filter.add_pattern("*")
        chooser.add_filter(file_filter)

        response = chooser.run()
        if response == gtk.RESPONSE_OK:
            fls.append(chooser.get_filename())
        else:
            fls.append(None)
        chooser.destroy()
        gtk.main_quit()

    gtk.idle_add(run_dlg)
    gtk.main()

    return fls[0]


def askSaveSchematic(initialDir, displayName, fileFormats):
    fileFormat = buildFileTypes(fileFormats)
    
    dt = datetime.now().strftime("%Y-%m-%d--%H-%M-%S")
    return askSaveFile(initialDir,
                       title=_('Save this schematic...'),
                       defaultName=displayName + "_" + dt + "." + fileFormats[0][fileFormats[0].keys()[1]][0],
                       filetype=fileFormat,
                       suffix=fileFormat,
                       )


def askCreateWorld(initialDir):
    defaultName = name = _("Untitled World")
    i = 0
    while exists(join(initialDir, name)):
        i += 1
        name = defaultName + " " + str(i)

    return askSaveFile(initialDir,
                       title=_('Name this new world.'),
                       defaultName=name,
                       filetype=_('Minecraft World\0*.*\0\0'),
                       suffix="",
    )


def askSaveFile(initialDir, title, defaultName, filetype, suffix):
    if sys.platform == "win32":  # !#
        try:
            if isinstance(suffix, (list, tuple)) and suffix:
                suffix = suffix[0]
            print repr(filetype)
            if not filetype.endswith("*.*\0*.*\0\0"):
                filetype = filetype[:-1] + "*.*\0*.*\0\0"
            print repr(filetype)
            (filename, customfilter, flags) = win32gui.GetSaveFileNameW(
                hwndOwner=display.get_wm_info()['window'],
                InitialDir=initialDir,
                Flags=win32con.OFN_EXPLORER | win32con.OFN_NOCHANGEDIR | win32con.OFN_OVERWRITEPROMPT,
                File=defaultName,
                DefExt=suffix,
                Title=title,
                Filter=filetype,
            )
        except Exception as e:
            print "Error getting file name: ", e
            return

        try:
            filename = filename[:filename.index('\0')]
            filename = filename.decode(sys.getfilesystemencoding())
        except:
            pass

    else:
        # Reformat the Windows stuff
        if "\0" in suffix and suffix.count("*.") > 1:
            _suffix = suffix.split("\0")[:-2]
        else:
            _suffix = suffix
        if "\0" in filetype and filetype.count("*.") > 0:
            _filetype = filetype.split("\0")[:-2]
        else:
            _filetype = filetype

        if hasGtk and not platChooser:  # !# #Linux (When GTK 2.4 or newer is installed)

            fls = []
            def run_dlg():
                chooser = gtk.FileChooserDialog(title,
                                                None, gtk.FILE_CHOOSER_ACTION_SAVE,
                                                (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                                                gtk.STOCK_SAVE, gtk.RESPONSE_OK))

                chooser.set_default_response(gtk.RESPONSE_OK)
                chooser.set_current_folder(initialDir)
                chooser.set_current_name(defaultName)

                # Add custom Filter
                if isinstance(_filetype, list) or isinstance(_filetype, tuple):
                    for i, stuff in enumerate(_filetype):
                        if i % 2 == 0:
                            file_filter = gtk.FileFilter()
                            file_filter.set_name(stuff)
                        else:
                            if ";" in stuff:
                                for _suff in stuff.split(";"):
                                    if _suff:
                                        file_filter.add_pattern(_suff)
                            else:
                                file_filter.add_pattern(stuff)
                            chooser.add_filter(file_filter)
                    if i % 2 == 0:
                        if ";" in stuff:
                            for _suff in stuff.split(";"):
                                if _suff:
                                    file_filter.add_pattern(_suff)
                        else:
                            file_filter.add_pattern(stuff)
                        chooser.add_filter(file_filter)
                else:
                    file_filter = gtk.FileFilter()
                    file_filter.set_name(filetype[:filetype.index("\0")])
                    if "\0" in suffix and suffix.count("*.") > 1:
                        __suffix = suffix.split("\0")[:-2]
                    else:
                        __suffix = suffix
                    if isinstance(__suffix, list) or isinstance(__suffix, tuple):
                        for suff in __suffix:
                            file_filter.add_pattern("*." + suff)
                    else:
                        file_filter.add_pattern("*." + __suffix)
                    chooser.add_filter(file_filter)

                # Add "All files" Filter
                file_filter = gtk.FileFilter()
                file_filter.set_name("All files")
                file_filter.add_pattern("*")
                chooser.add_filter(file_filter)

                response = chooser.run()
                if response == gtk.RESPONSE_OK:
                    fls.append(chooser.get_filename())
                else:
                    fls.append(None)
                chooser.destroy()
                gtk.main_quit()

            gtk.idle_add(run_dlg)
            gtk.main()

            filename = fls[0]

        else:  # Fallback
            log.debug("Calling internal file chooser.")
            log.debug("'initialDir' is %s (%s)" % (repr(initialDir), type(initialDir)))
            log.debug("'defaultName' is %s (%s)" % (repr(defaultName), type(defaultName)))
            try:
                iDir = initialDir.encode(enc)
            except Exception as e:
                iDir = initialDir
                log.debug("Could not encode 'initialDir' %s" % repr(initialDir))
                log.debug("Encode function returned: %s" % e)
            try:
                dName = defaultName.encode(enc)
            except Exception as e:
                dName = defaultName
                log.debug("Could not encode 'defaultName' %s" % repr(defaultName))
                log.debug("Encode function returned: %s" % e)
            if isinstance(_suffix, list) or isinstance(_suffix, tuple):
                sffxs = [a[1:] for a in _suffix[1::2]]
                sffx = sffxs.pop(0)
                sffxs.append('.*')
            else:
                sffx = _suffix
                sffxs = []

            for i, stuff in enumerate(_filetype):
                if i % 2 == 0:
                    file_filter = stuff
                else:
                    file_filter += " (%s)"%stuff
                    sffxs.append(file_filter)
            if i % 2 == 0:
                file_filter += " (%s)"%stuff
                sffxs.append(file_filter)

            if "All files (*.*)" not in sffxs and "*.* (*.*)" not in sffxs:
                sffxs.append("All files (*.*)")

            filename = request_new_filename(prompt=title,
                                            suffix=sffx,
                                            extra_suffixes=sffxs,
                                            directory=iDir,
                                            filename=dName,
                                            pathname=None)
    return filename

askSaveSchematic = dynamic_arguments(askSaveSchematic, askSaveFile)


# Start Open Folder Dialogs
# TODO: Possibly get an OS X dialog
def askOpenFolderWin32(title, initialDir):
    try:
        desktop_pidl = shell.SHGetFolderLocation(0, shellcon.CSIDL_DESKTOP, 0, 0)
        pidl, display_name, image_list = shell.SHBrowseForFolder (
                                                              win32gui.GetDesktopWindow(),
                                                              desktop_pidl,
                                                              "Choose a folder",
                                                              0,
                                                              None,
                                                              None
                                                              )
        return shell.SHGetPathFromIDList(pidl)
    except pywintypes.com_error as e:
        if e.args[0] == -2147467259:
            print "Invalid folder selected"


def askOpenFolderGtk(title, initialDir):
    if hasGtk:
        fls = []

        def run_dlg():
            chooser = gtk.FileChooserDialog(title,
                                        None, gtk.FILE_CHOOSER_ACTION_SAVE,
                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                                        gtk.STOCK_OPEN, gtk.RESPONSE_OK))

            chooser.set_default_response(gtk.RESPONSE_OK)
            chooser.set_current_folder(initialDir)
            chooser.set_current_name("world")
            chooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)

            response = chooser.run()
            if response == gtk.RESPONSE_OK:
                fls.append(chooser.get_filename())  # Returns the folder path if gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER is the action
            else:
                fls.append(None)
            chooser.destroy()
            gtk.main_quit()

        gtk.idle_add(run_dlg)
        gtk.main()
        return fls[0]
    else:
        print "You currently need gtk to use an Open Folder Dialog!"


def platform_open(path):
    try:
        if sys.platform == "win32":
            os.startfile(path)
        elif sys.platform == "darwin":
            os.system('open "' + path + '"')
        else:
            os.system('xdg-open "' + path + '"')

    except Exception as e:
        print "platform_open failed on {0}: {1}".format(sys.platform, e)


win32_window_size = True


#=============================================================================
#=============================================================================
# DESKTOP ENVIRONMENTS AND OS SIDE WINDOW MANAGEMENT.
#
# The idea is to have a single object to deal with underling OS specific window management interface.
# This will help to save/restore MCEdit window sate, position and size.
#
# TODO:
# * Test on the actually unsupported Linux DEs.
# * Review WWindowHandler class for Windows.
# * Create a DWindowHandler class for Darwin (OSX).

# Window states
MINIMIZED = 0
NORMAL = 1
MAXIMIZED = 2
FULLSCREEN = 3

#=============================================================================
# Linux desktop environment detection.
#
# source: http://stackoverflow.com/questions/2035657/what-is-my-current-desktop-environment (http://stackoverflow.com/a/21213358)
#
# Tweaked, of course ;)
#
def get_desktop_environment():
        # From http://stackoverflow.com/questions/2035657/what-is-my-current-desktop-environment
        # and http://ubuntuforums.org/showthread.php?t=652320
        # and http://ubuntuforums.org/showthread.php?t=652320
        # and http://ubuntuforums.org/showthread.php?t=1139057
        if sys.platform in ("win32", "cygwin"):
            return "windows"
        elif sys.platform == "darwin":
            return "mac"
        else:  # Most likely either a POSIX system or something not much common
            ds = os.environ.get("DESKTOP_SESSION", None)
            if ds in ('default', None):
                ds = os.environ.get("XDG_CURRENT_DESKTOP", None)
            if ds is not None:  # easier to match if we doesn't have  to deal with caracter cases
                desktop_session = ds.lower()
                found = re.findall(r"gnome|unity|cinnamon|mate|xfce4|lxde|fluxbox|blackbox|openbox|icewm|jwm|afterstep|trinity|kde", desktop_session, re.I)
                if len(found) == 1:
                    return found[0]
                elif len(found) > 1:
                    print "Houston? We have a problem...\n\nThe desktop environment can't be found: '%s' has been detected to be %s alltogeteher." % (ds, " and ".join((", ".join(found[:-1]), found[-1])))
                    return 'unknown'
                # # Special cases ##
                # Canonical sets $DESKTOP_SESSION to Lubuntu rather than LXDE if using LXDE.
                # There is no guarantee that they will not do the same with the other desktop environments.
                elif "xfce" in desktop_session or desktop_session.startswith("xubuntu"):
                    return "xfce4"
                elif desktop_session.startswith("ubuntu"):
                    return "unity"
                elif desktop_session.startswith("lubuntu"):
                    return "lxde"
                elif desktop_session.startswith("kubuntu"):
                    return "kde"
                elif desktop_session.startswith("razor"):  # e.g. razorkwin
                    return "razor-qt"
                elif desktop_session.startswith("wmaker"):  # e.g. wmaker-common
                    return "windowmaker"
                
            if os.environ.get('KDE_FULL_SESSION', None) == 'true':
                return "kde"
            elif os.environ.get('GNOME_DESKTOP_SESSION_ID', None):
                if not "deprecated" in os.environ.get('GNOME_DESKTOP_SESSION_ID', None):
                    return "gnome2"
            # From http://ubuntuforums.org/showthread.php?t=652320
            elif is_running("xfce-mcs-manage"):
                return "xfce4"
            elif is_running("ksmserver"):
                return "kde"
        return "unknown"


def is_running(process):
    # From http://www.bloggerpolis.com/2011/05/how-to-check-if-a-process-is-running-using-python/
    # and http://richarddingwall.name/2009/06/18/windows-equivalents-of-ps-and-kill-commands/
    try:  # Linux/Unix
        s = subprocess.Popen(["ps", "axw"], stdout=subprocess.PIPE)
    except:  # Windows
        s = subprocess.Popen(["tasklist", "/v"], stdout=subprocess.PIPE)
    for x in s.stdout:
        if re.search(process, x):
            return True
    return False

#=============================================================================
# Window handling.
desktop_environment = get_desktop_environment()

DEBUG_WM = False
USE_WM = True

# Desktops settings
# Each entry in the platform sub-dictionaries represent which object is used to get/set the window metrics.
#
# For Linux:
# Valid entries are: position_gap, position_getter, position_setter, size_getter, size_setter and state.
# Entries can be omitted; default values will be used.
# For position_gap the default is (0, 0, False, False)
# For the other ones, the default is the Pygame window object.
#
# position_gap is used on some environment to restore the windows at the coords it was formerly.
# The two first values of the tuple are the amount of pixels to add to the window x and y coords.
# The two last ones tell whether these pixels shall be added only once (at program startup) or always.
#
desktops = {'linux2': {
        'cinnamon': {  # Actually, there's a bug when resizing on XCinnamon.
            'position_setter': 'parent',
            'position_getter': 'parent.parent',
            'position_gap': (9, 8, True, True),
            'state': 'parent'
            },
        'gnome': {
            'position_setter': 'parent',
            'position_getter': 'parent.parent',
            'size_setter': 'parent',
            'size_getter': 'parent',
            'state': 'parent'
        },
        'kde': {
            'position_setter': 'parent',
            'position_getter': 'parent.parent.parent',
            'state': 'parent'
        },
        'unity': {
            'position_setter': 'parent',
            'position_getter': 'parent.parent.parent',
            'position_gap': (10, 10, False, False),
            'size_setter': 'parent',
            'state': 'parent'
        }
    },
}

# The environments in the next definition need to be tested.
linux_unsuported = ('afterstep',
                    'blackbox',
                    'fluxbox',
                    'gnome2',
                    'icewm',
                    'jwm',
                    'lxde',
                    'mate',
                    'openbox',
                    'razor-qt',
                    'trinity',
                    'windowmaker',
                    'xfce4')


# Window handlers classes
class BaseWindowHandler(object):
    """Abstract class for the platform specific window handlers.
    If initialized, this class casts a NotImplementedError."""
    desk_env = desktop_environment

    def __init__(self, *args, **kwargs):
        """..."""
        if not len(kwargs):
            raise NotImplementedError("Abstract class.")
        self.mode = kwargs['mode']

    def set_mode(self, size, mode):
        """Wrapper for pygame.display.set_mode()."""
        display.set_mode(size, mode)

    def get_root_rect(self):
        """..."""
        raise NotImplementedError("Abstract method.")

    def get_size(self):
        """..."""
        raise NotImplementedError("Abstract method.")

    def set_size(self, size, update=True):
        """..."""
        raise NotImplementedError("Abstract method.")

    def get_position(self):
        """..."""
        raise NotImplementedError("Abstract method.")

    def set_position(self, pos, update=True):
        """..."""
        raise NotImplementedError("Abstract method.")

    def get_state(self):
        """..."""
        raise NotImplementedError("Abstract method.")

    def set_state(self, state=NORMAL, size=(-1, -1), pos=(-1, -1), update=True):
        """..."""
        raise NotImplementedError("Abstract method.")

    def flush(self):
        """Just does nothing..."""
        return

    def sync(self):
        """Just does nothing..."""
        return


class XWindowHandler(BaseWindowHandler):
    """Object to deal with XWindow managers (Linux)."""
    desk_env = desktop_environment

    def __init__(self, pos=(0, 0), size=(0, 0), mode=None):
        """Set up the internal handlers."""
        BaseWindowHandler.__init__(self, pos=pos, size=size, mode=mode)
        self.mode = mode
        # setup the internal data, especially the Xlib object we need.
        # Tests
        if DEBUG_WM:
            print "#" * 72
            print "XWindowHandler.__init__"
            print "Desktop environment:", desktop_environment
        dis = self.display = Xlib.display.Display()
        pygame_win = dis.create_resource_object('window', display.get_wm_info()['window'])
        if DEBUG_WM:
            root = dis.screen().root
            active_wid_id = root.get_full_property(dis.intern_atom('_NET_ACTIVE_WINDOW'), Xlib.X.AnyPropertyType).value[0]
            active_win = dis.create_resource_object('window', active_wid_id)
            # Print pygame_win and active_win styff
            for (win, name) in ((pygame_win, 'pygame_win'), (active_win, 'active_win')):
                print "=" * 72
                print "%s guts" % name, "(ID %s)" % win.id
                print "-" * 72
                print "* State"
                prop = win.get_full_property(dis.intern_atom("_NET_WM_STATE"), 4)
                print " ", prop
                if prop:
                    print dir(prop)
                print "* Geometry"
                print " ", win.get_geometry()
                parent = win.query_tree().parent
                p = '%s.parent' % name
                while parent.id != root.id:
                    print "-" * 72
                    print p, "ID", parent.id
                    print "* State"
                    prop = parent.get_full_property(dis.intern_atom("_NET_WM_STATE"), 4)
                    print " ", prop
                    if prop:
                        print dir(prop)
                    print "* Geometry"
                    print " ", parent.get_geometry()
                    parent = parent.query_tree().parent
                    p += ".parent"

        # Size handlers
        self.base_handler = pygame_win
        self.base_handler_id = pygame_win.id
        size = desktops['linux2'][self.desk_env].get('size_getter', None)
        if size:
            if DEBUG_WM:
                print "size_getter.split('.')", size.split('.')
            handler = pygame_win
            for item in size.split('.'):
                handler = getattr(handler.query_tree(), item)
            self.sizeGetter = handler
        else:
            self.sizeGetter = pygame_win
        size = desktops['linux2'][self.desk_env].get('size_setter', None)
        if size:
            if DEBUG_WM:
                print "size_setter.split('.')", size.split('.')
            handler = pygame_win
            for item in size.split('.'):
                handler = getattr(handler.query_tree(), item)
            self.sizeSetter = handler
        else:
            self.sizeSetter = pygame_win
        # Position handlers
        pos = desktops['linux2'][self.desk_env].get('position_getter', None)
        if pos:
            if DEBUG_WM:
                print "pos_getter.split('.')", pos.split('.')
            handler = pygame_win
            for item in pos.split('.'):
                handler = getattr(handler.query_tree(), item)
            self.positionGetter = handler
        else:
            self.positionGetter = pygame_win
        pos = desktops['linux2'][self.desk_env].get('position_setter', None)
        if pos:
            if DEBUG_WM:
                print "pos_setter.split('.')", pos.split('.')
            handler = pygame_win
            for item in pos.split('.'):
                handler = getattr(handler.query_tree(), item)
            self.positionSetter = handler
        else:
            self.positionSetter = pygame_win
        # Position gap. Used to correct wrong positions on some environments.
        self.position_gap = desktops['linux2'][self.desk_env].get('position_gap', (0, 0, False, False))
        self.starting = True
        self.gx, self.gy = 0, 0
        # State handler
        state = desktops['linux2'][self.desk_env].get('state', None)
        if state:
            if DEBUG_WM:
                print "state.split('.')", state.split('.')
            handler = pygame_win
            for item in state.split('.'):
                handler = getattr(handler.query_tree(), item)
            self.stateHandler = handler
        else:
            self.stateHandler = pygame_win

        if DEBUG_WM:
            print "self.positionGetter:", self.positionGetter, 'ID:', self.positionGetter.id
            print "self.positionSetter:", self.positionSetter, 'ID:', self.positionSetter.id
            print "self.sizeGetter:", self.sizeGetter, 'ID:', self.sizeGetter.id
            print "self.sizeSetter:", self.sizeSetter, 'ID:', self.sizeSetter.id
            print "self.stateHandler:", self.stateHandler, 'ID:', self.stateHandler.id
            print self.stateHandler.get_wm_state()

    def get_root_rect(self):
        """Return a four values tuple containing the position and size of the very first OS window object."""
        geom = self.display.screen().root.get_geometry()
        return geom.x, geom.y, geom.width, geom.height

    def get_size(self):
        """Return the window actual size as a tuple (width, height)."""
        geom = self.sizeGetter.get_geometry()
        if DEBUG_WM:
            print "Actual size is", geom.width, geom.height
        return geom.width, geom.height

    def set_size(self, size, update=True):
        """Set the window size.
        :size: list or tuple: the new size.
        Raises a TypeError if something else than a list or a tuple is sent."""
        if isinstance(size, (list, tuple)):
            # Call the Xlib object handling the size to update it.
            if DEBUG_WM:
                print "Setting size to", size
                print "actual size", self.get_size()
            self.sizeSetter.configure(width=size[0], height=size[1])
            if update:
                self.sync()
        else:
            # Raise a Type error.
            raise TypeError("%s is not a list or a tuple." % size)

    def get_position(self):
        """Return the window actual position as a tuple."""
        geom = self.positionGetter.get_geometry()
#         if DEBUG_WM:
#             print "Actual position is", geom.x, geom.y
        return geom.x, geom.y

    def set_position(self, pos, update=True):
        """Set the window position.
        :pos: list or tuple: the new position (x, y).
        :update: bool: wheteher to call the internal sync method."""
        if DEBUG_WM:
            print "Setting position to", pos
        if isinstance(pos, (list, tuple)):
            gx, gy = 0 or self.gx, 0 or self.gy
            if self.starting:
                gx, gy = self.position_gap[:2]
                if self.position_gap[2]:
                    self.gx = gx
                if self.position_gap[3]:
                    self.gy = gy
                self.starting = False
            # Call the Xlib object handling the position to update it.
            self.positionSetter.configure(x=pos[0] + gx, y=pos[1] + gy)
            if update:
                self.sync()
        else:
            # Raise a Type error.
            raise TypeError("%s is not a list or a tuple." % pos)

    def get_state(self):
        """Return wheter the window is maximized or not, or minimized or full screen."""
        state = self.stateHandler.get_full_property(self.display.intern_atom("_NET_WM_STATE"), 4)
#         if DEBUG_WM:
#             print "state_1.value", state.value
#             print "max vert", self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_VERT") ,self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_VERT") in state.value
#             print "max horz", self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_HORZ"), self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_HORZ") in state.value
        if self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_HORZ") in state.value and self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_VERT") in state.value:
#             if DEBUG_WM:
#                 print MAXIMIZED
            return MAXIMIZED
        elif self.display.intern_atom("_NET_WM_STATE_HIDEN") in state.value:
#             if DEBUG_WM:
#                 print MINIMIZED
            return MINIMIZED
        elif self.display.intern_atom("_NET_WM_STATE_FULLSCREEN") in state.value:
#             if DEBUG_WM:
#                 print FULLSCREEN
            return FULLSCREEN
#         if DEBUG_WM:
#             print NORMAL
        return NORMAL

    def set_state(self, state=NORMAL, size=(-1, -1), pos=(-1, -1), update=True):
        """Set whether the window is maximized or not, or minimized or full screen.
        If no argument is given, assume the state will be windowed and not maximized.
        If arguments are given, only the first is relevant. The other ones are ignored.

        ** Only maximized and normal states are implemented for now. **

        :state: valid arguments:
        'minimized', MINIMIZED, 0.
        'normal', NORMAL, 1: windowed, not maximized.
        'maximized', MAXIMIZED, 2.
        'fullscreen, FULLSCREEN, 3.

        :size: list, tuple: the new size; if (-1, -1) self.get_size() is used.
               If one element is -1 it is replaced by the corresponding valur from self.get_size().
        :pos: list, tuple: the new position; if (-1, -1), self.get_position is used.
              If one element is -1 it is replaced by the corresponding valur from self.get_position().
        :update: bool: whether to call the internal flush method."""
        if state not in (0, MINIMIZED, 'minimized', 1, NORMAL, 'normal', 2, MAXIMIZED, 'maximized', 3, FULLSCREEN, 'fullscreen'):
            # Raise a value error.
            raise ValueError("Invalid state argument: %s is not a correct value" % state)
        if not isinstance(size, (list, tuple)):
            raise TypeError("Invalid size argument: %s is not a list or a tuple.")
        if not isinstance(pos, (list, tuple)):
            raise TypeError("Invalid pos argument: %s is not a list or a tuple.")

        if state in (1, NORMAL, 'normal'):
            size = list(size)
            sz = self.get_size()
            if size[0] == -1:
                size[0] = sz[0]
            if size[1] == -1:
                size[1] = sz[1]
            pos = list(pos)
            ps = self.get_position()
            if pos[0] == -1:
                pos[0] = ps[0]
            if pos[1] == -1:
                pos[1] = ps[1]
            self.set_mode(size, self.mode)
            self.set_position(pos)
        elif state in (0, MINIMIZED, 'minimized'):
            pass
        elif state in (2, MAXIMIZED, 'maximized'):
            data = [1, self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_VERT", False), self.display.intern_atom("_NET_WM_STATE_MAXIMIZED_HORZ", False)]
            data = (data + ([0] * (5 - len(data))))[:5]
            if DEBUG_WM:
                print self.stateHandler.get_wm_state()
                print "creating event", Xlib.protocol.event.ClientMessage
                print dir(self.stateHandler)
            x_event = Xlib.protocol.event.ClientMessage(window=self.stateHandler, client_type=self.display.intern_atom("_NET_WM_STATE", False), data=(32, data))
            if DEBUG_WM:
                print "sending event"
            self.display.screen().root.send_event(x_event, event_mask=Xlib.X.SubstructureRedirectMask)

            if DEBUG_WM:
                print self.stateHandler.get_wm_state()
        elif state in (3, FULLSCREEN, 'fullscreen'):
            pass
        if update:
            self.flush()

    def flush(self):
        """Wrapper around Xlib.Display.flush()"""
        if DEBUG_WM:
            print "* flushing display"
        self.display.flush()

    def sync(self):
        """Wrapper around Xlib.Display.sync()"""
        if DEBUG_WM:
            print "* syncing display"
        self.display.sync()


#=======================================================================
# WARNING: This class has been built on Linux using wine.
# Please review this code and change it consequently before using it without '--debug-wm' switch!
class WWindowHandler(BaseWindowHandler):
    """Object to deal with Microsoft Window managers."""
    desk_env = desktop_environment

    def __init__(self, pos=(0, 0), size=(0, 0), mode=None):
        """Set up the internal handlers."""
        BaseWindowHandler.__init__(self, pos=pos, size=size, mode=mode)
        # Tests
        if DEBUG_WM:
            print "#" * 72
            print "WWindowHandler.__init__"
            print "Desktop environment:", desktop_environment
            for item in dir(win32con):
                if 'maxim' in item.lower() or 'minim' in item.lower() or 'full' in item.lower():
                    print item, getattr(win32con, item)
        self.base_handler = display
        self.base_handler_id = display.get_wm_info()['window']

    if platform.dist() == ('', '', ''):
        # We're running on a native Windows.
        def set_mode(self, size, mode):
            """Wrapper for pygame.display.set_mode()."""
            # Windows pygame implementation seem to work on the display mode and size on it's own...
            return
    else:
        # We're running on wine.
        def set_mode(self, size, mode):
            """Wrapper for pygame.display.set_mode()."""
            self.wine_state_fix = False
            if getattr(self, 'wine_state_fix', False):
                self.set_size(size)
                self.wine_state_fix = True

    def get_root_rect(self):
        """Return a four values tuple containing the position and size of the very first OS window object."""
        flags, showCmd, ptMin, ptMax, rect = win32gui.GetWindowPlacement(win32gui.GetDesktopWindow())
        return rect

    def get_size(self):
        """Return the window actual size as a tuple (width, height)."""
        flags, showCmd, ptMin, ptMax, rect = win32gui.GetWindowPlacement(self.base_handler_id)
        w = rect[2] - rect[0]
        h = rect[3] - rect[1]
        return w, h

    def set_size(self, size, update=True):
        """Set the window size.
        :size: list or tuple: the new size.
        :mode: bool: (re)set the pygame.display mode; self.mode must be a pygame display mode object.
        Raises a TypeError if something else than a list or a tuple is sent."""
        if isinstance(size, (list, tuple)):
            w, h = size
            cx, cy = win32gui.GetCursorPos()
            if DEBUG_WM:
                print "Settin size to", size
                print "actual size", self.get_size()
                print "actual position", self.get_position()
                
                print 'cursor pos', cx, cy
            flags, showCmd, ptMin, ptMax, rect = win32gui.GetWindowPlacement(self.base_handler_id)
            if DEBUG_WM:
                print "set_size rect", rect, "ptMin", ptMin, "ptMax", ptMax, "flags", flags
            x = rect[0]
            y = rect[1]
            rect = x, y, x + w, y + h
            win32gui.SetWindowPlacement(self.base_handler_id, (0, showCmd, ptMin, ptMax, rect))
        else:
            # Raise a Type error.
            raise TypeError("%s is not a list or a tuple." % repr(size))

    def get_position(self):
        """Return the window actual position as a tuple."""
        flags, showCmd, ptMin, ptMax, rect = win32gui.GetWindowPlacement(self.base_handler_id)
        x, y, r, b = rect
        return x, y

    def set_position(self, pos, update=True):
        """Set the window position.
        :pos: list or tuple: the new position (x, y)."""
        if DEBUG_WM:
            print "Setting position to", pos
        if isinstance(pos, (list, tuple)):
            self.first_pos = False
            x, y = pos
            if update:
                flags, showCmd, ptMin, ptMax, rect = win32gui.GetWindowPlacement(self.base_handler_id)
                if DEBUG_WM:
                    print "set_position rect", rect, "ptMin", ptMin, "ptMax", ptMax
                realW = rect[2] - rect[0]
                realH = rect[3] - rect[1]
                if DEBUG_WM:
                    print 'rect[0]', rect[0], 'rect[1]', rect[1]
                    print 'realW', realW, 'realH', realH
                    print 'cursor pos', win32gui.GetCursorPos()

                rect = (x, y, x + realW, y + realH)

                win32gui.SetWindowPlacement(self.base_handler_id, (0, showCmd, ptMin, ptMax, rect))
        else:
            # Raise a Type error.
            raise TypeError("%s is not a list or a tuple." % repr(pos))

    def get_state(self):
        """Return wheter the window is maximized or not, or minimized or full screen."""
        flags, state, ptMin, ptMax, rect = win32gui.GetWindowPlacement(self.base_handler_id)
        if DEBUG_WM:
            print "state", state
        if state == win32con.SW_MAXIMIZE:
            return MAXIMIZED
        elif state == win32con.SW_MINIMIZE:
            return MINIMIZED
        return NORMAL

    def set_state(self, state=NORMAL, size=(-1, -1), pos=(-1, -1), update=True):
        """Set wheter the window is maximized or not, or minimized or full screen.
        If no argument is given, assume the state will be windowed and not maximized.
        If arguments are given, only the first is relevant. The other ones are ignored.

        ** Only maximized and normal states are implemented for now. **

        :state: valid arguments:
        'minimized', MINIMIZED, 0.
        'normal', NORMAL, 1: windowed, not maximized.
        'maximized', MAXIMIZED, 2.
        'fullscreen, FULLSCREEN, 3.

        :size: list, tuple: the new size; if (-1, -1) self.get_size() is used.
               If one element is -1 it is replaced by the corresponding valur from self.get_size().
        :pos: list, tuple: the new position; if (-1, -1), self.get_position is used.
              If one element is -1 it is replaced by the corresponding valur from self.get_position().
        :update: bool: whether to call the internal flush method."""
        if state not in (0, MINIMIZED, 'minimized', 1, NORMAL, 'normal', 2, MAXIMIZED, 'maximized', 3, FULLSCREEN, 'fullscreen'):
            # Raise a value error.
            raise ValueError("Invalid state argument: %s is not a correct value" % state)
        if not isinstance(size, (list, tuple)):
            raise TypeError("Invalid size argument: %s is not a list or a tuple.")
        if not isinstance(pos, (list, tuple)):
            raise TypeError("Invalid pos argument: %s is not a list or a tuple.")

        if state in (1, NORMAL, 'normal'):
            size = list(size)
            sz = self.get_size()
            if size[0] == -1:
                size[0] = sz[0]
            if size[1] == -1:
                size[1] = sz[1]
            pos = list(pos)
            ps = self.get_position()
            if pos[0] == -1:
                pos[0] = ps[0]
            if pos[1] == -1:
                pos[1] = ps[1]
            self.set_mode(size, self.mode)
            self.set_position(pos)
        elif state in (0, MINIMIZED, 'minimized'):
            pass
        elif state in (2, MAXIMIZED, 'maximized'):
            win32gui.ShowWindow(self.base_handler_id, win32con.SW_MAXIMIZE)
        elif state in (3, FULLSCREEN, 'fullscreen'):
            pass


WindowHandler = None


def setupWindowHandler():
    """'Link' the corresponding window handler class to WindowHandler."""
    # Don't initialize the window handler here.
    # We need MCEdit display objects to get the right object.
    global WindowHandler
    if USE_WM:
        log.warn("Initializing window management...")
        if sys.platform == 'linux2':
            if XWindowHandler.desk_env == 'unknown':
                log.warning("Your desktop environment could not be determined. The support for window sizing/moving is not availble.")
            elif XWindowHandler.desk_env in linux_unsuported:
                log.warning("Your desktop environment is not yet supported for window sizing/moving.")
            else:
                WindowHandler = XWindowHandler
                log.info("XWindowHandler initialized.")
        elif sys.platform == 'win32':
            WindowHandler = WWindowHandler
            log.info("WWindowHandler initialized.")
    return WindowHandler