Marty/dotfiles
1
0
Fork 0
Code Issues 3 Pull requests Projects Releases Wiki Activity
dotfiles/multimedia/.config/mpv/scripts/uosc.lua

3655 lines
132 KiB
Lua
Raw Blame History

--[[
uosc 2.9.0 - 2020-May-11 | https://github.com/darsain/uosc
Minimalist cursor proximity based UI for MPV player.
uosc replaces the default osc UI, so that has to be disabled first.
Place these options into your `mpv.conf` file:
```
# required so that the 2 UIs don't fight each other
osc=no
# uosc provides its own seeking/volume indicators, so you also don't need this
osd-bar=no
# uosc will draw its own window controls if you disable window border
border=no
```
Options go in `script-opts/uosc.conf`. Defaults:
```
# timeline size when fully retracted, 0 will hide it completely
timeline_size_min=2
# timeline size when fully expanded, in pixels, 0 to disable
timeline_size_max=40
# same as ^ but when in fullscreen
timeline_size_min_fullscreen=0
timeline_size_max_fullscreen=60
# same thing as calling toggle-progress command once on startup
timeline_start_hidden=no
# timeline opacity
timeline_opacity=0.8
# top (and bottom in no-border mode) border of background color to help visually
# separate elapsed bar from a video of similar color or desktop background
timeline_border=1
# when scrolling above timeline, wheel will seek by this amount of seconds
timeline_step=5
# display seekable buffered ranges for streaming videos, syntax `color:opacity`,
# color is an BBGGRR hex code, set to `none` to disable
timeline_cached_ranges=345433:0.5
# floating number font scale adjustment
timeline_font_scale=1
# briefly show timeline on external changes (e.g. seeking with a hotkey)
timeline_flash=yes
# timeline chapters style: none, dots, lines, lines-top, lines-bottom
chapters=dots
chapters_opacity=0.3
# where to display volume controls: none, left, right
volume=right
volume_size=40
volume_size_fullscreen=60
volume_opacity=0.8
volume_border=1
volume_step=1
volume_font_scale=1
volume_flash=yes
# playback speed widget: mouse drag or wheel to change, click to reset
speed=no
speed_size=46
speed_size_fullscreen=68
speed_opacity=1
speed_step=0.1
speed_font_scale=1
speed_flash=yes
# controls all menus, such as context menu, subtitle loader/selector, etc
menu_item_height=36
menu_item_height_fullscreen=50
menu_wasd_navigation=no
menu_hjkl_navigation=no
menu_opacity=0.8
menu_font_scale=1
# top bar with window controls and media title shown only in no-border mode
top_bar_size=40
top_bar_size_fullscreen=46
top_bar_controls=yes
top_bar_title=yes
# pause video on clicks shorter than this number of milliseconds, 0 to disable
pause_on_click_shorter_than=0
# for how long in milliseconds to show elements they're it's being flashed
flash_duration=400
# distances in pixels below which elements are fully faded in/out
proximity_in=40
proximity_out=120
# BBGGRR - BLUE GREEN RED hex color codes
color_foreground=ffffff
color_foreground_text=000000
color_background=000000
color_background_text=ffffff
# use bold font weight throughout the whole UI
font_bold=no
# hide UI when mpv autohides the cursor
autohide=no
# can be: none, flash, static
pause_indicator=flash
# load first file when calling next on a last file in a directory and vice versa
directory_navigation_loops=no
# file types to look for when navigating media files
media_types=3gp,avi,bmp,flac,flv,gif,h264,h265,jpeg,jpg,m4a,m4v,mid,midi,mkv,mov,mp3,mp4,mp4a,mp4v,mpeg,mpg,oga,ogg,ogm,ogv,opus,png,rmvb,svg,tif,tiff,wav,weba,webm,webp,wma,wmv
# file types to look for when loading external subtitles
subtitle_types=aqt,gsub,jss,sub,ttxt,pjs,psb,rt,smi,slt,ssf,srt,ssa,ass,usf,idx,vt
# used to approximate text width
# if you are using some wide font and see a lot of right side clipping in menus,
# try bumping this up
font_height_to_letter_width_ratio=0.5
# `chapter_ranges` lets you transform chapter indicators into range indicators.
#
# Chapter range definition syntax:
# ```
# start_pattern<color:opacity>end_pattern
# ```
#
# Multiple start and end patterns can be defined by separating them with `|`:
# ```
# p1|pN<color:opacity>p1|pN
# ```
#
# Multiple chapter ranges can be defined by separating them with comma:
#
# chapter_ranges=range1,rangeN
#
# One of `start_pattern`s can be a custom keyword `{bof}` that will match
# beginning of file when it makes sense.
#
# One of `end_pattern`s can be a custom keyword `{eof}` that will match end of
# file when it makes sense.
#
# Patterns are lua patterns (http://lua-users.org/wiki/PatternsTutorial).
# They only need to occur in a title, not match it completely.
# Matching is case insensitive.
#
# `color` is a `bbggrr` hexadecimal color code.
# `opacity` is a float number from 0 to 1.
#
# Examples:
#
# Display skippable youtube video sponsor blocks from https://github.com/po5/mpv_sponsorblock
# ```
# chapter_ranges=sponsor start<3535a5:0.5>sponsor end
# ```
#
# Display anime openings and endings as ranges:
# ```
# chapter_ranges=^op| op$|opening<968638:0.5>.*, ^ed| ed$|^end|ending$<968638:0.5>.*|{eof}
# ```
chapter_ranges=^op| op$|opening<968638:0.5>.*, ^ed| ed$|^end|ending$<968638:0.5>.*|{eof}, sponsor start<3535a5:.5>sponsor end
```
Available keybindings (place into `input.conf`):
```
Key script-binding uosc/peek-timeline
Key script-binding uosc/toggle-progress
Key script-binding uosc/menu
Key script-binding uosc/load-subtitles
Key script-binding uosc/subtitles
Key script-binding uosc/audio
Key script-binding uosc/video
Key script-binding uosc/playlist
Key script-binding uosc/chapters
Key script-binding uosc/open-file
Key script-binding uosc/next
Key script-binding uosc/prev
Key script-binding uosc/first
Key script-binding uosc/last
Key script-binding uosc/next-file
Key script-binding uosc/prev-file
Key script-binding uosc/first-file
Key script-binding uosc/last-file
Key script-binding uosc/delete-file-next
Key script-binding uosc/delete-file-quit
Key script-binding uosc/show-in-directory
Key script-binding uosc/open-config-directory
```
]] if mp.get_property('osc') == 'yes' then
mp.msg.info('Disabled because original osc is enabled!')
return
end
local assdraw = require('mp.assdraw')
local opt = require('mp.options')
local utils = require('mp.utils')
local msg = require('mp.msg')
local osd = mp.create_osd_overlay('ass-events')
local infinity = 1e309
-- OPTIONS/CONFIG/STATE
local options = {
timeline_size_min = 2,
timeline_size_max = 40,
timeline_size_min_fullscreen = 0,
timeline_size_max_fullscreen = 60,
timeline_start_hidden = false,
timeline_opacity = 0.8,
timeline_border = 1,
timeline_step = 5,
timeline_cached_ranges = '345433:0.5',
timeline_font_scale = 1,
timeline_flash = true,
chapters = 'dots',
chapters_opacity = 0.3,
volume = 'right',
volume_size = 40,
volume_size_fullscreen = 60,
volume_opacity = 0.8,
volume_border = 1,
volume_step = 1,
volume_font_scale = 1,
volume_flash = true,
speed = false,
speed_size = 46,
speed_size_fullscreen = 68,
speed_opacity = 1,
speed_step = 0.1,
speed_font_scale = 1,
speed_flash = true,
menu_item_height = 36,
menu_item_height_fullscreen = 50,
menu_wasd_navigation = false,
menu_hjkl_navigation = false,
menu_opacity = 0.8,
menu_font_scale = 1,
top_bar_size = 40,
top_bar_size_fullscreen = 46,
top_bar_controls = true,
top_bar_title = true,
pause_on_click_shorter_than = 0,
flash_duration = 400,
proximity_in = 40,
proximity_out = 120,
color_foreground = 'ffffff',
color_foreground_text = '000000',
color_background = '000000',
color_background_text = 'ffffff',
font_bold = false,
autohide = false,
pause_indicator = 'flash',
directory_navigation_loops = false,
media_types = '3gp,avi,bmp,flac,flv,gif,h264,h265,jpeg,jpg,m4a,m4v,mid,midi,mkv,mov,mp3,mp4,mp4a,mp4v,mpeg,mpg,oga,ogg,ogm,ogv,opus,png,rmvb,svg,tif,tiff,wav,weba,webm,webp,wma,wmv',
subtitle_types = 'aqt,gsub,jss,sub,ttxt,pjs,psb,rt,smi,slt,ssf,srt,ssa,ass,usf,idx,vt',
font_height_to_letter_width_ratio = 0.5,
chapter_ranges = '^op| op$|opening<968638:0.5>.*, ^ed| ed$|^end|ending$<968638:0.5>.*|{eof}, sponsor start<3535a5:.5>sponsor end'
}
opt.read_options(options, 'uosc')
local config = {
render_delay = 0.03, -- sets max rendering frequency
font = mp.get_property('options/osd-font'),
menu_parent_opacity = 0.4,
menu_min_width = 260
}
local bold_tag = options.font_bold and '\\b1' or ''
local display = {width = 1280, height = 720, aspect = 1.77778}
local cursor = {
hidden = true, -- true when autohidden or outside of the player window
x = 0,
y = 0
}
local state = {
os = (function()
if os.getenv('windir') ~= nil then return 'windows' end
local homedir = os.getenv('HOME')
if homedir ~= nil and string.sub(homedir, 1, 6) == '/Users' then
return 'macos'
end
return 'linux'
end)(),
cwd = mp.get_property('working-directory'),
media_title = '',
duration = nil,
position = nil,
pause = false,
chapters = nil,
chapter_ranges = nil,
fullscreen = mp.get_property_native('fullscreen'),
maximized = mp.get_property_native('window-maximized'),
render_timer = nil,
render_last_time = 0,
volume = nil,
volume_max = nil,
mute = nil,
cursor_autohide_timer = mp.add_timeout(
mp.get_property_native('cursor-autohide') / 1000, function()
if not options.autohide then return end
handle_mouse_leave()
end),
mouse_bindings_enabled = false,
cached_ranges = nil
}
local forced_key_bindings -- defined at the bottom next to events
-- HELPERS
function round(number)
local modulus = number % 1
return modulus < 0.5 and math.floor(number) or math.ceil(number)
end
function call_me_maybe(fn, value1, value2, value3)
if fn then fn(value1, value2, value3) end
end
function split(str, pattern)
local list = {}
local full_pattern = '(.-)' .. pattern
local last_end = 1
local start_index, end_index, capture = str:find(full_pattern, 1)
while start_index do
list[#list + 1] = capture
last_end = end_index + 1
start_index, end_index, capture = str:find(full_pattern, last_end)
end
if last_end <= (#str + 1) then
capture = str:sub(last_end)
list[#list + 1] = capture
end
return list
end
function itable_find(haystack, needle)
local is_needle = type(needle) == 'function' and needle or
function(index, value) return value == needle end
for index, value in ipairs(haystack) do
if is_needle(index, value) then return index, value end
end
end
function itable_filter(haystack, needle)
local is_needle = type(needle) == 'function' and needle or
function(index, value) return value == needle end
local filtered = {}
for index, value in ipairs(haystack) do
if is_needle(index, value) then filtered[#filtered + 1] = value end
end
return filtered
end
function itable_remove(haystack, needle)
local should_remove = type(needle) == 'function' and needle or
function(value) return value == needle end
local new_table = {}
for _, value in ipairs(haystack) do
if not should_remove(value) then
new_table[#new_table + 1] = value
end
end
return new_table
end
function itable_slice(haystack, start_pos, end_pos)
start_pos = start_pos and start_pos or 1
end_pos = end_pos and end_pos or #haystack
if end_pos < 0 then end_pos = #haystack + end_pos + 1 end
if start_pos < 0 then start_pos = #haystack + start_pos + 1 end
local new_table = {}
for index, value in ipairs(haystack) do
if index >= start_pos and index <= end_pos then
new_table[#new_table + 1] = value
end
end
return new_table
end
function table_copy(table)
local new_table = {}
for key, value in pairs(table) do new_table[key] = value end
return new_table
end
-- Sorting comparator close to (but not exactly) how file explorers sort files
local word_order_comparator = (function()
local symbol_order
local default_order
if state.os == 'win' then
symbol_order = {
['!'] = 1,
['#'] = 2,
['$'] = 3,
['%'] = 4,
['&'] = 5,
['('] = 6,
[')'] = 6,
[','] = 7,
['.'] = 8,
["'"] = 9,
['-'] = 10,
[';'] = 11,
['@'] = 12,
['['] = 13,
[']'] = 13,
['^'] = 14,
['_'] = 15,
['`'] = 16,
['{'] = 17,
['}'] = 17,
['~'] = 18,
['+'] = 19,
['='] = 20
}
default_order = 21
else
symbol_order = {
['`'] = 1,
['^'] = 2,
['~'] = 3,
['='] = 4,
['_'] = 5,
['-'] = 6,
[','] = 7,
[';'] = 8,
['!'] = 9,
["'"] = 10,
['('] = 11,
[')'] = 11,
['['] = 12,
[']'] = 12,
['{'] = 13,
['}'] = 14,
['@'] = 15,
['$'] = 16,
['*'] = 17,
['&'] = 18,
['%'] = 19,
['+'] = 20,
['.'] = 22,
['#'] = 23
}
default_order = 21
end
return function(a, b)
a = a:lower()
b = b:lower()
for i = 1, math.max(#a, #b) do
local ai = a:sub(i, i)
local bi = b:sub(i, i)
if ai == nil and bi then return true end
if bi == nil and ai then return false end
local a_order = symbol_order[ai] or default_order
local b_order = symbol_order[bi] or default_order
if a_order == b_order then
return a < b
else
return a_order < b_order
end
end
end
end)()
-- Creates in-between frames to animate value from `from` to `to` numbers.
-- Returns function that terminates animation.
-- `to` can be a function that returns target value, useful for movable targets.
-- `speed` is an optional float between 1-instant and 0-infinite duration
-- `callback` is called either on animation end, or when animation is canceled
function tween(from, to, setter, speed, callback)
if type(speed) ~= 'number' then
callback = speed
speed = 0.3
end
local timeout
local getTo = type(to) == 'function' and to or function() return to end
local cutoff = math.abs(getTo() - from) * 0.01
function tick()
from = from + ((getTo() - from) * speed)
local is_end = math.abs(getTo() - from) <= cutoff
setter(is_end and getTo() or from)
request_render()
if is_end then
call_me_maybe(callback)
else
timeout:resume()
end
end
timeout = mp.add_timeout(0.016, tick)
tick()
return function()
timeout:kill()
call_me_maybe(callback)
end
end
-- Kills ongoing animation if one is already running on this element.
-- Killed animation will not get its `on_end` called.
function tween_element(element, from, to, setter, speed, callback)
if type(speed) ~= 'number' then
callback = speed
speed = 0.3
end
tween_element_stop(element)
element.stop_current_animation = tween(from, to, function(value)
setter(element, value)
end, speed, function()
element.stop_current_animation = nil
call_me_maybe(callback, element)
end)
end
-- Stopped animation will not get its on_end called.
function tween_element_is_tweening(element)
return element and element.stop_current_animation
end
-- Stopped animation will not get its on_end called.
function tween_element_stop(element)
call_me_maybe(element and element.stop_current_animation)
end
-- Helper to automatically use an element property setter
function tween_element_property(element, prop, from, to, speed, callback)
tween_element(element, from, to,
function(_, value) element[prop] = value end, speed, callback)
end
function get_point_to_rectangle_proximity(point, rect)
local dx = math.max(rect.ax - point.x, 0, point.x - rect.bx + 1)
local dy = math.max(rect.ay - point.y, 0, point.y - rect.by + 1)
return math.sqrt(dx * dx + dy * dy);
end
function text_width_estimate(letters, font_size)
return letters and letters * font_size *
options.font_height_to_letter_width_ratio or 0
end
function opacity_to_alpha(opacity) return 255 - math.ceil(255 * opacity) end
function ass_opacity(opacity, fraction)
fraction = fraction ~= nil and fraction or 1
if type(opacity) == 'number' then
return string.format('{\\alpha&H%X&}',
opacity_to_alpha(opacity * fraction))
else
return string.format('{\\1a&H%X&\\2a&H%X&\\3a&H%X&\\4a&H%X&}',
opacity_to_alpha((opacity[1] or 0) * fraction),
opacity_to_alpha((opacity[2] or 0) * fraction),
opacity_to_alpha((opacity[3] or 0) * fraction),
opacity_to_alpha((opacity[4] or 0) * fraction))
end
end
-- Ensures path is absolute and normalizes slashes to the current platform
function normalize_path(path)
if not path or is_protocol(path) then return path end
-- Ensure path is absolute
if not (path:match('^/') or path:match('^%a+:') or path:match('^\\\\')) then
path = utils.join_path(state.cwd, path)
end
-- Use proper slashes
if state.os == 'windows' then
return path:gsub('/', '\\')
else
return path:gsub('\\', '/')
end
end
-- Check if path is a protocol, such as `http://...`
function is_protocol(path) return path:match('^%a[%a%d-_]+://') end
function get_extension(path)
local parts = split(path, '%.')
return parts and #parts > 1 and parts[#parts] or nil
end
-- Serializes path into its semantic parts
function serialize_path(path)
if not path or is_protocol(path) then return end
path = normalize_path(path)
local parts = split(path, '[\\/]+')
if parts[#parts] == '' then table.remove(parts, #parts) end -- remove trailing separator
local basename = parts and parts[#parts] or path
local dirname = #parts > 1 and
table.concat(itable_slice(parts, 1, #parts - 1),
state.os == 'windows' and '\\' or '/') or
nil
local dot_split = split(basename, '%.')
return {
path = path:sub(-1) == ':' and state.os == 'windows' and path .. '\\' or
path,
is_root = dirname == nil,
dirname = dirname,
basename = basename,
filename = #dot_split > 1 and
table.concat(itable_slice(dot_split, 1, #dot_split - 1), '.') or
basename,
extension = #dot_split > 1 and dot_split[#dot_split] or nil
}
end
function get_files_in_directory(directory, allowed_types)
local files, error = utils.readdir(directory, 'files')
if not files then
msg.error('Retrieving files failed: ' .. (error or ''))
return
end
-- Filter only requested file types
if allowed_types then
files = itable_filter(files, function(_, file)
local extension = get_extension(file)
return extension and itable_find(allowed_types, extension:lower())
end)
end
table.sort(files, word_order_comparator)
return files
end
function get_adjacent_file(file_path, direction, allowed_types)
local current_file = serialize_path(file_path)
local files = get_files_in_directory(current_file.dirname, allowed_types)
if not files then return end
for index, file in ipairs(files) do
if current_file.basename == file then
if direction == 'forward' then
if files[index + 1] then
return utils.join_path(current_file.dirname,
files[index + 1])
end
if options.directory_navigation_loops and files[1] then
return utils.join_path(current_file.dirname, files[1])
end
else
if files[index - 1] then
return utils.join_path(current_file.dirname,
files[index - 1])
end
if options.directory_navigation_loops and files[#files] then
return utils.join_path(current_file.dirname, files[#files])
end
end
-- This is the only file in directory
return nil
end
end
end
-- Ensures chapters are in chronological order
function get_normalized_chapters()
local chapters = mp.get_property_native('chapter-list')
if not chapters then return end
-- Copy table
chapters = itable_slice(chapters)
-- Ensure chronological order of chapters
table.sort(chapters, function(a, b) return a.time < b.time end)
return chapters
end
-- Element
--[[
Signature:
{
-- enables capturing button groups for this element
captures = {mouse_buttons = true, wheel = true},
-- element rectangle coordinates
ax = 0, ay = 0, bx = 0, by = 0,
-- cursor<>element relative proximity as a 0-1 floating number
-- where 0 = completely away, and 1 = touching/hovering
-- so it's easy to work with and throw into equations
proximity = 0,
-- raw cursor<>element proximity in pixels
proximity_raw = infinity,
-- called when element is created
?init = function(this),
-- called manually when disposing of element
?destroy = function(this),
-- triggered when event happens and cursor is above element
?on_{event_name} = function(this),
-- triggered when any event happens anywhere on a page
?on_global_{event_name} = function(this),
-- object
?render = function(this_element),
}
]]
local Element = {
captures = nil,
ax = 0,
ay = 0,
bx = 0,
by = 0,
proximity = 0,
proximity_raw = infinity
}
Element.__index = Element
function Element.new(props)
local element = setmetatable(props, Element)
element._eventListeners = {}
-- Flash timer
element._flash_out_timer = mp.add_timeout(options.flash_duration / 1000,
function()
local getTo = function() return element.proximity end
element:tween_property('forced_proximity', 1, getTo,
function() element.forced_proximity = nil end)
end)
element._flash_out_timer:kill()
element:init()
return element
end
function Element:init() end
function Element:destroy() end
-- Call method if it exists
function Element:maybe(name, ...)
if self[name] then return self[name](self, ...) end
end
-- Tween helpers
function Element:tween(...) tween_element(self, ...) end
function Element:tween_property(...) tween_element_property(self, ...) end
function Element:tween_stop() tween_element_stop(self) end
function Element:is_tweening() tween_element_is_tweening(self) end
-- Event listeners
function Element:on(name, handler)
if self._eventListeners[name] == nil then self._eventListeners[name] = {} end
local preexistingIndex = itable_find(self._eventListeners[name], handler)
if preexistingIndex then
return
else
self._eventListeners[name][#self._eventListeners[name] + 1] = handler
end
end
function Element:off(name, handler)
if self._eventListeners[name] == nil then return end
local index = itable_find(self._eventListeners, handler)
if index then table.remove(self._eventListeners, index) end
end
function Element:trigger(name, ...)
self:maybe('on_' .. name, ...)
if self._eventListeners[name] == nil then return end
for _, handler in ipairs(self._eventListeners[name]) do handler(...) end
end
-- Briefly flashes the element for `options.flash_duration` milliseconds.
-- Useful to visualize changes of volume and timeline when changed via hotkeys.
-- Implemented by briefly adding animated `forced_proximity` property to the element.
function Element:flash()
if options.flash_duration > 0 and
(self.proximity < 1 or self._flash_out_timer:is_enabled()) then
self:tween_stop()
self.forced_proximity = 1
self._flash_out_timer:kill()
self._flash_out_timer:resume()
end
end
-- ELEMENTS
local Elements = {itable = {}}
Elements.__index = Elements
local elements = setmetatable({}, Elements)
function Elements:add(name, element)
local insert_index = #Elements.itable + 1
-- Replace if element already exists
if self:has(name) then
insert_index = itable_find(Elements.itable, function(_, element)
return element.name == name
end)
end
element.name = name
Elements.itable[insert_index] = element
self[name] = element
request_render()
end
function Elements:remove(name, props)
Elements.itable = itable_remove(Elements.itable, self[name])
self[name] = nil
request_render()
end
function Elements:has(name) return self[name] ~= nil end
function Elements:ipairs() return ipairs(Elements.itable) end
function Elements:pairs(elements) return pairs(self) end
-- MENU
--[[
Usage:
```
local items = {
{title = 'Foo title', hint = 'Ctrl+F', value = 'foo'},
{title = 'Bar title', hint = 'Ctrl+B', value = 'bar'},
{
title = 'Submenu',
items = {
{title = 'Sub item 1', value = 'sub1'},
{title = 'Sub item 2', value = 'sub2'}
}
}
}
function open_item(value)
value -- value from `item.value`
end
menu:open(items, open_item)
```
]]
local Menu = {}
Menu.__index = Menu
local menu = setmetatable({key_bindings = {}, is_closing = false}, Menu)
function Menu:is_open(menu_type)
return elements.menu ~= nil and
(not menu_type or elements.menu.type == menu_type)
end
function Menu:open(items, open_item, opts)
opts = opts or {}
if menu:is_open() then
if not opts.parent_menu then
menu:close(true, function()
menu:open(items, open_item, opts)
end)
return
end
else
menu:enable_key_bindings()
elements.curtain:fadein()
end
elements:add('menu', Element.new({
captures = {mouse_buttons = true},
type = nil, -- menu type such as `menu`, `chapters`, ...
title = nil,
width = nil,
height = nil,
offset_x = 0, -- used to animated from/to left when submenu
item_height = nil,
item_spacing = 1,
item_content_spacing = nil,
font_size = nil,
scroll_step = nil,
scroll_height = nil,
scroll_y = 0,
opacity = 0,
relative_parent_opacity = 0.4,
items = items,
active_item = nil,
selected_item = nil,
open_item = open_item,
parent_menu = nil,
init = function(this)
-- Already initialized
if this.width ~= nil then return end
-- Apply options
for key, value in pairs(opts) do this[key] = value end
this.selected_item = this.active_item
-- Set initial dimensions
this:on_display_resize()
-- Scroll to active item
this:scroll_to_item(this.active_item)
-- Transition in animation
menu.transition = {to = 'child', target = this}
local start_offset = this.parent_menu and
(this.parent_menu.width + this.width) / 2 or
0
tween_element(menu.transition.target, 0, 1, function(_, pos)
this:set_offset_x(round(start_offset * (1 - pos)))
this.opacity = pos
this:set_parent_opacity(1 -
((1 - config.menu_parent_opacity) *
pos))
end, function()
menu.transition = nil
update_proximities()
end)
end,
destroy = function(this) request_render() end,
on_display_resize = function(this)
this.item_height = (state.fullscreen or state.maximized) and
options.menu_item_height_fullscreen or
options.menu_item_height
this.font_size = round(this.item_height * 0.48 *
options.menu_font_scale)
this.item_content_spacing = round(
(this.item_height - this.font_size) *
0.6)
this.scroll_step = this.item_height + this.item_spacing
-- Estimate width of a widest item
local estimated_max_width = 0
for _, item in ipairs(items) do
local item_text_length =
((item.title and item.title:len() or 0) +
(item.hint and item.hint:len() or 0))
local spacings_in_item = item.hint and 3 or 2
local estimated_width = text_width_estimate(item_text_length,
this.font_size) +
(this.item_content_spacing *
spacings_in_item)
if estimated_width > estimated_max_width then
estimated_max_width = estimated_width
end
end
-- Also check menu title
local menu_title_length = this.title and this.title:len() or 0
local estimated_menu_title_width =
text_width_estimate(menu_title_length, this.font_size)
if estimated_menu_title_width > estimated_max_width then
estimated_max_width = estimated_menu_title_width
end
-- Coordinates and sizes are of the scrollable area to make
-- consuming values in rendering easier. Title drawn above this, so
-- we need to account for that in max_height and ay position.
this.width = round(math.min(math.max(estimated_max_width,
config.menu_min_width),
display.width * 0.9))
local title_height = this.title and this.scroll_step or 0
local max_height = round(display.height * 0.9) - title_height
this.height = math.min(round(this.scroll_step * #items) -
this.item_spacing, max_height)
this.scroll_height = math.max(
(this.scroll_step * #this.items) -
this.height - this.item_spacing, 0)
this.ax = round((display.width - this.width) / 2) + this.offset_x
this.ay = round((display.height - this.height) / 2 +
(title_height / 2))
this.bx = round(this.ax + this.width)
this.by = round(this.ay + this.height)
if this.parent_menu then
this.parent_menu:on_display_resize()
end
end,
set_items = function(this, items, props)
this.items = items
this.selected_item = nil
this.active_item = nil
if props then
for key, value in pairs(props) do
this[key] = value
end
end
this:on_display_resize()
request_render()
end,
set_offset_x = function(this, offset)
local delta = offset - this.offset_x
this.offset_x = offset
this.ax = this.ax + delta
this.bx = this.bx + delta
if this.parent_menu then
this.parent_menu:set_offset_x(
offset - ((this.width + this.parent_menu.width) / 2) -
this.item_spacing)
else
update_proximities()
end
end,
fadeout = function(this, callback)
this:tween(1, 0, function(this, pos)
this.opacity = pos
this:set_parent_opacity(pos * config.menu_parent_opacity)
end, callback)
end,
set_parent_opacity = function(this, opacity)
if this.parent_menu then
this.parent_menu.opacity = opacity
this.parent_menu:set_parent_opacity(
opacity * config.menu_parent_opacity)
end
end,
get_item_index_below_cursor = function(this)
return math.ceil((cursor.y - this.ay + this.scroll_y) /
this.scroll_step)
end,
get_first_visible_index = function(this)
return round(this.scroll_y / this.scroll_step) + 1
end,
get_last_visible_index = function(this)
return round((this.scroll_y + this.height) / this.scroll_step)
end,
get_centermost_visible_index = function(this)
return round((this.scroll_y + (this.height / 2)) / this.scroll_step)
end,
scroll_to = function(this, pos)
this.scroll_y = math.max(math.min(pos, this.scroll_height), 0)
request_render()
end,
scroll_to_item = function(this, index)
if (index and index >= 1 and index <= #this.items) then
this:scroll_to(round((this.scroll_step * (index - 1)) -
((this.height - this.scroll_step) / 2)))
end
end,
select_index = function(this, index)
this.selected_item =
(index and index >= 1 and index <= #this.items) and index or nil
request_render()
end,
select_value = function(this, value)
this:select_index(itable_find(this.items, function(_, item)
return item.value == value
end))
end,
activate_index = function(this, index)
this.active_item =
(index and index >= 1 and index <= #this.items) and index or nil
request_render()
end,
activate_value = function(this, value)
this:activate_index(itable_find(this.items, function(_, item)
return item.value == value
end))
end,
delete_index = function(this, index)
if (index and index >= 1 and index <= #this.items) then
local previous_active_value =
this.active_index and this.items[this.active_index].value or
nil
table.remove(this.items, index)
this:on_display_resize()
if previous_active_value then
this:activate_value(previous_active_value)
end
this:scroll_to_item(this.selected_item)
end
end,
delete_value = function(this, value)
this:delete_index(itable_find(this.items, function(_, item)
return item.value == value
end))
end,
prev = function(this)
local default_anchor = this.scroll_height > this.scroll_step and
this:get_centermost_visible_index() or
this:get_last_visible_index()
local current_index = this.selected_item or default_anchor + 1
this.selected_item = math.max(current_index - 1, 1)
this:scroll_to_item(this.selected_item)
end,
next = function(this)
local default_anchor = this.scroll_height > this.scroll_step and
this:get_centermost_visible_index() or
this:get_first_visible_index()
local current_index = this.selected_item or default_anchor - 1
this.selected_item = math.min(current_index + 1, #this.items)
this:scroll_to_item(this.selected_item)
end,
back = function(this)
if menu.transition then
local transition_target = menu.transition.target
local transition_target_type = menu.transition.target
tween_element_stop(transition_target)
if transition_target_type == 'parent' then
elements:add('menu', transition_target)
end
menu.transition = nil
transition_target:back()
return
else
menu.transition = {to = 'parent', target = this.parent_menu}
end
if menu.transition.target == nil then
menu:close()
return
end
local target = menu.transition.target
local to_offset = -target.offset_x + this.offset_x
tween_element(target, 0, 1, function(_, pos)
this:set_offset_x(round(to_offset * pos))
this.opacity = 1 - pos
this:set_parent_opacity(config.menu_parent_opacity +
((1 - config.menu_parent_opacity) *
pos))
end, function()
menu.transition = nil
elements:add('menu', target)
update_proximities()
end)
end,
open_selected_item = function(this)
-- If there is a transition active and this method got called, it
-- means we are animating from this menu to parent menu, and all
-- calls to this method should be relayed to the parent menu.
if menu.transition and menu.transition.to == 'parent' then
local target = menu.transition.target
tween_element_stop(target)
menu.transition = nil
target:open_selected_item()
return
end
if this.selected_item then
local item = this.items[this.selected_item]
-- Is submenu
if item.items then
local opts = table_copy(opts)
opts.parent_menu = this
menu:open(item.items, this.open_item, opts)
else
menu:close(true)
this.open_item(item.value)
end
end
end,
close = function(this) menu:close() end,
on_global_mbtn_left_down = function(this)
if this.proximity_raw == 0 then
this.selected_item = this:get_item_index_below_cursor()
this:open_selected_item()
else
-- check if this is clicking on any parent menus
local parent_menu = this.parent_menu
repeat
if parent_menu then
if get_point_to_rectangle_proximity(cursor, parent_menu) ==
0 then
this:back()
return
end
parent_menu = parent_menu.parent_menu
end
until parent_menu == nil
menu:close()
end
end,
on_global_mouse_move = function(this)
if this.proximity_raw == 0 then
this.selected_item = this:get_item_index_below_cursor()
else
if this.selected_item then
this.selected_item = nil
end
end
request_render()
end,
on_wheel_up = function(this)
this.selected_item = nil
this:scroll_to(this.scroll_y - this.scroll_step)
-- Selects item below cursor
this:on_global_mouse_move()
request_render()
end,
on_wheel_down = function(this)
this.selected_item = nil
this:scroll_to(this.scroll_y + this.scroll_step)
-- Selects item below cursor
this:on_global_mouse_move()
request_render()
end,
on_pgup = function(this)
this.selected_item = nil
this:scroll_to(this.scroll_y - this.height)
end,
on_pgdwn = function(this)
this.selected_item = nil
this:scroll_to(this.scroll_y + this.height)
end,
on_home = function(this)
this.selected_item = nil
this:scroll_to(0)
end,
on_end = function(this)
this.selected_item = nil
this:scroll_to(this.scroll_height)
end,
render = render_menu
}))
elements.menu:maybe('on_open')
end
function Menu:add_key_binding(key, name, fn, flags)
menu.key_bindings[#menu.key_bindings + 1] = name
mp.add_forced_key_binding(key, name, fn, flags)
end
function Menu:enable_key_bindings()
menu.key_bindings = {}
-- The `mp.set_key_bindings()` method would be easier here, but that
-- doesn't support 'repeatable' flag, so we are stuck with this monster.
menu:add_key_binding('up', 'menu-prev', self:create_action('prev'),
'repeatable')
menu:add_key_binding('down', 'menu-next', self:create_action('next'),
'repeatable')
menu:add_key_binding('left', 'menu-back', self:create_action('back'))
menu:add_key_binding('right', 'menu-select',
self:create_action('open_selected_item'))
if options.menu_wasd_navigation then
menu:add_key_binding('w', 'menu-prev-alt', self:create_action('prev'),
'repeatable')
menu:add_key_binding('a', 'menu-back-alt', self:create_action('back'))
menu:add_key_binding('s', 'menu-next-alt', self:create_action('next'),
'repeatable')
menu:add_key_binding('d', 'menu-select-alt',
self:create_action('open_selected_item'))
end
if options.menu_hjkl_navigation then
menu:add_key_binding('h', 'menu-back-alt2', self:create_action('back'))
menu:add_key_binding('j', 'menu-next-alt2', self:create_action('next'),
'repeatable')
menu:add_key_binding('k', 'menu-prev-alt2', self:create_action('prev'),
'repeatable')
menu:add_key_binding('l', 'menu-select-alt2',
self:create_action('open_selected_item'))
end
menu:add_key_binding('mbtn_back', 'menu-back-alt3',
self:create_action('back'))
menu:add_key_binding('bs', 'menu-back-alt4', self:create_action('back'))
menu:add_key_binding('enter', 'menu-select-alt3',
self:create_action('open_selected_item'))
menu:add_key_binding('kp_enter', 'menu-select-alt4',
self:create_action('open_selected_item'))
menu:add_key_binding('esc', 'menu-close', self:create_action('close'))
menu:add_key_binding('pgup', 'menu-page-up', self:create_action('on_pgup'))
menu:add_key_binding('pgdwn', 'menu-page-down',
self:create_action('on_pgdwn'))
menu:add_key_binding('home', 'menu-home', self:create_action('on_home'))
menu:add_key_binding('end', 'menu-end', self:create_action('on_end'))
end
function Menu:disable_key_bindings()
for _, name in ipairs(menu.key_bindings) do mp.remove_key_binding(name) end
menu.key_bindings = {}
end
function Menu:create_action(name)
return function(...)
if elements.menu then elements.menu:maybe(name, ...) end
end
end
function Menu:close(immediate, callback)
if type(immediate) ~= 'boolean' then callback = immediate end
if elements:has('menu') and not menu.is_closing then
function close()
elements.menu:maybe('on_close')
elements.menu:destroy()
elements:remove('menu')
menu.is_closing = false
update_proximities()
menu:disable_key_bindings()
call_me_maybe(callback)
end
menu.is_closing = true
elements.curtain:fadeout()
if immediate then
close()
else
elements.menu:fadeout(close)
end
end
end
-- ICONS
--[[
ASS \shadN shadows are drawn also below the element, which when there is an
opacity in play, blends icon colors into ugly greys. The mess below is an
attempt to fix it by rendering shadows for icons with clipping.
Add icons by adding functions to render them to `icons` table.
Signature: function(pos_x, pos_y, size) => string
Function has to return ass path coordinates to draw the icon centered at pox_x
and pos_y of passed size.
]]
local icons = {}
function icon(name, icon_x, icon_y, icon_size, shad_x, shad_y, shad_size,
backdrop, opacity, clip)
local ass = assdraw.ass_new()
local icon_path = icons[name](icon_x, icon_y, icon_size)
local icon_color = options['color_' .. backdrop .. '_text']
local shad_color = options['color_' .. backdrop]
local use_border = (shad_x + shad_y) == 0
local icon_border = use_border and shad_size or 0
-- clip can't clip out shadows, a very annoying limitation I can't work
-- around without going back to ugly default ass shadows, but atm I actually
-- don't need clipping of icons with shadows, so I'm choosing to ignore this
if not clip then clip = '' end
if not use_border then
ass:new_event()
ass:append('{\\blur0\\bord0\\shad0\\1c&H' .. shad_color .. '\\iclip(' ..
ass.scale .. ', ' .. icon_path .. ')}')
ass:append(ass_opacity(opacity))
ass:pos(shad_x + shad_size, shad_y + shad_size)
ass:draw_start()
ass:append(icon_path)
ass:draw_stop()
end
ass:new_event()
ass:append(
'{\\blur0\\bord' .. icon_border .. '\\shad0\\1c&H' .. icon_color ..
'\\3c&H' .. shad_color .. clip .. '}')
ass:append(ass_opacity(opacity))
ass:pos(0, 0)
ass:draw_start()
ass:append(icon_path)
ass:draw_stop()
return ass.text
end
function icons._volume(muted, pos_x, pos_y, size)
local ass = assdraw.ass_new()
local scale = size / 200
function x(number) return pos_x + (number * scale) end
function y(number) return pos_y + (number * scale) end
ass:move_to(x(-85), y(-35))
ass:line_to(x(-50), y(-35))
ass:line_to(x(-5), y(-75))
ass:line_to(x(-5), y(75))
ass:line_to(x(-50), y(35))
ass:line_to(x(-85), y(35))
if muted then
ass:move_to(x(76), y(-35))
ass:line_to(x(50), y(-9))
ass:line_to(x(24), y(-35))
ass:line_to(x(15), y(-26))
ass:line_to(x(41), y(0))
ass:line_to(x(15), y(26))
ass:line_to(x(24), y(35))
ass:line_to(x(50), y(9))
ass:line_to(x(76), y(35))
ass:line_to(x(85), y(26))
ass:line_to(x(59), y(0))
ass:line_to(x(85), y(-26))
else
ass:move_to(x(20), y(-30))
ass:line_to(x(20), y(30))
ass:line_to(x(35), y(30))
ass:line_to(x(35), y(-30))
ass:move_to(x(55), y(-60))
ass:line_to(x(55), y(60))
ass:line_to(x(70), y(60))
ass:line_to(x(70), y(-60))
end
return ass.text
end
function icons.volume(pos_x, pos_y, size)
return icons._volume(false, pos_x, pos_y, size)
end
function icons.volume_muted(pos_x, pos_y, size)
return icons._volume(true, pos_x, pos_y, size)
end
function icons.arrow_right(pos_x, pos_y, size)
local ass = assdraw.ass_new()
local scale = size / 200
function x(number) return pos_x + (number * scale) end
function y(number) return pos_y + (number * scale) end
ass:move_to(x(-22), y(-80))
ass:line_to(x(-45), y(-57))
ass:line_to(x(12), y(0))
ass:line_to(x(-45), y(57))
ass:line_to(x(-22), y(80))
ass:line_to(x(58), y(0))
return ass.text
end
-- STATE UPDATES
function update_display_dimensions()
local o = mp.get_property_native('osd-dimensions')
display.width = o.w
display.height = o.h
display.aspect = o.aspect
-- Tell elements about this
for _, element in elements:ipairs() do
if element.on_display_resize ~= nil then
element.on_display_resize(element)
end
end
end
function update_element_cursor_proximity(element)
if cursor.hidden then
element.proximity_raw = infinity
element.proximity = 0
else
local range = options.proximity_out - options.proximity_in
element.proximity_raw =
get_point_to_rectangle_proximity(cursor, element)
element.proximity = menu:is_open() and 0 or 1 -
(math.min(
math.max(
element.proximity_raw -
options.proximity_in, 0), range) /
range)
end
end
function update_proximities()
local capture_mouse_buttons = false
local capture_wheel = false
local menu_only = menu:is_open()
local mouse_left_elements = {}
local mouse_entered_elements = {}
-- Calculates proximities and opacities for defined elements
for _, element in elements:ipairs() do
local previous_proximity_raw = element.proximity_raw
-- If menu is open, all other elements have to be disabled
if menu_only then
if element.name == 'menu' then
capture_mouse_buttons = true
capture_wheel = true
update_element_cursor_proximity(element)
else
element.proximity_raw = infinity
element.proximity = 0
end
else
update_element_cursor_proximity(element)
end
if element.proximity_raw == 0 then
-- Mouse is over element
if element.captures and element.captures.mouse_buttons then
capture_mouse_buttons = true
end
if element.captures and element.captures.wheel then
capture_wheel = true
end
-- Mouse entered element area
if previous_proximity_raw ~= 0 then
mouse_entered_elements[#mouse_entered_elements + 1] = element
end
else
-- Mouse left element area
if previous_proximity_raw == 0 then
mouse_left_elements[#mouse_left_elements + 1] = element
end
end
end
-- Enable key group captures elements request.
if capture_mouse_buttons then
forced_key_bindings.mouse_buttons:enable()
else
forced_key_bindings.mouse_buttons:disable()
end
if capture_wheel then
forced_key_bindings.wheel:enable()
else
forced_key_bindings.wheel:disable()
end
-- Trigger `mouse_leave` and `mouse_enter` events
for _, element in ipairs(mouse_left_elements) do
element:trigger('mouse_leave')
end
for _, element in ipairs(mouse_entered_elements) do
element:trigger('mouse_enter')
end
end
-- ELEMENT RENDERERS
function render_timeline(this)
if this.size_max == 0 or state.duration == nil or state.position == nil then
return
end
local size_min = this:get_effective_size_min()
local size = this:get_effective_size()
if size < 1 then return end
local ass = assdraw.ass_new()
-- Text opacity rapidly drops to 0 just before it starts overflowing, or before it reaches timeline.size_min
local hide_text_below = math.max(this.font_size * 0.7, size_min * 2)
local hide_text_ramp = hide_text_below / 2
local text_opacity = math.max(math.min(size - hide_text_below,
hide_text_ramp), 0) / hide_text_ramp
local spacing = math.max(math.floor((this.size_max - this.font_size) / 2.5),
4)
local progress = state.position / state.duration
-- Background bar coordinates
local bax = 0
local bay = display.height - size - this.bottom_border - this.top_border
local bbx = display.width
local bby = display.height
-- Foreground bar coordinates
local fax = bax
local fay = bay + this.top_border
local fbx = bbx * progress
local fby = bby - this.bottom_border
local foreground_size = bby - bay
local foreground_coordinates = fax .. ',' .. fay .. ',' .. fbx .. ',' .. fby -- for clipping
-- Background
ass:new_event()
ass:append(
'{\\blur0\\bord0\\1c&H' .. options.color_background .. '\\iclip(' ..
foreground_coordinates .. ')}')
ass:append(ass_opacity(math.max(options.timeline_opacity - 0.1, 0)))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(bax, bay, bbx, bby)
ass:draw_stop()
-- Foreground
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_foreground .. '}')
ass:append(ass_opacity(options.timeline_opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(fax, fay, fbx, fby)
ass:draw_stop()
-- Seekable ranges
if options.timeline_cached_ranges and state.cached_ranges then
local range_height = math.max(foreground_size / 8, size_min)
local range_ay = fby - range_height
for _, range in ipairs(state.cached_ranges) do
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' ..
options.timeline_cached_ranges.color .. '}')
ass:append(ass_opacity(options.timeline_cached_ranges.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(bbx * (range['start'] / state.duration), range_ay,
bbx * (range['end'] / state.duration),
range_ay + range_height)
ass:draw_stop()
end
end
-- Custom ranges
if state.chapter_ranges ~= nil then
for i, chapter_range in ipairs(state.chapter_ranges) do
for i, range in ipairs(chapter_range.ranges) do
local rax = display.width *
(range['start'].time / state.duration)
local rbx = display.width * (range['end'].time / state.duration)
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. chapter_range.color .. '}')
ass:append(ass_opacity(chapter_range.opacity))
ass:pos(0, 0)
ass:draw_start()
-- for 1px chapter size, use the whole size of the bar including padding
if size <= 1 then
ass:rect_cw(rax, bay, rbx, bby)
else
ass:rect_cw(rax, fay, rbx, fby)
end
ass:draw_stop()
end
end
end
-- Chapters
if options.chapters ~= 'none' and state.chapters ~= nil and #state.chapters >
0 then
local half_size = size / 2
local dots = false
local chapter_size, chapter_y
if options.chapters == 'dots' then
dots = true
chapter_size = math.min(6, (foreground_size / 2) + 2)
chapter_y = math.min(fay + chapter_size, fay + half_size)
elseif options.chapters == 'lines' then
chapter_size = size
chapter_y = fay + (chapter_size / 2)
elseif options.chapters == 'lines-top' then
chapter_size = math.min(this.size_max / 3.5, size)
chapter_y = fay + (chapter_size / 2)
elseif options.chapters == 'lines-bottom' then
chapter_size = math.min(this.size_max / 3.5, size)
chapter_y = fay + size - (chapter_size / 2)
end
if chapter_size ~= nil then
-- for 1px chapter size, use the whole size of the bar including padding
chapter_size = size <= 1 and foreground_size or chapter_size
local chapter_half_size = chapter_size / 2
for i, chapter in ipairs(state.chapters) do
local chapter_x = display.width *
(chapter.time / state.duration)
local color = chapter_x > fbx and options.color_foreground or
options.color_background
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. color .. '}')
ass:append(ass_opacity(options.chapters_opacity))
ass:pos(0, 0)
ass:draw_start()
if dots then
local bezier_stretch = chapter_size * 0.67
ass:move_to(chapter_x - chapter_half_size, chapter_y)
ass:bezier_curve(chapter_x - chapter_half_size,
chapter_y - bezier_stretch,
chapter_x + chapter_half_size,
chapter_y - bezier_stretch,
chapter_x + chapter_half_size, chapter_y)
ass:bezier_curve(chapter_x + chapter_half_size,
chapter_y + bezier_stretch,
chapter_x - chapter_half_size,
chapter_y + bezier_stretch,
chapter_x - chapter_half_size, chapter_y)
else
ass:rect_cw(chapter_x, chapter_y - chapter_half_size,
chapter_x + 1, chapter_y + chapter_half_size)
end
ass:draw_stop()
end
end
end
if text_opacity > 0 then
-- Elapsed time
if state.elapsed_seconds then
ass:new_event()
ass:append('{\\blur0\\bord0\\shad0\\1c&H' ..
options.color_foreground_text .. '\\fn' ..
config.font .. '\\fs' .. this.font_size .. bold_tag ..
'\\clip(' .. foreground_coordinates .. ')')
ass:append(ass_opacity(math.min(options.timeline_opacity + 0.1, 1),
text_opacity))
ass:pos(spacing, fay + (size / 2))
ass:an(4)
ass:append(state.elapsed_time)
ass:new_event()
ass:append('{\\blur0\\bord0\\shad1\\1c&H' ..
options.color_background_text .. '\\4c&H' ..
options.color_background .. '\\fn' .. config.font ..
'\\fs' .. this.font_size .. bold_tag .. '\\iclip(' ..
foreground_coordinates .. ')')
ass:append(ass_opacity(math.min(options.timeline_opacity + 0.1, 1),
text_opacity))
ass:pos(spacing, fay + (size / 2))
ass:an(4)
ass:append(state.elapsed_time)
end
-- Remaining time
if state.remaining_seconds then
ass:new_event()
ass:append('{\\blur0\\bord0\\shad0\\1c&H' ..
options.color_foreground_text .. '\\fn' ..
config.font .. '\\fs' .. this.font_size .. bold_tag ..
'\\clip(' .. foreground_coordinates .. ')')
ass:append(ass_opacity(math.min(options.timeline_opacity + 0.1, 1),
text_opacity))
ass:pos(display.width - spacing, fay + (size / 2))
ass:an(6)
ass:append('-' .. state.remaining_time)
ass:new_event()
ass:append('{\\blur0\\bord0\\shad1\\1c&H' ..
options.color_background_text .. '\\4c&H' ..
options.color_background .. '\\fn' .. config.font ..
'\\fs' .. this.font_size .. bold_tag .. '\\iclip(' ..
foreground_coordinates .. ')')
ass:append(ass_opacity(math.min(options.timeline_opacity + 0.1, 1),
text_opacity))
ass:pos(display.width - spacing, fay + (size / 2))
ass:an(6)
ass:append('-' .. state.remaining_time)
end
end
if (this.proximity_raw == 0 or this.pressed) and
not (elements.speed and elements.speed.dragging) then
-- Hovered time
local hovered_seconds = state.duration * (cursor.x / display.width)
local box_half_width_guesstimate = (this.font_size * 4.2) / 2
ass:new_event()
ass:append('{\\blur0\\bord1\\shad0\\1c&H' ..
options.color_background_text .. '\\3c&H' ..
options.color_background .. '\\fn' .. config.font ..
'\\fs' .. this.font_size .. bold_tag .. '')
ass:append(ass_opacity(math.min(options.timeline_opacity + 0.1, 1)))
ass:pos(math.min(math.max(cursor.x, box_half_width_guesstimate),
display.width - box_half_width_guesstimate), fay)
ass:an(2)
ass:append(mp.format_time(hovered_seconds))
-- Cursor line
ass:new_event()
ass:append('{\\blur0\\bord0\\xshad-1\\yshad0\\1c&H' ..
options.color_foreground .. '\\4c&H' ..
options.color_background .. '}')
ass:append(ass_opacity(0.2))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(cursor.x, fay, cursor.x + 1, fby)
ass:draw_stop()
end
return ass
end
function render_top_bar(this)
local opacity = this:get_effective_proximity()
if not this.enabled or opacity == 0 then return end
local ass = assdraw.ass_new()
if options.top_bar_controls then
-- Close button
local close = elements.window_controls_close
if close.proximity_raw == 0 then
-- Background on hover
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H2311e8}')
ass:append(ass_opacity(this.button_opacity, opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(close.ax, close.ay, close.bx, close.by)
ass:draw_stop()
end
ass:new_event()
ass:append('{\\blur0\\bord1\\shad1\\3c&HFFFFFF\\4c&H000000}')
ass:append(ass_opacity(this.button_opacity, opacity))
ass:pos(close.ax + (this.button_width / 2), (this.size / 2))
ass:draw_start()
ass:move_to(-this.icon_size, this.icon_size)
ass:line_to(this.icon_size, -this.icon_size)
ass:move_to(-this.icon_size, -this.icon_size)
ass:line_to(this.icon_size, this.icon_size)
ass:draw_stop()
-- Maximize button
local maximize = elements.window_controls_maximize
if maximize.proximity_raw == 0 then
-- Background on hover
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H222222}')
ass:append(ass_opacity(this.button_opacity, opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(maximize.ax, maximize.ay, maximize.bx, maximize.by)
ass:draw_stop()
end
ass:new_event()
ass:append('{\\blur0\\bord2\\shad0\\1c\\3c&H000000}')
ass:append(ass_opacity({[3] = this.button_opacity}, opacity))
ass:pos(maximize.ax + (this.button_width / 2), (this.size / 2))
ass:draw_start()
ass:rect_cw(-this.icon_size + 1, -this.icon_size + 1,
this.icon_size + 1, this.icon_size + 1)
ass:draw_stop()
ass:new_event()
ass:append('{\\blur0\\bord2\\shad0\\1c\\3c&HFFFFFF}')
ass:append(ass_opacity({[3] = this.button_opacity}, opacity))
ass:pos(maximize.ax + (this.button_width / 2), (this.size / 2))
ass:draw_start()
ass:rect_cw(-this.icon_size, -this.icon_size, this.icon_size,
this.icon_size)
ass:draw_stop()
-- Minimize button
local minimize = elements.window_controls_minimize
if minimize.proximity_raw == 0 then
-- Background on hover
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H222222}')
ass:append(ass_opacity(this.button_opacity, opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(minimize.ax, minimize.ay, minimize.bx, minimize.by)
ass:draw_stop()
end
ass:new_event()
ass:append('{\\blur0\\bord1\\shad1\\3c&HFFFFFF\\4c&H000000}')
ass:append(ass_opacity(this.button_opacity, opacity))
ass:append('{\\1a&HFF&}')
ass:pos(minimize.ax + (this.button_width / 2), (this.size / 2))
ass:draw_start()
ass:move_to(-this.icon_size, 0)
ass:line_to(this.icon_size, 0)
ass:draw_stop()
end
-- Window title
if options.top_bar_title and state.media_title then
local clip_coordinates =
'0,0,' .. (this.title_bx - this.spacing) .. ',' .. this.size
ass:new_event()
ass:append('{\\q2\\blur0\\bord1\\shad0\\1c&HFFFFFF\\3c&H000000\\fn' ..
config.font .. '\\fs' .. this.font_size .. bold_tag ..
'\\clip(' .. clip_coordinates .. ')')
ass:append(ass_opacity(1, opacity))
ass:pos(0 + this.spacing, this.size / 2)
ass:an(4)
ass:append(state.media_title)
end
return ass
end
function render_volume(this)
local slider = elements.volume_slider
local opacity = this:get_effective_proximity()
if this.width == 0 or opacity == 0 then return end
local ass = assdraw.ass_new()
if slider.height > 0 then
-- Background bar coordinates
local bax = slider.ax
local bay = slider.ay
local bbx = slider.bx
local bby = slider.by
-- Foreground bar coordinates
local height_without_border = slider.height -
(options.volume_border * 2)
local fax = slider.ax + options.volume_border
local fay = slider.ay +
(height_without_border *
(1 - math.min(state.volume / state.volume_max, 1))) +
options.volume_border
local fbx = slider.bx - options.volume_border
local fby = slider.by - options.volume_border
-- Path to draw a foreground bar with a 100% volume indicator, already
-- clipped by volume level. Can't just clip it with rectangle, as it itself
-- also needs to be used as a path to clip the background bar and volume
-- number.
local fpath = assdraw.ass_new()
fpath:move_to(fbx, fby)
fpath:line_to(fax, fby)
local nudge_bottom_y = slider.nudge_y + slider.nudge_size
if fay <= nudge_bottom_y and slider.draw_nudge then
fpath:line_to(fax, math.min(nudge_bottom_y))
if fay <= slider.nudge_y then
fpath:line_to((fax + slider.nudge_size), slider.nudge_y)
local nudge_top_y = slider.nudge_y - slider.nudge_size
if fay <= nudge_top_y then
fpath:line_to(fax, nudge_top_y)
fpath:line_to(fax, fay)
fpath:line_to(fbx, fay)
fpath:line_to(fbx, nudge_top_y)
else
local triangle_side = fay - nudge_top_y
fpath:line_to((fax + triangle_side), fay)
fpath:line_to((fbx - triangle_side), fay)
end
fpath:line_to((fbx - slider.nudge_size), slider.nudge_y)
else
local triangle_side = nudge_bottom_y - fay
fpath:line_to((fax + triangle_side), fay)
fpath:line_to((fbx - triangle_side), fay)
end
fpath:line_to(fbx, nudge_bottom_y)
else
fpath:line_to(fax, fay)
fpath:line_to(fbx, fay)
end
fpath:line_to(fbx, fby)
-- Background
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_background ..
'\\iclip(' .. fpath.scale .. ', ' .. fpath.text .. ')}')
ass:append(ass_opacity(math.max(options.volume_opacity - 0.1, 0),
opacity))
ass:pos(0, 0)
ass:draw_start()
ass:move_to(bax, bay)
ass:line_to(bbx, bay)
local half_border = options.volume_border / 2
if slider.draw_nudge then
ass:line_to(bbx, math.max(slider.nudge_y - slider.nudge_size +
half_border, bay))
ass:line_to(bbx - slider.nudge_size + half_border, slider.nudge_y)
ass:line_to(bbx, slider.nudge_y + slider.nudge_size - half_border)
end
ass:line_to(bbx, bby)
ass:line_to(bax, bby)
if slider.draw_nudge then
ass:line_to(bax, slider.nudge_y + slider.nudge_size - half_border)
ass:line_to(bax + slider.nudge_size - half_border, slider.nudge_y)
ass:line_to(bax, math.max(slider.nudge_y - slider.nudge_size +
half_border, bay))
end
ass:line_to(bax, bay)
ass:draw_stop()
-- Foreground
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_foreground .. '}')
ass:append(ass_opacity(options.volume_opacity, opacity))
ass:pos(0, 0)
ass:draw_start()
ass:append(fpath.text)
ass:draw_stop()
-- Current volume value
local volume_string = tostring(round(state.volume * 10) / 10)
local font_size = round(((this.width * 0.6) -
(#volume_string * (this.width / 20))) *
options.volume_font_scale)
if fay < slider.by - slider.spacing then
ass:new_event()
ass:append('{\\blur0\\bord0\\shad0\\1c&H' ..
options.color_foreground_text .. '\\fn' ..
config.font .. '\\fs' .. font_size .. bold_tag ..
'\\clip(' .. fpath.scale .. ', ' .. fpath.text ..
')}')
ass:append(ass_opacity(math.min(options.volume_opacity + 0.1, 1),
opacity))
ass:pos(slider.ax + (slider.width / 2), slider.by - slider.spacing)
ass:an(2)
ass:append(volume_string)
end
if fay > slider.by - slider.spacing - font_size then
ass:new_event()
ass:append('{\\blur0\\bord0\\shad1\\1c&H' ..
options.color_background_text .. '\\4c&H' ..
options.color_background .. '\\fn' .. config.font ..
'\\fs' .. font_size .. bold_tag .. '\\iclip(' ..
fpath.scale .. ', ' .. fpath.text .. ')}')
ass:append(ass_opacity(math.min(options.volume_opacity + 0.1, 1),
opacity))
ass:pos(slider.ax + (slider.width / 2), slider.by - slider.spacing)
ass:an(2)
ass:append(volume_string)
end
end
-- Mute button
local mute = elements.volume_mute
local icon_name = state.mute and 'volume_muted' or 'volume'
ass:new_event()
ass:append(icon(icon_name, mute.ax + (mute.width / 2),
mute.ay + (mute.height / 2), mute.width * 0.7, -- x, y, size
0, 0, options.volume_border, -- shadow_x, shadow_y, shadow_size
'background', options.volume_opacity * opacity -- backdrop, opacity
))
return ass
end
function render_speed(this)
if not this.dragging and (elements.curtain.opacity > 0) then return end
local timeline = elements.timeline
local proximity = timeline:get_effective_proximity()
local opacity = this.forced_proximity and this.forced_proximity or
(this.dragging and 1 or proximity)
if opacity == 0 then return end
local ass = assdraw.ass_new()
-- Coordinates
local ax = this.ax
local ay = this.ay + timeline.size_max - timeline:get_effective_size() -
timeline.top_border - timeline.bottom_border
local bx = this.bx
local by = ay + this.height
local half_width = (this.width / 2)
local half_x = ax + half_width
-- Notches
local speed_at_center = state.speed
if this.dragging then
speed_at_center = this.dragging.start_speed +
((-this.dragging.distance / this.step_distance) *
options.speed_step)
speed_at_center = math.min(math.max(speed_at_center, 0.01), 100)
end
local nearest_notch_speed = round(speed_at_center / this.notch_every) *
this.notch_every
local nearest_notch_x = half_x +
(((nearest_notch_speed - speed_at_center) /
this.notch_every) * this.notch_spacing)
local guide_size = math.floor(this.height / 7.5)
local notch_by = by - guide_size
local notch_ay_big = ay + round(this.font_size * 1.1)
local notch_ay_medium = notch_ay_big + ((notch_by - notch_ay_big) * 0.2)
local notch_ay_small = notch_ay_big + ((notch_by - notch_ay_big) * 0.4)
local from_to_index = math.floor(this.notches / 2)
for i = -from_to_index, from_to_index do
local notch_speed = nearest_notch_speed + (i * this.notch_every)
if notch_speed < 0 or notch_speed > 100 then goto continue end
local notch_x = nearest_notch_x + (i * this.notch_spacing)
local notch_thickness = 1
local notch_ay = notch_ay_small
if (notch_speed % (this.notch_every * 10)) < 0.00000001 then
notch_ay = notch_ay_big
notch_thickness = 1
elseif (notch_speed % (this.notch_every * 5)) < 0.00000001 then
notch_ay = notch_ay_medium
end
ass:new_event()
ass:append('{\\blur0\\bord1\\shad0\\1c&HFFFFFF\\3c&H000000}')
ass:append(ass_opacity(math.min(1.2 -
(math.abs(
(notch_x - ax - half_width) /
half_width)), 1), opacity))
ass:pos(0, 0)
ass:draw_start()
ass:move_to(notch_x - notch_thickness, notch_ay)
ass:line_to(notch_x + notch_thickness, notch_ay)
ass:line_to(notch_x + notch_thickness, notch_by)
ass:line_to(notch_x - notch_thickness, notch_by)
ass:draw_stop()
::continue::
end
-- Center guide
ass:new_event()
ass:append('{\\blur0\\bord1\\shad0\\1c&HFFFFFF\\3c&H000000}')
ass:append(ass_opacity(options.speed_opacity, opacity))
ass:pos(0, 0)
ass:draw_start()
ass:move_to(half_x, by - 2 - guide_size)
ass:line_to(half_x + guide_size, by - 2)
ass:line_to(half_x - guide_size, by - 2)
ass:draw_stop()
-- Speed value
local speed_text = (round(state.speed * 100) / 100) .. 'x'
ass:new_event()
ass:append(
'{\\blur0\\bord1\\shad0\\1c&H' .. options.color_background_text ..
'\\3c&H' .. options.color_background .. '\\fn' .. config.font ..
'\\fs' .. this.font_size .. bold_tag .. '}')
ass:append(ass_opacity(options.speed_opacity, opacity))
ass:pos(half_x, ay)
ass:an(8)
ass:append(speed_text)
return ass
end
function render_menu(this)
local ass = assdraw.ass_new()
if this.parent_menu then ass:merge(this.parent_menu:render()) end
-- Menu title
if this.title then
-- Background
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_background .. '}')
ass:append(ass_opacity(options.menu_opacity, this.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(this.ax, this.ay - this.item_height, this.bx, this.ay - 1)
ass:draw_stop()
-- Title
ass:new_event()
ass:append('{\\blur0\\bord0\\shad1\\b1\\1c&H' ..
options.color_background_text .. '\\4c&H' ..
options.color_background .. '\\fn' .. config.font ..
'\\fs' .. this.font_size .. '\\q2\\clip(' .. this.ax ..
',' .. this.ay - this.item_height .. ',' .. this.bx ..
',' .. this.ay .. ')}')
ass:append(ass_opacity(options.menu_opacity, this.opacity))
ass:pos(display.width / 2, this.ay - (this.item_height * 0.5))
ass:an(5)
ass:append(this.title)
end
local scroll_area_clip = '\\clip(' .. this.ax .. ',' .. this.ay .. ',' ..
this.bx .. ',' .. this.by .. ')'
for index, item in ipairs(this.items) do
local item_ay = this.ay - this.scroll_y +
(this.item_height * (index - 1) + this.item_spacing *
(index - 1))
local item_by = item_ay + this.item_height
local item_clip = ''
-- Clip items overflowing scroll area
if item_ay <= this.ay or item_by >= this.by then
item_clip = scroll_area_clip
end
if item_by < this.ay or item_ay > this.by then goto continue end
local is_active = this.active_item == index
local font_color, background_color, ass_shadow, ass_shadow_color
local icon_size = this.font_size
if is_active then
font_color, background_color = options.color_foreground_text,
options.color_foreground
ass_shadow, ass_shadow_color = '\\shad0', ''
else
font_color, background_color = options.color_background_text,
options.color_background
ass_shadow, ass_shadow_color = '\\shad1',
'\\4c&H' .. background_color
end
local has_submenu = item.items ~= nil
local hint_width = 0
if item.hint then
hint_width = text_width_estimate(item.hint:len(), this.font_size) +
this.item_content_spacing
elseif has_submenu then
hint_width = icon_size + this.item_content_spacing
end
-- Background
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. background_color .. item_clip ..
'}')
ass:append(ass_opacity(options.menu_opacity, this.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(this.ax, item_ay, this.bx, item_by)
ass:draw_stop()
-- Selected highlight
if this.selected_item == index then
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_foreground ..
item_clip .. '}')
ass:append(ass_opacity(0.1, this.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(this.ax, item_ay, this.bx, item_by)
ass:draw_stop()
end
-- Title
if item.title then
item.ass_save_title = item.ass_save_title or
item.title:gsub("([{}])", "\\%1")
local title_clip_x = (this.bx - hint_width -
this.item_content_spacing)
local title_clip = '\\clip(' .. this.ax .. ',' ..
math.max(item_ay, this.ay) .. ',' ..
title_clip_x .. ',' ..
math.min(item_by, this.by) .. ')'
ass:new_event()
ass:append(
'{\\blur0\\bord0\\shad1\\1c&H' .. font_color .. '\\4c&H' ..
background_color .. '\\fn' .. config.font .. '\\fs' ..
this.font_size .. bold_tag .. title_clip .. '\\q2}')
ass:append(ass_opacity(options.menu_opacity, this.opacity))
ass:pos(this.ax + this.item_content_spacing,
item_ay + (this.item_height / 2))
ass:an(4)
ass:append(item.ass_save_title)
end
-- Hint
if item.hint then
item.ass_save_hint = item.ass_save_hint or
item.hint:gsub("([{}])", "\\%1")
ass:new_event()
ass:append(
'{\\blur0\\bord0' .. ass_shadow .. '\\1c&H' .. font_color .. '' ..
ass_shadow_color .. '\\fn' .. config.font .. '\\fs' ..
(this.font_size - 1) .. bold_tag .. item_clip .. '}')
ass:append(ass_opacity(options.menu_opacity *
(has_submenu and 1 or 0.5), this.opacity))
ass:pos(this.bx - this.item_content_spacing,
item_ay + (this.item_height / 2))
ass:an(6)
ass:append(item.ass_save_hint)
elseif has_submenu then
ass:new_event()
ass:append(icon('arrow_right',
this.bx - this.item_content_spacing -
(icon_size / 2), -- x
item_ay + (this.item_height / 2), -- y
icon_size, -- size
0, 0, 1, -- shadow_x, shadow_y, shadow_size
is_active and 'foreground' or 'background', this.opacity, -- backdrop, opacity
item_clip))
end
::continue::
end
-- Scrollbar
if this.scroll_height > 0 then
local groove_height = this.height - 2
local thumb_height = math.max((this.height /
(this.scroll_height + this.height)) *
groove_height, 40)
local thumb_y = this.ay + 1 +
((this.scroll_y / this.scroll_height) *
(groove_height - thumb_height))
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_foreground .. '}')
ass:append(ass_opacity(options.menu_opacity, this.opacity * 0.8))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(this.bx - 3, thumb_y, this.bx - 1, thumb_y + thumb_height)
ass:draw_stop()
end
return ass
end
-- MAIN RENDERING
-- Request that render() is called.
-- The render is then either executed immediately, or rate-limited if it was
-- called a small time ago.
function request_render()
if state.render_timer == nil then
state.render_timer = mp.add_timeout(0, render)
end
if not state.render_timer:is_enabled() then
local now = mp.get_time()
local timeout = config.render_delay - (now - state.render_last_time)
if timeout < 0 then timeout = 0 end
state.render_timer.timeout = timeout
state.render_timer:resume()
end
end
function render()
state.render_last_time = mp.get_time()
-- Actual rendering
local ass = assdraw.ass_new()
for _, element in elements.ipairs() do
local result = element:maybe('render')
if result then
ass:new_event()
ass:merge(result)
end
end
-- submit
if osd.res_x == display.width and osd.res_y == display.height and osd.data ==
ass.text then return end
osd.res_x = display.width
osd.res_y = display.height
osd.data = ass.text
osd.z = 2000
osd:update()
end
-- STATIC ELEMENTS
if itable_find({'flash', 'static'}, options.pause_indicator) then
elements:add('pause_indicator', Element.new(
{
base_icon_opacity = options.pause_indicator == 'flash' and 1 or 0.8,
paused = false,
is_flash = options.pause_indicator == 'flash',
is_static = options.pause_indicator == 'static',
opacity = 0,
init = function(this)
local initial_call = true
mp.observe_property('pause', 'bool', function(_, paused)
if initial_call then
initial_call = false
return
end
this.paused = paused
if options.pause_indicator == 'flash' then
this.opacity = 1
this:tween_property('opacity', 1, 0, 0.15)
else
this.opacity = paused and 1 or 0
request_render()
end
end)
end,
render = function(this)
if this.opacity == 0 then return end
local ass = assdraw.ass_new()
-- Background fadeout
if this.is_static then
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' ..
options.color_background .. '}')
ass:append(ass_opacity(0.3, this.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(0, 0, display.width, display.height)
ass:draw_stop()
end
-- Icon
local size = round((math.min(display.width, display.height) *
(this.is_static and 0.20 or 0.15)) / 2)
size = size + size * (1 - this.opacity)
if this.paused then
ass:new_event()
ass:append('{\\blur0\\bord1\\1c&H' ..
options.color_foreground .. '\\3c&H' ..
options.color_background .. '}')
ass:append(ass_opacity(this.base_icon_opacity, this.opacity))
ass:pos(display.width / 2, display.height / 2)
ass:draw_start()
ass:rect_cw(-size, -size, -size / 3, size)
ass:draw_stop()
ass:new_event()
ass:append('{\\blur0\\bord1\\1c&H' ..
options.color_foreground .. '\\3c&H' ..
options.color_background .. '}')
ass:append(ass_opacity(this.base_icon_opacity, this.opacity))
ass:pos(display.width / 2, display.height / 2)
ass:draw_start()
ass:rect_cw(size / 3, -size, size, size)
ass:draw_stop()
elseif this.is_flash then
ass:new_event()
ass:append('{\\blur0\\bord1\\1c&H' ..
options.color_foreground .. '\\3c&H' ..
options.color_background .. '}')
ass:append(ass_opacity(this.base_icon_opacity, this.opacity))
ass:pos(display.width / 2, display.height / 2)
ass:draw_start()
ass:move_to(-size * 0.6, -size)
ass:line_to(size, 0)
ass:line_to(-size * 0.6, size)
ass:draw_stop()
end
return ass
end
}))
end
elements:add('timeline', Element.new({
captures = {mouse_buttons = true, wheel = true},
pressed = false,
size_max = 0,
size_min = 0, -- set in `on_display_resize` handler based on `state.fullscreen`
size_min_override = options.timeline_start_hidden and 0 or nil, -- used for toggle-progress command
font_size = 0, -- calculated in on_display_resize
top_border = options.timeline_border,
bottom_border = 0, -- set dynamically in `border` property observer
init = function(this)
-- Toggle 1px bottom border for timeline in no-border mode
mp.observe_property('border', 'bool', function(_, border)
this.bottom_border = not border and options.timeline_border or 0
request_render()
end)
-- Flash on external changes
if options.timeline_flash then
mp.register_event('seek', function()
local position = mp.get_property_native('playback-time')
if position and state.position then
local seek_length = math.abs(position - state.position)
-- Don't flash on video looping (seek to 0) or tiny seeks (frame-step)
if position > 0.5 and seek_length > 0.5 then
this:flash()
end
end
end)
end
end,
get_effective_proximity = function(this)
if (elements.volume_slider and elements.volume_slider.pressed) then
return 0
end
if this.pressed then return 1 end
return this.forced_proximity and this.forced_proximity or this.proximity
end,
get_effective_size_min = function(this)
return this.size_min_override or this.size_min
end,
get_effective_size = function(this)
if elements.speed and elements.speed.dragging then
return this.size_max
end
local size_min = this:get_effective_size_min()
return size_min +
math.ceil((this.size_max - size_min) *
this:get_effective_proximity())
end,
on_display_resize = function(this)
if state.fullscreen or state.maximized then
this.size_min = options.timeline_size_min_fullscreen
this.size_max = options.timeline_size_max_fullscreen
else
this.size_min = options.timeline_size_min
this.size_max = options.timeline_size_max
end
this.font_size = math.floor(math.min((this.size_max + 60) * 0.2,
this.size_max * 0.96) *
options.timeline_font_scale)
this.ax = 0
this.ay = display.height - this.size_max - this.top_border -
this.bottom_border
this.bx = display.width
this.by = display.height
end,
set_from_cursor = function(this)
mp.commandv('seek', ((cursor.x / display.width) * 100),
'absolute-percent+exact')
end,
on_mbtn_left_down = function(this)
this.pressed = true
this:set_from_cursor()
end,
on_global_mbtn_left_up = function(this) this.pressed = false end,
on_global_mouse_leave = function(this) this.pressed = false end,
on_global_mouse_move = function(this)
if this.pressed then this:set_from_cursor() end
end,
on_wheel_up = function(this)
if options.timeline_step > 0 then
mp.commandv('seek', -options.timeline_step)
end
end,
on_wheel_down = function(this)
if options.timeline_step > 0 then
mp.commandv('seek', options.timeline_step)
end
end,
render = render_timeline
}))
if options.top_bar_controls or options.top_bar_title then
elements:add('top_bar', Element.new({
button_opacity = 0.8,
enabled = false,
init = function(this)
mp.observe_property('border', 'bool', function(_, border)
this.enabled = not border
end)
end,
get_effective_proximity = function(this)
if (elements.volume_slider and elements.volume_slider.pressed) or
elements.curtain.opacity > 0 then return 0 end
return this.forced_proximity and this.forced_proximity or
this.proximity
end,
on_display_resize = function(this)
this.size = (state.fullscreen or state.maximized) and
options.top_bar_size_fullscreen or
options.top_bar_size
this.icon_size = round(this.size / 8)
this.spacing = math.ceil(this.size * 0.25)
this.font_size = math.floor(this.size - (this.spacing * 2))
this.button_width = round(this.size * 1.15)
this.title_bx = display.width -
(options.top_bar_controls and
(this.button_width * 3) or 0)
this.ax = options.top_bar_title and 0 or this.title_bx
this.ay = 0
this.bx = display.width
this.by = this.size
end,
render = render_top_bar
}))
end
if options.top_bar_controls then
elements:add('window_controls_minimize', Element.new(
{
captures = {mouse_buttons = true},
on_display_resize = function(this)
this.ax = display.width - (elements.top_bar.button_width * 3)
this.ay = 0
this.bx = this.ax + elements.top_bar.button_width
this.by = elements.top_bar.size
end,
on_mbtn_left_down = function()
mp.commandv('cycle', 'window-minimized')
end
}))
elements:add('window_controls_maximize', Element.new(
{
captures = {mouse_buttons = true},
on_display_resize = function(this)
this.ax = display.width - (elements.top_bar.button_width * 2)
this.ay = 0
this.bx = this.ax + elements.top_bar.button_width
this.by = elements.top_bar.size
end,
on_mbtn_left_down = function()
mp.commandv('cycle', 'window-maximized')
end
}))
elements:add('window_controls_close', Element.new(
{
captures = {mouse_buttons = true},
on_display_resize = function(this)
this.ax = display.width - elements.top_bar.button_width
this.ay = 0
this.bx = this.ax + elements.top_bar.button_width
this.by = elements.top_bar.size
end,
on_mbtn_left_down = function() mp.commandv('quit') end
}))
end
if itable_find({'left', 'right'}, options.volume) then
elements:add('volume', Element.new({
width = nil, -- set in `on_display_resize` handler based on `state.fullscreen`
height = nil, -- set in `on_display_resize` handler based on `state.fullscreen`
margin = nil, -- set in `on_display_resize` handler based on `state.fullscreen`
init = function(this)
-- FLash on external changes
if options.volume_flash then
local is_initial_volume_call = true
mp.observe_property('volume', 'number', function(_, value)
if not is_initial_volume_call then
this:flash()
end
is_initial_volume_call = false
end)
local is_initial_mute_call = true
mp.observe_property('mute', 'bool', function(_, value)
if not is_initial_mute_call then
this:flash()
end
is_initial_mute_call = false
end)
end
end,
get_effective_proximity = function(this)
if elements.volume_slider.pressed then return 1 end
if elements.timeline.proximity_raw == 0 or elements.curtain.opacity >
0 then return 0 end
return this.forced_proximity and this.forced_proximity or
this.proximity
end,
on_display_resize = function(this)
this.width = (state.fullscreen or state.maximized) and
options.volume_size_fullscreen or
options.volume_size
this.height = round(math.min(this.width * 8, (elements.timeline.ay -
elements.top_bar.size) * 0.8))
-- Don't bother rendering this if too small
if this.height < (this.width * 2) then this.height = 0 end
this.margin = this.width / 2
this.ax = round(options.volume == 'left' and this.margin or
display.width - this.margin - this.width)
this.ay = round((display.height - this.height) / 2)
this.bx = round(this.ax + this.width)
this.by = round(this.ay + this.height)
end,
render = render_volume
}))
elements:add('volume_mute', Element.new(
{
captures = {mouse_buttons = true},
width = 0,
height = 0,
on_display_resize = function(this)
this.width = elements.volume.width
this.height = this.width
this.ax = elements.volume.ax
this.ay = elements.volume.by - this.height
this.bx = elements.volume.bx
this.by = elements.volume.by
end,
on_mbtn_left_down = function(this)
mp.commandv('cycle', 'mute')
end
}))
elements:add('volume_slider', Element.new(
{
captures = {mouse_buttons = true, wheel = true},
pressed = false,
width = 0,
height = 0,
nudge_y = 0, -- vertical position where volume overflows 100
nudge_size = nil, -- set on resize
font_size = nil,
spacing = nil,
on_display_resize = function(this)
this.ax = elements.volume.ax
this.ay = elements.volume.ay
this.bx = elements.volume.bx
this.by = elements.volume_mute.ay
this.width = this.bx - this.ax
this.height = this.by - this.ay
this.nudge_y = this.by -
round(this.height * (100 / state.volume_max))
this.nudge_size = round(elements.volume.width * 0.18)
this.draw_nudge = this.ay < this.nudge_y
this.spacing = round(this.width * 0.2)
end,
set_from_cursor = function(this)
local volume_fraction = (this.by - cursor.y -
options.volume_border) /
(this.height - options.volume_border)
local new_volume = math.min(math.max(volume_fraction, 0), 1) *
state.volume_max
new_volume = round(new_volume / options.volume_step) *
options.volume_step
if state.volume ~= new_volume then
mp.commandv('set', 'volume',
math.min(new_volume, state.volume_max))
end
end,
on_mbtn_left_down = function(this)
this.pressed = true
this:set_from_cursor()
end,
on_global_mbtn_left_up = function(this)
this.pressed = false
end,
on_global_mouse_leave = function(this)
this.pressed = false
end,
on_global_mouse_move = function(this)
if this.pressed then this:set_from_cursor() end
end,
on_wheel_up = function(this)
local current_rounded_volume =
round(state.volume / options.volume_step) *
options.volume_step
mp.commandv('set', 'volume', math.min(
current_rounded_volume + options.volume_step,
state.volume_max))
end,
on_wheel_down = function(this)
local current_rounded_volume =
round(state.volume / options.volume_step) *
options.volume_step
mp.commandv('set', 'volume', math.min(
current_rounded_volume - options.volume_step,
state.volume_max))
end
}))
end
if options.speed then
elements:add('speed', Element.new({
captures = {mouse_buttons = true, wheel = true},
dragging = nil,
width = 0,
height = 0,
notches = 10,
notch_every = 0.1,
step_distance = nil,
font_size = nil,
init = function(this)
-- Fade out/in on timeline mouse enter/leave
elements.timeline:on('mouse_enter', function()
if not this.dragging then this:fadeout() end
end)
elements.timeline:on('mouse_leave', function()
if not this.dragging then this:fadein() end
end)
-- Flash on external changes
if options.speed_flash then
local initial_call = true
mp.observe_property('speed', 'number', function()
if not initial_call and not this.dragging then
this:flash()
end
initial_call = false
end)
end
end,
fadeout = function(this)
this:tween_property('forced_proximity', 1, 0,
function(this)
this.forced_proximity = 0
end)
end,
fadein = function(this)
local get_current_proximity =
function() return this.proximity end
this:tween_property('forced_proximity', 0, get_current_proximity,
function(this)
this.forced_proximity = nil
end)
end,
on_display_resize = function(this)
this.height = (state.fullscreen or state.maximized) and
options.speed_size_fullscreen or
options.speed_size
this.width = round(this.height * 3.6)
this.notch_spacing = this.width / this.notches
this.step_distance = this.notch_spacing *
(options.speed_step / this.notch_every)
this.ax = (display.width - this.width) / 2
this.by = display.height - elements.timeline.size_max
this.ay = this.by - this.height
this.bx = this.ax + this.width
this.font_size =
round(this.height * 0.48 * options.speed_font_scale)
end,
set_from_cursor = function(this)
local volume_fraction =
(this.by - cursor.y - options.volume_border) /
(this.height - options.volume_border)
local new_volume = math.min(math.max(volume_fraction, 0), 1) *
state.volume_max
new_volume = round(new_volume / options.volume_step) *
options.volume_step
if state.volume ~= new_volume then
mp.commandv('set', 'volume', new_volume)
end
end,
on_mbtn_left_down = function(this)
this:tween_stop() -- Stop and cleanup possible ongoing animations
this.dragging = {
start_time = mp.get_time(),
start_x = cursor.x,
distance = 0,
start_speed = state.speed
}
end,
on_global_mouse_move = function(this)
if not this.dragging then return end
this.dragging.distance = cursor.x - this.dragging.start_x
local steps_dragged = round(-this.dragging.distance /
this.step_distance)
local new_speed = this.dragging.start_speed +
(steps_dragged * options.speed_step)
mp.set_property_native('speed', round(new_speed * 100) / 100)
end,
on_mbtn_left_up = function(this)
-- Reset speed on short clicks
if this.dragging and math.abs(this.dragging.distance) < 6 and
mp.get_time() - this.dragging.start_time < 0.15 then
mp.set_property_native('speed', 1)
end
end,
on_global_mbtn_left_up = function(this)
if this.dragging and elements.timeline.proximity_raw == 0 then
this:fadeout()
end
this.dragging = nil
request_render()
end,
on_global_mouse_leave = function(this)
this.dragging = nil
request_render()
end,
on_wheel_up = function(this)
mp.set_property_native('speed', state.speed - options.speed_step)
end,
on_wheel_down = function(this)
mp.set_property_native('speed', state.speed + options.speed_step)
end,
render = render_speed
}))
end
elements:add('curtain', Element.new({
opacity = 0,
fadeout = function(this) this:tween_property('opacity', this.opacity, 0); end,
fadein = function(this) this:tween_property('opacity', this.opacity, 1); end,
render = function(this)
if this.opacity > 0 then
local ass = assdraw.ass_new()
ass:new_event()
ass:append('{\\blur0\\bord0\\1c&H' .. options.color_background ..
'}')
ass:append(ass_opacity(0.4, this.opacity))
ass:pos(0, 0)
ass:draw_start()
ass:rect_cw(0, 0, display.width, display.height)
ass:draw_stop()
return ass
end
end
}))
-- CHAPTERS SERIALIZATION
-- Parse `chapter_ranges` option into workable data structure
for _, definition in ipairs(split(options.chapter_ranges, ' *,+ *')) do
local start_patterns, color, opacity, end_patterns =
string.match(definition, '([^<]+)<(%x%x%x%x%x%x):(%d?%.?%d*)>([^>]+)')
-- Invalid definition
if start_patterns == nil then goto continue end
start_patterns = start_patterns:lower()
end_patterns = end_patterns:lower()
local uses_bof = start_patterns:find('{bof}') ~= nil
local uses_eof = end_patterns:find('{eof}') ~= nil
local chapter_range = {
start_patterns = split(start_patterns, '|'),
end_patterns = split(end_patterns, '|'),
color = color,
opacity = tonumber(opacity),
ranges = {}
}
-- Filter out special keywords so we don't use them when matching titles
if uses_bof then
chapter_range.start_patterns = itable_remove(
chapter_range.start_patterns, '{bof}')
end
if uses_eof and chapter_range.end_patterns then
chapter_range.end_patterns = itable_remove(chapter_range.end_patterns,
'{eof}')
end
chapter_range['serialize'] = function(chapters)
chapter_range.ranges = {}
local current_range = nil
-- bof and eof should be used only once per timeline
-- eof is only used when last range is missing end
local bof_used = false
function start_range(chapter)
-- If there is already a range started, should we append or overwrite?
-- I chose overwrite here.
current_range = {['start'] = chapter}
end
function end_range(chapter)
current_range['end'] = chapter
chapter_range.ranges[#chapter_range.ranges + 1] = current_range
-- Mark both chapter objects
current_range['start']._uosc_used_as_range_point = true
current_range['end']._uosc_used_as_range_point = true
-- Clear for next range
current_range = nil
end
for _, chapter in ipairs(chapters) do
if type(chapter.title) == 'string' then
local lowercase_title = chapter.title:lower()
local is_end = false
local is_start = false
-- Is ending check and handling
if chapter_range.end_patterns then
for _, end_pattern in ipairs(chapter_range.end_patterns) do
is_end = is_end or lowercase_title:find(end_pattern) ~=
nil
end
if is_end then
if current_range == nil and uses_bof and not bof_used then
bof_used = true
start_range({time = 0})
end
if current_range ~= nil then
end_range(chapter)
else
is_end = false
end
end
end
-- Is start check and handling
for _, start_pattern in ipairs(chapter_range.start_patterns) do
is_start =
is_start or lowercase_title:find(start_pattern) ~= nil
end
if is_start then start_range(chapter) end
end
end
-- If there is an unfinished range and range type accepts eof, use it
if current_range ~= nil and uses_eof then
end_range({time = state.duration or infinity})
end
end
state.chapter_ranges = state.chapter_ranges or {}
state.chapter_ranges[#state.chapter_ranges + 1] = chapter_range
::continue::
end
function parse_chapters()
-- Sometimes state.duration is not initialized yet for some reason
state.duration = mp.get_property_native('duration')
local chapters = get_normalized_chapters()
if not chapters or not state.duration then return end
-- Reset custom ranges
for _, chapter_range in ipairs(state.chapter_ranges or {}) do
chapter_range.serialize(chapters)
end
-- Filter out chapters that were used as ranges
state.chapters = itable_remove(chapters, function(chapter)
return chapter._uosc_used_as_range_point == true
end)
request_render()
end
-- CONTEXT MENU SERIALIZATION
state.context_menu_items = (function()
local input_conf_path = mp.command_native({'expand-path', '~~/input.conf'})
local input_conf_meta, meta_error = utils.file_info(input_conf_path)
-- File doesn't exist
if not input_conf_meta or not input_conf_meta.is_file then return end
local items = {}
local items_by_command = {}
local submenus_by_id = {}
for line in io.lines(input_conf_path) do
local key, command, title = string.match(line,
' *([%S]+) +(.*) #! *(.*)')
if key then
local is_dummy = key:sub(1, 1) == '#'
local submenu_id = ''
local target_menu = items
local title_parts = split(title or '', ' *> *')
for index, title_part in ipairs(
#title_parts > 0 and title_parts or
{''}) do
if index < #title_parts then
submenu_id = submenu_id .. title_part
if not submenus_by_id[submenu_id] then
submenus_by_id[submenu_id] =
{title = title_part, items = {}}
target_menu[#target_menu + 1] =
submenus_by_id[submenu_id]
end
target_menu = submenus_by_id[submenu_id].items
else
-- If command is already in menu, just append the key to it
if items_by_command[command] then
items_by_command[command].hint =
items_by_command[command].hint .. ', ' .. key
else
items_by_command[command] =
{
title = title_part,
hint = not is_dummy and key or nil,
value = command
}
target_menu[#target_menu + 1] =
items_by_command[command]
end
end
end
end
end
if #items > 0 then return items end
end)()
-- EVENT HANDLERS
function create_state_setter(name)
return function(_, value)
state[name] = value
dispatch_event_to_elements('prop_' .. name, value)
request_render()
end
end
function dispatch_event_to_elements(name, ...)
for _, element in pairs(elements) do
if element.proximity_raw == 0 then
element:maybe('on_' .. name, ...)
end
element:maybe('on_global_' .. name, ...)
end
end
function create_event_to_elements_dispatcher(name, ...)
return function(...) dispatch_event_to_elements(name, ...) end
end
function handle_mouse_leave()
-- Slowly fadeout elements that are currently visible
for _, element_name in ipairs({'timeline', 'volume', 'top_bar'}) do
local element = elements[element_name]
if element and element.proximity > 0 then
element:tween_property('forced_proximity',
element:get_effective_proximity(), 0,
function()
element.forced_proximity = nil
end)
end
end
cursor.hidden = true
update_proximities()
dispatch_event_to_elements('mouse_leave')
end
function handle_mouse_enter()
cursor.hidden = false
cursor.x, cursor.y = mp.get_mouse_pos()
tween_element_stop(state)
dispatch_event_to_elements('mouse_enter')
end
function handle_mouse_move()
-- Handle case when we are in cursor hidden state but not left the actual
-- window (i.e. when autohide simulates mouse_leave).
if cursor.hidden then
handle_mouse_enter()
return
end
cursor.x, cursor.y = mp.get_mouse_pos()
update_proximities()
dispatch_event_to_elements('mouse_move')
request_render()
-- Restart timer that hides UI when mouse is autohidden
if options.autohide then
state.cursor_autohide_timer:kill()
state.cursor_autohide_timer:resume()
end
end
function navigate_directory(direction)
local path = mp.get_property_native("path")
if not path or is_protocol(path) then return end
local next_file = get_adjacent_file(path, direction, options.media_types)
if next_file then
mp.commandv("loadfile",
utils.join_path(serialize_path(path).dirname, next_file))
end
end
function load_file_in_current_directory(index)
local path = mp.get_property_native("path")
if not path or is_protocol(path) then return end
local dirname = serialize_path(path).dirname
local files = get_files_in_directory(dirname, options.media_types)
if not files then return end
if index < 0 then index = #files + index + 1 end
if files[index] then
mp.commandv("loadfile", utils.join_path(dirname, files[index]))
end
end
-- MENUS
function create_select_tracklist_type_menu_opener(menu_title, track_type,
track_prop)
return function()
if menu:is_open(track_type) then
menu:close()
return
end
local items = {}
local active_item = nil
for index, track in ipairs(mp.get_property_native('track-list')) do
if track.type == track_type then
if track.selected then active_item = track.id end
items[#items + 1] = {
title = (track.title and track.title or 'Track ' .. track.id),
hint = track.lang and track.lang:upper() or nil,
value = track.id
}
end
end
-- Add option to disable a subtitle track. This works for all tracks,
-- but why would anyone want to disable audio or video? Better to not
-- let people mistakenly select what is unwanted 99.999% of the time.
-- If I'm mistaken and there is an active need for this, feel free to
-- open an issue.
if track_type == 'sub' then
active_item = active_item and active_item + 1 or 1
table.insert(items, 1, {hint = 'disabled', value = nil})
end
menu:open(items, function(id)
mp.commandv('set', track_prop, id and id or 'no')
-- If subtitle track was selected, assume user also wants to see it
if id and track_type == 'sub' then
mp.commandv('set', 'sub-visibility', 'yes')
end
menu:close()
end, {type = track_type, title = menu_title, active_item = active_item})
end
end
-- `menu_options`:
-- **allowed_types** - table with file extensions to display
-- **active_path** - full path of a file to preselect
-- Rest of the options are passed to `menu:open()`
function open_file_navigation_menu(directory, handle_select, menu_options)
directory = serialize_path(directory)
local directories, error = utils.readdir(directory.path, 'dirs')
local files, error = get_files_in_directory(directory.path,
menu_options.allowed_types)
if not files or not directories then
msg.error('Retrieving files from ' .. directory .. ' failed: ' ..
(error or ''))
return
end
-- Files are already sorted
table.sort(directories, word_order_comparator)
-- Pre-populate items with parent directory selector if not at root
local items = not directory.dirname and {} or
{
{title = '..', hint = 'parent dir', value = directory.dirname}
}
for _, dir in ipairs(directories) do
local serialized = serialize_path(utils.join_path(directory.path, dir))
items[#items + 1] = {
title = serialized.basename,
value = serialized.path,
hint = '/'
}
end
menu_options.active_item = nil
for _, file in ipairs(files) do
local serialized = serialize_path(utils.join_path(directory.path, file))
local item_index = #items + 1
items[item_index] = {
title = serialized.basename,
value = serialized.path
}
if menu_options.active_path == serialized.path then
menu_options.active_item = item_index
end
end
menu_options.title = directory.basename .. '/'
menu:open(items, function(path)
local meta, error = utils.file_info(path)
if not meta then
msg.error('Retrieving file info for ' .. path .. ' failed: ' ..
(error or ''))
return
end
if meta.is_dir then
open_file_navigation_menu(path, handle_select, menu_options)
else
handle_select(path)
menu:close()
end
end, menu_options)
end
-- VALUE SERIALIZATION/NORMALIZATION
options.proximity_out =
math.max(options.proximity_out, options.proximity_in + 1)
options.chapters = itable_find({'dots', 'lines', 'lines-top', 'lines-bottom'},
options.chapters) and options.chapters or 'none'
options.media_types = split(options.media_types, ' *, *')
options.subtitle_types = split(options.subtitle_types, ' *, *')
options.timeline_cached_ranges = (function()
if options.timeline_cached_ranges == '' or options.timeline_cached_ranges ==
'no' then return nil end
local parts = split(options.timeline_cached_ranges, ':')
return parts[1] and {color = parts[1], opacity = tonumber(parts[2])} or nil
end)()
-- HOOKS
mp.register_event('file-loaded', parse_chapters)
mp.observe_property('chapter-list', 'native', parse_chapters)
mp.observe_property('duration', 'number', create_state_setter('duration'))
mp.observe_property('media-title', 'string', create_state_setter('media_title'))
mp.observe_property('fullscreen', 'bool', create_state_setter('fullscreen'))
mp.observe_property('window-maximized', 'bool', create_state_setter('maximized'))
mp.observe_property('idle-active', 'bool', create_state_setter('idle'))
mp.observe_property('speed', 'number', create_state_setter('speed'))
mp.observe_property('pause', 'bool', create_state_setter('pause'))
mp.observe_property('volume', 'number', create_state_setter('volume'))
mp.observe_property('volume-max', 'number', create_state_setter('volume_max'))
mp.observe_property('mute', 'bool', create_state_setter('mute'))
mp.observe_property('playback-time', 'number', function(name, val)
-- Ignore the initial call with nil value
if val == nil then return end
state.position = val
state.elapsed_seconds = val
state.elapsed_time = state.elapsed_seconds and
mp.format_time(state.elapsed_seconds) or nil
state.remaining_seconds = mp.get_property_native('playtime-remaining')
state.remaining_time = state.remaining_seconds and
mp.format_time(state.remaining_seconds) or nil
request_render()
end)
mp.observe_property('osd-dimensions', 'native', function(name, val)
update_display_dimensions()
request_render()
end)
mp.observe_property('demuxer-cache-state', 'native', function(prop, cache_state)
if cache_state == nil then
state.cached_ranges = nil
return
end
local cache_ranges = cache_state['seekable-ranges']
state.cached_ranges = #cache_ranges > 0 and cache_ranges or nil
end)
-- CONTROLS
-- Mouse movement key binds
local base_keybinds = {
{'mouse_move', handle_mouse_move}, {'mouse_leave', handle_mouse_leave},
{'mouse_enter', handle_mouse_enter}
}
if options.pause_on_click_shorter_than > 0 then
-- Cycles pause when click is shorter than `options.pause_on_click_shorter_than`
-- while filtering out double clicks.
local duration_seconds = options.pause_on_click_shorter_than / 1000
local last_down_event;
local click_timer = mp.add_timeout(duration_seconds,
function() mp.command('cycle pause') end);
click_timer:kill()
base_keybinds[#base_keybinds + 1] = {
'mbtn_left', function()
if mp.get_time() - last_down_event < duration_seconds then
click_timer:resume()
end
end, function()
if click_timer:is_enabled() then
click_timer:kill()
last_down_event = 0
else
last_down_event = mp.get_time()
end
end
}
end
mp.set_key_bindings(base_keybinds, 'mouse_movement', 'force')
mp.enable_key_bindings('mouse_movement', 'allow-vo-dragging+allow-hide-cursor')
-- Context based key bind groups
forced_key_bindings = (function()
mp.set_key_bindings({
{
'mbtn_left', create_event_to_elements_dispatcher('mbtn_left_up'),
create_event_to_elements_dispatcher('mbtn_left_down')
}, {'mbtn_left_dbl', 'ignore'}
}, 'mouse_buttons', 'force')
mp.set_key_bindings({
{'wheel_up', create_event_to_elements_dispatcher('wheel_up')},
{'wheel_down', create_event_to_elements_dispatcher('wheel_down')}
}, 'wheel', 'force')
local groups = {}
for _, group in ipairs({'mouse_buttons', 'wheel'}) do
groups[group] = {
is_enabled = false,
enable = function(this)
if this.is_enabled then return end
this.is_enabled = true
mp.enable_key_bindings(group)
end,
disable = function(this)
if not this.is_enabled then return end
this.is_enabled = false
mp.disable_key_bindings(group)
end
}
end
return groups
end)()
-- KEY BINDABLE FEATURES
mp.add_key_binding(nil, 'peek-timeline', function()
if elements.timeline.proximity > 0.5 then
elements.timeline:tween_property('proximity',
elements.timeline.proximity, 0)
else
elements.timeline:tween_property('proximity',
elements.timeline.proximity, 1)
end
end)
mp.add_key_binding(nil, 'toggle-progress', function()
local timeline = elements.timeline
if timeline.size_min_override then
timeline:tween_property('size_min_override', timeline.size_min_override,
timeline.size_min,
function()
timeline.size_min_override = nil
end)
else
timeline:tween_property('size_min_override', timeline.size_min, 0)
end
end)
mp.add_key_binding(nil, 'menu', function()
if menu:is_open('menu') then
menu:close()
elseif state.context_menu_items then
menu:open(state.context_menu_items,
function(command) mp.command(command) end, {type = 'menu'})
end
end)
mp.add_key_binding(nil, 'load-subtitles', function()
if menu:is_open('load-subtitles') then
menu:close()
return
end
local path = mp.get_property_native('path')
if path and not is_protocol(path) then
open_file_navigation_menu(serialize_path(path).dirname, function(path)
mp.commandv('sub-add', path)
end, {type = 'load-subtitles', allowed_types = options.subtitle_types})
end
end)
mp.add_key_binding(nil, 'subtitles', create_select_tracklist_type_menu_opener(
'Subtitles', 'sub', 'sid'))
mp.add_key_binding(nil, 'audio', create_select_tracklist_type_menu_opener(
'Audio', 'audio', 'aid'))
mp.add_key_binding(nil, 'video', create_select_tracklist_type_menu_opener(
'Video', 'video', 'vid'))
mp.add_key_binding(nil, 'playlist', function()
if menu:is_open('playlist') then
menu:close()
return
end
function serialize_playlist()
local pos = mp.get_property_number('playlist-pos-1', 0)
local items = {}
local active_item
for index, item in ipairs(mp.get_property_native('playlist')) do
local is_url = item.filename:find('://')
items[index] = {
title = is_url and item.filename or
serialize_path(item.filename).basename,
hint = tostring(index),
value = index
}
if index == pos then active_item = index end
end
return items, active_item
end
-- Update active index and playlist content on playlist changes
function handle_playlist_change()
if menu:is_open('playlist') then
local items, active_item = serialize_playlist()
elements.menu:set_items(items, {
active_item = active_item,
selected_item = active_item
})
end
end
local items, active_item = serialize_playlist()
menu:open(items, function(index)
mp.commandv('set', 'playlist-pos-1', tostring(index))
end, {
type = 'playlist',
title = 'Playlist',
active_item = active_item,
on_open = function()
mp.observe_property('playlist', 'native', handle_playlist_change)
mp.observe_property('playlist-pos-1', 'native',
handle_playlist_change)
end,
on_close = function()
mp.unobserve_property(handle_playlist_change)
end
})
end)
mp.add_key_binding(nil, 'chapters', function()
if menu:is_open('chapters') then
menu:close()
return
end
local items = {}
local chapters = get_normalized_chapters()
for index, chapter in ipairs(chapters) do
items[#items + 1] = {
title = chapter.title or '',
hint = mp.format_time(chapter.time),
value = chapter.time
}
end
-- Select first chapter from the end with time lower
-- than current playing position (with 100ms leeway).
function get_selected_chapter_index()
local position = mp.get_property_native('playback-time')
if not position then return nil end
for index = #items, 1, -1 do
if position - 0.1 > items[index].value then return index end
end
end
-- Update selected chapter in chapter navigation menu
function seek_handler()
if menu:is_open('chapters') then
elements.menu:activate_index(get_selected_chapter_index())
end
end
menu:open(items, function(time)
mp.commandv('seek', tostring(time), 'absolute')
end, {
type = 'chapters',
title = 'Chapters',
active_item = get_selected_chapter_index(),
on_open = function() mp.register_event('seek', seek_handler) end,
on_close = function() mp.unregister_event(seek_handler) end
})
end)
mp.add_key_binding(nil, 'show-in-directory', function()
local path = mp.get_property_native('path')
-- Ignore URLs
if not path or is_protocol(path) then return end
path = normalize_path(path)
if state.os == 'windows' then
utils.subprocess_detached({
args = {'explorer', '/select,', path},
cancellable = false
})
elseif state.os == 'macos' then
utils.subprocess_detached({
args = {'open', '-R', path},
cancellable = false
})
elseif state.os == 'linux' then
local result = utils.subprocess({
args = {'nautilus', path},
cancellable = false
})
-- Fallback opens the folder with xdg-open instead
if result.status ~= 0 then
utils.subprocess({
args = {'xdg-open', serialize_path(path).dirname},
cancellable = false
})
end
end
end)
mp.add_key_binding(nil, 'open-file', function()
if menu:is_open('open-file') then
menu:close()
return
end
local path = mp.get_property_native('path')
local directory
local active_file
if path == nil or is_protocol(path) then
local path = serialize_path(mp.command_native({'expand-path', '~/'}))
directory = path.path
active_file = nil
else
local path = serialize_path(path)
directory = path.dirname
active_file = path.path
end
-- Update selected file in directory navigation menu
function handle_file_loaded()
if menu:is_open('open-file') then
local path = normalize_path(mp.get_property_native('path'))
elements.menu:activate_value(path)
elements.menu:select_value(path)
end
end
open_file_navigation_menu(directory,
function(path) mp.commandv('loadfile', path) end,
{
type = 'open-file',
allowed_types = options.media_types,
active_path = active_file,
on_open = function()
mp.register_event('file-loaded', handle_file_loaded)
end,
on_close = function() mp.unregister_event(handle_file_loaded) end
})
end)
mp.add_key_binding(nil, 'next', function()
if mp.get_property_native('playlist-count') > 1 then
mp.command('playlist-next')
else
navigate_directory('forward')
end
end)
mp.add_key_binding(nil, 'prev', function()
if mp.get_property_native('playlist-count') > 1 then
mp.command('playlist-prev')
else
navigate_directory('backward')
end
end)
mp.add_key_binding(nil, 'next-file',
function() navigate_directory('forward') end)
mp.add_key_binding(nil, 'prev-file',
function() navigate_directory('backward') end)
mp.add_key_binding(nil, 'first', function()
if mp.get_property_native('playlist-count') > 1 then
mp.commandv('set', 'playlist-pos-1', '1')
else
load_file_in_current_directory(1)
end
end)
mp.add_key_binding(nil, 'last', function()
local playlist_count = mp.get_property_native('playlist-count')
if playlist_count > 1 then
mp.commandv('set', 'playlist-pos-1', tostring(playlist_count))
else
load_file_in_current_directory(-1)
end
end)
mp.add_key_binding(nil, 'first-file',
function() load_file_in_current_directory(1) end)
mp.add_key_binding(nil, 'last-file',
function() load_file_in_current_directory(-1) end)
mp.add_key_binding(nil, 'delete-file-next', function()
local path = mp.get_property_native('path')
if not path or is_protocol(path) then return end
path = normalize_path(path)
local playlist_count = mp.get_property_native('playlist-count')
if playlist_count > 1 then
mp.commandv('playlist-remove', 'current')
else
local next_file =
get_adjacent_file(path, 'forward', options.media_types)
if menu:is_open('open-file') then
elements.menu:delete_value(path)
end
if next_file then
mp.commandv('loadfile', next_file)
else
mp.commandv('stop')
end
end
os.remove(path)
end)
mp.add_key_binding(nil, 'delete-file-quit', function()
local path = mp.get_property_native('path')
if not path or is_protocol(path) then return end
os.remove(normalize_path(path))
mp.command('quit')
end)
mp.add_key_binding(nil, 'open-config-directory', function()
local config = serialize_path(mp.command_native(
{'expand-path', '~~/mpv.conf'}))
local args
if state.os == 'windows' then
args = {'explorer', '/select,', config.path}
elseif state.os == 'macos' then
args = {'open', '-R', config.path}
elseif state.os == 'linux' then
args = {'xdg-open', config.dirname}
end
utils.subprocess_detached({args = args, cancellable = false})
end)
Reference in a new issue View git blame Copy permalink