diff options
| -rw-r--r-- | README.md | 1 | ||||
| -rw-r--r-- | plugins/ipc.lua | 1026 |
2 files changed, 1027 insertions, 0 deletions
@@ -55,6 +55,7 @@ _Note: if you make a pull request, the table should be updated and kept in alpha | [`immersive-title`](https://github.com/takase1121/lite-xl-immersive-title)\* | Dark (or even Mica!) title bar for Lite XL | | [`indent_convert`](plugins/indent_convert.lua?raw=1) | Convert between tabs and spaces indentation | | [`indentguide`](plugins/indentguide.lua?raw=1) | Adds indent guides _([screenshot](https://user-images.githubusercontent.com/3920290/79640716-f9860000-818a-11ea-9c3b-26d10dd0e0c0.png))_ | +| [`ipc`](plugins/ipc.lua?raw=1) | Adds inter-process communication support | | [`Kinc Projects`](https://github.com/Kode-Community/kinc_plugin)\* | Adds [Kinc](https://github.com/Kode/Kinc) Project generation with basic build commands(depends on [`console`](https://github.com/franko/console)) | | [`language_angelscript`](plugins/language_angelscript.lua?raw=1) | Syntax for the [Angelscript](https://www.angelcode.com/angelscript/) programming language | | [`language_assembly_x86`](plugins/language_assembly_x86.lua?raw=1) | Syntax for Intel x86 assembly | diff --git a/plugins/ipc.lua b/plugins/ipc.lua new file mode 100644 index 0000000..128e39c --- /dev/null +++ b/plugins/ipc.lua @@ -0,0 +1,1026 @@ +-- mod-version:3 +-- +-- Crossplatform file based IPC system for lite-xl. +-- @copyright Jefferson Gonzalez <jgmdev@gmail.com> +-- @license MIT +-- +local core = require "core" +local config = require "core.config" +local common = require "core.common" +local command = require "core.command" +local Object = require "core.object" +local RootView = require "core.rootview" +local settings_found, settings = pcall(require, "plugins.settings") + +---The maximum amount of seconds a message will be broadcasted. +---@type integer +local MESSAGE_EXPIRATION=3 + +---@class config.plugins.ipc +---@field single_instance boolean +---@field dirs_instance boolean +config.plugins.ipc = common.merge({ + single_instance = true, + dirs_instance = true, + -- The config specification used by the settings gui + config_spec = { + name = "Inter-process communication", + { + label = "Single Instance", + description = "Run a single instance of lite-xl.", + path = "single_instance", + type = "toggle", + default = true + }, + { + label = "Directories Instance", + description = "Open a new instance for directories.", + path = "dirs_instance", + type = "toggle", + default = true + } + } +}, config.plugins.ipc) + +---@alias plugins.ipc.onmessageread fun(message: plugins.ipc.message) | nil +---@alias plugins.ipc.onreplyread fun(reply: plugins.ipc.reply) | nil +---@alias plugins.ipc.onmessage fun(message: plugins.ipc.message, reply: plugins.ipc.reply) | nil +---@alias plugins.ipc.onreply fun(reply: plugins.ipc.reply) | nil +---@alias plugins.ipc.function fun(...) + +---@alias plugins.ipc.messagetype +---| '"message"' +---| '"method"' +---| '"signal"' + +---@class plugins.ipc.message +---@field id string +---@field sender string +---@field name string +---@field type plugins.ipc.messagetype | string +---@field destinations table<integer,string> +---@field data table<string,any> +---@field timestamp number +---@field on_read plugins.ipc.onmessageread +---@field on_reply plugins.ipc.onreply +---@field replies plugins.ipc.reply[] +local IPCMessage = { + ---Id of the message + id = "", + ---The id of process that sent the message + sender = "", + ---Name of the message + name = "", + ---Type of message. + type = "", + ---List with id of the instance that should receive the message. + destinations = {}, + ---A list of named values sent to receivers. + data = {}, + ---Time in seconds when the message was sent for automatic expiration purposes. + timestamp = 0, + ---Optional callback executed by the receiver when the message is read. + on_read = function(message) end, + ---Optional callback executed when a reply to the message is received. + on_reply = function(reply) end, + ---The received replies for the message. + replies = {} +} + +---@class plugins.ipc.reply +---@field id string +---@field sender string +---@field replier string +---@field data table<string,any> +---@field timestamp number +---@field on_read plugins.ipc.onreplyread +local IPCReply = { + ---Id of the message + id = "", + ---The id of process that sent the message + sender = "", + ---The id of the replier + replier = "", + ---A list of named values sent back to sender. + data = {}, + ---Time in seconds when the reply was sent for automatic expiration purposes. + timestamp = 0, + ---Optional callback executed by the sender when the reply is read. + on_read = function(reply) end +} + +---@class plugins.ipc.instance +---@field id string +---@field position integer +---@field last_update integer +---@field messages plugins.ipc.message[] +---@field replies plugins.ipc.reply[] +---@field properties table +local IPCInstance = { + ---Process id of the instance. + id = "", + ---The position in which the instance was launched. + position = 0, + ---Flag that indicates if this instance was the first started. + primary = false, + ---Indicates the last time this instance updated its session file. + last_update = 0, + ---The messages been broadcasted. + messages = {}, + ---The replies been broadcasted. + replies = {}, + ---Table of properties associated with the instance. + properties = {} +} + +---@class core.ipc : core.object +---@field private id string +---@field private user_dir string +---@field private running boolean +---@field private file string +---@field private primary boolean +---@field private position integer +---@field private messages plugins.ipc.message[] +---@field private replies plugins.ipc.reply[] +---@field private listeners table<string,table<integer,plugins.ipc.onmessage>> +---@field private signals table<string,integer> +---@field private methods table<string,integer> +---@field private signal_definitions table<integer,string> +---@field private method_definitions table<integer,string> +local IPC = Object:extend() + +---@class plugins.ipc.threads +---@field cr thread +---@field wake number + +---List of threads belonging to all instantiated IPC objects. +---@type plugins.ipc.threads[] +local threads = {} + +---Register a new thread to be run on the background. +---@param f function +local function add_thread(f) + local key = #threads + 1 + threads[key] = { cr = coroutine.create(f), wake = 0 } + return key +end + +---Updates the session file of an IPC object. +---@param self core.ipc +local function update_file(self) + local file, errmsg = io.open(self.file, "w+") + + if file then + local output = "-- Warning: Generated by IPC system do not edit manually!\n" + .. "return " .. common.serialize( + { + id = self.id, + primary = self.primary, + position = self.position, + last_update = os.time(), + messages = self.messages, + replies = self.replies, + signals = self.signal_definitions, + methods = self.method_definitions + }, + { + pretty = true + } + ) + + output = output:gsub("%s+%[\"on_reply\"%].-\n", "") + + file:write(output) + file:close() + else + core.error("IPC Error: failed updating status (%s)", errmsg) + end +end + +---Constructor +---@param id? string Defaults to current lite-xl process id. +function IPC:new(id) + self.id = id or tostring(system.get_process_id()) + self.user_dir = USERDIR .. "/ipc" + self.file = self.user_dir .. "/" .. self.id .. ".lua" + self.primary = false + self.running = false + self.messages = {} + self.replies = {} + self.listeners = {} + self.signals = {} + self.methods = {} + self.signal_definitions = {} + self.method_definitions = {} + + local ipc_dir_status = system.get_file_info(self.user_dir) + + if not ipc_dir_status then + local created, errmsg = common.mkdirp(self.user_dir) + if not created then + core.error("Error initializing IPC system: %s", errmsg) + return + end + end + + local file, errmsg = io.open(self.file, "w+") + + if not file then + core.error("Error initializing IPC system: %s", errmsg) + return + else + file:close() + os.remove(self.file) + end + + -- Execute to set the instance position and primary attribute if no other running. + local instances = self:get_instances() + self.primary = #instances == 0 and true or false + self.position = #instances + 1 + + self:start() +end + +---Starts and registers the ipc session and monitoring. +function IPC:start() + if not self.running then + self.running = true + + update_file(self) + + local wait_time = 0.3 + + local this = self + self.coroutine_key = add_thread(function() + coroutine.yield(wait_time) + while(true) do + this:read_messages() + this:read_replies() + update_file(this) + coroutine.yield(wait_time) + end + end) + end +end + +---Stop and unregister the ipc session and monitoring. +function IPC:stop() + self.running = false + table.remove(threads, self.coroutine_key) + os.remove(self.file) +end + +---Get a list of running lite-xl instances. +---@return plugins.ipc.instance[] +function IPC:get_instances() + ---@type plugins.ipc.instance[] + local instances = {} + + local files, errmsg = system.list_dir(self.user_dir) + + if files then + for _, file in ipairs(files) do + if string.match(file, "^%d+%.lua$") then + local path = self.user_dir .. "/" .. file + local file_info = system.get_file_info(path) + if file_info and file_info.type == "file" then + ::read_instance_file:: + ---@type plugins.ipc.instance + local instance = dofile(path) + if instance and instance.id ~= self.id then + if instance.last_update + 2 > os.time() then + table.insert(instances, instance) + else + -- Delete expired instance session maybe result of a crash + os.remove(path) + end + elseif not instance and path ~= self.file then + --We retry reading the file since it was been modified + --by its owner instance. + goto read_instance_file + end + end + end + end + else + core.error("IPC Error: failed getting running instances (%s)", errmsg) + end + + local instances_count = #instances + + if instances_count > 0 then + table.sort(instances, function(ia, ib) + return ia.position < ib.position + end) + end + + if not self.primary and self.position then + if instances_count == 0 or instances[1].position > self.position then + self.primary = true + end + end + + return instances +end + +---@class plugins.ipc.vardecl +---@field name string +---@field type string +---@field optional boolean + +---Generate a string representation of a function +---@param name string +---@param params? plugins.ipc.vardecl[] +---@param returns? plugins.ipc.vardecl[] +---@return string function_definition +local function generate_definition(name, params, returns) + local declaration = name .. "(" + + if params and #params > 0 then + local params_string = "" + for _, param in ipairs(params) do + params_string = params_string .. param.name + if param.optional then + params_string = params_string .. "?: " + else + params_string = params_string .. ": " + end + params_string = params_string .. param.type .. ", " + end + local params_stripped = params_string:gsub(", $", "") + declaration = declaration .. params_stripped + end + + declaration = declaration .. ")" + + if returns and #returns > 0 then + declaration = declaration .. " -> " + local returns_string = "" + for _, ret in ipairs(returns) do + if ret.name then + returns_string = returns_string .. ret.name .. ": " + end + returns_string = returns_string .. ret.type + if ret.optional then + returns_string = returns_string .. "?, " + else + returns_string = returns_string .. ", " + end + end + local returns_stripped = returns_string:gsub(", $", "") + declaration = declaration .. returns_stripped + end + + return declaration +end + +---Retrieve the id of the primary instance if found. +---@return string | nil +function IPC:get_primary_instance() + local instances = self:get_instances() + for _, instance in ipairs(instances) do + if instance.primary then + return instance.id + end + end + return nil +end + +---Get a queued message. +---@param message_id string +---@return plugins.ipc.message | nil +function IPC:get_message(message_id) + for _, message in ipairs(self.messages) do + if message.id == message_id then + return message + end + end + return nil +end + +---Remove a message from the queue. +---@param message_id string +function IPC:remove_message(message_id) + for m, message in ipairs(self.messages) do + if message.id == message_id then + table.remove(self.messages, m) + break + end + end +end + +---Get the reply sent to a specific message. +---@param message_id string +---@return plugins.ipc.reply | nil +function IPC:get_reply(message_id) + for _, reply in ipairs(self.replies) do + if reply.id == message_id then + return reply + end + end + return nil +end + +---Verify all the messages sent by running instances, read those directed +---to the currently running instance and reply to them. +function IPC:read_messages() + local instances = self:get_instances() + + local awaiting_replies = {} + + for _, instance in ipairs(instances) do + for _, message in ipairs(instance.messages) do + for _, destination in ipairs(message.destinations) do + if destination == self.id then + local reply = self:get_reply(message.id) + + if not reply then + if message.on_read then + local on_read, errmsg = load(message.on_read) + if on_read then + local executed = core.try(function() on_read(message) end) + if not executed then + core.error( + "IPC Error: could not run message on_read\n" + .. "Message: %s\n", + common.serialize(message, {pretty = true}) + ) + end + else + core.error( + "IPC Error: could not run message on_read (%s)\n" + .. "Message: %s\n", + errmsg, + common.serialize(message, {pretty = true}) + ) + end + end + + ---@type plugins.ipc.reply + reply = {} + reply.id = message.id + reply.sender = message.sender + reply.replier = self.id + reply.data = {} + reply.on_read = nil + + local type_name = message.type .. "." .. message.name + + -- Allow listeners to react to message and modify reply + if self.listeners[type_name] and #self.listeners[type_name] > 0 then + for _, on_message in ipairs(self.listeners[type_name]) do + on_message(message, reply) + end + end + + if reply.on_read then + reply.on_read = string.dump(reply.on_read) + end + + reply.timestamp = os.time() + end + + table.insert(awaiting_replies, reply) + break + end + end + end + end + + self.replies = awaiting_replies +end + +---Reads replies directed to messages sent by the currently running instance +---and if any returns them. +---@return plugins.ipc.reply[] | nil +function IPC:read_replies() + if #self.messages == 0 then + return + end + + local instances = self:get_instances() + + local replies = {} + + local messages_removed = 0; + for m=1, #self.messages do + local message = self.messages[m-messages_removed] + local message_removed = false + + local destinations_removed = 0 + for d=1, #message.destinations do + local destination = message.destinations[d-destinations_removed] + + local found = false + for _, instance in ipairs(instances) do + if instance.id == destination then + found = true + for _, reply in ipairs(instance.replies) do + if reply.id == message.id then + local reply_registered = false + for _, message_reply in ipairs(message.replies) do + if message_reply.replier == instance.id then + reply_registered = true + break + end + end + if not reply_registered then + if message.on_reply then + message.on_reply(reply) + end + + if reply.on_read then + local on_read, errmsg = load(reply.on_read) + if on_read then + local executed = core.try(function() on_read(reply) end) + if not executed then + core.error( + "IPC Error: could not run reply on_read\n" + .. "Message: %s\n" + .. "Reply: %s", + common.serialize(message, {pretty = true}), + common.serialize(reply, {pretty = true}) + ) + end + else + core.error( + "IPC Error: could not run reply on_read (%s)\n" + .. "Message: %s\n" + .. "Reply: %s", + errmsg, + common.serialize(message, {pretty = true}), + common.serialize(reply, {pretty = true}) + ) + end + end + + table.insert(replies, reply) + table.insert(message.replies, reply) + end + end + end + break + end + end + if not found then + table.remove(message.destinations, d-destinations_removed) + destinations_removed = destinations_removed + 1 + if #message.destinations == 0 then + table.remove(self.messages, m-messages_removed) + messages_removed = messages_removed + 1 + message_removed = true + end + end + end + if + not message_removed + and + ( + #message.replies == #message.destinations + or + message.timestamp + MESSAGE_EXPIRATION < os.time() + ) + then + table.remove(self.messages, m-messages_removed) + messages_removed = messages_removed + 1 + end + end + + return replies +end + +---Blocks execution of current instance to wait for all replies by the +---specified message and when finished returns them. +---@param message_id string +---@return plugins.ipc.reply[] | nil +function IPC:wait_for_replies(message_id) + local message_data = self:get_message(message_id) + + update_file(self) + + if message_data then + self:read_replies() + while true do + if + message_data.replies + and + #message_data.replies == #message_data.destinations + then + return message_data.replies + elseif not self:get_message(message_id) then + return message_data.replies + end + self:read_replies() + end + end + return nil +end + +---Blocks execution of current instance to wait for all messages to +---be replied to. +function IPC:wait_for_messages() + update_file(self) + while #self.messages > 0 do + self:read_replies() + system.sleep(0.1) + end +end + +---@class plugins.ipc.sendmessageoptions +---@field data table<string,any> @Optional data given to the receiver. +---@field on_reply plugins.ipc.onreply @Callback that allows monitoring all the replies received for this message. +---@field on_read plugins.ipc.onmessage @Function executed by the message receiver. +---@field destinations string | table<integer,string> | nil @Id of the running instances to receive the message, if not set all running instances will receive the message. + +---Queue a new message to be sent to other lite-xl instances. +---@param name string +---@param options? plugins.ipc.sendmessageoptions +---@param message_type? plugins.ipc.messagetype +---@return string | nil message_id +function IPC:send_message(name, options, message_type) + options = options or {} + + local found_destinations = {} + local instances = self:get_instances() + local destinations = options.destinations + + if type(destinations) == "string" then + destinations = { destinations } + end + + if not destinations then + for _, instance in ipairs(instances) do + table.insert(found_destinations, instance.id) + end + else + for _, destination in ipairs(destinations) do + for _, instance in ipairs(instances) do + if instance.id == destination then + table.insert(found_destinations, destination) + end + end + end + end + + if #found_destinations <= 0 then + return nil + end + + ---@type plugins.ipc.message + local message = {} + message.id = self.id .. "." .. tostring(system.get_time()) + message.name = name + message.type = message_type or "message" + message.sender = self.id + message.data = options.data or {} + message.destinations = found_destinations + message.timestamp = os.time() + message.on_reply = options.on_reply or nil + message.on_read = options.on_read and string.dump(options.on_read) or nil + message.replies = {} + + table.insert(self.messages, message) + + update_file(self) + + return message.id +end + +---Add a listener for a given type of message. +---@param name string +---@param callback plugins.ipc.onmessage +---@param message_type? plugins.ipc.messagetype +---@return integer listener_position +function IPC:listen_message(name, callback, message_type) + message_type = message_type or "message" + + local type_name = message_type .. "." .. name + if not self.listeners[type_name] then + self.listeners[type_name] = {} + end + + table.insert(self.listeners[type_name], callback) + + return #self.listeners[type_name] +end + +---Listen for a given signal. +---@param name string +---@param callback plugins.ipc.function +---@return integer listener_position +function IPC:listen_signal(name, callback) + local signal_cb = function(message) + callback(table.unpack(message.data)) + end + return self:listen_message(name, signal_cb, "signal") +end + +---Add a new signal that can be sent to other instances. +---@param name string A unique name for the signal. +---@param params? plugins.ipc.vardecl[] Parameters that are going to be passed into callback. +function IPC:register_signal(name, params) + if self.signals[name] then + core.log_quiet("IPC: Overriding signal '%s'", name) + table.remove(self.signal_definitions, self.signals[name]) + end + + self.signals[name] = table.insert( + self.signal_definitions, + generate_definition(name, params) + ) + + table.sort(self.signal_definitions) +end + +---Add a new method that can be invoked from other instances. +---@param name string A unique name for the method. +---@param method fun(...) Function invoked when the method is called. +---@param params? plugins.ipc.vardecl[] Parameters that are going to be passed into method. +---@param returns? plugins.ipc.vardecl[] Return values of the method. +function IPC:register_method(name, method, params, returns) + if self.methods[name] then + core.log_quiet("IPC: Overriding method '%s'", name) + table.remove(self.method_definitions, self.methods[name]) + end + + self.methods[name] = table.insert( + self.method_definitions, + generate_definition(name, params, returns) + ) + + table.sort(self.method_definitions) + + self:listen_message(name, function(message, reply) + local ret = table.pack(method(table.unpack(message.data))) + reply.data = ret + end, "method") +end + +---Broadcast a signal to running instances. +---@param destinations string | table<integer, string> | nil +---@param name string +---@vararg any signal_parameters +function IPC:signal(destinations, name, ...) + self:send_message(name, { + destinations = destinations, + data = table.pack(self.id, ...) + }, "signal") +end + +---Call a method on another instance and wait for reply. +---@param destinations string | table<integer, string> | nil +---@param name string +---@return any | table<string,table> return_of_called_method +function IPC:call(destinations, name, ...) + local message_id = self:send_message(name, { + destinations = destinations, + data = table.pack(...) + }, "method") + + local ret = nil + + if message_id then + local replies = self:wait_for_replies(message_id) + if replies and #replies > 1 then + ret = {} + for _, reply in ipairs(replies) do + ret[reply.replier] = reply.data + end + elseif replies and #replies > 0 then + return table.unpack(replies[1].data) + end + else + core.error("IPC Error: could not make call to '%s'", name) + end + + return ret +end + +---Call a method on another instance asynchronously waiting for the replies. +---@param destinations string | table<integer, string> | nil +---@param name string +---@param callback fun(id: string, ret: table) | nil Called with the returned values +---@return string | nil message_id +function IPC:call_async(destinations, name, callback, ...) + return self:send_message(name, { + destinations = destinations, + data = table.pack(...), + on_reply = callback and function(reply) + callback(reply.replier, reply.data) + end or nil + }, "method") +end + +---Main ipc session for current instance. +---@type core.ipc +local ipc = IPC() + +---Get the IPC session for the running lite-xl instance. +---@return core.ipc +function IPC.current() + return ipc +end + +-------------------------------------------------------------------------------- +-- Override system.wait_event to allow ipc monitoring on the background. +-------------------------------------------------------------------------------- +local system_wait_event = system.wait_event + +local run_threads = coroutine.wrap(function() + while true do + for k, thread in pairs(threads) do + if thread.wake < system.get_time() then + local _, wait = assert(coroutine.resume(thread.cr)) + if coroutine.status(thread.cr) == "dead" then + table.remove(threads, k) + elseif wait then + thread.wake = system.get_time() + wait + end + end + coroutine.yield() + end + end +end) + +system.wait_event = function(timeout) + run_threads() + + if not timeout then + if not system.window_has_focus() then + local t = system.get_time() + local h = 0.5 / 2 + local dt = math.ceil(t / h) * h - t + + system_wait_event(dt + 1 / config.fps) + else + system_wait_event() + end + else + system_wait_event(timeout) + end +end + +-------------------------------------------------------------------------------- +-- Override system.show_fatal_error to be able and destroy session file on crash. +-------------------------------------------------------------------------------- +local system_show_fatal_error = system.show_fatal_error + +system.show_fatal_error = function(title, message) + if title == "Lite XL internal error" then + ipc:stop() + end + system_show_fatal_error(title, message) +end + +-------------------------------------------------------------------------------- +-- Override core.run to destroy ipc session file on exit. +-------------------------------------------------------------------------------- +local core_run = core.run + +core.run = function() + core_run() + ipc:stop() +end + +-------------------------------------------------------------------------------- +-- Override system.get_time temporarily as first function called on core.run +-- to allow settings gui to properly load ipc config options. +-------------------------------------------------------------------------------- +local system_get_time = system.get_time + +system.get_time = function() + if settings_found and not settings.ui then + return system_get_time() + end + + if config.plugins.ipc.single_instance then + system.get_time = system_get_time + + local primary_instance = ipc:get_primary_instance() + if primary_instance and ARGS[2] then + local open_directory = false + for i=2, #ARGS do + local path = system.absolute_path(ARGS[i]) + + if path then + local path_info = system.get_file_info(path) + if path_info then + if path_info.type == "file" then + ipc:call_async(primary_instance, "core.open_file", nil, path) + else + if not config.plugins.ipc.dirs_instance then + ipc:call_async(primary_instance, "core.open_directory", nil, path) + else + if #ARGS > 2 then + system.exec(string.format("%q %q", EXEFILE, path)) + else + open_directory = true + end + end + end + end + end + end + ipc:wait_for_messages() + if not open_directory then + os.exit() + end + end + else + system.get_time = system_get_time + end + + return system_get_time() +end + +-------------------------------------------------------------------------------- +-- Register methods for opening files and directories. +-------------------------------------------------------------------------------- +ipc:register_method("core.open_file", function(file) + if system.get_file_info(file) then + if system.raise_window then system.raise_window() end + core.root_view:open_doc(core.open_doc(file)) + end +end, {{name = "file", type = "string"}}) + +ipc:register_method("core.open_directory", function(directory) + if system.get_file_info(directory) then + if system.raise_window then system.raise_window() end + core.add_project_directory(directory) + end +end, {{name = "directory", type = "string"}}) + +-------------------------------------------------------------------------------- +-- Register file dragging signals from instance to instance +-------------------------------------------------------------------------------- +ipc:register_signal("core.tab_drag_start", {{name = "file", type = "string"}}) +ipc:register_signal("core.tab_drag_stop") +ipc:register_signal("core.tab_drag_received", {{name = "file", type = "string"}}) + +local rootview_tab_dragging = false +local rootview_dragged_node = nil +local rootview_waiting_drop_file = "" +local rootview_waiting_drop_instance = "" + +local rootview_on_mouse_moved = RootView.on_mouse_moved +function RootView:on_mouse_moved(x, y, dx, dy) + rootview_on_mouse_moved(self, x, y, dx, dy) + if + self.dragged_node and self.dragged_node.dragging + and + not rootview_tab_dragging + then + ---@type core.doc + local doc = core.active_view.doc + if doc and doc.abs_filename then + rootview_tab_dragging = true + ipc:signal(nil, "core.tab_drag_start", doc.abs_filename) + rootview_dragged_node = self.dragged_node + end + elseif rootview_dragged_node then + local w, h, wx, wy = system.get_window_size() + if x < 0 or x > w or y < 0 or y > h then + self.dragged_node = nil + self:set_show_overlay(self.drag_overlay, false) + elseif not self.dragged_node then + self.dragged_node = rootview_dragged_node + self:set_show_overlay(self.drag_overlay, true) + end + core.request_cursor("hand") + elseif rootview_waiting_drop_file ~= "" then + ipc:signal( + rootview_waiting_drop_instance, + "core.tab_drag_received", + rootview_waiting_drop_file + ) + core.root_view:open_doc(core.open_doc(rootview_waiting_drop_file)) + rootview_waiting_drop_file = "" + end +end + +local rootview_on_mouse_released = RootView.on_mouse_released +function RootView:on_mouse_released(button, x, y, ...) + rootview_on_mouse_released(self, button, x, y, ...) + if rootview_tab_dragging then + rootview_tab_dragging = false + rootview_dragged_node = nil + ipc:signal(nil, "core.tab_drag_stop") + end +end + +ipc:listen_signal("core.tab_drag_start", function(instance, file) + rootview_waiting_drop_instance = instance + rootview_waiting_drop_file = file +end) + +ipc:listen_signal("core.tab_drag_stop", function() + rootview_waiting_drop_instance = "" + rootview_waiting_drop_file = "" +end) + +ipc:listen_signal("core.tab_drag_received", function() + command.perform("root:close") +end) + + +return IPC |