plugins_path() - Code Metrics - Inspection of "Externalized plugin path into plugin path provider" - thatsIch/sublime-rainmeter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 28ac24...6b7ebe )

by thatsIch

created 2016-12-09 21:54 UTC

plugins_path() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
c	2
b	0
f	0
dl	0
loc	4
rs	10

"""Module for getting Rainmeter-specific paths"""

import os
import re
import io
import getpass
import platform
import winreg

import sublime
import sublime_plugin

# own dependencies
from . import logger

from .path.program_path_provider import get_cached_program_path
from .path.setting_path_provider import get_cached_setting_path
from .path.program_drive_provider import get_cached_program_drive
from .path.plugin_path_provider import get_cached_plugin_path

from .completion.completion import ContextSensAutoCompletion


def skins_path():
    """Get the cached value of the #SKINSPATH# variable"""

    return _skins_path


def addons_path():
    """Get the cached value of the #ADDONSPATH# variable"""

    return _addons_path


def get_skins_path():
    """Get the value of the #SKINSPATH# variable"""

    # First try to load the value from the "rainmeter_skins_path" setting
    loaded_settings = sublime.load_settings("Rainmeter.sublime-settings")
    skinspath = loaded_settings.get("rainmeter_skins_path", None)

    # if it's found, return it
    # We trust the user to enter something meaningful here
    # and don't check anything.
    if skinspath:
        logger.info(__file__, "get_skins_path", "Skins path found in sublime-settings file.")
        return os.path.normpath(skinspath) + "\\"

    # If it's not set, try to detect it automagically

    rainmeterpath = get_cached_program_path()
    if not rainmeterpath:
        return

    settingspath = get_cached_setting_path()
    if not settingspath:
        return

    # First, try to read the SkinPath setting from Rainmeter.ini
    fhnd = io.open(os.path.join(settingspath, "Rainmeter.ini"))
    lines = fhnd.read()
    fhnd.close()

    # Find the skinspath setting in the file
    match = re.search(r"""(?imsx)

                     # Find the first [Rainmeter] section
                     (^\s*\[\s*Rainmeter\s*\]\s*$)
                     (.*?

                         # Find the "SkinPath" and "="
                         (^\s*SkinPath\s*=\s*

                             # Read until the next line ending and store
                             # in named group
                             (?P<skinpath>[^$]+?)\s*?$
                         )
                     ).*?

                     # All of this needs to happen before the next section
                     (?:^\s*\[\s*[^\[\]\s]+\s*\]\s*$)
                     """, lines)

    # if skinspath setting was found, return it
    if match:
        logger.info(__file__, "get_skins_path", "Skins path found in Rainmeter.ini.")
        return match.group("skinpath").strip().replace("/", "\\")

    # if it's not found in the settings file, try to guess it

    # If program path and setting path are equal, we have a portable
    # installation. In this case, the Skins folder is inside the rainmeter
    # path
    if os.path.samefile(rainmeterpath, settingspath):
        logger.info(__file__, "get_skins_path", "Skin path found in #PROGRAMPATH#" +
                    " because portable installation")
        return os.path.join(rainmeterpath, "Skins") + "\\"

    # If it's not a portable installation, we try looking into the "My
    # Documents" folder Since it could be relocated by the user, we have to
    # query its value from the registry
    try:
        regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                                r"Software\Microsoft\Windows" +
                                r"\CurrentVersion\Explorer" +
                                r"\User Shell Folders")
        keyval = winreg.QueryValueEx(regkey, "Personal")

        pathrep = keyval[0]

        # The path could (and most likely, will) contain environment
        # variables that have to be expanded first
        pathrep = os.path.expandvars(pathrep)

        logger.info(__file__, "get_skins_path", "Guessed Skin path from My Documents" +
                    " location in registry")
        return os.path.join(pathrep, "Rainmeter\\Skins") + "\\"

    except OSError:
        pass

    # If the value could not be retrieved from the registry,
    # we try some educated guesses about default locations
    try:
        username = getpass.getuser()
    except Exception:
        logger.info(__file__, "get_skins_path", "Skins path could not be located." +
                    " Please set the \"skins_path\" setting in your Rainmeter" +
                    " settings file.")
        return
    else:
        # check if windows version is XP
        winversion = platform.version()
        if int(winversion[0]) < 6:
            mydocuments = os.path.join("C:\\Documents and Settings",
                                       username,
                                       "My Documents") + "\\"

            logger.info(__file__, "get_skins_path", "Found Windows XP or lower." +
                        " Skins path assumed to be " + mydocuments +
                        "Rainmeter\\Skins\\")
        else:
            mydocuments = os.path.join("C:\\Users",
                                       username,
                                       "Documents") + "\\"

            logger.info(__file__, "get_skins_path", "Found Windows Vista or higher." +
                        " Skins path assumed to be " + mydocuments +
                        "Rainmeter\\Skins\\")

        logger.info(__file__, "get_skins_path", "Skin path guessed from user name" +
                    " and Windows version")
        return os.path.join(mydocuments, "Rainmeter\\Skins") + "\\"


def get_addons_path():
    """Get the value of the #ADDONSPATH# variable"""

    settingspath = get_cached_setting_path()
    if not settingspath:
        return
    return os.path.join(settingspath, "Addons") + "\\"


def get_current_path(filepath):
    """Get the value of the #CURRENTPATH# variable for the specified path.

    Returns None if the file path is not in the skins folder

    """

    filepath = os.path.normpath(filepath)

    skinspath = skins_path()
    if not skinspath or not filepath.startswith(skinspath):
        logger.info(__file__, "get_current_path", "current path could not be found because" +
                    " either the skins path could not be found or the current file" +
                    " is not located in the skins path.")
        return

    if os.path.isfile(filepath):
        return os.path.dirname(filepath) + "\\"
    else:
        return filepath + "\\"


def get_root_config_path(filepath):
    """Get the value of the #ROOTCONFIGPATH# variable for the specified path

    Returns None if the path is not in the skins folder

    """

    filepath = os.path.normpath(filepath)

    skinspath = skins_path()
    if not skinspath or not filepath.startswith(skinspath):
        logger.info(__file__, "get_root_config_path", "root config path could not be found" +
                    " because either the skins path could not be found or the" +
                    " current file is not located in the skins path.")
        return

    relpath = os.path.relpath(filepath, skinspath)
    logger.info(__file__, "get_root_config_path",
                os.path.join(skinspath, relpath.split("\\")[0]) + "\\")

    return os.path.join(skinspath, relpath.split("\\")[0]) + "\\"


def get_current_file(filepath):
    """Get the value of the #CURRENTFILE# variable for the specified path

    Returns None if the path is not in the skins folder

    """

    filepath = os.path.normpath(filepath)

    skinspath = skins_path()
    if not skinspath or not filepath.startswith(skinspath):
        logger.info(__file__, "get_current_file", "current file could not be found because" +
                    " either the skins path could not be found or the current" +
                    " file is not located in the skins path.")
        return

    if os.path.isfile(filepath):
        return os.path.basename(filepath)
    else:
        logger.info(__file__, "get_current_file", "specified path is not a file.")
        return


def get_current_config(filepath):
    """Get the value of the #CURRENTCONFIG# variable for the specified path

    Returns None if the path is not in the skins folder

    """

    filepath = os.path.normpath(filepath)

    skinspath = skins_path()
    if not skinspath or not filepath.startswith(skinspath):
        logger.info(__file__, "get_current_config", "current config could not be found" +
                    " because \either the skins path could not be found or the" +
                    " current file is not located in the skins path.")
        return

    if os.path.isfile(filepath):
        filepath = os.path.dirname(filepath)

    return os.path.relpath(filepath, skinspath)


def get_resources_path(filepath):
    """Get the value of the #@# variable for the specified path

    Returns None if the path is not in the skins folder

    """

    rfp = get_root_config_path(filepath)

    if not rfp:
        return
    logger.info(__file__, "get_resources_path", os.path.join(rfp, "@Resources") + "\\")
    return os.path.join(rfp, "@Resources") + "\\"


def replace_variables(string, filepath):
    """Replace Rainmeter built-in variables and Windows environment variables
    in string.

    Replaces occurrences of the following variables in the string:
    #CURRENTFILE#
    #CURRENTPATH#
    #ROOTCONFIGPATH#
    #CURRENTCONFIG#
    #@#
    #SKINSPATH#
    #SETTINGSPATH#
    #PROGRAMPATH#
    #PROGRAMDRIVE#
    #ADDONSPATH#
    #PLUGINSPATH#
    Any Windows environment variables (like %APPDATA%)
    filepath must be a skin file located in a subdirectory of the skins folder

    """

    # lambdas for lazy evaluation
    variables = {"#CURRENTFILE#": lambda: get_current_file(filepath),
                 "#CURRENTPATH#": lambda: get_current_path(filepath),
                 "#ROOTCONFIGPATH#": lambda: get_root_config_path(filepath),
                 "#CURRENTCONFIG#": lambda: get_current_config(filepath),
                 "#@#": lambda: get_resources_path(filepath),
                 "#SKINSPATH#": lambda: skins_path(),
                 "#SETTINGSPATH#": lambda: get_cached_setting_path(),
                 "#PROGRAMPATH#": lambda: get_cached_program_path(),
                 "#PROGRAMDRIVE#": lambda: get_cached_program_drive(),
                 "#ADDONSPATH#": lambda: addons_path(),
                 "#PLUGINSPATH#": lambda: get_cached_plugin_path()}

    pattern = re.compile("(?i)" + "|".join(list(variables.keys())))
    # replace Rainmeter variables
    repl = pattern.sub(lambda x: variables[x.group().upper()](),
                       string)
    # expand windows environment variables
    repl = os.path.expandvars(repl)
    return repl


def make_path(string, filepath):
    """Make the string into an absolute path of an existing file or folder,

    replacing Rainmeter built-in variables relative to the file specified in
    filepath (see replace_variables()) will return None if the file or folder
    doesn't exist, or if string is None or empty.

    """

    if not string:
        return None

    repl = replace_variables(string, filepath)
    norm = os.path.normpath(repl)

    # For relative paths, try folder of current file first

    if not os.path.isabs(norm):
        curpath = get_current_path(filepath)
        if curpath:
            abso = os.path.join(curpath, norm)
        else:
            abso = os.path.join(os.path.dirname(filepath), norm)

        if os.path.exists(abso):
            return abso

        # if that doesn't work, try relative to skins path
        # (for #CURRENTCONFIG#)
        abso = os.path.join(skins_path(), norm)
        if os.path.exists(abso):
            return abso
    # for absolute paths, try opening containing folder if file does not exist
    else:
        if os.path.exists(norm):
            return norm

        if os.path.exists(os.path.dirname(norm)):
            return os.path.dirname(norm)

    return


# Initialize Module
# Global Variables
settings = None

_skins_path = None
_addons_path = None


# Called automatically from ST3 if plugin is loaded
# Is required now due to async call and ignoring sublime.* from main routine
def plugin_loaded():
    # define variables from the global scope
    global settings

    global _skins_path
    global _addons_path

    settings = sublime.load_settings("Rainmeter.sublime-settings")

    # Cache the paths
    _skins_path = get_skins_path()
    _addons_path = get_addons_path()

    logger.info(__file__, "plugin_loaded()", "#PROGRAMPATH#:\t\t" + get_cached_program_path())
    logger.info(__file__, "plugin_loaded()", "#PROGRAMDRIVE#:\t" + get_cached_program_drive())
    logger.info(__file__, "plugin_loaded()", "#SETTINGSPATH#:\t" + get_cached_setting_path())
    logger.info(__file__, "plugin_loaded()", "#SKINSPATH#:\t\t" + skins_path())
    logger.info(__file__, "plugin_loaded()", "#PLUGINSPATH#:\t\t" + get_cached_plugin_path())
    logger.info(__file__, "plugin_loaded()", "#ADDONSPATH#:\t\t" + addons_path())


class MeterAutoComplete(sublime_plugin.EventListener):

    # only show our completion list because nothing else makes sense in this context
    flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS | sublime.INHIBIT_WORD_COMPLETIONS
    scope = "source.rainmeter"

    comment_exp = re.compile(r'^\s*;.*')
    meter_exp = re.compile(r'^\s*')

    completions = [
        # measures
        (re.compile(r'^\s*Measure\s*=\s*'), [
            # key, value
            ["Calc", "Calc"],
            ["CPU", "CPU"],
            ["FreeDiskSpace", "FreeDiskSpace"],
            ["Loop", "Loop"],

            # memory measure
            ["Memory", "Memory"],
            ["PhysicalMemory", "PhysicalMemory"],
            ["SwapMemory", "SwapMemory"],

            # net measure
            ["NetIn", "NetIn"],
            ["NetOut", "NetOut"],
            ["NetTotal", "NetTotal"],

            ["Plugin", "Plugin"],
            ["Registry", "Registry"],
            ["Script", "Script"],
            ["String", "String"],
            ["Time", "Time"],
            ["Uptime", "Uptime"]
        ]),

        # meters
        (re.compile(r'^\s*Meter\s*=\s*'), [
            # key, value
            ["Bar", "Bar"],
            ["Bitmap", "Bitmap"],
            ["Button", "Button"],
            ["Histogram", "Histogram"],
            ["Image", "Image"],
            ["Line", "Line"],
            ["Rotator", "Rotator"],
            ["Roundline", "Roundline"],
            ["Shape", "Shape"],
            ["String", "String"]
        ]),
        # general options

        # bar
        # bar orientation
        (re.compile(r'^\s*BarOrientation\s*=\s*'), [
            # key, value
            ["Horizontal", "Horizontal"],
            ["Vertical\tDefault", "Vertical"]
        ]),

        # bar flip
        (re.compile(r'^\s*Flip\s*=\s*'), [
            # key, value
            ["0\tDefault", "0"],
            ["1\tBar is flipped", "1"]
        ]),

        # bitmap

        # button
        # histogram
        # image
        # line
        # rotator
        # roundline
        # shape
        # string

        # plugins
        (re.compile(r'^\s*Plugin\s*=\s*'), [
            # key, value
            ["ActionTimer", "ActionTimer"],
            ["AdvancedCPU", "AdvancedCPU"],
            ["AudioLevel", "AudioLevel"],
            ["CoreTemp", "CoreTemp"],
            ["FileView", "FileView"],
            ["FolderInfo", "FolderInfo"],
            ["InputText", "InputText"],
            ["iTunes", "iTunesPlugin"],
            ["MediaKey", "MediaKey"],
            ["NowPlaying", "NowPlaying"],
            ["PerfMon", "PerfMon"],
            ["Ping", "PingPlugin"],
            ["Power", "PowerPlugin"],
            ["Process", "Process"],
            ["Quote", "QuotePlugin"],
            ["RecycleManager", "RecycleManager"],
            ["ResMon", "ResMon"],
            ["RunCommand", "RunCommand"],
            ["SpeedFan", "SpeedFanPlugin"],
            ["SysInfo", "SysInfo"],
            ["WebParser", "WebParser"],
            ["WiFiStatus", "WiFiStatus"],
            ["Win7Audio", "Win7AudioPlugin"],
            ["WindowMessage", "WindowMessagePlugin"]
        ]),
    ]

    def on_query_completions(self, view, prefix, locations):
        for location in locations:
            # checks if the current scope is correct so it is only called in the files with the correct scope
            # here is scope only rainmeter files
            if view.match_selector(location, self.scope):
                # find last occurance of the [] to determine the ini sections
                line = view.line(location)
                line_contents = view.substr(line)

                # starts with Measure, followed by an equal sign
                for exp, elements in self.completions:
                    if exp.search(line_contents):
                        return elements, self.flags
        return None


class CompletionProxy(sublime_plugin.EventListener):

    proxied_completion = None

    def __init__(self):
        self.proxied_completion = ContextSensAutoCompletion()

    def on_query_completions(self, view, prefix, locations):
        return self.proxied_completion.on_query_completions(view, prefix, locations)


1			"""Module for getting Rainmeter-specific paths"""
2
3			import os
4			import re
5			import io
6			import getpass
7			import platform
8			import winreg
9
10			import sublime
11			import sublime_plugin
12
13			# own dependencies
14			from . import logger
15
16			from .path.program_path_provider import get_cached_program_path
17			from .path.setting_path_provider import get_cached_setting_path
18			from .path.program_drive_provider import get_cached_program_drive
19			from .path.plugin_path_provider import get_cached_plugin_path
20
21			from .completion.completion import ContextSensAutoCompletion
22
23
24			def skins_path():
25			"""Get the cached value of the #SKINSPATH# variable"""
26
27			return _skins_path
28
29
30			def addons_path():
31			"""Get the cached value of the #ADDONSPATH# variable"""
32
33			return _addons_path
34
35
36			def get_skins_path():
37			"""Get the value of the #SKINSPATH# variable"""
38
39			# First try to load the value from the "rainmeter_skins_path" setting
40			loaded_settings = sublime.load_settings("Rainmeter.sublime-settings")
41			skinspath = loaded_settings.get("rainmeter_skins_path", None)
42
43			# if it's found, return it
44			# We trust the user to enter something meaningful here
45			# and don't check anything.
46			if skinspath:
47			logger.info(__file__, "get_skins_path", "Skins path found in sublime-settings file.")
48			return os.path.normpath(skinspath) + "\\"
49
50			# If it's not set, try to detect it automagically
51
52			rainmeterpath = get_cached_program_path()
53			if not rainmeterpath:
54			return
55
56			settingspath = get_cached_setting_path()
57			if not settingspath:
58			return
59
60			# First, try to read the SkinPath setting from Rainmeter.ini
61			fhnd = io.open(os.path.join(settingspath, "Rainmeter.ini"))
62			lines = fhnd.read()
63			fhnd.close()
64
65			# Find the skinspath setting in the file
66			match = re.search(r"""(?imsx)
67
68			# Find the first [Rainmeter] section
69			(^\s\[\sRainmeter\s\]\s$)
70			(.*?
71
72			# Find the "SkinPath" and "="
73			(^\sSkinPath\s=\s*
74
75			# Read until the next line ending and store
76			# in named group
77			(?P<skinpath>[^$]+?)\s*?$
78			)
79			).*?
80
81			# All of this needs to happen before the next section
82			(?:^\s\[\s[^\[\]\s]+\s\]\s$)
83			""", lines)
84
85			# if skinspath setting was found, return it
86			if match:
87			logger.info(__file__, "get_skins_path", "Skins path found in Rainmeter.ini.")
88			return match.group("skinpath").strip().replace("/", "\\")
89
90			# if it's not found in the settings file, try to guess it
91
92			# If program path and setting path are equal, we have a portable
93			# installation. In this case, the Skins folder is inside the rainmeter
94			# path
95			if os.path.samefile(rainmeterpath, settingspath):
96			logger.info(__file__, "get_skins_path", "Skin path found in #PROGRAMPATH#" +
97			" because portable installation")
98			return os.path.join(rainmeterpath, "Skins") + "\\"
99
100			# If it's not a portable installation, we try looking into the "My
101			# Documents" folder Since it could be relocated by the user, we have to
102			# query its value from the registry
103			try:
104			regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
105			r"Software\Microsoft\Windows" +
106			r"\CurrentVersion\Explorer" +
107			r"\User Shell Folders")
108			keyval = winreg.QueryValueEx(regkey, "Personal")
109
110			pathrep = keyval[0]
111
112			# The path could (and most likely, will) contain environment
113			# variables that have to be expanded first
114			pathrep = os.path.expandvars(pathrep)
115
116			logger.info(__file__, "get_skins_path", "Guessed Skin path from My Documents" +
117			" location in registry")
118			return os.path.join(pathrep, "Rainmeter\\Skins") + "\\"
119
120			except OSError:
121			pass
122
123			# If the value could not be retrieved from the registry,
124			# we try some educated guesses about default locations
125			try:
126			username = getpass.getuser()
127			except Exception:
128			logger.info(__file__, "get_skins_path", "Skins path could not be located." +
129			" Please set the \"skins_path\" setting in your Rainmeter" +
130			" settings file.")
131			return
132			else:
133			# check if windows version is XP
134			winversion = platform.version()
135			if int(winversion[0]) < 6:
136			mydocuments = os.path.join("C:\\Documents and Settings",
137			username,
138			"My Documents") + "\\"
139
140			logger.info(__file__, "get_skins_path", "Found Windows XP or lower." +
141			" Skins path assumed to be " + mydocuments +
142			"Rainmeter\\Skins\\")
143			else:
144			mydocuments = os.path.join("C:\\Users",
145			username,
146			"Documents") + "\\"
147
148			logger.info(__file__, "get_skins_path", "Found Windows Vista or higher." +
149			" Skins path assumed to be " + mydocuments +
150			"Rainmeter\\Skins\\")
151
152			logger.info(__file__, "get_skins_path", "Skin path guessed from user name" +
153			" and Windows version")
154			return os.path.join(mydocuments, "Rainmeter\\Skins") + "\\"
155
156
157			def get_addons_path():
158			"""Get the value of the #ADDONSPATH# variable"""
159
160			settingspath = get_cached_setting_path()
161			if not settingspath:
162			return
163			return os.path.join(settingspath, "Addons") + "\\"
164
165
166			def get_current_path(filepath):
167			"""Get the value of the #CURRENTPATH# variable for the specified path.
168
169			Returns None if the file path is not in the skins folder
170
171			"""
172
173			filepath = os.path.normpath(filepath)
174
175			skinspath = skins_path()
176			if not skinspath or not filepath.startswith(skinspath):
177			logger.info(__file__, "get_current_path", "current path could not be found because" +
178			" either the skins path could not be found or the current file" +
179			" is not located in the skins path.")
180			return
181
182			if os.path.isfile(filepath):
183			return os.path.dirname(filepath) + "\\"
184			else:
185			return filepath + "\\"
186
187
188			def get_root_config_path(filepath):
189			"""Get the value of the #ROOTCONFIGPATH# variable for the specified path
190
191			Returns None if the path is not in the skins folder
192
193			"""
194
195			filepath = os.path.normpath(filepath)
196
197			skinspath = skins_path()
198			if not skinspath or not filepath.startswith(skinspath):
199			logger.info(__file__, "get_root_config_path", "root config path could not be found" +
200			" because either the skins path could not be found or the" +
201			" current file is not located in the skins path.")
202			return
203
204			relpath = os.path.relpath(filepath, skinspath)
205			logger.info(__file__, "get_root_config_path",
206			os.path.join(skinspath, relpath.split("\\")[0]) + "\\")
207
208			return os.path.join(skinspath, relpath.split("\\")[0]) + "\\"
209
210
211			def get_current_file(filepath):
212			"""Get the value of the #CURRENTFILE# variable for the specified path
213
214			Returns None if the path is not in the skins folder
215
216			"""
217
218			filepath = os.path.normpath(filepath)
219
220			skinspath = skins_path()
221			if not skinspath or not filepath.startswith(skinspath):
222			logger.info(__file__, "get_current_file", "current file could not be found because" +
223			" either the skins path could not be found or the current" +
224			" file is not located in the skins path.")
225			return
226
227			if os.path.isfile(filepath):
228			return os.path.basename(filepath)
229			else:
230			logger.info(__file__, "get_current_file", "specified path is not a file.")
231			return
232
233
234			def get_current_config(filepath):
235			"""Get the value of the #CURRENTCONFIG# variable for the specified path
236
237			Returns None if the path is not in the skins folder
238
239			"""
240
241			filepath = os.path.normpath(filepath)
242
243			skinspath = skins_path()
244			if not skinspath or not filepath.startswith(skinspath):
245			logger.info(__file__, "get_current_config", "current config could not be found" +
246			" because \either the skins path could not be found or the" +
247			" current file is not located in the skins path.")
248			return
249
250			if os.path.isfile(filepath):
251			filepath = os.path.dirname(filepath)
252
253			return os.path.relpath(filepath, skinspath)
254
255
256			def get_resources_path(filepath):
257			"""Get the value of the #@# variable for the specified path
258
259			Returns None if the path is not in the skins folder
260
261			"""
262
263			rfp = get_root_config_path(filepath)
264
265			if not rfp:
266			return
267			logger.info(__file__, "get_resources_path", os.path.join(rfp, "@Resources") + "\\")
268			return os.path.join(rfp, "@Resources") + "\\"
269
270
271			def replace_variables(string, filepath):
272			"""Replace Rainmeter built-in variables and Windows environment variables
273			in string.
274
275			Replaces occurrences of the following variables in the string:
276			#CURRENTFILE#
277			#CURRENTPATH#
278			#ROOTCONFIGPATH#
279			#CURRENTCONFIG#
280			#@#
281			#SKINSPATH#
282			#SETTINGSPATH#
283			#PROGRAMPATH#
284			#PROGRAMDRIVE#
285			#ADDONSPATH#
286			#PLUGINSPATH#
287			Any Windows environment variables (like %APPDATA%)
288			filepath must be a skin file located in a subdirectory of the skins folder
289
290			"""
291
292			# lambdas for lazy evaluation
293			variables = {"#CURRENTFILE#": lambda: get_current_file(filepath),
294			"#CURRENTPATH#": lambda: get_current_path(filepath),
295			"#ROOTCONFIGPATH#": lambda: get_root_config_path(filepath),
296			"#CURRENTCONFIG#": lambda: get_current_config(filepath),
297			"#@#": lambda: get_resources_path(filepath),
298			"#SKINSPATH#": lambda: skins_path(),
299			"#SETTINGSPATH#": lambda: get_cached_setting_path(),
300			"#PROGRAMPATH#": lambda: get_cached_program_path(),
301			"#PROGRAMDRIVE#": lambda: get_cached_program_drive(),
302			"#ADDONSPATH#": lambda: addons_path(),
303			"#PLUGINSPATH#": lambda: get_cached_plugin_path()}
304
305			pattern = re.compile("(?i)" + "\|".join(list(variables.keys())))
306			# replace Rainmeter variables
307			repl = pattern.sub(lambda x: variables[x.group().upper()](),
308			string)
309			# expand windows environment variables
310			repl = os.path.expandvars(repl)
311			return repl
312
313
314			def make_path(string, filepath):
315			"""Make the string into an absolute path of an existing file or folder,
316
317			replacing Rainmeter built-in variables relative to the file specified in
318			filepath (see replace_variables()) will return None if the file or folder
319			doesn't exist, or if string is None or empty.
320
321			"""
322
323			if not string:
324			return None
325
326			repl = replace_variables(string, filepath)
327			norm = os.path.normpath(repl)
328
329			# For relative paths, try folder of current file first
330
331			if not os.path.isabs(norm):
332			curpath = get_current_path(filepath)
333			if curpath:
334			abso = os.path.join(curpath, norm)
335			else:
336			abso = os.path.join(os.path.dirname(filepath), norm)
337
338			if os.path.exists(abso):
339			return abso
340
341			# if that doesn't work, try relative to skins path
342			# (for #CURRENTCONFIG#)
343			abso = os.path.join(skins_path(), norm)
344			if os.path.exists(abso):
345			return abso
346			# for absolute paths, try opening containing folder if file does not exist
347			else:
348			if os.path.exists(norm):
349			return norm
350
351			if os.path.exists(os.path.dirname(norm)):
352			return os.path.dirname(norm)
353
354			return
355
356
357			# Initialize Module
358			# Global Variables
359			settings = None
360
361			_skins_path = None
362			_addons_path = None
363
364
365			# Called automatically from ST3 if plugin is loaded
366			# Is required now due to async call and ignoring sublime.* from main routine
367			def plugin_loaded():
368			# define variables from the global scope
369			global settings
370
371			global _skins_path
372			global _addons_path
373
374			settings = sublime.load_settings("Rainmeter.sublime-settings")
375
376			# Cache the paths
377			_skins_path = get_skins_path()
378			_addons_path = get_addons_path()
379
380			logger.info(__file__, "plugin_loaded()", "#PROGRAMPATH#:\t\t" + get_cached_program_path())
381			logger.info(__file__, "plugin_loaded()", "#PROGRAMDRIVE#:\t" + get_cached_program_drive())
382			logger.info(__file__, "plugin_loaded()", "#SETTINGSPATH#:\t" + get_cached_setting_path())
383			logger.info(__file__, "plugin_loaded()", "#SKINSPATH#:\t\t" + skins_path())
384			logger.info(__file__, "plugin_loaded()", "#PLUGINSPATH#:\t\t" + get_cached_plugin_path())
385			logger.info(__file__, "plugin_loaded()", "#ADDONSPATH#:\t\t" + addons_path())
386
387
388			class MeterAutoComplete(sublime_plugin.EventListener):
389
390			# only show our completion list because nothing else makes sense in this context
391			flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS \| sublime.INHIBIT_WORD_COMPLETIONS
392			scope = "source.rainmeter"
393
394			comment_exp = re.compile(r'^\s;.')
395			meter_exp = re.compile(r'^\s*')
396
397			completions = [
398			# measures
399			(re.compile(r'^\sMeasure\s=\s*'), [
400			# key, value
401			["Calc", "Calc"],
402			["CPU", "CPU"],
403			["FreeDiskSpace", "FreeDiskSpace"],
404			["Loop", "Loop"],
405
406			# memory measure
407			["Memory", "Memory"],
408			["PhysicalMemory", "PhysicalMemory"],
409			["SwapMemory", "SwapMemory"],
410
411			# net measure
412			["NetIn", "NetIn"],
413			["NetOut", "NetOut"],
414			["NetTotal", "NetTotal"],
415
416			["Plugin", "Plugin"],
417			["Registry", "Registry"],
418			["Script", "Script"],
419			["String", "String"],
420			["Time", "Time"],
421			["Uptime", "Uptime"]
422			]),
423
424			# meters
425			(re.compile(r'^\sMeter\s=\s*'), [
426			# key, value
427			["Bar", "Bar"],
428			["Bitmap", "Bitmap"],
429			["Button", "Button"],
430			["Histogram", "Histogram"],
431			["Image", "Image"],
432			["Line", "Line"],
433			["Rotator", "Rotator"],
434			["Roundline", "Roundline"],
435			["Shape", "Shape"],
436			["String", "String"]
437			]),
438			# general options
439
440			# bar
441			# bar orientation
442			(re.compile(r'^\sBarOrientation\s=\s*'), [
443			# key, value
444			["Horizontal", "Horizontal"],
445			["Vertical\tDefault", "Vertical"]
446			]),
447
448			# bar flip
449			(re.compile(r'^\sFlip\s=\s*'), [
450			# key, value
451			["0\tDefault", "0"],
452			["1\tBar is flipped", "1"]
453			]),
454
455			# bitmap
456
457			# button
458			# histogram
459			# image
460			# line
461			# rotator
462			# roundline
463			# shape
464			# string
465
466			# plugins
467			(re.compile(r'^\sPlugin\s=\s*'), [
468			# key, value
469			["ActionTimer", "ActionTimer"],
470			["AdvancedCPU", "AdvancedCPU"],
471			["AudioLevel", "AudioLevel"],
472			["CoreTemp", "CoreTemp"],
473			["FileView", "FileView"],
474			["FolderInfo", "FolderInfo"],
475			["InputText", "InputText"],
476			["iTunes", "iTunesPlugin"],
477			["MediaKey", "MediaKey"],
478			["NowPlaying", "NowPlaying"],
479			["PerfMon", "PerfMon"],
480			["Ping", "PingPlugin"],
481			["Power", "PowerPlugin"],
482			["Process", "Process"],
483			["Quote", "QuotePlugin"],
484			["RecycleManager", "RecycleManager"],
485			["ResMon", "ResMon"],
486			["RunCommand", "RunCommand"],
487			["SpeedFan", "SpeedFanPlugin"],
488			["SysInfo", "SysInfo"],
489			["WebParser", "WebParser"],
490			["WiFiStatus", "WiFiStatus"],
491			["Win7Audio", "Win7AudioPlugin"],
492			["WindowMessage", "WindowMessagePlugin"]
493			]),
494			]
495
496			def on_query_completions(self, view, prefix, locations):
497			for location in locations:
498			# checks if the current scope is correct so it is only called in the files with the correct scope
499			# here is scope only rainmeter files
500			if view.match_selector(location, self.scope):
501			# find last occurance of the [] to determine the ini sections
502			line = view.line(location)
503			line_contents = view.substr(line)
504
505			# starts with Measure, followed by an equal sign
506			for exp, elements in self.completions:
507			if exp.search(line_contents):
508			return elements, self.flags
509			return None
510
511
512			class CompletionProxy(sublime_plugin.EventListener):
513
514			proxied_completion = None
515
516			def __init__(self):
517			self.proxied_completion = ContextSensAutoCompletion()
518
519			def on_query_completions(self, view, prefix, locations):
520			return self.proxied_completion.on_query_completions(view, prefix, locations)
521

thatsIch / sublime-rainmeter

GitHub Access Token became invalid

Push — master ( 28ac24...6b7ebe )

plugins_path() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like