def get_items():
        """Return a list of quick panel items for all color schemes.

        The values are the full path of each *.tmTheme.

        NOTE: Excludes color schemes manipulated by SublimeLinter as
              they are automatically created and used if required.
        """
        names = []
        values = []
        settings = sublime.load_settings("Theme-Switcher.sublime-settings")
        exclude_list = settings.get("colors_exclude") or []
        paths = sorted(
            sublime.find_resources("*.sublime-color-scheme") +
            sublime.find_resources("*.tmTheme"),
            key=lambda x: os.path.basename(x).lower())
        for path in paths:
            if not any(exclude in path for exclude in exclude_list):
                elems = path.split("/")
                # elems[1] package name
                # elems[-1] color scheme file name
                names.append(
                    [built_res_name(elems[-1]),    # title
                     "Package: " + elems[1]])      # description
                values.append(path)
        return [names, values]

def get_all_syntax_files():
    """ Find all sublime-syntax and tmLanguage files. """
    syntax_files = []
    if USE_ST_SYNTAX:
        syntax_files += sublime.find_resources("*.sublime-syntax")
    syntax_files += sublime.find_resources("*.tmLanguage")
    return syntax_files

    def findSyntaxFilePaths(self, dropDuplicated=False):
        """
        @brief find the path of all syntax files

        @param dropDuplicated if True, for a syntax, only the highest priority resource will be returned

        @return list<string> the path of all syntax files
        """

        if dropDuplicated is False:
            syntaxFiles = []
            for syntaxFileExt in ST_LANGUAGES:
                syntaxFiles += sublime.find_resources('*'+syntaxFileExt)
        else:
            # key   = syntax resource path without extension
            # value = the corresponding extension
            # example: { 'Packages/Java/Java': '.sublime-syntax' }
            syntaxGriddle = {}
            for syntaxFileExt in ST_LANGUAGES:
                resources = sublime.find_resources('*'+syntaxFileExt)
                for resource in resources:
                    resourceName, resourceExt = os.path.splitext(resource)
                    if resourceName not in syntaxGriddle:
                        syntaxGriddle[resourceName] = resourceExt

            # combine a name and an extension back into a full path
            syntaxFiles = [n+e for n, e in syntaxGriddle.items()]

        return syntaxFiles

    def set_syntax_by_host(host, view):
        """
        Sets the view's syntax by using the host_to_syntax for an lookup.
        """
        settings = sublime.load_settings('GhostText.sublime-settings')
        host_to_syntax = settings.get('host_to_syntax')

        syntax = None
        syntax_part = None
        for host_fragment in host_to_syntax:
            if host_fragment not in host:
                continue

            syntax_part = host_to_syntax[host_fragment]
            resources = sublime.find_resources('*{}'.format(syntax_part))

            if len(resources) > 0:
                syntax = resources[0]

        if syntax is not None:
            view.set_syntax_file(syntax)
        else:
            if syntax_part is not None:
                sublime.error_message('Syntax "{}" is not installed!'.format(syntax_part))

            default_syntax = settings.get('default_syntax', 'Markdown.tmLanguage')
            resources = sublime.find_resources('*{}'.format(default_syntax))

            if len(resources) > 0:
                view.set_syntax_file(resources[0])
            else:
                print('Default syntax "{}" is not installed!'.format(default_syntax))

	def run(self):
		print ('ok')
		sublime.status_message("Indexing Color Schemes..")
		self.initial = sublime.load_settings("Preferences.sublime-settings").get('color_scheme')
		self.syntax = list(sorted(sublime.find_resources("*.tmTheme") + sublime.find_resources("*.sublime-syntax")))
		sublime.status_message("Found {0} color schemes in total".format(len(self.syntax)))
		self.display_list(self.syntax)

    def _load_settings(self, on_loaded_once=None):
        """Load and merge settings and their comments from all base files.

        The idea is each package which wants to add a valid entry to the
        `Preferences.sublime-settings` file must provide such a file with all
        keys it wants to add. These keys and the associated comments above it
        are loaded into dictionaries and used to provide tooltips, completions
        and linting.
        """
        ignored_patterns = frozenset(("/User/", "/Preferences Editor/"))

        # TODO project settings include "Preferences",
        # but we don't have a syntax def for those yet
        l.debug("loading defaults and comments for %r", self.filename)
        start_time = time.time()
        resources = sublime.find_resources(self.filename)
        resources += sublime.find_resources(self.filename + "-hints")
        if self.filename == PREF_FILE:
            resources += sublime.find_resources(PREF_FILE_ALIAS)
        l.debug("found %d %r files", len(resources), self.filename)

        for resource in resources:
            if any(ignored in resource for ignored in ignored_patterns):
                l.debug("ignoring %r", resource)
                continue

            try:
                l.debug("parsing %r", resource)
                lines = sublime.load_resource(resource).splitlines()
                for key, value in self._parse_settings(lines).items():
                    # merge settings without overwriting existing ones
                    self.defaults.setdefault(key, value)
            except Exception as e:
                l.error("error parsing %r - %s%s",
                        resource, e.__class__.__name__, e.args)

        duration = time.time() - start_time
        l.debug("loading took %.3fs", duration)

        # include general settings if we're in a syntax-specific file
        is_syntax_specific = self._is_syntax_specific()
        if is_syntax_specific and not self.fallback_settings:
            self.fallback_settings = KnownSettings(PREF_FILE)
            # add fallbacks to the ChainMaps
            self.defaults.maps.append(self.fallback_settings.defaults)
            self.comments.maps.append(self.fallback_settings.comments)
            # these may be loaded later, so delay calling our own callbacks
            self.fallback_settings.add_on_loaded(self._has_loaded, once=True)
        else:
            if self.fallback_settings and not is_syntax_specific:
                # file was renamed, probably
                self.fallback_settings = None
                self.defaults.maps.pop()
                self.comments.maps.pop()
            self._has_loaded()

    def run(self):
        self.prefs = sublime.load_settings(self.PREFS_FILE)

        self.views = None

        self.current = self.prefs.get('color_scheme', self.DEFAULT_CS)

        show_legacy = sublime.load_settings(
            "Preferences.sublime-settings").get("show_legacy_color_schemes", False)

        initial_highlight = -1
        self.schemes = []
        names = []
        package_set = set()

        files = sublime.find_resources('*.tmTheme')
        trimmed_names = set()
        for f in files:
            name, ext = os.path.splitext(os.path.basename(f))
            trimmed_names.add(name)

        # Add all the sublime-color-scheme files, but not the overrides
        for f in sublime.find_resources('*.sublime-color-scheme'):
            name, ext = os.path.splitext(os.path.basename(f))
            if not name in trimmed_names:
                trimmed_names.add(name)
                files.append(f)

        for cs in files:
            if self.current and cs == self.current:
                initial_highlight = len(self.schemes)
            if len(cs.split('/', 2)) != 3:  # Not in a package
                continue
            pkg = os.path.dirname(cs)
            if pkg == "Packages/Color Scheme - Legacy" and not show_legacy:
                continue
            if pkg.startswith("Packages/"):
                pkg = pkg[len("Packages/"):]
            name, ext = os.path.splitext(os.path.basename(cs))
            self.schemes.append(cs)
            names.append([name, pkg])
            package_set.add(pkg)

        # Don't show the package name if all color schemes are in the same
        # package
        if len(package_set) == 1:
            names = [name for name, pkg in names]

        self.window.show_quick_panel(
            names,
            self.on_done,
            sublime.KEEP_OPEN_ON_FOCUS_LOST,
            initial_highlight,
            self.on_highlighted
        )

    def find_tooltip_themes(self):
        """
        Find all SublimeLinter.tooltip-theme resources.

        For each found resource, if it doesn't match one of the patterns
        from the "tooltip_theme_excludes" setting, return the base name
        of resource and info on whether the theme is a standard theme
        or a user theme, as well as whether it is colorized.

        The list of paths to the resources is appended to self.themes.

        """

        self.themes = []
        settings = []
        tooltip_themes = sublime.find_resources('*.tooltip-theme')
        excludes = persist.settings.get('tooltip_theme_excludes', [])

        for theme in tooltip_themes:
            exclude = False
            parent = os.path.dirname(theme)
            htmls = sublime.find_resources('*.html')

            if '{}/tooltip.html'.format(parent) not in htmls:
                continue

            # Now see if the theme name is in tooltip_theme_excludes
            name = os.path.splitext(os.path.basename(theme))[0]

            for pattern in excludes:
                if fnmatch(name, pattern):
                    exclude = True
                    break

            if exclude:
                continue

            self.themes.append(theme)

            std_theme = theme.startswith('Packages/SublimeLinter/tooltip-themes/')

            settings.append([
                name,
                'SublimeLinter theme' if std_theme else 'User theme'
            ])

        # Sort self.themes and settings in parallel using the zip trick
        settings, self.themes = zip(*sorted(zip(settings, self.themes)))

        # zip returns tuples, convert back to lists
        settings = list(settings)
        self.themes = list(self.themes)

        return settings

	def set_syntax(self, syntax):

		langs = sublime.find_resources('*language')
		langs += sublime.find_resources('*sublime-syntax')
		new_syntax = next((s for s in langs if syntax[0] in s), None)
		print('new syntax is ' + new_syntax)

		if new_syntax != self.syn:
			# let's make sure it exists first!
			# if os.path.exists(new_syntax_path):
			self.view.set_syntax_file(new_syntax)
			print('Syntax set to ' + syntax[0] + ' using ' + new_syntax)

def validate_skin(skin_data, fallback_theme=None, fallback_colors=None):
    """Check skin integrity and return the boolean result.

    For a skin to be valid at least 'color_scheme' or 'theme' must exist.
    If one of both values is invalid, it may be replaced with a fallback value.
    Otherwise SublimeText's behavior when loading the skin is unpredictable.

    SublimeLinter automatically creates and applies patched color schemes if
    they doesn't contain linter icon scopes. To ensure not to break this
    feature this function ensures not to apply such a hacked color scheme
    directly so SublimeLinter can do his job correctly.

    Arguments:
        skin_data (dict):
            JSON object with all settings to apply for the skin.
        fallback_theme (string):
            A valid theme name to inject into skin_data, if skin_data does not
            contain a valid one.
        fallback_colors (string):
            A valid color_scheme path to inject into skin_data, if skin_data
            does not contain a valid one.
    """
    # check theme file
    theme_name = skin_data[PREF].get("theme")
    theme_ok = theme_name and sublime.find_resources(theme_name)
    # check color scheme
    color_scheme_ok = False
    color_scheme_name = skin_data[PREF].get("color_scheme")
    if color_scheme_name:
        path, tail = os.path.split(color_scheme_name)
        name = tail.replace(" (SL)", "")
        color_schemes = sublime.find_resources(name)
        if color_schemes:
            # Try to find the exact path from *.skins file
            resource_path = "/".join((path, name))
            for found in color_schemes:
                if found == resource_path:
                    color_scheme_ok = True
                    break
            # Use the first found color scheme which matches 'name'
            if not color_scheme_ok:
                skin_data[PREF]["color_scheme"] = color_schemes[0]
                color_scheme_ok = True
    valid = theme_ok or color_scheme_ok
    if valid:
        if fallback_theme and not theme_ok:
            skin_data[PREF]["theme"] = fallback_theme
        if fallback_colors and not color_scheme_ok:
            skin_data[PREF]["color_scheme"] = fallback_colors
    return valid

 def find_syntax_files(self):
     # ST3
     if hasattr(sublime, 'find_resources'):
         for f in sublime.find_resources("*.tmLanguage"):
             yield f
         for f in sublime.find_resources("*.sublime-syntax"):
             yield f
     else:
         for root, dirs, files in os.walk(sublime.packages_path()):
             for f in files:
                 if f.endswith(".tmLanguage") or f.endswith("*.sublime-syntax"):
                     langfile = os.path.relpath(os.path.join(root, f), sublime.packages_path())
                     # ST2 (as of build 2181) requires unix/MSYS style paths for the 'syntax' view setting
                     yield os.path.join('Packages', langfile).replace("\\", "/")

	def on_ignored_packages_change():
		the_theme = Themr.get_theme()
		if sublime.find_resources(the_theme):
			Themr.theme = the_theme
		else:
			Themr.set_theme('Default.sublime-theme')
			sublime.status_message('Theme disabled. Reverting to Default.sublime-theme')

	def on_theme_change():
		the_theme = Themr.get_theme()
		if sublime.find_resources(the_theme):
			Themr.theme = the_theme
		else:
			Themr.set_theme(Themr.theme)
			sublime.status_message('Theme not found. Reverting to ' + Themr.theme)

def plugin_loaded():
	print('themr ready')

	def on_theme_change():
		the_theme = Themr.get_theme()
		if sublime.find_resources(the_theme):
			Themr.theme = the_theme
		else:
			Themr.set_theme(Themr.theme)
			sublime.status_message('Theme not found. Reverting to ' + Themr.theme)

	def on_ignored_packages_change():
		the_theme = Themr.get_theme()
		if sublime.find_resources(the_theme):
			Themr.theme = the_theme
		else:
			Themr.set_theme('Default.sublime-theme')
			sublime.status_message('Theme disabled. Reverting to Default.sublime-theme')

	preferences = sublime.load_settings('Preferences.sublime-settings')

	preferences.add_on_change('theme', on_theme_change)
	preferences.add_on_change('ignored_packages', on_ignored_packages_change)

	the_theme = Themr.get_theme()
	if sublime.find_resources(the_theme):
		Themr.theme = the_theme
	else:
		Themr.set_theme('Default.sublime-theme')
		sublime.status_message('Theme not found. Reverting to Default.sublime-theme')

    def syntax_testing(self, stream, package):
        total_assertions = 0
        failed_assertions = 0

        try:
            tests = sublime.find_resources("syntax_test*")
            if package != "__all__":
                tests = [t for t in tests if t.startswith("Packages/%s/" % package)]

            # remove UnitTesting syntax_tests
            tests = [t for t in tests if not t.startswith("Packages/UnitTesting/")]

            if not tests:
                raise RuntimeError("No syntax_test files are found in %s!" % package)
            for t in tests:
                assertions, test_output_lines = sublime_api.run_syntax_test(t)
                total_assertions += assertions
                if len(test_output_lines) > 0:
                    failed_assertions += len(test_output_lines)
                    for line in test_output_lines:
                        stream.write(line + "\n")
            if failed_assertions > 0:
                stream.write("FAILED: %d of %d assertions in %d files failed\n" %
                             (failed_assertions, total_assertions, len(tests)))
            else:
                stream.write("Success: %d assertions in %s files passed\n" %
                             (total_assertions, len(tests)))
                stream.write("OK\n")
        except Exception as e:
            if not stream.closed:
                stream.write("ERROR: %s\n" % e)

        stream.write("\n")
        stream.write(DONE_MESSAGE)
        stream.close()

	def load_schemes(self):
		scheme_paths = []
		favorites = self.get_favorites()

		try: # use find_resources() first for ST3.
			scheme_paths = sublime.find_resources('*.tmTheme')

		except: # fallback to walk() for ST2
			# Load the paths for schemes contained in zipped .sublime-package files.
			for root, dirs, files in os.walk(sublime.installed_packages_path()):
				for package in (package for package in files if package.endswith('.sublime-package')):
					zf = zipfile.ZipFile(os.path.join(sublime.installed_packages_path(), package))
					for filename in (filename for filename in zf.namelist() if filename.endswith('.tmTheme')):
						filepath = os.path.join(root, package, filename).replace(sublime.installed_packages_path(), 'Packages').replace('.sublime-package', '').replace('\\', '/')
						scheme_paths.append(filepath)

			# Load the paths for schemes contained in folders.
			for root, dirs, files in os.walk(sublime.packages_path()):
				for filename in (filename for filename in files if filename.endswith('.tmTheme')):
					filepath = os.path.join(root, filename).replace(sublime.packages_path(), 'Packages').replace('\\', '/')
					scheme_paths.append(filepath)

		scheme_paths = self.filter_scheme_list(scheme_paths)

		# Given the paths of all the color schemes, add in the information for
		# the pretty-printed name and whether or not it's been favorited.
		schemes = []
		for scheme_path in scheme_paths:
			scheme_name = self.filter_scheme_name(scheme_path)
			is_favorite = ''
			if scheme_path in favorites: is_favorite = u'   \u2605' # Put a pretty star icon next to favorited schemes. :)
			schemes.append([scheme_name, scheme_path, is_favorite])

		schemes.sort(key=lambda s: s[0].lower())
		return schemes

def get_language_files(ignored_packages, *paths):
    r'''
    Get a list of language files respecting ignored packages.
    '''

    paths = list(paths)
    tml_files = []
    tml_files.extend(sublime.find_resources('*.tmLanguage'))

    for path in paths:
        for dir, dirs, files in os.walk(path):
            # TODO: be sure that not tmLanguage from disabled package is taken
            for fn in files:
                if fn.endswith('.tmLanguage'):
                    tml_files.append(os.path.join(dir, fn))

    R = re.compile("Packages[\\/]([^\\/]+)[\\/]")
    result = []
    for f in tml_files:
        m = R.search(f)
        if m:
            if m.group(1) not in ignored_packages:
                result.append(f)

    return result

def get_theme(obj, default=None):
    """
    Get the theme for the theme object.

    See if ST2 or ST3 variant is avaliable,
    if not use the standard theme format.
    """

    special = "@st3" if ST3 else "@st2"
    theme = obj.get("theme", None)
    if theme is None:
        theme = default
    elif ST3:
        parts = os.path.splitext(theme)
        special_theme = parts[0] + special + parts[1]
        resources = sublime.find_resources(special_theme)
        for r in resources:
            if r == "Packages/Theme - Aprosopo/%s" % special_theme:
                theme = special_theme
                break
    else:
        parts = os.path.splitext(theme)
        special_theme = parts[0] + special + parts[1]
        pkgs = sublime.packages_path()
        resource = os.path.join(pkgs, "Theme - Aprosopo", special_theme)
        if os.path.exists(resource):
            theme = special_theme

    return theme

def get_installed(logging=True):
    if logging:
        log("Getting installed themes")

    theme_resources = sublime.find_resources("*.sublime-theme")
    all_themes_ordered = OrderedDict([])
    installed_themes = {}

    for res in theme_resources:
        package = re.sub(PATTERN, "", res)
        all_themes_ordered[package] = []

    for res in theme_resources:
        package = re.sub(PATTERN, "", res)
        theme = os.path.basename(res)

        all_themes_ordered[package].append(theme)

    for k in all_themes_ordered.keys():
        value = all_themes_ordered[k]
        is_addon = False
        is_patch = True if k == settings.OVERLAY_ROOT else False

        for v in installed_themes.values():
            if set(value).issubset(set(v)):
                is_addon = True

        if not (is_addon or is_patch):
            installed_themes[k] = value

    if logging:
        dump(installed_themes)

    return installed_themes

 def on_load(self, view):
     if not requirements_file(view):
         return
     syntax_file = "Packages/requirementstxt/requirementstxt.tmLanguage"
     if hasattr(sublime, "find_resources"):
         syntax_file = sublime.find_resources("requirementstxt.tmLanguage")[0]
     view.set_syntax_file(syntax_file)