python类message_dialog()的实例源码

def run(self):
        info = {}

        info['platform'] = sublime.platform()
        info['version'] = sublime.version()
        info['file_icons_version'] = __version__
        info['pc_install'] = is_installed_by_package_control()
        info['current_theme'] = get_current_theme()
        info['installed_themes'] = get_installed_themes()

        msg = textwrap.dedent(
            '''\
            - File Icons: %(file_icons_version)s
            - Sublime Text: %(version)s
            - Platform: %(platform)s
            - Package Control: %(pc_install)s
            - Current Theme: %(current_theme)s
            - Installed Themes: %(installed_themes)s
            ''' % info
        )

        sublime.message_dialog(
            msg + '\nInfo has been copied to the clipboard.'
        )
        sublime.set_clipboard(msg)

def run(self, edit):
        scope = self.view.scope_name(self.view.sel()[0].a)

        if "source.json" in scope or "source.sublimecompletions" in scope: 
            print("Atomizr: JSON detected, trying to convert")
            self.view.run_command('subl_to_atom')
        elif "source.coffee" in scope:
            print("Atomizr: CoffeeScript detected, trying to convert")
            self.view.run_command('atom_to_subl')
        elif "text.xml" in scope:
            print("Atomizr: XML detected, trying to convert")
            self.view.run_command('subl_snippets_to_atom')
        elif "text.plain" in scope:
            sublime.message_dialog("Atomizr\n\nAutomatic conversion requires a supported CoffeeScript package to be installed")
        else:
            sublime.message_dialog("Atomizr\n\nUnsupported scope, aborting")

# Convert Atom format

def run(self, edit, languageName=None, set_fallback=False, is_init=False):
        view = self.view
        global currentView
        currentView = view

        if self.downloading:
            sublime.message_dialog('Another progress is working for checkout ' + self.downloading + '. Please try again later.')
            return

        self.languageList, index = getLanguageList(languageName)
        self.set_fallback = set_fallback

        if languageName:
            self.updateLanguage(index)
        else:
            currentView.window().show_quick_panel(self.languageList, self.updateLanguage, sublime.KEEP_OPEN_ON_FOCUS_LOST)

def checkoutLanguage(self):
        global language
        languageName = self.languageName
        if not self.downloadLanguageGZ(languageName):
            if getSetting('debug'):
                print('download error')
            return False

        setSetting('language', languageName)
        language = languageName
        languageSettings = currentSettings.get('languages')

        languageSettings[languageName] = 'gz'

        setSetting('languages', languageSettings)
        if self.set_fallback:
            setSetting('language_fallback', languageName)

        loadLanguage()

        sublime.message_dialog('Language ' + languageName + ' is checked out')

def _finish(self):
        """ make and write tsconfig.json. Call finished_callback """
        Debug('project+', 'Wizzard finished: Create and write tsconfig.json')
        content = { "compilerOptions" : {}, "files" : {}}
        if self.module is None:
            content['compilerOptions']['out'] = self.outfile
            content['compilerOptions']['target'] = self.target
            content['compilerOptions']['sourceMap'] = self.sourcemap
        elif self.module == "commonjs" or self.module == "amd":
            content['compilerOptions']['outDir'] = self.outdir
            content['compilerOptions']['target'] = self.target
            content['compilerOptions']['sourceMap'] = self.sourcemap
            content['compilerOptions']['module'] = self.module

        content['files'] = self.files

        self.write_json_to_tsconfigfile(content)

        if self.finished_callback:
            self.finished_callback()

        sublime.active_window().open_file(self.tspath)
        sublime.message_dialog("For more compilerOptions, see tsc --help.\n\n To configure ArcticTypescript, see README.md")

        self._cleanup()

def on_model_name_provided(self, name):
        response, code = HTTP.post(self.env.project_manager.get_build_api_key(),
                                   PL_BUILD_API_URL_V4 + "models/", '{"name" : "' + name + '" }')

        if not HTTP.is_response_code_valid(code) \
                and sublime.ok_cancel_dialog(STR_MODEL_NAME_EXISTS):
            self.create_new_model(False)
            return
        elif not HTTP.is_response_code_valid(code):
            sublime.message_dialog(STR_MODEL_FAILED_TO_CREATE)
            return

        # Save newly created model to the project settings
        settings = self.load_settings()
        settings[EI_MODEL_ID] = response.get("model").get("id")
        settings[EI_MODEL_NAME] = response.get("model").get("name")
        self.env.project_manager.save_settings(PR_SETTINGS_FILE, settings)

        self.update_model_name_in_status(query_model_name=False)

        # Reset the logs
        self.env.log_manager.reset()

        # Check settings
        self.check_settings(selecting_or_creating_model=True)

def on_device_to_add_selected(self, index):
        # Selection was canceled, just return
        if index == -1:
            return

        model = self.env.tmp_model
        device_id = self.env.tmp_device_ids[index]

        response, code = HTTP.put(self.env.project_manager.get_build_api_key(),
                                  PL_BUILD_API_URL_V4 + "devices/" + device_id,
                                  '{"model_id": "' + model.get("id") + '"}')
        if not HTTP.is_response_code_valid(code):
            sublime.message_dialog(STR_MODEL_ADDING_DEVICE_FAILED)

        # Once the device is registered, select this device
        self.on_device_selected(index)

        sublime.message_dialog(STR_MODEL_IMP_REGISTERED)

        self.env.tmp_model = None
        self.env.tmp_device_ids = None

def add_device(self, need_to_confirm=True):
        model = self.load_this_model()
        if not model:
            sublime.message_dialog(STR_MODEL_NOT_ASSIGNED)
            return

        if need_to_confirm and not sublime.ok_cancel_dialog(STR_MODEL_ADD_DEVICE): return

        device_ids = model.get("devices")
        (device_ids, device_names) = self.load_devices(exclude_device_ids=device_ids)

        if len(device_ids) == 0:
            sublime.message_dialog(STR_NO_DEVICES_AVAILABLE)
            return

        self.env.tmp_model = model
        self.env.tmp_device_ids = device_ids
        self.window.show_quick_panel(device_names, self.on_device_to_add_selected)

def on_remove_device_selected(self, index):
        device_id = self.env.tmp_device_ids[index]
        active_device_id = self.load_settings().get(EI_DEVICE_ID)

        if device_id == active_device_id:
            sublime.message_dialog(STR_MODEL_CANT_REMOVE_ACTIVE_DEVICE)
            return

        response, code = HTTP.put(self.env.project_manager.get_build_api_key(),
                                  PL_BUILD_API_URL_V4 + "devices/" + device_id,
                                  '{"model_id": ""}')
        if not HTTP.is_response_code_valid(code):
            sublime.message_dialog(STR_MODEL_REMOVE_DEVICE_FAILED)
            return

        sublime.message_dialog(STR_MODEL_DEVICE_REMOVED)

        self.env.tmp_model = None
        self.env.tmp_device_ids = None

def run(self, edit):
        scope_name = []
        settings = []
        for i in range(500):
            t = time.time()
            self.view.scope_name(0)
            scope_name.append(time.time() - t)
        for i in range(500):
            t = time.time()
            self.view.settings().get('markdown_live_preview_enabled')
            settings.append(time.time() - t)

        msg = ["scope_name: {}".format(sum(scope_name) / len(scope_name))]
        msg += ["settings  : {}".format(sum(settings) / len(settings))]
        msg = '\n'.join(msg)

        sublime.message_dialog(msg)

def run(self):
        self.recent_workspaces = self.get_recent_workspaces()
        if not self.recent_workspaces:
            return sublime.error_message('No project to load!')

        for i, recent_workspace in enumerate(self.recent_workspaces):
            self.recent_workspaces[i] = recent_workspace.replace('C/', 'C:/').strip('/')


        # only display workspaces that really exist
        self.recent_workspaces_that_really_exist = []
        for recent_workspace in self.recent_workspaces:
            if os.path.isfile(recent_workspace):
                self.recent_workspaces_that_really_exist.append(recent_workspace)

        sublime.message_dialog(str(self.recent_workspaces_that_really_exist))
        self.window.show_quick_panel(self.recent_workspaces_that_really_exist, self.on_done)

def _log(message, *args, status=False, dialog=False):
    """
    A simple logic facility to ensure that all console output is prefixed with
    the package name so the source is clear. Can also optionally send the output
    to the status line and/or a message dialog.
    """
    message = message % args
    print("HyperHelp:", message)
    if status:
        sublime.status_message(message)
    if dialog:
        sublime.message_dialog(message)

def display_confirmation_message(self, files_without_key, files_with_key):
    confirmation_message = ""
    for key, value in self.properties.items():
      confirmation_message += "Property " + key + "=" + value + " was: " 
      if files_without_key[key]:
        confirmation_message += "\nAdded in files:\n" + "\n".join(files_without_key[key])
      if files_with_key[key]:
        confirmation_message += "\n\nEdited in files:\n" + "\n".join(files_with_key[key])
      confirmation_message += "\n\n"
    sublime.message_dialog(confirmation_message)

def display_confirmation_message(self, files_without_key, files_with_key):
    confirmation_message = "Property with key " + self.key + " was: "
    if files_with_key:
      confirmation_message += "\nRemoved in files:\n" + "\n".join(files_with_key)
    if files_without_key:
      confirmation_message += "\n\nNot found in files:\n" + "\n".join(files_without_key)  
    if files_without_key:
      sublime.error_message(confirmation_message)
    else:
      sublime.message_dialog(confirmation_message)

def display_confirmation_message(self, files_without_old_key, files_with_new_key, files_with_renamed_key):
    confirmation_message = "Key " + self.old_key + " was: " 
    if files_with_renamed_key:
      confirmation_message += "\nRenamed in files:\n" + "\n".join(files_with_renamed_key)
    if files_without_old_key:
      confirmation_message += "\n\nNot found in files:\n" + "\n".join(files_without_old_key)
    if files_with_new_key:
      confirmation_message += "\n\nKey " + self.new_key + " already exists in files:\n" + "\n".join(files_with_new_key)
    if files_without_old_key or files_with_new_key:
      sublime.error_message(confirmation_message)
    else:
      sublime.message_dialog(confirmation_message)

def message(record):
        """
        shows text in message dialog
        """
        sublime.message_dialog(record.msg)

def run(self, edit):
        scope = self.view.scope_name(self.view.sel()[0].a)

        if "source.json" in scope: 
            print("Atomizr: JSON detected, trying to convert to CSON")
            self.view.run_command('atom_json_to_cson')
        elif "source.coffee" in scope:
            print("Atomizr: CSON detected, trying to convert to JSON")
            self.view.run_command('atom_cson_to_json')
        else:
            sublime.message_dialog("Atomizr\n\nUnsupported scope, aborting")

# Converts Atom snippets into Sublime Text completions

def run(self, edit):
        import cson, json

        # read data from view
        selection = self.view.substr(sublime.Region(0, self.view.size()))

        # interprete and validate data
        try:
            data = cson.loads(selection)
        except BaseException as e:
            sublime.message_dialog("Atomizr\n\nInvalid CSON, aborting conversion. See console for details.")
            print(e)

        sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("json_sort_keys") or False
        indent = sublime.load_settings('Atomizr.sublime-settings').get("json_indentation") or 2

        # write converted data to view
        selection = sublime.Region(0, self.view.size())
        self.view.replace(edit, selection, json.dumps(data, sort_keys=sort_keys, indent=indent, separators=(',', ': ')))

        # set syntax to JSON
        Helpers.set_json(self)
        Helpers.rename_file(self, "json")

        # Reset selection
        Helpers.reset_selection(self)

# Converts Atom snippets (JSON into CSON)

def run(self, edit):
        import cson, json

        # read data from view
        selection = self.view.substr(sublime.Region(0, self.view.size()))

        # interprete and validate data
        try:
            data = json.loads(selection)
        except BaseException as e:
            sublime.message_dialog("Atomizr\n\nInvalid JSON, aborting conversion. See console for details.")
            print(e)

        sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("cson_sort_keys") or True
        indent = sublime.load_settings('Atomizr.sublime-settings').get("cson_indentation") or 2

        # write converted data to view
        selection = sublime.Region(0, self.view.size())
        self.view.replace(edit, selection, ATOM_GENERATOR + cson.dumps(data, sort_keys=sort_keys, indent=indent))

        # set syntax to CSON, requires supported CoffeeScript package
        if Helpers.get_coffee(self) is True:
            Helpers.rename_file(self, "cson")

        # Reset selection
        Helpers.reset_selection(self)

# Converts Atom snippets into Visual Studio Code snippets

def run(self, edit):
        import cson, json

        # read data from view
        input = self.view.substr(sublime.Region(0, self.view.size()))

        try:
            data = cson.loads(input)
        except BaseException as e:
            sublime.message_dialog("Atomizr\n\nInvalid CSON, aborting conversion. See console for details.")
            print(e)

        for key in data.keys():
            if key[0] != ".":
                sublime.message_dialog("Atomizr\n\nNot an Atom snippet file")
                return
            output = data[key]

        sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("json_sort_keys") or True
        indent = sublime.load_settings('Atomizr.sublime-settings').get("json_indentation") or 2

        selection = sublime.Region(0, self.view.size())
        self.view.replace(edit, selection, json.dumps(output, sort_keys=sort_keys, indent=indent, separators=(',', ': ')))

        # set syntax to JSON
        Helpers.set_json(self)
        Helpers.rename_file(self, "json")

        # Reset selection
        Helpers.reset_selection(self)

# Converts Sublime Text into Atom snippets

def run(self, edit):
        scope = self.view.scope_name(self.view.sel()[0].a)

        if "source.json" in scope or "source.sublimecompletions" in scope:
            print("Atomizr: JSON detected, trying to convert to XML")
            self.view.run_command('subl_json_to_xml')
        elif "text.xml" in scope:
            print("Atomizr: XML detected, trying to convert to JSON")
            self.view.run_command('subl_xml_to_json')
        else:
            sublime.message_dialog("Atomizr\n\nUnsupported scope, aborting")

# Converts Sublime Text snippets into Sublime Text completions

def run(self, edit):
        import cson, json

        scope = self.view.scope_name(self.view.sel()[0].a)

        # read data from view
        input = self.view.substr(sublime.Region(0, self.view.size()))

        if "source.json" in scope or "source.sublimecompletions" in scope: 
            print("Atomizr: JSON detected, trying to convert")
            data = SublimeText.read_json(input)
        elif "text.xml" in scope:
            print("Atomizr: XML detected, trying to convert")
            data = SublimeText.read_xml(input)
        else:
            sublime.message_dialog("Atomizr\n\nNot a Sublime Text completions file")

        if data is False:
            return

        output = VsCode.write_json(data)

        sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("json_sort_keys") or True
        indent = sublime.load_settings('Atomizr.sublime-settings').get("json_indentation") or 2

        selection = sublime.Region(0, self.view.size())
        self.view.replace(edit, selection, json.dumps(output, sort_keys=sort_keys, indent=indent, separators=(',', ': ')))

        # set syntax to JSON
        Helpers.set_json(self)
        Helpers.rename_file(self, "sublime-completions")

        # Reset selection
        Helpers.reset_selection(self)

# Convert Visual Studio Code into Atom snippets

def get_coffee(this):
        import os

        # package locations
        locations = [sublime.installed_packages_path(), sublime.packages_path()]

        # supported packages
        packages = ["Better CoffeeScript", "CoffeeScript", "IcedCoffeeScript", "Mongoose CoffeeScript"]

        # iterate over packages locations
        for location in locations:
            # iterate over packages installed with Package Control
            for package in packages:
                # is "ignored_package"?
                settings = sublime.load_settings('Preferences.sublime-settings').get("ignored_packages")
                if package in settings:
                    continue

                if os.path.isfile(location + "/" + package + ".sublime-package") is True:
                    if package is "IcedCoffeeScript":
                        this.view.set_syntax_file("Packages/IcedCoffeeScript/Syntaxes/IcedCoffeeScript.tmLanguage")
                        return True
                    elif package is "Mongoose CoffeeScript":
                        this.view.set_syntax_file("Packages/Mongoose CoffeeScript/CoffeeScript.tmLanguage")
                        return True
                    else:
                        this.view.set_syntax_file("Packages/" + package + "/CoffeeScript.tmLanguage")
                        return True

        sublime.message_dialog("Atomizr\n\nAutomatic conversion requires a supported CoffeeScript package to be installed")
        return False

def read_json(input):
        """Reads Visual Studio Code snippets, returns object"""
        import json

        # interprete and validate data
        try:
            data = json.loads(input)
        except BaseException as e:
            sublime.message_dialog("Atomizr\n\nInvalid JSON, aborting conversion. See console for details.")
            print(e)
            return False

        completions = []

        # but is it a Visual Studio snippet?
        try:
            for k in data:
                prefix = data[k]["prefix"]
                if "description" in data[k]:
                    description = data[k]["description"]
                body = Helpers.remove_trailing_tabstop(data[k]["body"])

                if "description" in data[k]:
                    completions.append( {"trigger": prefix, "contents": body, "description": description} )
                else:
                    completions.append( {"trigger": prefix, "contents": body} )

        except:
            sublime.message_dialog("Atomizr\n\nNot a Visual Studio Code snippet file")
            return False

        output = {
            "scope": "source",
            "completions": completions
        }

        return output

def md(*t, **kwargs):
    sublime.message_dialog(kwargs.get('sep', '\n').join([str(el) for el in t]))

def show_in_dialog(message_str):
    sublime.message_dialog(xstr(message_str))

def show_in_panel(message_str):
    # sublime.message_dialog(message_str)
    XyPanel.show_in_panel("xypanel", xstr(message_str))

def run(self, paths = []):
        sublime.message_dialog('Sidebar Enhancements: Thanks for your support ^.^')
        browser = s.get('default_browser', '')
        SideBarOpenInBrowserThread('','','').try_open("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=DD4SL2AHYJGBW", browser)

def md(*t, **kwargs):
    sublime.message_dialog(kwargs.get('sep', '\n').join([str(el) for el in t]))

def update_interpreter_build_system(self, cmd):
        """Updates the project and adds/modifies the build system
        """

        view = active_view()
        if get_settings(view, 'auto_python_builder_enabled', True) is False:
            return

        if is_remote_session(view):
            return

        if cmd is None:
            sublime.message_dialog(
                'Your python interpreter is not set or is invalid'
            )
            return

        project = self._get_project()
        if project.get('build_systems', False) is not False:
            if type(project['build_systems']) is list:
                done = False
                current_list = project['build_systems']
                for i in range(len(current_list)):
                    build = current_list[i]
                    if build['name'] == 'Anaconda Python Builder':
                        current_list[i] = self._parse_tpl(cmd)
                        done = True
                        break

                if not done:
                    project['build_systems'].append(self._parse_tpl(cmd))
            else:
                sublime.message_dialog(
                    'Your project build_systems is messed up'
                )
        else:
            project.update({
                'build_systems': [self._parse_tpl(cmd)]
            })

        self._save_project(project)