diff --git a/awesompd/README.md b/awesompd/README.md deleted file mode 100644 index 739800b..0000000 --- a/awesompd/README.md +++ /dev/null @@ -1,19 +0,0 @@ -## Description ## - -This is an advanced MPD widget\client for AwesomeWM. - -For the detailed installation guide please see http://awesome.naquadah.org/wiki/Awesompd_widget . - -Also you can find an example of the widget configuration in the file rcsample.lua. - -## Version explanation ## - -Use this version with Awesome v3.4.x. If you are using the git pre-4.0 version of Awesome, please consider using [this](https://github.com/alexander-yakushev/awesompd/tree/for-awesome-git) version instead. - -### Changes in 1.1.0 ### - -* Album covers are now also shown for the local tracks (images are taken from the current track's folder) -* When the Jamendo track is playing you can visit artist's or album's page from the Jamendo menu -* Notification now shows the album name for the current track (for both local and Jamendo tracks) -* A few minor modifications and bugfixes - diff --git a/awesompd/asyncshell.lua b/awesompd/asyncshell.lua deleted file mode 100644 index 7510065..0000000 --- a/awesompd/asyncshell.lua +++ /dev/null @@ -1,67 +0,0 @@ --- Asynchronous io.popen for Awesome WM. --- How to use... --- ...asynchronously: --- asyncshell.request('wscript -Kiev', function(f) wwidget.text = f:read("*l") end) --- ...synchronously --- wwidget.text = asyncshell.demand('wscript -Kiev', 5):read("*l") or "Error" - -asyncshell = {} -asyncshell.request_table = {} -asyncshell.id_counter = 0 -asyncshell.folder = "/tmp/asyncshell" -asyncshell.file_template = asyncshell.folder .. '/req' - --- Create a directory for asynchell response files -os.execute("mkdir -p " .. asyncshell.folder) - --- Returns next tag - unique identifier of the request -local function next_id() - asyncshell.id_counter = (asyncshell.id_counter + 1) % 100000 - return asyncshell.id_counter -end - --- Sends an asynchronous request for an output of the shell command. --- @param command Command to be executed and taken output from --- @param callback Function to be called when the command finishes --- @return Request ID -function asyncshell.request(command, callback) - local id = next_id() - local tmpfname = asyncshell.file_template .. id - asyncshell.request_table[id] = {callback = callback} - local req = - string.format("bash -c '%s > %s; " .. - 'echo "asyncshell.deliver(%s)" | ' .. - "awesome-client' 2> /dev/null", - string.gsub(command, "'", "'\\''"), tmpfname, id, tmpfname) - awful.util.spawn(req) - return id -end - --- Calls the remembered callback function on the output of the shell --- command. --- @param id Request ID --- @param output The output file of the shell command to be delievered -function asyncshell.deliver(id) - if asyncshell.request_table[id] and - asyncshell.request_table[id].callback then - local output = io.open(asyncshell.file_template .. id, 'r') - asyncshell.request_table[id].callback(output) - end -end - --- Sends a synchronous request for an output of the command. Waits for --- the output, but if the given timeout expires returns nil. --- @param command Command to be executed and taken output from --- @param timeout Maximum amount of time to wait for the result --- @return File handler on success, nil otherwise -function asyncshell.demand(command, timeout) - local id = next_id() - local tmpfname = asyncshell.file_template .. id - local f = io.popen(string.format("(%s > %s; echo asyncshell_done) & " .. - "(sleep %s; echo asynchell_timeout)", - command, tmpfname, timeout)) - local result = f:read("*line") - if result == "asyncshell_done" then - return io.open(tmpfname) - end -end \ No newline at end of file diff --git a/awesompd/awesompd.lua b/awesompd/awesompd.lua deleted file mode 100644 index faf1253..0000000 --- a/awesompd/awesompd.lua +++ /dev/null @@ -1,1140 +0,0 @@ ---------------------------------------------------------------------------- --- @author Alexander Yakushev --- @copyright 2010-2011 Alexander Yakushev --- @release v1.1.5 ---------------------------------------------------------------------------- - -awesompd = {} - --- Function for checking icons and modules. Checks if a file exists, --- and if it does, returns the path to file, nil otherwise. -function awesompd.try_load(file) - if awful.util.file_readable(file) then - return file - end -end - --- Function for loading modules. -function awesompd.try_require(module) - if awesompd.try_load(awful.util.getdir("config") .. - "/awesompd/" .. module .. ".lua") then - return require('awesompd/' .. module) - else - return require(module) - end -end - -awesompd.try_require("utf8") -awesompd.try_require("asyncshell") -awesompd.try_require("jamendo") -local beautiful = require('beautiful') -local naughty = naughty -local awful = awful -local format = string.format -local keygrabber = keygrabber - --- Debug stuff - -local enable_dbg = true -local function dbg (...) - if enable_dbg then - print(...) - end -end - -local function tbl_pr(tbl,shift) - if enable_dbg then - local shift = shift or "" - for k, v in pairs(tbl) do - print(shift .. k .. ": " .. tostring(v)) - if type(v) == "table" then - tbl_pr(v, shift .. " ") - end - end - end -end - --- Constants -awesompd.PLAYING = "Playing" -awesompd.PAUSED = "Paused" -awesompd.STOPPED = "MPD stopped" -awesompd.DISCONNECTED = "Disconnected" - -awesompd.MOUSE_LEFT = 1 -awesompd.MOUSE_MIDDLE = 2 -awesompd.MOUSE_RIGHT = 3 -awesompd.MOUSE_SCROLL_UP = 4 -awesompd.MOUSE_SCROLL_DOWN = 5 - -awesompd.NOTIFY_VOLUME = 1 -awesompd.NOTIFY_REPEAT = 2 -awesompd.NOTIFY_RANDOM = 3 -awesompd.NOTIFY_SINGLE = 4 -awesompd.NOTIFY_CONSUME = 5 -awesompd.FORMAT_MP3 = jamendo.FORMAT_MP3 -awesompd.FORMAT_OGG = jamendo.FORMAT_OGG -awesompd.ESCAPE_SYMBOL_MAPPING = {} -awesompd.ESCAPE_SYMBOL_MAPPING["&"] = "&" --- Menus do not handle symbol escaping correctly, so they need their --- own mapping. -awesompd.ESCAPE_MENU_SYMBOL_MAPPING = {} -awesompd.ESCAPE_MENU_SYMBOL_MAPPING["&"] = "'n'" - --- /// Current track variables and functions /// - --- Returns a string for the given track to be displayed in the widget --- and notification. -function awesompd.get_display_name(track) - if track.display_name then - return track.display_name - elseif track.artist_name and track.track_name then - return track.artist_name .. " - " .. track.name - end -end - --- Returns a track display name, album name (if exists) and album --- release year (if exists). -function awesompd.get_extended_info(track) - local result = awesompd.get_display_name(track) - if track.album_name then - result = result .. "\n" .. track.album_name - end - if track.year then - result = result .. "\n" .. track.year - end - return result -end - --- Returns true if the current status is either PLAYING or PAUSED -function awesompd:playing_or_paused() - return self.status == awesompd.PLAYING - or self.status == awesompd.PAUSED -end - --- /// Helper functions /// - --- Just like awful.util.pread, but takes an argument how to read like --- "*line" or "*all". -function awesompd.pread(com, mode) - local f = io.popen(com, 'r') - local result = nil - if f then - result = f:read(mode) - f:close() - end - return result -end - --- Slightly modified function awful.util.table.join. -function awesompd.ajoin(buttons) - local result = {} - for i = 1, table.getn(buttons) do - if buttons[i] then - for k, v in pairs(buttons[i]) do - if type(k) == "number" then - table.insert(result, v) - else - result[k] = v - end - end - end - end - return result - end - --- Splits a given string with linebreaks into an array. -function awesompd.split(s) - local l = { n = 0 } - if s == "" then - return l - end - s = s .. "\n" - local f = function (s) - l.n = l.n + 1 - l[l.n] = s - end - local p = "%s*(.-)%s*\n%s*" - s = string.gsub(s,p,f) - return l -end - --- Icons - -function awesompd.load_icons(path) - awesompd.ICONS = {} - awesompd.ICONS.PLAY = awesompd.try_load(path .. "/play_icon.png") - awesompd.ICONS.PAUSE = awesompd.try_load(path .. "/pause_icon.png") - awesompd.ICONS.PLAY_PAUSE = awesompd.try_load(path .. "/play_pause_icon.png") - awesompd.ICONS.STOP = awesompd.try_load(path .. "/stop_icon.png") - awesompd.ICONS.NEXT = awesompd.try_load(path .. "/next_icon.png") - awesompd.ICONS.PREV = awesompd.try_load(path .. "/prev_icon.png") - awesompd.ICONS.CHECK = awesompd.try_load(path .. "/check_icon.png") - awesompd.ICONS.RADIO = awesompd.try_load(path .. "/radio_icon.png") - awesompd.ICONS.DEFAULT_ALBUM_COVER = - awesompd.try_load(path .. "/default_album_cover.png") -end - --- Function that returns a new awesompd object. -function awesompd:create() --- Initialization - local instance = {} - setmetatable(instance,self) - self.__index = self - instance.current_server = 1 - instance.widget = widget({ type = "textbox" }) - instance.notification = nil - instance.scroll_pos = 1 - instance.text = "" - instance.to_notify = false - instance.album_cover = nil - instance.current_track = { } - instance.recreate_menu = true - instance.recreate_playback = true - instance.recreate_list = true - instance.recreate_servers = true - instance.recreate_options = true - instance.recreate_jamendo_formats = true - instance.recreate_jamendo_order = true - instance.recreate_jamendo_browse = true - instance.current_number = 0 - instance.menu_shown = false - --- Default user options - instance.servers = { { server = "localhost", port = 6600 } } - instance.font = "Monospace" - instance.scrolling = true - instance.output_size = 30 - instance.update_interval = 10 - instance.path_to_icons = "" - instance.ldecorator = " " - instance.rdecorator = " " - instance.jamendo_format = awesompd.FORMAT_MP3 - instance.show_album_cover = true - instance.album_cover_size = 50 - instance.browser = "firefox" - --- Widget configuration - instance.widget:add_signal("mouse::enter", function(c) - instance:notify_track() - end) - instance.widget:add_signal("mouse::leave", function(c) - instance:remove_hint() - end) - return instance -end - --- Registers timers for the widget -function awesompd:run() - enable_dbg = self.debug_mode - self.load_icons(self.path_to_icons) - jamendo.set_current_format(self.jamendo_format) - if self.album_cover_size > 100 then - self.album_cover_size = 100 - end - - self:update_track() - self:check_playlists() - self.update_widget_timer = timer({ timeout = 1 }) - self.update_widget_timer:add_signal("timeout", function() - self:update_widget() - end) - self.update_widget_timer:start() - self.update_track_timer = timer({ timeout = self.update_interval }) - self.update_track_timer:add_signal("timeout", function() - self:update_track() - end) - self.update_track_timer:start() -end - --- Function that registers buttons on the widget. -function awesompd:register_buttons(buttons) - widget_buttons = {} - self.global_bindings = {} - for b=1,table.getn(buttons) do - if type(buttons[b][1]) == "string" then - mods = { buttons[b][1] } - else - mods = buttons[b][1] - end - if type(buttons[b][2]) == "number" then - -- This is a mousebinding, bind it to the widget - table.insert(widget_buttons, - awful.button(mods, buttons[b][2], buttons[b][3])) - else - -- This is a global keybinding, remember it for later usage in append_global_keys - table.insert(self.global_bindings, awful.key(mods, buttons[b][2], buttons[b][3])) - end - end - self.widget:buttons(self.ajoin(widget_buttons)) -end - --- Takes the current table with keybindings and adds widget's own --- global keybindings that were specified in register_buttons. --- If keytable is not specified, then adds bindings to default --- globalkeys table. If specified, then adds bindings to keytable and --- returns it. -function awesompd:append_global_keys(keytable) - if keytable then - for i = 1, table.getn(self.global_bindings) do - keytable = awful.util.table.join(keytable, self.global_bindings[i]) - end - return keytable - else - for i = 1, table.getn(self.global_bindings) do - globalkeys = awful.util.table.join(globalkeys, self.global_bindings[i]) - end - end -end - --- /// Group of mpc command functions /// - --- Takes a command to mpc and a hook that is provided with awesompd --- instance and the result of command execution. -function awesompd:command(com,hook) - local file = io.popen(self:mpcquery() .. com) - if hook then - hook(self,file) - end - file:close() -end - --- Takes a command to mpc and read mode and returns the result. -function awesompd:command_read(com, mode) - mode = mode or "*line" - self:command(com, function(_, f) - result = f:read(mode) - end) - return result -end - -function awesompd:command_playpause() - return function() - self:command("toggle",self.update_track) - end -end - -function awesompd:command_next_track() - return function() - self:command("next",self.update_track) - end -end - -function awesompd:command_prev_track() - return function() - self:command("seek 0") - self:command("prev",self.update_track) - end -end - -function awesompd:command_stop() - return function() - self:command("stop",self.update_track) - end -end - -function awesompd:command_play_specific(n) - return function() - self:command("play " .. n,self.update_track) - end -end - -function awesompd:command_volume_up() - return function() - self:command("volume +5") - self:update_track() -- Nasty! I should replace it with proper callback later. - self:notify_state(self.NOTIFY_VOLUME) - end -end - -function awesompd:command_volume_down() - return function() - self:command("volume -5") - self:update_track() - self:notify_state(self.NOTIFY_VOLUME) - end -end - -function awesompd:command_load_playlist(name) - return function() - self:command("load " .. name, function() - self.recreate_menu = true - end) - end -end - -function awesompd:command_replace_playlist(name) - return function() - self:command("clear") - self:command("load " .. name) - self:command("play 1", self.update_track) - end -end - -function awesompd:command_clear_playlist() - return function() - self:command("clear", self.update_track) - self.recreate_list = true - self.recreate_menu = true - end -end - -function awesompd:command_open_in_browser(link) - return function() - if self.browser then - awful.util.spawn(self.browser .. " '" .. link .. "'") - end - end -end - --- /// End of mpc command functions /// - --- /// Menu generation functions /// - -function awesompd:command_show_menu() - return - function() - self:remove_hint() - if self.recreate_menu then - local new_menu = {} - if self.main_menu ~= nil then - self.main_menu:hide() - end - if self.status ~= awesompd.DISCONNECTED - then - self:check_list() - self:check_playlists() - local jamendo_menu = { { "Search by", - { { "Nothing (Top 100)", self:menu_jamendo_top() }, - { "Artist", self:menu_jamendo_search_by(jamendo.SEARCH_ARTIST) }, - { "Album", self:menu_jamendo_search_by(jamendo.SEARCH_ALBUM) }, - { "Tag", self:menu_jamendo_search_by(jamendo.SEARCH_TAG) }}} } - local browse_menu = self:menu_jamendo_browse() - if browse_menu then - table.insert(jamendo_menu, browse_menu) - end - table.insert(jamendo_menu, self:menu_jamendo_format()) - table.insert(jamendo_menu, self:menu_jamendo_order()) - - new_menu = { { "Playback", self:menu_playback() }, - { "Options", self:menu_options() }, - { "List", self:menu_list() }, - { "Playlists", self:menu_playlists() }, - { "Jamendo", jamendo_menu } } - end - table.insert(new_menu, { "Servers", self:menu_servers() }) - self.main_menu = awful.menu({ items = new_menu, width = 300 }) - self.recreate_menu = false - end - self.main_menu:toggle() - end -end - --- Returns an icon for a checkbox menu item if it is checked, nil --- otherwise. -function awesompd:menu_item_toggle(checked) - return checked and self.ICONS.CHECK or nil -end - --- Returns an icon for a radiobox menu item if it is selected, nil --- otherwise. -function awesompd:menu_item_radio(selected) - return selected and self.ICONS.RADIO or nil -end - --- Returns the playback menu. Menu contains of: --- Play\Pause - always --- Previous - if the current track is not the first --- in the list and playback is not stopped --- Next - if the current track is not the last --- in the list and playback is not stopped --- Stop - if the playback is not stopped --- Clear playlist - always -function awesompd:menu_playback() - if self.recreate_playback then - local new_menu = {} - table.insert(new_menu, { "Play\\Pause", - self:command_toggle(), - self.ICONS.PLAY_PAUSE }) - if self:playing_or_paused() then - if self.list_array and self.list_array[self.current_number-1] then - table.insert(new_menu, - { "Prev: " .. - awesompd.protect_string(jamendo.replace_link( - self.list_array[self.current_number - 1]), - true), - self:command_prev_track(), self.ICONS.PREV }) - end - if self.list_array and self.current_number ~= table.getn(self.list_array) then - table.insert(new_menu, - { "Next: " .. - awesompd.protect_string(jamendo.replace_link( - self.list_array[self.current_number + 1]), - true), - self:command_next_track(), self.ICONS.NEXT }) - end - table.insert(new_menu, { "Stop", self:command_stop(), self.ICONS.STOP }) - table.insert(new_menu, { "", nil }) - end - table.insert(new_menu, { "Clear playlist", self:command_clear_playlist() }) - self.recreate_playback = false - playback_menu = new_menu - end - return playback_menu -end - --- Returns the current playlist menu. Menu consists of all elements in the playlist. -function awesompd:menu_list() - if self.recreate_list then - local new_menu = {} - if self.list_array then - local total_count = table.getn(self.list_array) - local start_num = (self.current_number - 15 > 0) and self.current_number - 15 or 1 - local end_num = (self.current_number + 15 < total_count ) and self.current_number + 15 or total_count - for i = start_num, end_num do - table.insert(new_menu, { jamendo.replace_link(self.list_array[i]), - self:command_play_specific(i), - self.current_number == i and - (self.status == self.PLAYING and self.ICONS.PLAY or self.ICONS.PAUSE) - or nil} ) - end - end - self.recreate_list = false - self.list_menu = new_menu - end - return self.list_menu -end - --- Returns the playlists menu. Menu consists of all files in the playlist folder. -function awesompd:menu_playlists() - if self.recreate_playlists then - local new_menu = {} - if table.getn(self.playlists_array) > 0 then - for i = 1, table.getn(self.playlists_array) do - local submenu = {} - submenu[1] = { "Add to current", self:command_load_playlist(self.playlists_array[i]) } - submenu[2] = { "Replace current", self:command_replace_playlist(self.playlists_array[i]) } - new_menu[i] = { self.playlists_array[i], submenu } - end - table.insert(new_menu, {"", ""}) -- This is a separator - end - table.insert(new_menu, { "Refresh", function() self:check_playlists() end }) - self.recreate_playlists = false - self.playlists_menu = new_menu - end - return self.playlists_menu -end - --- Returns the server menu. Menu consists of all servers specified by user during initialization. -function awesompd:menu_servers() - if self.recreate_servers then - local new_menu = {} - for i = 1, table.getn(self.servers) do - table.insert(new_menu, {"Server: " .. self.servers[i].server .. - ", port: " .. self.servers[i].port, - function() self:change_server(i) end, - self:menu_item_radio(i == self.current_server)}) - end - self.servers_menu = new_menu - end - return self.servers_menu -end - --- Returns the options menu. Menu works like checkboxes for it's elements. -function awesompd:menu_options() - if self.recreate_options then - local new_menu = { { "Repeat", self:menu_toggle_repeat(), - self:menu_item_toggle(self.state_repeat == "on")}, - { "Random", self:menu_toggle_random(), - self:menu_item_toggle(self.state_random == "on")}, - { "Single", self:menu_toggle_single(), - self:menu_item_toggle(self.state_single == "on")}, - { "Consume", self:menu_toggle_consume(), - self:menu_item_toggle(self.state_consume == "on")} } - self.options_menu = new_menu - self.recreate_options = false - end - return self.options_menu -end - -function awesompd:menu_toggle_random() - return function() - self:command("random",self.update_track) - self:notify_state(self.NOTIFY_RANDOM) - end -end - -function awesompd:menu_toggle_repeat() - return function() - self:command("repeat",self.update_track) - self:notify_state(self.NOTIFY_REPEAT) - end -end - -function awesompd:menu_toggle_single() - return function() - self:command("single",self.update_track) - self:notify_state(self.NOTIFY_SINGLE) - end -end - -function awesompd:menu_toggle_consume() - return function() - self:command("consume",self.update_track) - self:notify_state(self.NOTIFY_CONSUME) - end -end - -function awesompd:menu_jamendo_top() - return - function () - local track_table = jamendo.return_track_table() - if not track_table then - self:add_hint("Can't connect to Jamendo server", "Please check your network connection") - else - self:add_jamendo_tracks(track_table) - self:add_hint("Jamendo Top 100 by " .. - jamendo.current_request_table.params.order.short_display, - format("Added %s tracks to the playlist", - table.getn(track_table))) - end - end -end - -function awesompd:menu_jamendo_format() - if self.recreate_jamendo_formats then - local setformat = - function(format) - return function() - jamendo.set_current_format(format) - self.recreate_menu = true - self.recreate_jamendo_formats = true - end - end - - local iscurr = - function(f) - return jamendo.current_request_table.params.streamencoding.value - == f.value - end - - local new_menu = {} - for _, format in pairs(jamendo.ALL_FORMATS) do - table.insert(new_menu, { format.display, setformat(format), - self:menu_item_radio(iscurr(format))}) - end - self.recreate_jamendo_formats = false - self.jamendo_formats_menu = { - "Format: " .. - jamendo.current_request_table.params.streamencoding.short_display, - new_menu } - end - return self.jamendo_formats_menu -end - -function awesompd:menu_jamendo_browse() - if self.recreate_jamendo_browse and self.browser - and self.current_track.unique_name then - local track = jamendo.get_track_by_link(self.current_track.unique_name) - local new_menu - if track then - local artist_link = - "http://www.jamendo.com/artist/" .. track.artist_link_name - local album_link = - "http://www.jamendo.com/album/" .. track.album_id - new_menu = { { "Artist's page" , - self:command_open_in_browser(artist_link) }, - { "Album's page" , - self:command_open_in_browser(album_link) } } - self.jamendo_browse_menu = { "Browse on Jamendo", new_menu } - else - self.jamendo_browse_menu = nil - end - end - return self.jamendo_browse_menu -end - -function awesompd:menu_jamendo_order() - if self.recreate_jamendo_order then - local setorder = - function(order) - return function() - jamendo.set_current_order(order) - self.recreate_menu = true - self.recreate_jamendo_order = true - end - end - - local iscurr = - function(o) - return jamendo.current_request_table.params.order.value - == o.value - end - - local new_menu = {} - for _, order in pairs(jamendo.ALL_ORDERS) do - table.insert(new_menu, { order.display, setorder(order), - self:menu_item_radio(iscurr(order))}) - end - self.recreate_jamendo_order = false - self.jamendo_order_menu = { - "Order: " .. - jamendo.current_request_table.params.order.short_display, - new_menu } - end - return self.jamendo_order_menu -end - -function awesompd:menu_jamendo_search_by(what) - return function() - local callback = - function(s) - local result = jamendo.search_by(what, s) - if result then - local track_count = table.getn(result.tracks) - self:add_jamendo_tracks(result.tracks) - self:add_hint(format("%s \"%s\" was found", - what.display, - result.search_res.name), - format("Added %s tracks to the playlist", - track_count)) - else - self:add_hint("Search failed", - format("%s \"%s\" was not found", - what.display, s)) - end - end - self:display_inputbox("Search music on Jamendo", - what.display, callback) - end -end - --- Checks if the current playlist has changed after the last check. -function awesompd:check_list() - local bus = io.popen(self:mpcquery() .. "playlist") - local info = bus:read("*all") - bus:close() - if info ~= self.list_line then - self.list_line = info - if string.len(info) > 0 then - self.list_array = self.split(string.sub(info,1,string.len(info))) - else - self.list_array = {} - end - self.recreate_menu = true - self.recreate_list = true - end -end - --- Checks if the collection of playlists changed after the last check. -function awesompd:check_playlists() - local bus = io.popen(self:mpcquery() .. "lsplaylists") - local info = bus:read("*all") - bus:close() - if info ~= self.playlists_line then - self.playlists_line = info - if string.len(info) > 0 then - self.playlists_array = self.split(info) - else - self.playlists_array = {} - end - self.recreate_menu = true - self.recreate_playlists = true - end -end - --- Changes the current server to the specified one. -function awesompd:change_server(server_number) - self.current_server = server_number - self:remove_hint() - self.recreate_menu = true - self.recreate_playback = true - self.recreate_list = true - self.recreate_playlists = true - self.recreate_servers = true - self:update_track() -end - -function awesompd:add_jamendo_tracks(track_table) - for i = 1,table.getn(track_table) do - self:command("add '" .. string.gsub(track_table[i].stream, '\\/', '/') .. "'") - end - self.recreate_menu = true - self.recreate_list = true -end - --- /// End of menu generation functions /// - -function awesompd:add_hint(hint_title, hint_text, hint_image) - self:remove_hint() - self.notification = naughty.notify({ title = hint_title - , text = awesompd.protect_string(hint_text) - , timeout = 5 - , position = "top_right" - , icon = hint_image - , icon_size = self.album_cover_size - }) -end - -function awesompd:remove_hint() - if self.notification ~= nil then - naughty.destroy(self.notification) - self.notification = nil - end -end - -function awesompd:notify_track() - if self:playing_or_paused() then - local caption = self.status_text - local nf_text = self.get_display_name(self.current_track) - local al_cover = nil - if self.show_album_cover then - nf_text = self.get_extended_info(self.current_track) - al_cover = self.current_track.album_cover - end - self:add_hint(caption, nf_text, al_cover) - end -end - -function awesompd:notify_state(state_changed) - state_array = { "Volume: " .. self.state_volume , - "Repeat: " .. self.state_repeat , - "Random: " .. self.state_random , - "Single: " .. self.state_single , - "Consume: " .. self.state_consume } - state_header = state_array[state_changed] - table.remove(state_array,state_changed) - full_state = state_array[1] - for i = 2, table.getn(state_array) do - full_state = full_state .. "\n" .. state_array[i] - end - self:add_hint(state_header, full_state) -end - -function awesompd:wrap_output(text) - return format('%s%s%s', - self.font, self.ldecorator, - awesompd.protect_string(text), self.rdecorator) -end - -function awesompd:mpcquery() - return "mpc -h " .. self.servers[self.current_server].server .. - " -p " .. self.servers[self.current_server].port .. " " -end - --- This function actually sets the text on the widget. -function awesompd:set_text(text) - self.widget.text = self:wrap_output(text) -end - -function awesompd.find_pattern(text, pattern, start) - return utf8sub(text, string.find(text, pattern, start)) -end - --- Scroll the given text by the current number of symbols. -function awesompd:scroll_text(text) - local result = text - if self.scrolling then - if self.output_size < utf8len(text) then - text = text .. " - " - if self.scroll_pos + self.output_size - 1 > utf8len(text) then - result = utf8sub(text, self.scroll_pos) - result = result .. utf8sub(text, 1, self.scroll_pos + self.output_size - 1 - utf8len(text)) - self.scroll_pos = self.scroll_pos + 1 - if self.scroll_pos > utf8len(text) then - self.scroll_pos = 1 - end - else - result = utf8sub(text, self.scroll_pos, self.scroll_pos + self.output_size - 1) - self.scroll_pos = self.scroll_pos + 1 - end - end - else - if self.output_size < utf8len(text) then - result = utf8sub(text, 1, self.output_size) - end - end - return result -end - --- This function is called every second. -function awesompd:update_widget() - self:set_text(self:scroll_text(self.text)) - self:check_notify() -end - --- This function is called by update_track each time content of --- the widget must be changed. -function awesompd:update_widget_text() - if self:playing_or_paused() then - self.text = self.get_display_name(self.current_track) - else - self.text = self.status - end -end - --- Checks if notification should be shown and shows if positive. -function awesompd:check_notify() - if self.to_notify then - self:notify_track() - self.to_notify = false - end -end - -function awesompd:notify_connect() - self:add_hint("Connected", "Connection established to " .. self.servers[self.current_server].server .. - " on port " .. self.servers[self.current_server].port) -end - -function awesompd:notify_disconnect() - self:add_hint("Disconnected", "Cannot connect to " .. self.servers[self.current_server].server .. - " on port " .. self.servers[self.current_server].port) -end - -function awesompd:update_track(file) - local file_exists = (file ~= nil) - if not file_exists then - file = io.popen(self:mpcquery()) - end - local track_line = file:read("*line") - local status_line = file:read("*line") - local options_line = file:read("*line") - if not file_exists then - file:close() - end - - if not track_line or string.len(track_line) == 0 then - if self.status ~= awesompd.DISCONNECTED then - self:notify_disconnect() - self.recreate_menu = true - self.status = awesompd.DISCONNECTED - self.current_track = { } - self:update_widget_text() - end - else - if self.status == awesompd.DISCONNECTED then - self:notify_connect() - self.recreate_menu = true - self:update_widget_text() - end - if string.find(track_line,"volume:") or string.find(track_line,"Updating DB") then - if self.status ~= awesompd.STOPPED then - self.status = awesompd.STOPPED - self.current_number = 0 - self.recreate_menu = true - self.recreate_playback = true - self.recreate_list = true - self.album_cover = nil - self.current_track = { } - self:update_widget_text() - end - self:update_state(track_line) - else - self:update_state(options_line) - local _, _, new_file, new_album = - string.find(self:command_read('current -f "%file%-<>-%album%"', "*line"), "(.+)%-<>%-(.*)") - if new_file ~= self.current_track.unique_name then - self.current_track = jamendo.get_track_by_link(new_file) - if not self.current_track then - self.current_track = { display_name = track_line, - album_name = new_album } - end - self.current_track.unique_name = new_file - if self.show_album_cover then - self.current_track.album_cover = self:get_cover(new_file) - end - self.to_notify = true - self.recreate_menu = true - self.recreate_playback = true - self.recreate_list = true - self.current_number = tonumber(self.find_pattern(status_line,"%d+")) - self:update_widget_text() - - -- If the track is not the last, asynchronously download - -- the cover for the next track. - if self.list_array and self.current_number ~= table.getn(self.list_array) then - -- Get the link (in case it is Jamendo stream) to the next track - local next_track = - self:command_read('playlist -f "%file%" | head -' .. - self.current_number + 1 .. ' | tail -1', "*line") - jamendo.try_get_cover_async(next_track) - end - end - local tmp_pst = string.find(status_line,"%d+%:%d+%/") - local progress = self.find_pattern(status_line,"%#%d+/%d+") .. " " .. string.sub(status_line,tmp_pst) - local new_status = awesompd.PLAYING - if string.find(status_line,"paused") then - new_status = awesompd.PAUSED - end - if new_status ~= self.status then - self.to_notify = true - self.recreate_list = true - self.status = new_status - self:update_widget_text() - end - self.status_text = self.status .. " " .. progress - end - end -end - -function awesompd:update_state(state_string) - self.state_volume = self.find_pattern(state_string,"%d+%% ") - if string.find(state_string,"repeat: on") then - self.state_repeat = self:check_set_state(self.state_repeat, "on") - else - self.state_repeat = self:check_set_state(self.state_repeat, "off") - end - if string.find(state_string,"random: on") then - self.state_random = self:check_set_state(self.state_random, "on") - else - self.state_random = self:check_set_state(self.state_random, "off") - end - if string.find(state_string,"single: on") then - self.state_single = self:check_set_state(self.state_single, "on") - else - self.state_single = self:check_set_state(self.state_single, "off") - end - if string.find(state_string,"consume: on") then - self.state_consume = self:check_set_state(self.state_consume, "on") - else - self.state_consume = self:check_set_state(self.state_consume, "off") - end -end - -function awesompd:check_set_state(statevar, val) - if statevar ~= val then - self.recreate_menu = true - self.recreate_options = true - end - return val -end - -function awesompd:run_prompt(welcome,hook) - awful.prompt.run({ prompt = welcome }, - self.promptbox[mouse.screen].widget, - hook) -end - --- Replaces control characters with escaped ones. --- for_menu - defines if the special escable table for menus should be --- used. -function awesompd.protect_string(str, for_menu) - if for_menu then - return utf8replace(str, awesompd.ESCAPE_MENU_SYMBOL_MAPPING) - else - return utf8replace(str, awesompd.ESCAPE_SYMBOL_MAPPING) - end -end - --- Displays an inputbox on the screen (looks like naughty with prompt). --- title_text - bold text on the first line --- prompt_text - preceding text on the second line --- hook - function that will be called with input data --- Use it like this: --- self:display_inputbox("Search music on Jamendo", "Artist", print) -function awesompd:display_inputbox(title_text, prompt_text, hook) - if self.inputbox then -- Inputbox already exists, replace it - keygrabber.stop() - self.inputbox.screen = nil - self.inputbox = nil - end - local width = 200 - local height = 30 - local border_color = beautiful.bg_focus or '#535d6c' - local margin = 5 - local wbox = wibox({ name = "awmpd_ibox", height = height , width = width, - border_color = border_color, border_width = 1 }) - self.inputbox = wbox - local ws = screen[mouse.screen].workarea - - wbox:geometry({ x = ws.width - width - 5, y = 25 }) - wbox.screen = mouse.screen - wbox.ontop = true - - local exe_callback = function(s) - hook(s) - wbox.screen = nil - self.inputbox = nil - end - local done_callback = function() - wbox.screen = nil - self.inputbox = nil - end - local wprompt = awful.widget.prompt({ layout = awful.widget.layout.horizontal.leftright }) - local wtbox = widget({ type = "textbox" }) - wtbox:margin({ right = margin, left = margin, bottom = margin, top = margin }) - wtbox.text = "" .. title_text .. "" - wbox.widgets = { wtbox, wprompt, layout = awful.widget.layout.vertical.flex } - awful.prompt.run( { prompt = " " .. prompt_text .. ": " }, wprompt.widget, - exe_callback, nil, nil, nil, done_callback) -end - --- Gets the cover for the given track. First looks in the Jamendo --- cache. If the track is not a Jamendo stream, looks in local --- folders. If there is no cover art either returns the default album --- cover. -function awesompd:get_cover(track) - return jamendo.try_get_cover(track) or - self:try_get_local_cover() or self.ICONS.DEFAULT_ALBUM_COVER -end - --- Tries to find an album cover for the track that is currently --- playing. -function awesompd:try_get_local_cover() - if self.mpd_config then - local result - -- First find the music directory in MPD configuration file - local _, _, music_folder = string.find( - self.pread('cat ' .. self.mpd_config .. ' | grep -v "#" | grep music_directory', "*line"), - 'music_directory%s+"(.+)"') - music_folder = music_folder .. "/" - - -- If the music_folder is specified with ~ at the beginning, - -- replace it with user home directory - if string.sub(music_folder, 1, 1) == "~" then - local user_folder = self.pread("echo ~", "*line") - music_folder = user_folder .. string.sub(music_folder, 2) - end - - -- Get the path to the file currently playing. - local current_file = self:command_read('current -f "%file%"') - local _, _, current_file_folder = string.find(current_file, '(.+%/).*') - - -- Check if the current file is not some kind of http stream or - -- Spotify track (like spotify:track:5r65GeuIoebfJB5sLcuPoC) - if not current_file_folder or string.match(current_file, "%w+://") then - return -- Let the default image to be the cover - end - - local folder = music_folder .. current_file_folder - - -- Get all images in the folder. Also escape occasional single - -- quotes in folder name. - local request = format("ls '%s' | grep -P '\.jpg\|\.png\|\.gif|\.jpeg'", - string.gsub(folder, "'", "'\\''")) - - local covers = self.pread(request, "*all") - local covers_table = self.split(covers) - - if covers_table.n > 0 then - result = folder .. covers_table[1] - if covers_table.n > 1 then - -- Searching for front cover with grep because Lua regular - -- expressions suck:[ - local front_cover = - self.pread('echo "' .. covers .. - '" | grep -i "cover\|front\|folder\|albumart" | head -n 1', "*line") - if front_cover then - result = folder .. front_cover - end - end - end - return result - end -end - --- /// Deprecated, left for some backward compatibility in --- configuration /// - -function awesompd:command_toggle() - return self:command_playpause() -end diff --git a/awesompd/icons/check_icon.png b/awesompd/icons/check_icon.png deleted file mode 100644 index dc5cba1..0000000 Binary files a/awesompd/icons/check_icon.png and /dev/null differ diff --git a/awesompd/icons/default_album_cover.png b/awesompd/icons/default_album_cover.png deleted file mode 100644 index b952ba4..0000000 Binary files a/awesompd/icons/default_album_cover.png and /dev/null differ diff --git a/awesompd/icons/next_icon.png b/awesompd/icons/next_icon.png deleted file mode 100644 index 918ff89..0000000 Binary files a/awesompd/icons/next_icon.png and /dev/null differ diff --git a/awesompd/icons/pause_icon.png b/awesompd/icons/pause_icon.png deleted file mode 100644 index 83a92ee..0000000 Binary files a/awesompd/icons/pause_icon.png and /dev/null differ diff --git a/awesompd/icons/play_icon.png b/awesompd/icons/play_icon.png deleted file mode 100644 index 83230d1..0000000 Binary files a/awesompd/icons/play_icon.png and /dev/null differ diff --git a/awesompd/icons/play_pause_icon.png b/awesompd/icons/play_pause_icon.png deleted file mode 100644 index e54beb6..0000000 Binary files a/awesompd/icons/play_pause_icon.png and /dev/null differ diff --git a/awesompd/icons/prev_icon.png b/awesompd/icons/prev_icon.png deleted file mode 100644 index 8e16381..0000000 Binary files a/awesompd/icons/prev_icon.png and /dev/null differ diff --git a/awesompd/icons/radio_icon.png b/awesompd/icons/radio_icon.png deleted file mode 100644 index ffdf065..0000000 Binary files a/awesompd/icons/radio_icon.png and /dev/null differ diff --git a/awesompd/icons/stop_icon.png b/awesompd/icons/stop_icon.png deleted file mode 100644 index 6bef770..0000000 Binary files a/awesompd/icons/stop_icon.png and /dev/null differ diff --git a/awesompd/jamendo.lua b/awesompd/jamendo.lua deleted file mode 100644 index 9fa0428..0000000 --- a/awesompd/jamendo.lua +++ /dev/null @@ -1,524 +0,0 @@ ---------------------------------------------------------------------------- --- @author Alexander Yakushev --- @copyright 2011 Alexander Yakushev --- @release v1.1.5 ---------------------------------------------------------------------------- - --- Grab environment -local os = os -local awful = awful -local string = string -local table = table -local io = io -local pairs = pairs -local type = type -local assert = assert -local print = print -local tonumber = tonumber -local math = math -local tostring = tostring -local asyncshell = asyncshell - -module('jamendo') - --- UTILITY STUFF --- Checks whether file specified by filename exists. -local function file_exists(filename, mode) - mode = mode or 'r' - f = io.open(filename, mode) - if f then - f:close() - return true - else - return false - end -end - --- Global variables -FORMAT_MP3 = { display = "MP3 (128k)", - short_display = "MP3", - value = "mp31" } -FORMAT_OGG = { display = "Ogg Vorbis (q4)", - short_display = "Ogg", - value = "ogg2" } -ORDER_RATINGDAILY = { display = "Daily rating", - short_display = "daily rating", - value = "ratingday_desc" } -ORDER_RATINGWEEKLY = { display = "Weekly rating", - short_display = "weekly rating", - value = "ratingweek_desc" } -ORDER_RATINGTOTAL = { display = "All time rating", - short_display = "all time rating", - value = "ratingtotal_desc" } -ORDER_RANDOM = { display = "Random", - short_display = "random", - value = "random_desc" } -ORDER_RELEVANCE = { display = "None (consecutive)", - short_display = "none", - value = "searchweight_desc" } -SEARCH_ARTIST = { display = "Artist", - unit = "artist", - value = "artist_id" } -SEARCH_ALBUM = { display = "Album", - unit = "album", - value = "album_id" } -SEARCH_TAG = { display = "Tag", - unit = "tag", - value = "tag_id" } -ALL_FORMATS = { FORMAT_MP3, FORMAT_OGG } -ALL_ORDERS = { ORDER_RELEVANCE, ORDER_RANDOM, ORDER_RATINGDAILY, - ORDER_RATINGWEEKLY, ORDER_RATINGTOTAL } - -current_request_table = { unit = "track", - fields = {"id", "artist_url", "artist_name", "name", - "stream", "album_image", "album_name" }, - joins = { "track_album", "album_artist" }, - params = { streamencoding = FORMAT_MP3, - order = ORDER_RATINGWEEKLY, - n = 100 }} - --- Local variables -local jamendo_list = {} -local cache_file = awful.util.getdir ("cache").."/jamendo_cache" -local cache_header = "[version=1.1.0]" -local album_covers_folder = awful.util.getdir("cache") .. "/jamendo_covers/" -local default_mp3_stream = nil -local search_template = { fields = { "id", "name" }, - joins = {}, - params = { order = ORDER_RELEVANCE, - n = 1}} - --- DEPRECATED. Will be removed in the next major release. --- Returns default stream number for MP3 format. Requests API for it --- not more often than every hour. -local function get_default_mp3_stream() - if not default_mp3_stream or - (os.time() - default_mp3_stream.last_checked) > 3600 then - local trygetlink = - perform_request("echo $(curl -w %{redirect_url} " .. - "'http://api.jamendo.com/get2/stream/track/redirect/" .. - "?streamencoding="..FORMAT_MP3.value.."&id=729304')") - local _, _, prefix = string.find(trygetlink,"stream(%d+)\.jamendo\.com") - default_mp3_stream = { id = prefix, last_checked = os.time() } - end - return default_mp3_stream.id -end - --- Returns the track ID from the given link to Jamendo stream. If the --- given text is not the Jamendo stream returns nil. -function get_id_from_link(link) - local _, _, id = string.find(link,"storage%-new.newjamendo.com%?trackid=(%d+)") - return id -end - --- Returns link to music stream for the given track ID. Uses MP3 --- format and the default stream for it. -local function get_link_by_id(id) - -- This function is subject to change in the future. - return string.format("http://storage-new.newjamendo.com?trackid=%s&format=mp31&u=0", id) -end - --- -- Returns the album id for given music stream. --- function get_album_id_by_link(link) --- local id = get_id_from_link(link, true) --- if id and jamendo_list[id] then --- return jamendo_list[id].album_id --- end --- end - --- Returns the track table for the given music stream. -function get_track_by_link(link) - local id = get_id_from_link(link, true) - if id and jamendo_list[id] then - return jamendo_list[id] - end -end - --- If a track is actually a Jamendo stream, replace it with normal --- track name. -function replace_link(track_name) - local track = get_track_by_link(track_name) - if track then - return track.display_name - else - return track_name - end -end - --- Returns table of track IDs, names and other things based on the --- request table. -function return_track_table(request_table) - local req_string = form_request(request_table) - local response = perform_request(req_string) - if not response then - return nil -- Bad internet connection - end - parse_table = parse_json(response) - for i = 1, table.getn(parse_table) do - if parse_table[i].stream == "" then - -- Some songs don't have Ogg stream, use MP3 instead - parse_table[i].stream = get_link_by_id(parse_table[i].id) - end - _, _, parse_table[i].artist_link_name = - string.find(parse_table[i].artist_url, "\\/artist\\/(.+)") - -- Remove Jamendo escape slashes - parse_table[i].artist_name = - string.gsub(parse_table[i].artist_name, "\\/", "/") - parse_table[i].name = string.gsub(parse_table[i].name, "\\/", "/") - - parse_table[i].display_name = - parse_table[i].artist_name .. " - " .. parse_table[i].name - -- Do Jamendo a favor, extract album_id for the track yourself - -- from album_image link :) - local _, _, album_id = - string.find(parse_table[i].album_image, "\\/(%d+)\\/covers") - parse_table[i].album_id = album_id or 0 - -- Save fetched tracks for further caching - jamendo_list[parse_table[i].id] = parse_table[i] - end - save_cache() - return parse_table -end - --- Generates the request to Jamendo API based on provided request --- table. If request_table is nil, uses current_request_table instead. --- For all values that do not exist in request_table use ones from --- current_request_table. --- return - HTTP-request -function form_request(request_table) - local curl_str = "curl -A 'Mozilla/4.0' -fsm 5 \"%s\"" - local url = "http://api.jamendo.com/en/?m=get2%s%s" - request_table = request_table or current_request_table - - local fields = request_table.fields or current_request_table.fields - local joins = request_table.joins or current_request_table.joins - local unit = request_table.unit or current_request_table.unit - - -- Form field&joins string (like field1+field2+fieldN%2Fjoin+) - local fnj_string = "&m_params=" - for i = 1, table.getn(fields) do - fnj_string = fnj_string .. fields[i] .. "+" - end - fnj_string = string.sub(fnj_string,1,string.len(fnj_string)-1) - - fnj_string = fnj_string .. "%2F" .. unit .. "%2Fjson%2F" - for i = 1, table.getn(joins) do - fnj_string = fnj_string .. joins[i] .. "+" - end - fnj_string = fnj_string .. "%2F" - - local params = {} - -- If parameters where supplied in request_table, add them to the - -- parameters in current_request_table. - if request_table.params and - request_table.params ~= current_request_table.params then - -- First fill params with current_request_table parameters - for k, v in pairs(current_request_table.params) do - params[k] = v - end - -- Then add and overwrite them with request_table parameters - for k, v in pairs(request_table.params) do - params[k] = v - end - else -- Or just use current_request_table.params - params = current_request_table.params - end - -- Form parameter string (like param1=value1¶m2=value2) - local param_string = "" - for k, v in pairs(params) do - if type(v) == "table" then - v = v.value - end - v = string.gsub(v, " ", "+") - param_string = param_string .. "&" .. k .. "=" .. v - end - - return string.format(curl_str, string.format(url, fnj_string, param_string)) -end - --- Primitive function for parsing Jamendo API JSON response. Does not --- support arrays. Supports only strings and numbers as values. --- Provides basic safety (correctly handles special symbols like comma --- and curly brackets inside strings) --- text - JSON text -function parse_json(text) - local parse_table = {} - local block = {} - local i = 0 - local inblock = false - local instring = false - local curr_key = nil - local curr_val = nil - while i and i < string.len(text) do - if not inblock then -- We are not inside the block, find next { - i = string.find(text, "{", i+1) - inblock = true - block = {} - else - if not curr_key then -- We haven't found key yet - if not instring then -- We are not in string, check for more tags - local j = string.find(text, '"', i+1) - local k = string.find(text, '}', i+1) - if j and j < k then -- There are more tags in this block - i = j - instring = true - else -- Block is over, we found its ending - i = k - inblock = false - table.insert(parse_table, block) - end - else -- We are in string, find its ending - _, i, curr_key = string.find(text,'(.-[^%\\])"', i+1) - instring = false - end - else -- We have the key, let's find the value - if not curr_val then -- Value is not found yet - if not instring then -- Not in string, check if value is string - local j = string.find(text, '"', i+1) - local k = string.find(text, '[,}]', i+1) - if j and j < k then -- Value is string - i = j - instring = true - else -- Value is int - _, i, curr_val = string.find(text,'(%d+)', i+1) - end - else -- We are in string, find its ending - local j = string.find(text, '"', i+1) - if j == i+1 then -- String is empty - i = j - curr_val = "" - else - _, i, curr_val = string.find(text,'(.-[^%\\])"', i+1) - curr_val = utf8_codes_to_symbols(curr_val) - end - instring = false - end - else -- We have both key and value, add it to table - block[curr_key] = curr_val - curr_key = nil - curr_val = nil - end - end - end - end - return parse_table -end - --- Jamendo returns Unicode symbols as \uXXXX. Lua does not transform --- them into symbols so we need to do it ourselves. -function utf8_codes_to_symbols (s) - local hexnums = "[%dabcdefABCDEF]" - local pattern = string.format("\\u(%s%s%s%s?)", - hexnums, hexnums, hexnums, hexnums) - local decode = function(code) - code = tonumber(code, 16) - if code < 128 then -- one-byte symbol - return string.char(code) - elseif code < 2048 then -- two-byte symbol - -- Grab high and low bytes - local hi = math.floor(code / 64) - local lo = math.mod(code, 64) - -- Return symbol as \hi\lo - return string.char(hi + 192, lo + 128) - elseif code < 65536 then - -- Grab high, middle and low bytes - local hi = math.floor(code / 4096) - local leftover = code - hi * 4096 - local mi = math.floor(leftover / 64) - leftover = leftover - mi * 64 - local lo = math.mod(leftover, 64) - -- Return symbol as \hi\mi\lo - return string.char(hi + 224, mi + 160, lo + 128) - elseif code < 1114112 then - -- Grab high, highmiddle, lowmiddle and low bytes - local hi = math.floor(code / 262144) - local leftover = code - hi * 262144 - local hm = math.floor(leftover / 4096) - leftover = leftover - hm * 4096 - local lm = math.floor(leftover / 64) - local lo = math.mod(leftover, 64) - -- Return symbol as \hi\hm\lm\lo - return string.char(hi + 240, hm + 128, lm + 128, lo + 128) - else -- It is not Unicode symbol at all - return tostring(code) - end - end - return string.gsub(s, pattern, decode) -end - --- Retrieves mapping of track IDs to track names and album IDs to --- avoid redundant queries when Awesome gets restarted. -local function retrieve_cache() - local bus = io.open(cache_file) - local track = {} - if bus then - local header = bus:read("*line") - if header == cache_header then - for l in bus:lines() do - local _, _, id, artist_link_name, album_name, album_id, track_name = - string.find(l,"(%d+)-([^-]+)-([^-]+)-(%d+)-(.+)") - track = {} - track.id = id - track.artist_link_name = string.gsub(artist_link_name, '\\_', '-') - track.album_name = string.gsub(album_name, '\\_', '-') - track.album_id = album_id - track.display_name = track_name - jamendo_list[id] = track - end - else - -- We encountered an outdated version of the cache - -- file. Let's just remove it. - awful.util.spawn("rm -f " .. cache_file) - end - end -end - --- Saves track IDs to track names and album IDs mapping into the cache --- file. -function save_cache() - local bus = io.open(cache_file, "w") - bus:write(cache_header .. "\n") - for id,track in pairs(jamendo_list) do - bus:write(string.format("%s-%s-%s-%s-%s\n", id, - string.gsub(track.artist_link_name, '-', '\\_'), - string.gsub(track.album_name, '-', '\\_'), - track.album_id, track.display_name)) - end - bus:flush() - bus:close() -end - --- Retrieve cache on initialization -retrieve_cache() - --- Returns a filename of the album cover and formed wget request that --- downloads the album cover for the given track name. If the album --- cover already exists returns nil as the second argument. -function fetch_album_cover_request(track_id) - local track = jamendo_list[track_id] - local album_id = track.album_id - - if album_id == 0 then -- No cover for tracks without album! - return nil - end - local file_path = album_covers_folder .. album_id .. ".jpg" - - if not file_exists(file_path) then -- We need to download it - -- First check if cache directory exists - f = io.popen('test -d ' .. album_covers_folder .. ' && echo t') - if f:read("*line") ~= 't' then - awful.util.spawn("mkdir " .. album_covers_folder) - end - f:close() - - if not track.album_image then -- Wow! We have album_id, but - local a_id = tostring(album_id) --don't have album_image. Well, - local prefix = --it happens. - string.sub(a_id, 1, string.len(a_id) - 3) - track.album_image = - string.format("http://imgjam.com/albums/s%s/%s/covers/1.100.jpg", - prefix == "" and 0 or prefix, a_id) - end - - return file_path, string.format("wget %s -O %s 2> /dev/null", - track.album_image, file_path) - else -- Cover already downloaded, return its filename and nil - return file_path, nil - end -end - --- Returns a file containing an album cover for given track id. First --- searches in the cache folder. If file is not there, fetches it from --- the Internet and saves into the cache folder. -function get_album_cover(track_id) - local file_path, fetch_req = fetch_album_cover_request(track_id) - if fetch_req then - local f = io.popen(fetch_req) - f:close() - - -- Let's check if file is finally there, just in case - if not file_exists(file_path) then - return nil - end - end - return file_path -end - --- Same as get_album_cover, but downloads (if necessary) the cover --- asynchronously. -function get_album_cover_async(track_id) - local file_path, fetch_req = fetch_album_cover_request(track_id) - if fetch_req then - asyncshell.request(fetch_req) - end -end - --- Checks if track_name is actually a link to Jamendo stream. If true --- returns the file with album cover for the track. -function try_get_cover(track_name) - local id = get_id_from_link(track_name) - if id then - return get_album_cover(id) - end -end - --- Same as try_get_cover, but calls get_album_cover_async inside. -function try_get_cover_async(track_name) - local id = get_id_from_link(track_name) - if id then - return get_album_cover_async(id) - end -end - --- Returns the track table for given query and search method. --- what - search method - SEARCH_ARTIST, ALBUM or TAG --- s - string to search -function search_by(what, s) - -- Get a default request and set unit and query - local req = search_template - req.unit = what.unit - req.params.searchquery = s - local resp = perform_request(form_request(req)) - if resp then - local search_res = parse_json(resp)[1] - - if search_res then - -- Now when we got the search result, find tracks filtered by - -- this result. - local params = {} - params[what.value] = search_res.id - req = { params = params } - local track_table = return_track_table(req) - return { search_res = search_res, tracks = track_table } - end - end -end - --- Executes request_string with io.popen and returns the response. -function perform_request(reqest_string) - local bus = assert(io.popen(reqest_string,'r')) - local response = bus:read("*all") - bus:close() - -- Curl with popen can sometimes fail to fetch data when the - -- connection is slow. Let's try again if it fails. - if string.len(response) == 0 then - bus = assert(io.popen(reqest_string,'r')) - response = bus:read("*all") - bus:close() - -- If it still can't read anything, return nil - if string.len(response) ~= 0 then - return nil - end - end - return response -end - --- Sets default streamencoding in current_request_table. -function set_current_format(format) - current_request_table.params.streamencoding = format -end - --- Sets default order in current_request_table. -function set_current_order(order) - current_request_table.params.order = order -end diff --git a/awesompd/rcsample.lua b/awesompd/rcsample.lua deleted file mode 100644 index c5e0364..0000000 --- a/awesompd/rcsample.lua +++ /dev/null @@ -1,407 +0,0 @@ --- Standard awesome library -require("awful") -require("awful.autofocus") -require("awful.rules") --- Theme handling library -require("beautiful") --- Notification library -require("naughty") - --- Load Debian menu entries -require("debian.menu") - --- {{{ Variable definitions --- Themes define colours, icons, and wallpapers -beautiful.init("/usr/share/awesome/themes/default/theme.lua") - --- This is used later as the default terminal and editor to run. -terminal = "x-terminal-emulator" -editor = os.getenv("EDITOR") or "editor" -editor_cmd = terminal .. " -e " .. editor - --- Default modkey. --- Usually, Mod4 is the key with a logo between Control and Alt. --- If you do not like this or do not have such a key, --- I suggest you to remap Mod4 to another key using xmodmap or other tools. --- However, you can use another modifier like Mod1, but it may interact with others. -modkey = "Mod4" - --- Table of layouts to cover with awful.layout.inc, order matters. -layouts = -{ - awful.layout.suit.floating, - awful.layout.suit.tile, - awful.layout.suit.tile.left, - awful.layout.suit.tile.bottom, - awful.layout.suit.tile.top, - awful.layout.suit.fair, - awful.layout.suit.fair.horizontal, - awful.layout.suit.spiral, - awful.layout.suit.spiral.dwindle, - awful.layout.suit.max, - awful.layout.suit.max.fullscreen, - awful.layout.suit.magnifier -} --- }}} - --- {{{ Tags --- Define a tag table which hold all screen tags. -tags = {} -for s = 1, screen.count() do - -- Each screen has its own tag table. - tags[s] = awful.tag({ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s, layouts[1]) -end --- }}} - --- {{{ Menu --- Create a laucher widget and a main menu -myawesomemenu = { - { "manual", terminal .. " -e man awesome" }, - { "edit config", editor_cmd .. " " .. awful.util.getdir("config") .. "/rc.lua" }, - { "restart", awesome.restart }, - { "quit", awesome.quit } -} - -mymainmenu = awful.menu({ items = { { "awesome", myawesomemenu, beautiful.awesome_icon }, - { "Debian", debian.menu.Debian_menu.Debian }, - { "open terminal", terminal } - } - }) - -mylauncher = awful.widget.launcher({ image = image(beautiful.awesome_icon), - menu = mymainmenu }) --- }}} - --- {{{ Wibox --- Create a textclock widget -mytextclock = awful.widget.textclock({ align = "right" }) - --- Create a systray -mysystray = widget({ type = "systray" }) - --- BEGIN OF AWESOMPD WIDGET DECLARATION - - require('awesompd/awesompd') - - musicwidget = awesompd:create() -- Create awesompd widget - musicwidget.font = "Liberation Mono" -- Set widget font - musicwidget.scrolling = true -- If true, the text in the widget will be scrolled - musicwidget.output_size = 30 -- Set the size of widget in symbols - musicwidget.update_interval = 10 -- Set the update interval in seconds - - -- Set the folder where icons are located (change username to your login name) - musicwidget.path_to_icons = "/home/username/.config/awesome/icons" - - -- Set the default music format for Jamendo streams. You can change - -- this option on the fly in awesompd itself. - -- possible formats: awesompd.FORMAT_MP3, awesompd.FORMAT_OGG - musicwidget.jamendo_format = awesompd.FORMAT_MP3 - - -- Specify the browser you use so awesompd can open links from - -- Jamendo in it. - musicwidget.browser = "firefox" - - -- If true, song notifications for Jamendo tracks and local tracks - -- will also contain album cover image. - musicwidget.show_album_cover = true - - -- Specify how big in pixels should an album cover be. Maximum value - -- is 100. - musicwidget.album_cover_size = 50 - - -- This option is necessary if you want the album covers to be shown - -- for your local tracks. - musicwidget.mpd_config = "/home/username/.mpdconf" - - -- Specify decorators on the left and the right side of the - -- widget. Or just leave empty strings if you decorate the widget - -- from outside. - musicwidget.ldecorator = " " - musicwidget.rdecorator = " " - - -- Set all the servers to work with (here can be any servers you use) - musicwidget.servers = { - { server = "localhost", - port = 6600 }, - { server = "192.168.0.72", - port = 6600 } - } - - -- Set the buttons of the widget. Keyboard keys are working in the - -- entire Awesome environment. Also look at the line 352. - musicwidget:register_buttons({ { "", awesompd.MOUSE_LEFT, musicwidget:command_playpause() }, - { "Control", awesompd.MOUSE_SCROLL_UP, musicwidget:command_prev_track() }, - { "Control", awesompd.MOUSE_SCROLL_DOWN, musicwidget:command_next_track() }, - { "", awesompd.MOUSE_SCROLL_UP, musicwidget:command_volume_up() }, - { "", awesompd.MOUSE_SCROLL_DOWN, musicwidget:command_volume_down() }, - { "", awesompd.MOUSE_RIGHT, musicwidget:command_show_menu() }, - { "", "XF86AudioLowerVolume", musicwidget:command_volume_down() }, - { "", "XF86AudioRaiseVolume", musicwidget:command_volume_up() }, - { modkey, "Pause", musicwidget:command_playpause() } }) - - musicwidget:run() -- After all configuration is done, run the widget - --- END OF AWESOMPD WIDGET DECLARATION --- Don't forget to add the widget to the wibox. It is done on the line 216. - -mywibox = {} -mypromptbox = {} -mylayoutbox = {} -mytaglist = {} -mytaglist.buttons = awful.util.table.join( - awful.button({ }, 1, awful.tag.viewonly), - awful.button({ modkey }, 1, awful.client.movetotag), - awful.button({ }, 3, awful.tag.viewtoggle), - awful.button({ modkey }, 3, awful.client.toggletag), - awful.button({ }, 4, awful.tag.viewnext), - awful.button({ }, 5, awful.tag.viewprev) - ) -mytasklist = {} -mytasklist.buttons = awful.util.table.join( - awful.button({ }, 1, function (c) - if not c:isvisible() then - awful.tag.viewonly(c:tags()[1]) - end - client.focus = c - c:raise() - end), - awful.button({ }, 3, function () - if instance then - instance:hide() - instance = nil - else - instance = awful.menu.clients({ width=250 }) - end - end), - awful.button({ }, 4, function () - awful.client.focus.byidx(1) - if client.focus then client.focus:raise() end - end), - awful.button({ }, 5, function () - awful.client.focus.byidx(-1) - if client.focus then client.focus:raise() end - end)) - -for s = 1, screen.count() do - -- Create a promptbox for each screen - mypromptbox[s] = awful.widget.prompt({ layout = awful.widget.layout.horizontal.leftright }) - -- Create an imagebox widget which will contains an icon indicating which layout we're using. - -- We need one layoutbox per screen. - mylayoutbox[s] = awful.widget.layoutbox(s) - mylayoutbox[s]:buttons(awful.util.table.join( - awful.button({ }, 1, function () awful.layout.inc(layouts, 1) end), - awful.button({ }, 3, function () awful.layout.inc(layouts, -1) end), - awful.button({ }, 4, function () awful.layout.inc(layouts, 1) end), - awful.button({ }, 5, function () awful.layout.inc(layouts, -1) end))) - -- Create a taglist widget - mytaglist[s] = awful.widget.taglist(s, awful.widget.taglist.label.all, mytaglist.buttons) - - -- Create a tasklist widget - mytasklist[s] = awful.widget.tasklist(function(c) - return awful.widget.tasklist.label.currenttags(c, s) - end, mytasklist.buttons) - - -- Create the wibox - mywibox[s] = awful.wibox({ position = "top", screen = s }) - -- Add widgets to the wibox - order matters - mywibox[s].widgets = { - { - mylauncher, - mytaglist[s], - mypromptbox[s], - layout = awful.widget.layout.horizontal.leftright - }, - mylayoutbox[s], - mytextclock, - musicwidget.widget, -- Awesompd widget is added like this - s == 1 and mysystray or nil, - mytasklist[s], - layout = awful.widget.layout.horizontal.rightleft - } -end --- }}} - --- {{{ Mouse bindings -root.buttons(awful.util.table.join( - awful.button({ }, 3, function () mymainmenu:toggle() end), - awful.button({ }, 4, awful.tag.viewnext), - awful.button({ }, 5, awful.tag.viewprev) -)) --- }}} - --- {{{ Key bindings -globalkeys = awful.util.table.join( - awful.key({ modkey, }, "Left", awful.tag.viewprev ), - awful.key({ modkey, }, "Right", awful.tag.viewnext ), - awful.key({ modkey, }, "Escape", awful.tag.history.restore), - - awful.key({ modkey, }, "j", - function () - awful.client.focus.byidx( 1) - if client.focus then client.focus:raise() end - end), - awful.key({ modkey, }, "k", - function () - awful.client.focus.byidx(-1) - if client.focus then client.focus:raise() end - end), - awful.key({ modkey, }, "w", function () mymainmenu:show({keygrabber=true}) end), - - -- Layout manipulation - awful.key({ modkey, "Shift" }, "j", function () awful.client.swap.byidx( 1) end), - awful.key({ modkey, "Shift" }, "k", function () awful.client.swap.byidx( -1) end), - awful.key({ modkey, "Control" }, "j", function () awful.screen.focus_relative( 1) end), - awful.key({ modkey, "Control" }, "k", function () awful.screen.focus_relative(-1) end), - awful.key({ modkey, }, "u", awful.client.urgent.jumpto), - awful.key({ modkey, }, "Tab", - function () - awful.client.focus.history.previous() - if client.focus then - client.focus:raise() - end - end), - - -- Standard program - awful.key({ modkey, }, "Return", function () awful.util.spawn(terminal) end), - awful.key({ modkey, "Control" }, "r", awesome.restart), - awful.key({ modkey, "Shift" }, "q", awesome.quit), - - awful.key({ modkey, }, "l", function () awful.tag.incmwfact( 0.05) end), - awful.key({ modkey, }, "h", function () awful.tag.incmwfact(-0.05) end), - awful.key({ modkey, "Shift" }, "h", function () awful.tag.incnmaster( 1) end), - awful.key({ modkey, "Shift" }, "l", function () awful.tag.incnmaster(-1) end), - awful.key({ modkey, "Control" }, "h", function () awful.tag.incncol( 1) end), - awful.key({ modkey, "Control" }, "l", function () awful.tag.incncol(-1) end), - awful.key({ modkey, }, "space", function () awful.layout.inc(layouts, 1) end), - awful.key({ modkey, "Shift" }, "space", function () awful.layout.inc(layouts, -1) end), - - -- Prompt - awful.key({ modkey }, "r", function () mypromptbox[mouse.screen]:run() end), - - awful.key({ modkey }, "x", - function () - awful.prompt.run({ prompt = "Run Lua code: " }, - mypromptbox[mouse.screen].widget, - awful.util.eval, nil, - awful.util.getdir("cache") .. "/history_eval") - end) -) - -clientkeys = awful.util.table.join( - awful.key({ modkey, }, "f", function (c) c.fullscreen = not c.fullscreen end), - awful.key({ modkey, "Shift" }, "c", function (c) c:kill() end), - awful.key({ modkey, "Control" }, "space", awful.client.floating.toggle ), - awful.key({ modkey, "Control" }, "Return", function (c) c:swap(awful.client.getmaster()) end), - awful.key({ modkey, }, "o", awful.client.movetoscreen ), - awful.key({ modkey, "Shift" }, "r", function (c) c:redraw() end), - awful.key({ modkey, }, "t", function (c) c.ontop = not c.ontop end), - awful.key({ modkey, }, "n", function (c) c.minimized = not c.minimized end), - awful.key({ modkey, }, "m", - function (c) - c.maximized_horizontal = not c.maximized_horizontal - c.maximized_vertical = not c.maximized_vertical - end) -) - --- Compute the maximum number of digit we need, limited to 9 -keynumber = 0 -for s = 1, screen.count() do - keynumber = math.min(9, math.max(#tags[s], keynumber)); -end - --- Bind all key numbers to tags. --- Be careful: we use keycodes to make it works on any keyboard layout. --- This should map on the top row of your keyboard, usually 1 to 9. -for i = 1, keynumber do - globalkeys = awful.util.table.join(globalkeys, - awful.key({ modkey }, "#" .. i + 9, - function () - local screen = mouse.screen - if tags[screen][i] then - awful.tag.viewonly(tags[screen][i]) - end - end), - awful.key({ modkey, "Control" }, "#" .. i + 9, - function () - local screen = mouse.screen - if tags[screen][i] then - awful.tag.viewtoggle(tags[screen][i]) - end - end), - awful.key({ modkey, "Shift" }, "#" .. i + 9, - function () - if client.focus and tags[client.focus.screen][i] then - awful.client.movetotag(tags[client.focus.screen][i]) - end - end), - awful.key({ modkey, "Control", "Shift" }, "#" .. i + 9, - function () - if client.focus and tags[client.focus.screen][i] then - awful.client.toggletag(tags[client.focus.screen][i]) - end - end)) -end - -clientbuttons = awful.util.table.join( - awful.button({ }, 1, function (c) client.focus = c; c:raise() end), - awful.button({ modkey }, 1, awful.mouse.client.move), - awful.button({ modkey }, 3, awful.mouse.client.resize)) - --- Set keys --- Add this line before root.keys(globalkeys). -musicwidget:append_global_keys() - -root.keys(globalkeys) --- }}} - --- {{{ Rules -awful.rules.rules = { - -- All clients will match this rule. - { rule = { }, - properties = { border_width = beautiful.border_width, - border_color = beautiful.border_normal, - focus = true, - keys = clientkeys, - buttons = clientbuttons } }, - { rule = { class = "MPlayer" }, - properties = { floating = true } }, - { rule = { class = "pinentry" }, - properties = { floating = true } }, - { rule = { class = "gimp" }, - properties = { floating = true } }, - -- Set Firefox to always map on tags number 2 of screen 1. - -- { rule = { class = "Firefox" }, - -- properties = { tag = tags[1][2] } }, -} --- }}} - --- {{{ Signals --- Signal function to execute when a new client appears. -client.add_signal("manage", function (c, startup) - -- Add a titlebar - -- awful.titlebar.add(c, { modkey = modkey }) - - -- Enable sloppy focus - c:add_signal("mouse::enter", function(c) - if awful.layout.get(c.screen) ~= awful.layout.suit.magnifier - and awful.client.focus.filter(c) then - client.focus = c - end - end) - - if not startup then - -- Set the windows at the slave, - -- i.e. put it at the end of others instead of setting it master. - -- awful.client.setslave(c) - - -- Put windows in a smart way, only if they does not set an initial position. - if not c.size_hints.user_position and not c.size_hints.program_position then - awful.placement.no_overlap(c) - awful.placement.no_offscreen(c) - end - end -end) - -client.add_signal("focus", function(c) c.border_color = beautiful.border_focus end) -client.add_signal("unfocus", function(c) c.border_color = beautiful.border_normal end) --- }}} diff --git a/awesompd/utf8.lua b/awesompd/utf8.lua deleted file mode 100644 index 72177c2..0000000 --- a/awesompd/utf8.lua +++ /dev/null @@ -1,158 +0,0 @@ --- Provides UTF-8 aware string functions implemented in pure lua: --- * string.utf8len(s) --- * string.utf8sub(s, i, j) --- --- All functions behave as their non UTF-8 aware counterparts with the exception --- that UTF-8 characters are used instead of bytes for all units. --- --- Note: all validations had been removed due to awesome usage specifics. ---[[ -Copyright (c) 2006-2007, Kyle Smith -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, -this list of conditions and the following disclaimer. -* Redistributions in binary form must reproduce the above copyright -notice, this list of conditions and the following disclaimer in the -documentation and/or other materials provided with the distribution. -* Neither the name of the author nor the names of its contributors may be -used to endorse or promote products derived from this software without -specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---]] - --- ABNF from RFC 3629 --- --- UTF8-octets = *( UTF8-char ) --- UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4 --- UTF8-1 = %x00-7F --- UTF8-2 = %xC2-DF UTF8-tail --- UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / --- %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail ) --- UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / --- %xF4 %x80-8F 2( UTF8-tail ) --- UTF8-tail = %x80-BF --- - --- returns the number of bytes used by the UTF-8 character at byte i in s --- also doubles as a UTF-8 character validator -function utf8charbytes (s, i) - -- argument defaults - i = i or 1 - local c = string.byte(s, i) - - -- determine bytes needed for character, based on RFC 3629 - if c > 0 and c <= 127 then - -- UTF8-1 - return 1 - elseif c >= 194 and c <= 223 then - -- UTF8-2 - local c2 = string.byte(s, i + 1) - return 2 - elseif c >= 224 and c <= 239 then - -- UTF8-3 - local c2 = s:byte(i + 1) - local c3 = s:byte(i + 2) - return 3 - elseif c >= 240 and c <= 244 then - -- UTF8-4 - local c2 = s:byte(i + 1) - local c3 = s:byte(i + 2) - local c4 = s:byte(i + 3) - return 4 - end -end - --- returns the number of characters in a UTF-8 string -function utf8len (s) - local pos = 1 - local bytes = string.len(s) - local len = 0 - - while pos <= bytes and len ~= chars do - local c = string.byte(s,pos) - len = len + 1 - - pos = pos + utf8charbytes(s, pos) - end - - if chars ~= nil then - return pos - 1 - end - - return len -end - --- functions identically to string.sub except that i and j are UTF-8 characters --- instead of bytes -function utf8sub (s, i, j) - j = j or -1 - - if i == nil then - return "" - end - - local pos = 1 - local bytes = string.len(s) - local len = 0 - - -- only set l if i or j is negative - local l = (i >= 0 and j >= 0) or utf8len(s) - local startChar = (i >= 0) and i or l + i + 1 - local endChar = (j >= 0) and j or l + j + 1 - - -- can't have start before end! - if startChar > endChar then - return "" - end - - -- byte offsets to pass to string.sub - local startByte, endByte = 1, bytes - - while pos <= bytes do - len = len + 1 - - if len == startChar then - startByte = pos - end - - pos = pos + utf8charbytes(s, pos) - - if len == endChar then - endByte = pos - 1 - break - end - end - - return string.sub(s, startByte, endByte) -end - --- replace UTF-8 characters based on a mapping table -function utf8replace (s, mapping) - local pos = 1 - local bytes = string.len(s) - local charbytes - local newstr = "" - - while pos <= bytes do - charbytes = utf8charbytes(s, pos) - local c = string.sub(s, pos, pos + charbytes - 1) - newstr = newstr .. (mapping[c] or c) - pos = pos + charbytes - end - - return newstr -end