sublime3dsmax.py

"""Send maxscript/python files or codelines to 3ds Max.

This is the main sublime plugin file. It currently implements 4 commands
that you can bind to keys:

    - SendFileToMaxCommand aka send_file_to_max
    - SendSelectionToMaxCommand aka send_selection_to_max
    - SelectMaxInstanceCommand aka select_max_instance
    - OpenMaxHelpCommand aka open_max_help

See the README for details on how to use them.
"""
from __future__ import unicode_literals

import os
import re
import webbrowser
import zipfile

import sublime
import sublime_plugin

from . import constants
from . import filters
from . import winapi


__version__ = "0.11.0"

DEFAULT_DOCS_VERSION = "2019"

# Holds the current 3ds Max window object that we send commands to.
# It is filled automatically when sending the first command.
mainwindow = None

# Used to preselect the last 3ds Max window in the quick panel.
last_index = 0


def _get_api_lines():
    """Read the mxs API definition file and return as a list of lines."""
    def get_decoded_lines(file_obj):
        content = file_obj.read()
        try:
            content = content.decode("utf-8")
        except (UnicodeDecodeError, AttributeError):
            pass
        return content.split("\n")

    # Zipped .sublime-package as installed by package control.
    if ".sublime-package" in constants.APIPATH:
        apifile = os.path.basename(constants.APIPATH)
        package = zipfile.ZipFile(os.path.dirname(constants.APIPATH), "r")
        return get_decoded_lines(package.open(apifile))
    # Expanded folder, e.g. during development.
    else:
        return get_decoded_lines(open(constants.APIPATH))


def _is_maxscriptfile(filepath):
    """Return if the file uses one of the MAXScript file extensions."""
    name, ext = os.path.splitext(filepath)
    return ext in (".ms", ".mcr", ".mse", ".mzp")


def _is_pythonfile(filepath):
    """Return if the file uses a Python file extension."""
    name, ext = os.path.splitext(filepath)
    return ext in (".py",)


def _save_to_tempfile(text):
    """Store code in a temporary maxscript file."""
    with open(constants.TEMPFILE, "w") as tempfile:
        tempfile.write(text)


def _send_cmd_to_max(cmd):
    """Try to find the 3ds Max window by title and the mini
    macrorecorder by class.

    Sends a string command and a return-key buttonstroke to it to
    evaluate the command.

    """
    global mainwindow

    if mainwindow is None:
        mainwindow = winapi.Window.find_window(
            constants.TITLE_IDENTIFIER)

    if mainwindow is None:
        sublime.error_message(constants.MAX_NOT_FOUND)
        return

    try:
        mainwindow.find_child(text=None, cls="MXS_Scintilla")
    except OSError:
        # Window handle is invalid, 3ds Max has probably been closed.
        # Call this function again and try to find one automatically.
        mainwindow = None
        _send_cmd_to_max(cmd)
        return

    minimacrorecorder = mainwindow.find_child(text=None, cls="MXS_Scintilla")
    # If the mini macrorecorder was not found, there is still a chance
    # we are targetting an ancient Max version (e.g. 9) where the
    # listener was not Scintilla based, but instead a rich edit box.
    if minimacrorecorder is None:
        statuspanel = mainwindow.find_child(text=None, cls="StatusPanel")
        if statuspanel is None:
            sublime.error_message(constants.RECORDER_NOT_FOUND)
            return
        minimacrorecorder = statuspanel.find_child(text=None, cls="RICHEDIT")
        # Verbatim strings (the @ at sign) are also not yet supported.
        cmd = cmd.replace("@", "")
        cmd = cmd.replace("\\", "\\\\")

    if minimacrorecorder is None:
        sublime.error_message(constants.RECORDER_NOT_FOUND)
        return

    sublime.status_message('Send to 3ds Max: {cmd}'.format(
        **locals())[:-1])  # Cut ';'
    cmd = cmd.encode("utf-8")  # Needed for ST3!
    minimacrorecorder.send(winapi.WM_SETTEXT, 0, cmd)
    minimacrorecorder.send(winapi.WM_CHAR, winapi.VK_RETURN, 0)
    minimacrorecorder = None


def _get_max_version():
    """Try to determine the version of 3ds Max we are connected to."""
    global mainwindow
    if mainwindow is None:
        mainwindow = winapi.Window.find_window(
            constants.TITLE_IDENTIFIER)

    # Default to 2018 help, this has the most updated docs and will
    # filter to Maxscript results.
    max_version = DEFAULT_DOCS_VERSION

    if mainwindow is not None:
        window_text = mainwindow.get_text()
        matches = re.findall(r"(?:Max )(2\d{3})", window_text)
        if matches:
            last_match = matches[-1]
            max_version = last_match

    return max_version


class SendFileToMaxCommand(sublime_plugin.TextCommand):
    """Send the current file by using 'fileIn <file>'."""

    def run(self, edit):
        currentfile = self.view.file_name()
        if currentfile is None:
            sublime.error_message(constants.NOT_SAVED)
            return

        is_mxs = _is_maxscriptfile(currentfile)
        is_python = _is_pythonfile(currentfile)

        if is_mxs:
            cmd = 'fileIn @"{0}"\r\n'.format(currentfile)
            _send_cmd_to_max(cmd)
        elif is_python:
            cmd = 'python.executeFile @"{0}"\r\n'.format(currentfile)
            _send_cmd_to_max(cmd)
        else:
            sublime.error_message(constants.NO_SUPPORTED_FILE)


class SendSelectionToMaxCommand(sublime_plugin.TextCommand):
    """Send selected part of the file.

    Selection is extended to full line(s).

    """
    def expand(self, line):
        """Expand selection to encompass whole line."""
        self.view.run_command("expand_selection", {"to": line.begin()})

    def run(self, edit):
        """Analyse selection and determine a method to send it to 3ds Max.

        Single line maxscript commands can be send directly. Python
        commands could, but since we wrap them we may get issues with
        quotation marks or backslashes, so it is safer to send them via
        a temporary file that we import. That is also the method to send
        multiline code, since the mini macrorecorder does not accept
        multiline input.
        """
        def get_mxs_tempfile_import():
            return 'fileIn @"{0}"\r\n'.format(constants.TEMPFILE)

        def get_python_tempfile_import():
            return 'python.executeFile @"{0}"\r\n'.format(constants.TEMPFILE)

        # We need the user to have an actual file opened so that we can
        # derive the language from its file extension.
        currentfile = self.view.file_name()
        if not currentfile:
            sublime.error_message(constants.NOT_SAVED)
            return

        is_mxs = _is_maxscriptfile(currentfile)
        is_python = _is_pythonfile(currentfile)

        regions = [region for region in self.view.sel()]
        for region in regions:
            line = self.view.line(region)
            text = self.view.substr(line)

            is_empty = region.empty()
            is_singleline = len(text.split("\n")) == 1
            is_multiline = not (is_empty or is_singleline)

            if is_multiline:
                self.expand(line)
                _save_to_tempfile(text)
                if not os.path.isfile(constants.TEMPFILE):
                    sublime.error_message(constants.NO_TEMP)
                    return

                if is_mxs:
                    cmd = get_mxs_tempfile_import()
                else:
                    cmd = get_python_tempfile_import()

                _send_cmd_to_max(cmd)
                return
            else:
                if is_empty:
                    self.expand(line)
                    text = self.view.substr(self.view.line(region))
                elif is_singleline:
                    text = self.view.substr(region)

                if is_mxs:
                    cmd = '{0}\r\n'.format(text)
                elif is_python:
                    _save_to_tempfile(text)
                    if not os.path.isfile(constants.TEMPFILE):
                        sublime.error_message(constants.NO_TEMP)
                        return
                    cmd = get_python_tempfile_import()

                _send_cmd_to_max(cmd)
                return


class OpenMaxHelpCommand(sublime_plugin.TextCommand):
    """Open the online MAXScript help searching for the current selection."""

    # Based on: https://forum.sublimetext.com/t/select-word-under-cursor-for-further-processing/10913  # noqa
    def run(self, edit):
        for region in self.view.sel():
            if region.begin() == region.end():
                word = self.view.word(region)
            else:
                word = region
            if not word.empty():
                keyword = self.view.substr(word)
                url = self.get_query_help_url(keyword)
                webbrowser.open(url, new=0, autoraise=True)

    def get_query_help_url(self, keyword):
        """Return a URL to the MAXScript help, looking for given keyword.

        The docs may need special handling regarding filtering and query
        parameters.

        Test URL for Max 2019:

        http://help.autodesk.com/view/3DSMAX/2019/ENU/index.html?query=polyOp&cg=Scripting%20%26%20Customization  # noqa
        """
        query_param = "?query=" + keyword
        max_version = _get_max_version()
        url = constants.ONLINE_MAXSCRIPT_HELP_URL[max_version] + query_param
        if max_version == DEFAULT_DOCS_VERSION:
            # Make sure to search in a specific section of the docs.
            url += r"&cg=Scripting%20%26%20Customization"
        return url


class SelectMaxInstanceCommand(sublime_plugin.TextCommand):
    """Display a dialog of open 3ds Max instances to pick one.

    The chosen instance is used from then on to send commands to.
    """
    def run(self, edit):
        item2window = {}
        candidates = winapi.Window.find_windows(
            constants.TITLE_IDENTIFIER)
        for window in candidates:
            text = window.get_text()
            normtext = text.replace("b'", "").replace("'", "")
            item = ("{txt} ({hwnd})".format(txt=normtext,
                                            hwnd=window.get_handle()))
            item2window[item] = window

        items = list(item2window.keys())

        def on_select(idx):
            if idx == -1:
                return

            global last_index
            last_index = idx

            item = items[idx]
            global mainwindow
            mainwindow = item2window[item]

            sublime.message_dialog(constants.PREFIX +
                                   " Now connected to: \n\n" + item)

        def on_highlighted(idx):
            pass

        sublime.active_window().show_quick_panel(items,
                                                 on_select,
                                                 0,
                                                 last_index,
                                                 on_highlighted)


class Completions(sublime_plugin.EventListener):
    """Handle auto-completion from file content and the official API.

    To test this feature try typing the following in a .ms file:
        polyOps.
    It should offer autocompletions like:
        polyOps.retriangulate
        polyOps.autosmooth
        ...
    """
    completions_list = []

    def is_mxs(self, view):
        return view.match_selector(view.id(), "source.maxscript")

    def on_activated(self, view):
        if self.is_mxs(view) and not self.completions_list:
            self.completions_list = _get_api_lines()

    def on_query_completions(self, view, prefix, locations):
        if self.is_mxs(view):
            self.completions_list = _get_api_lines()
            comp_default = set(view.extract_completions(prefix))
            completions = set(list(self.completions_list))
            comp_default = comp_default - completions
            completions = list(comp_default) + list(completions)
            completions = [(attr, attr) for attr in completions]
            completions = filters.manager.apply_filters(
                view, prefix, locations, completions)
            return completions


def plugin_unloaded():
    """Perform cleanup work."""
    if os.path.isfile(constants.TEMPFILE):
        try:
            os.remove(constants.TEMPFILE)
        except OSError:
            pass