2012-10-30 14:00:44 +01:00
|
|
|
#include "client_manager.hh"
|
|
|
|
|
2012-10-31 14:23:44 +01:00
|
|
|
#include "event_manager.hh"
|
2012-11-07 14:02:23 +01:00
|
|
|
#include "buffer_manager.hh"
|
2012-12-18 21:20:36 +01:00
|
|
|
#include "command_manager.hh"
|
2012-10-31 14:23:44 +01:00
|
|
|
|
2012-10-30 14:00:44 +01:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
2013-01-07 13:59:09 +01:00
|
|
|
String ClientManager::generate_name() const
|
|
|
|
{
|
|
|
|
for (int i = 0; true; ++i)
|
|
|
|
{
|
|
|
|
String name = "unnamed" + int_to_str(i);
|
|
|
|
bool found = false;
|
|
|
|
for (auto& client : m_clients)
|
|
|
|
{
|
|
|
|
if (client->name == name)
|
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (not found)
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-31 14:23:44 +01:00
|
|
|
void ClientManager::create_client(std::unique_ptr<UserInterface>&& ui,
|
2013-01-11 19:17:21 +01:00
|
|
|
const String& init_commands)
|
2012-10-30 14:00:44 +01:00
|
|
|
{
|
2012-12-28 13:51:14 +01:00
|
|
|
Buffer& buffer = **BufferManager::instance().begin();
|
2013-01-07 13:59:09 +01:00
|
|
|
m_clients.emplace_back(new Client{std::move(ui), get_unused_window_for_buffer(buffer),
|
|
|
|
generate_name()});
|
2012-10-31 14:23:44 +01:00
|
|
|
|
2012-11-22 14:17:46 +01:00
|
|
|
InputHandler* input_handler = &m_clients.back()->input_handler;
|
|
|
|
Context* context = &m_clients.back()->context;
|
2012-12-19 18:56:47 +01:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
CommandManager::instance().execute(init_commands, *context);
|
|
|
|
}
|
|
|
|
catch (Kakoune::runtime_error& error)
|
|
|
|
{
|
|
|
|
context->print_status(error.description());
|
|
|
|
}
|
|
|
|
catch (Kakoune::client_removed&)
|
|
|
|
{
|
|
|
|
m_clients.pop_back();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-01-11 19:17:21 +01:00
|
|
|
context->ui().set_input_callback([input_handler, context, this]() {
|
2012-10-31 14:23:44 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
input_handler->handle_available_inputs(*context);
|
2012-11-05 19:58:04 +01:00
|
|
|
context->window().forget_timestamp();
|
2012-10-31 14:23:44 +01:00
|
|
|
}
|
|
|
|
catch (Kakoune::runtime_error& error)
|
|
|
|
{
|
|
|
|
context->print_status(error.description());
|
|
|
|
}
|
|
|
|
catch (Kakoune::client_removed&)
|
|
|
|
{
|
2012-11-20 18:54:35 +01:00
|
|
|
ClientManager::instance().remove_client_by_context(*context);
|
2012-10-31 14:23:44 +01:00
|
|
|
}
|
2012-11-05 19:58:04 +01:00
|
|
|
ClientManager::instance().redraw_clients();
|
2012-10-31 14:23:44 +01:00
|
|
|
});
|
2012-11-05 19:58:04 +01:00
|
|
|
redraw_clients();
|
2012-10-30 14:00:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void ClientManager::remove_client_by_context(Context& context)
|
|
|
|
{
|
|
|
|
for (auto it = m_clients.begin(); it != m_clients.end(); ++it)
|
|
|
|
{
|
2012-11-22 14:17:46 +01:00
|
|
|
if (&(*it)->context == &context)
|
2012-10-30 14:00:44 +01:00
|
|
|
{
|
|
|
|
m_clients.erase(it);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(false);
|
|
|
|
}
|
|
|
|
|
2012-11-22 14:08:55 +01:00
|
|
|
Window& ClientManager::get_unused_window_for_buffer(Buffer& buffer)
|
2012-11-05 19:15:42 +01:00
|
|
|
{
|
2012-11-22 14:08:55 +01:00
|
|
|
for (auto& w : m_windows)
|
2012-11-05 19:15:42 +01:00
|
|
|
{
|
2012-11-22 14:08:55 +01:00
|
|
|
if (&w->buffer() != &buffer)
|
|
|
|
continue;
|
|
|
|
|
2012-11-05 19:15:42 +01:00
|
|
|
auto it = std::find_if(m_clients.begin(), m_clients.end(),
|
2012-11-22 14:17:46 +01:00
|
|
|
[&](const std::unique_ptr<Client>& client)
|
|
|
|
{ return &client->context.window() == w.get(); });
|
2012-11-05 19:15:42 +01:00
|
|
|
if (it == m_clients.end())
|
2012-11-05 19:58:04 +01:00
|
|
|
{
|
|
|
|
w->forget_timestamp();
|
2012-11-05 19:15:42 +01:00
|
|
|
return *w;
|
2012-11-05 19:58:04 +01:00
|
|
|
}
|
2012-11-05 19:15:42 +01:00
|
|
|
}
|
2012-11-22 14:08:55 +01:00
|
|
|
m_windows.emplace_back(new Window(buffer));
|
|
|
|
return *m_windows.back();
|
2012-11-05 19:15:42 +01:00
|
|
|
}
|
|
|
|
|
2012-11-07 14:02:23 +01:00
|
|
|
void ClientManager::ensure_no_client_uses_buffer(Buffer& buffer)
|
|
|
|
{
|
|
|
|
for (auto& client : m_clients)
|
|
|
|
{
|
2012-11-22 14:17:46 +01:00
|
|
|
client->context.forget_jumps_to_buffer(buffer);
|
2012-11-12 19:59:25 +01:00
|
|
|
|
2012-11-22 14:17:46 +01:00
|
|
|
if (&client->context.buffer() != &buffer)
|
2012-11-07 14:02:23 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// change client context to edit the first buffer which is not the
|
|
|
|
// specified one. As BufferManager stores buffer according to last
|
|
|
|
// access, this selects a sensible buffer to display.
|
|
|
|
for (auto& buf : BufferManager::instance())
|
|
|
|
{
|
|
|
|
if (buf != &buffer)
|
|
|
|
{
|
|
|
|
Window& w = get_unused_window_for_buffer(*buf);
|
2012-11-22 14:17:46 +01:00
|
|
|
client->context.change_editor(w);
|
2012-11-07 14:02:23 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-11-22 14:08:55 +01:00
|
|
|
auto end = std::remove_if(m_windows.begin(), m_windows.end(),
|
2012-11-22 14:17:46 +01:00
|
|
|
[&buffer](const std::unique_ptr<Window>& w)
|
2012-11-22 14:08:55 +01:00
|
|
|
{ return &w->buffer() == &buffer; });
|
|
|
|
m_windows.erase(end, m_windows.end());
|
2012-11-07 14:02:23 +01:00
|
|
|
}
|
|
|
|
|
2012-12-03 18:56:53 +01:00
|
|
|
void ClientManager::set_client_name(Context& context, String name)
|
|
|
|
{
|
|
|
|
auto it = find_if(m_clients, [&name](std::unique_ptr<Client>& client)
|
|
|
|
{ return client->name == name; });
|
|
|
|
if (it != m_clients.end() and &(*it)->context != &context)
|
|
|
|
throw runtime_error("name not unique: " + name);
|
|
|
|
|
|
|
|
for (auto& client : m_clients)
|
|
|
|
{
|
|
|
|
if (&client->context == &context)
|
|
|
|
{
|
|
|
|
client->name = std::move(name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
throw runtime_error("no client for current context");
|
|
|
|
}
|
|
|
|
|
2013-01-07 13:59:09 +01:00
|
|
|
String ClientManager::get_client_name(const Context& context)
|
|
|
|
{
|
|
|
|
for (auto& client : m_clients)
|
|
|
|
{
|
|
|
|
if (&client->context == &context)
|
|
|
|
return client->name;
|
|
|
|
}
|
|
|
|
throw runtime_error("no client for current context");
|
|
|
|
}
|
|
|
|
|
2012-12-03 18:56:53 +01:00
|
|
|
Context& ClientManager::get_client_context(const String& name)
|
|
|
|
{
|
|
|
|
auto it = find_if(m_clients, [&name](std::unique_ptr<Client>& client)
|
|
|
|
{ return client->name == name; });
|
|
|
|
if (it != m_clients.end())
|
|
|
|
return (*it)->context;
|
|
|
|
throw runtime_error("no client named: " + name);
|
|
|
|
}
|
|
|
|
|
2012-11-05 19:58:04 +01:00
|
|
|
void ClientManager::redraw_clients() const
|
|
|
|
{
|
|
|
|
for (auto& client : m_clients)
|
|
|
|
{
|
2012-11-22 14:17:46 +01:00
|
|
|
Context& context = client->context;
|
2012-11-05 19:58:04 +01:00
|
|
|
if (context.window().timestamp() != context.buffer().timestamp())
|
|
|
|
{
|
|
|
|
DisplayCoord dimensions = context.ui().dimensions();
|
|
|
|
if (dimensions == DisplayCoord{0,0})
|
|
|
|
return;
|
|
|
|
context.window().set_dimensions(dimensions);
|
|
|
|
context.window().update_display_buffer();;
|
|
|
|
context.ui().draw(context.window().display_buffer(),
|
|
|
|
context.window().status_line());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-30 14:00:44 +01:00
|
|
|
}
|