local old_log_level = log.log_level()

log.log_level(level)

return old_log_level

local old_log_level = set_log_level(sm.log_level)

log.msg(log.debug, "name is " .. name .. " and type is " .. pref_type)

local val = dt.preferences.read(MODULE, name, pref_type)

log.msg(log.debug, "read value " .. tostring(val))

restore_log_level(old_log_level)

return val

local old_log_level = set_log_level(sm.log_level)

log.msg(log.debug, "writing value " .. tostring(value) .. " for name " .. name)

dt.preferences.write(MODULE, name, pref_type, value)

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local p = io.popen("cd " .. repo .. CS .. "git status")

if p then

local data = p:read("*a")

p:close()

return data

end

log.msg(log.error, "unable to get status of " .. repo)

restore_log_level(old_log_level)

return nil

local old_log_level = set_log_level(sm.log_level)

local branch = nil

local p = io.popen("cd " .. repo .. CS .. "git branch --all")

if p then

local data = p:read("*a")

p:close()

local branches = du.split(data, "\n")

for _, b in ipairs(branches) do

log.msg(log.debug, "branch for testing is " .. b)

branch = string.match(b, "^%* (.-)$")

if branch then

log.msg(log.info, "current repo branch is " .. branch)

return branch

end

end

end

if not branch then

log.msg(log.error, "no current branch detected in repo_data")

end

restore_log_level(old_log_level)

return nil

local old_log_level = set_log_level(sm.log_level)

local branches = {}

local p = io.popen("cd " .. repo .. CS .. "git pull --all" .. CS .. "git branch --all")

if p then

local data = p:read("*a")

p:close()

log.msg(log.debug, "data is \n" .. data)

local branch_data = du.split(data, "\n")

for _, line in ipairs(branch_data) do

log.msg(log.debug, "line is " .. line)

local branch = string.gsub(line, "%s+remotes/%a+/", "")

if string.match(branch, "API") then

log.msg(log.info, "found branch - " .. branch)

table.insert(branches, branch)

end

end

end

restore_log_level(old_log_level)

return branches

local old_log_level = set_log_level(sm.log_level)

if string.match(repo_data, "\n%s-%a.-%a:%s-%a%g-\n") then

log.msg(log.info, "repo is dirty")

return false

else

log.msg(log.info, "repo is clean")

return true

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

log.msg(log.info, "checkout out branch " .. branch .. " from repository " .. repo)

os.execute("cd " .. repo .. CS .. "git checkout " .. branch)

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local items = #combobox

local choices = #choice_table

for i, name in ipairs(choice_table) do

combobox[i] = name

end

if choices < items then

for j = items, choices + 1, -1 do

combobox[j] = nil

end

end

if not selected then

selected = 1

end

combobox.value = selected

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local result = string.gsub(str, "^%s+", "")

result = string.gsub(result, "%s+$", "")

restore_log_level(old_log_level)

return result

local old_log_level = set_log_level(sm.log_level)

if #sm.categories == 0 or not string.match(du.join(sm.categories, " "), ds.sanitize_lua(category)) then

table.insert(sm.categories, category)

sm.scripts[category] = {}

log.msg(log.debug, "created category " .. category)

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local description = nil

f = io.open(LUA_DIR .. PS .. script .. ".lua")

if f then

-- slurp the file

local content = f:read("*all")

f:close()

-- assume that the second block comment is the documentation

description = string.match(content, "%-%-%[%[.-%]%].-%-%-%[%[(.-)%]%]")

else

log.msg(log.error, _("Cant read from " .. script))

end

if description then

restore_log_level(old_log_level)

return description

else

restore_log_level(old_log_level)

return "No documentation available"

end

local old_log_level = set_log_level(sm.log_level)

local status = nil -- status of start function

local err = nil -- error message returned if module doesn't start

log.msg(log.info, "activating " .. script.name)

if script.running == false then

script_manager_running_script = script.name

status, err = du.prequire(script.path)

log.msg(log.debug, "prequire returned " .. tostring(status) .. " and for err " .. tostring(err))

script_manager_running_script = nil

if status then

pref_write(script.script_name, "bool", true)

log.msg(log.screen, _("Loaded ") .. script.script_name)

script.running = true

if err ~= true then

log.msg(log.debug, "got lib data")

script.data = err

if script.data.destroy_method and script.data.destroy_method == "hide" and script.data.show and dt.gui.current_view().id == "lighttable" then

script.data.show()

end

else

script.data = nil

end

else

log.msg(log.screen, script.script_name .. _(" failed to load"))

log.msg(log.error, "Error loading " .. script.script_name)

log.msg(log.error, "Error message: " .. err)

end

else -- script is a lib and loaded but hidden and the user wants to reload

script.data.restart()

script.running = true

status = true

pref_write(script.script_name, "bool", true)

end

restore_log_level(old_log_level)

return status

-- presently the lua api doesn't support unloading lib elements however, we

-- can hide libs, so we just mark those as hidden and hide the gui

-- can delete storages

-- can delete actions

-- can delete selects

-- and mark them inactive for the next time darktable starts

-- deactivate it....

local old_log_level = set_log_level(sm.log_level)

pref_write(script.script_name, "bool", false)

if script.data then

script.data.destroy()

if script.data.destroy_method then

if string.match(script.data.destroy_method, "hide") then

script.running = "hidden"

else

package.loaded[script.script_name] = nil

script.running = false

end

else

package.loaded[script.script_name] = nil

script.running = false

end

log.msg(log.info, "turned off " .. script.script_name)

log.msg(log.screen, script.name .. _(" stopped"))

else

script.running = false

log.msg(log.info, "setting " .. script.script_name .. " to not start")

log.msg(log.screen, script.name .. _(" will not start when darktable is restarted"))

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

log.msg(log.debug, "category is " .. category)

log.msg(log.debug, "name is " .. name)

local script = {

name = name,

path = category .. "/" .. path .. name,

running = false,

doc = get_script_doc(category .. "/" .. path .. name),

script_name = category .. "/" .. name,

data = nil

}

table.insert(sm.scripts[category], script)

if pref_read(script.script_name, "bool") then

activate(script)

else

pref_write(script.script_name, "bool", false)

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

-- the script file supplied is category/filename.filetype

-- the following pattern splits the string into category, path, name, fileename, and filetype

-- for example contrib/gimp.lua becomes

-- category - contrib

-- path -

-- name - gimp.lua

-- filename - gimp

-- filetype - lua

-- Thanks Tobias Jakobs for the awesome regulary expression

local pattern = "(.-)/(.-)(([^\\/]-)%.?([^%.\\/]*))$"

if dt.configuration.running_os == "windows" then

-- change the path separator from / to \ for windows

pattern = "(.-)\\(.-)(([^\\]-)%.?([^%.\\]*))$"

end

log.msg(log.info, "processing " .. script_file)

-- add the script data

local category,path,name,filename,filetype = string.match(script_file, pattern)

if category and name and path then

log.msg(log.debug, "category is " .. category)

log.msg(log.debug, "name is " .. name)

add_script_category(category)

add_script_name(name, path, category)

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

set_log_level(log.debug)

log.msg(log.debug, "line is " .. line)

if string.match(line, ds.sanitize_lua(dt.configuration.config_dir .. PS .. "lua" .. PS .. "lib")) then

log.msg(log.debug, line .. " is already in search path, returning...")

return

end

local pattern = dt.configuration.running_os == "windows" and "(.+)\\lib\\.+lua" or "(.+)/lib/.+lua"

local path = string.match(line, pattern)

log.msg(log.debug, "extracted path is " .. path)

log.msg(log.debug, "package.path is " .. package.path)

if not string.match(package.path, ds.sanitize_lua(path)) then

log.msg(log.debug, "path isn't in package.path, adding...")

package.path = package.path .. ";" .. path .. "/?.lua"

log.msg(log.debug, "new package.path is " .. package.path)

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local script_count = 0

local find_cmd = "find -L " .. script_dir .. " -name \\*.lua -print | sort"

if dt.configuration.running_os == "windows" then

find_cmd = "dir /b/s \"" .. script_dir .. "\\*.lua\" | sort"

end

log.msg(log.debug, _("find command is ") .. find_cmd)

-- scan the scripts

local output = io.popen(find_cmd)

for line in output:lines() do

local l = string.gsub(line, ds.sanitize_lua(LUA_DIR) .. PS, "") -- strip the lua dir off

local script_file = l:sub(1,-5) -- strip off .lua\n

if not string.match(script_file, "script_manager") then -- let's not include ourself

if not string.match(script_file, "plugins") then -- skip plugins

if not string.match(script_file, "lib" .. PS) then -- let's not try and run libraries

if not string.match(script_file, "%.git") then -- don't match files in the .git directory

process_script_data(script_file)

script_count = script_count + 1

end

else

ensure_lib_in_search_path(line) -- but let's make sure libraries can be found

end

end

end

end

restore_log_level(old_log_level)

return script_count

local old_log_level = set_log_level(sm.log_level)

local result = false

local git = sm.executables.git

if not git then

dt.print(_("ERROR: git not found. Install or specify the location of the git executable."))

return

end

local git_command = "cd " .. LUA_DIR .. " " .. CS .. " " .. git .. " pull"

log.msg(log.debug, "update git command is " .. git_command)

if dt.configuration.running_os == "windows" then

result = dtsys.windows_command(git_command)

else

result = os.execute(git_command)

end

if result == 0 then

dt.print(_("lua scripts successfully updated"))

end

restore_log_level(old_log_level)

return result

local old_log_level = set_log_level(sm.log_level)

local installs = {}

local pref_string = ""

for i, repo in ipairs(sm.installed_repositories) do

table.insert(installs, repo.name)

pref_string = pref_string .. i .. "," .. repo.name .. "," .. repo.directory .. ","

end

update_combobox_choices(sm.widgets.update_script_choices, installs, 1)

log.msg(log.debug, "repo pref string is " .. pref_string)

pref_write("installed_repos", "string", pref_string)

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local script_count = 0

local find_cmd = "find -L " .. LUA_DIR .. " -name \\*.git -print | sort"

if dt.configuration.running_os == "windows" then

find_cmd = "dir /b/s /a:d " .. LUA_DIR .. PS .. "*.git | sort"

end

log.msg(log.debug, _("find command is ") .. find_cmd)

local output = io.popen(find_cmd)

for line in output:lines() do

local l = string.gsub(line, ds.sanitize_lua(LUA_DIR) .. PS, "") -- strip the lua dir off

local category = string.match(l, "(.-)" .. PS) -- get everything to teh first /

if category then -- if we have a category (.git doesn't)

log.msg(log.debug, "found category " .. category)

if not string.match(category, "plugins") and not string.match(category, "%.git") then -- skip plugins

if #sm.installed_repositories == 1 then

log.msg(log.debug, "only 1 repo, adding " .. category)

table.insert(sm.installed_repositories, {name = category, directory = LUA_DIR .. PS .. category})

else

log.msg(log.debug, "more than 1 repo, we have to search the repos to make sure it's not there")

local found = nil

for _, repo in ipairs(sm.installed_repositories) do

if string.match(repo.name, ds.sanitize_lua(category)) then

log.msg(log.debug, "matched " .. repo.name)

found = true

break

end

end

if not found then

table.insert(sm.installed_repositories, {name = category, directory = LUA_DIR .. PS .. category})

end

end

end

end

end

update_script_update_choices()

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local url = sm.widgets.script_url.text

local category = sm.widgets.new_category.text

if string.match(du.join(sm.categories, " "), ds.sanitize_lua(category)) then

log.msg(log.screen, _("category ") .. category .. _(" is already in use. Please specify a different category name."))

log.msg(log.error, "category " .. category .. " already exists, returning...")

restore_log_level(old_log_level)

return

end

local result = false

local git = sm.executables.git

if not git then

dt.print(_("ERROR: git not found. Install or specify the location of the git executable."))

restore_log_level(old_log_level)

return

end

local git_command = "cd " .. LUA_DIR .. " " .. CS .. " " .. git .. " clone " .. url .. " " .. category

log.msg(log.debug, "update git command is " .. git_command)

if dt.configuration.running_os == "windows" then

result = dtsys.windows_command(git_command)

else

result = dtsys.external_command(git_command)

end

log.msg(log.info, "result from import is " .. result)

if result == 0 then

local count = scan_scripts(LUA_DIR .. PS .. category)

if count > 0 then

update_combobox_choices(sm.widgets.category_selector, sm.categories, sm.widgets.category_selector.selected)

dt.print(_("scripts successfully installed into category ") .. category)

table.insert(sm.installed_repositories, {name = category, directory = LUA_DIR .. PS .. category})

update_script_update_choices()

for i = 1, #sm.widgets.category_selector do

if string.match(sm.widgets.category_selector[i], ds.sanitize_lua(category)) then

log.msg(log.debug, "setting category selector to " .. i)

sm.widgets.category_selector.selected = i

break

end

i = i + 1

end

log.msg(log.debug, "clearing text fields")

sm.widgets.script_url.text = ""

sm.widgets.new_category.text = ""

sm.widgets.main_menu.selected = 3

else

dt.print(_("No scripts found to install"))

log.msg(log.error, "scan_scripts returned " .. count .. " scripts found. Not adding to category_selector")

end

else

dt.print(_("failed to download scripts"))

end

restore_log_level(old_log_level)

return result

local old_log_level = set_log_level(sm.log_level)

local button = sm.widgets.buttons[number]

button.label = ""

button.tooltip = ""

button.sensitive = false

--button.name = ""

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

log.msg(log.debug, "looking for script " .. name .. " in category " .. category)

for _, script in ipairs(sm.scripts[category]) do

if string.match(script.name, "^" .. ds.sanitize_lua(name) .. "$") then

return script

end

end

restore_log_level(old_log_level)

return nil

local old_log_level = set_log_level(sm.log_level)

log.msg(log.debug, "category is " .. category .. " and first is " .. first .. " and last is " .. last)

local button_num = 1

for i = first, last do

script = sm.scripts[category][i]

button = sm.widgets.buttons[button_num]

if script.running == true then

if sm.use_color then

button.label = script.name

button.name = "sm_started"

else

button.label = script.name .. _(" started")

end

else

if sm.use_color then

button.label = script.name

button.name = "sm_stopped"

else

button.label = script.name .. _(" stopped")

end

end

button.ellipsize = "middle"

button.sensitive = true

button.tooltip = script.doc

button.clicked_callback = function (this)

local script_name = nil

local state = nil

if sm.use_color then

script_name = string.match(this.label, "(.+)")

else

script_name, state = string.match(this.label, "(.-) (.+)")

end

local script = find_script(sm.widgets.category_selector.value, script_name)

if script then

log.msg(log.debug, "found script " .. script.name .. " with path " .. script.path)

if script.running == true then

log.msg(log.debug, "deactivating " .. script.name .. " on " .. script.path .. " for button " .. this.label)

deactivate(script)

if sm.use_color then

this.name = "sm_stopped"

else

this.label = script.name .. _(" stopped")

end

else

log.msg(log.debug, "activating " .. script.name .. " on " .. script.path .. " for button " .. this.label)

local result = activate(script)

if result then

if sm.use_color then

this.name = "sm_started"

else

this.label = script.name .. " started"

end

end

end

else

log.msg(log.error, "script " .. script_name .. " not found")

end

end

button_num = button_num + 1

end

if button_num <= sm.page_status.num_buttons then

for i = button_num, sm.page_status.num_buttons do

clear_button(i)

end

end

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

local category = sm.page_status.category

log.msg(log.debug, "category is " .. category)

local num_scripts = #sm.scripts[category]

log.msg(log.debug, "num_scripts is " .. num_scripts)

local max_pages = math.ceil(num_scripts / sm.page_status.num_buttons)

local cur_page = sm.page_status.current_page

log.msg(log.debug, "max pages is " .. max_pages)

local buttons_needed = nil

local first = nil

local last = nil

if direction == 0 then

cur_page = cur_page - 1

if cur_page < 1 then

cur_page = 1

end

elseif direction == 1 then

cur_page = cur_page + 1

if cur_page > max_pages then

cur_page = max_pages

end

else

log.msg(log.debug, "took path 2")

cur_page = 1

end

log.msg(log.debug, "cur_page is " .. cur_page .. " and max_pages is " .. max_pages)

if cur_page == max_pages and cur_page == 1 then

sm.widgets.page_forward.sensitive = false

sm.widgets.page_back.sensitive = false

elseif cur_page == max_pages then

sm.widgets.page_forward.sensitive = false

sm.widgets.page_back.sensitive = true

elseif cur_page == 1 then

sm.widgets.page_forward.sensitive = true

sm.widgets.page_back.sensitive = false

else

sm.widgets.page_forward.sensitive = true

sm.widgets.page_back.sensitive = true

end

sm.page_status.current_page = cur_page

first = (cur_page * sm.page_status.num_buttons) - (sm.page_status.num_buttons - 1)

if first + sm.page_status.num_buttons > num_scripts then

last = num_scripts

else

last = first + sm.page_status.num_buttons - 1

end

sm.widgets.page_status.label = _("Page ") .. cur_page .. _(" of ") .. max_pages

populate_buttons(category, first, last)

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

if not category then

log.msg(log.debug "setting category to selector value " .. sm.widgets.category_selector.value)

sm.page_status.category = sm.widgets.category_selector.value

else

log.msg(log.debug, "setting catgory to argument " .. category)

sm.page_status.category = category

end

paginate(2)

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

cur_buttons = sm.page_status.num_buttons

new_buttons = sm.widgets.num_buttons.value

pref_write("num_buttons", "integer", new_buttons)

if new_buttons < cur_buttons then

for i = 1, cur_buttons - new_buttons do

table.remove(sm.widgets.scripts)

end

log.msg(log.debug, "finished removing widgets, now there are " .. #sm.widgets.buttons)

elseif new_buttons > cur_buttons then

if new_buttons > sm.page_status.buttons_created then

for i = sm.page_status.buttons_created + 1, new_buttons do

table.insert(sm.widgets.buttons, dt.new_widget("button"){})

sm.page_status.buttons_created = sm.page_status.buttons_created + 1

end

end

log.msg(log.debug, "cur_buttons is " .. cur_buttons .. " and new_buttons is " .. new_buttons)

log.msg(log.debug, #sm.widgets.buttons .. " buttons are available")

for i = cur_buttons + 1, new_buttons do

log.msg(log.debug, "inserting button " .. i .. " into scripts widget")

table.insert(sm.widgets.scripts, sm.widgets.buttons[i])

end

log.msg(log.debug, "finished adding widgets, now there are " .. #sm.widgets.buttons)

else -- no change

log.msg(log.debug, "no change, just returning")

return

end

sm.page_status.num_buttons = new_buttons

log.msg(log.debug, "num_buttons set to " .. sm.page_status.num_buttons)

paginate(2) -- force the buttons to repopulate

sm.widgets.main_menu.selected = 3 -- jump back to start/stop scripts

restore_log_level(old_log_level)

local old_log_level = set_log_level(sm.log_level)

-- load the prefs and update settings

-- update_script_choices

local pref_string = pref_read("installed_repos", "string")

local entries = du.split(pref_string, ",")

while #entries > 2 do

local num = table.remove(entries, 1)

local name = table.remove(entries, 1)

local directory = table.remove(entries, 1)

if not string.match(sm.installed_repositories[1].name, "^" .. ds.sanitize_lua(name) .. "$") then

table.insert(sm.installed_repositories, {name = name, directory = directory})