kakoune/src/client_manager.cc

170 lines
4.9 KiB
C++
Raw Normal View History

#include "client_manager.hh"
#include "buffer_manager.hh"
#include "color_registry.hh"
#include "command_manager.hh"
#include "event_manager.hh"
#include "file.hh"
#include "user_interface.hh"
#include "window.hh"
2012-10-31 14:23:44 +01:00
namespace Kakoune
{
ClientManager::ClientManager() = default;
ClientManager::~ClientManager() = default;
String ClientManager::generate_name() const
{
for (int i = 0; true; ++i)
{
2013-05-13 14:23:07 +02:00
String name = "unnamed" + to_string(i);
2013-09-13 00:01:47 +02:00
if (validate_client_name(name))
return name;
}
}
2013-09-12 23:47:23 +02:00
Client* ClientManager::create_client(std::unique_ptr<UserInterface>&& ui,
const String& init_commands)
{
Buffer& buffer = **BufferManager::instance().begin();
WindowAndSelections ws = get_free_window(buffer);
Client* client = new Client{std::move(ui), std::move(std::get<0>(ws)),
std::move(std::get<1>(ws)), generate_name()};
m_clients.emplace_back(client);
try
{
CommandManager::instance().execute(init_commands, client->context());
}
catch (Kakoune::runtime_error& error)
{
client->context().print_status({ error.what(), get_color("Error") });
client->context().hooks().run_hook("RuntimeError", error.what(),
client->context());
}
catch (Kakoune::client_removed&)
{
m_clients.pop_back();
return nullptr;
}
client->ui().set_input_callback([client, this]() {
2012-10-31 14:23:44 +01:00
try
{
client->handle_available_input();
2012-10-31 14:23:44 +01:00
}
catch (Kakoune::runtime_error& error)
{
client->context().print_status({ error.what(), get_color("Error") });
client->context().hooks().run_hook("RuntimeError", error.what(),
client->context());
2012-10-31 14:23:44 +01:00
}
catch (Kakoune::client_removed&)
{
ClientManager::instance().remove_client(*client);
2012-10-31 14:23:44 +01:00
}
});
return client;
}
2013-09-12 23:47:23 +02:00
void ClientManager::remove_client(Client& client)
{
for (auto it = m_clients.begin(); it != m_clients.end(); ++it)
{
if (it->get() == &client)
{
m_clients.erase(it);
return;
}
}
kak_assert(false);
}
WindowAndSelections ClientManager::get_free_window(Buffer& buffer)
{
for (auto it = m_free_windows.begin(), end = m_free_windows.end();
it != end; ++it)
{
auto& w = std::get<0>(*it);
if (&w->buffer() == &buffer)
{
w->forget_timestamp();
WindowAndSelections res = std::move(*it);
m_free_windows.erase(it);
return res;
}
}
return WindowAndSelections{ std::unique_ptr<Window>{new Window{buffer}}, DynamicSelectionList{buffer, { Selection{ {}, {} } } } };
}
void ClientManager::add_free_window(std::unique_ptr<Window>&& window, SelectionList selections)
{
Buffer& buffer = window->buffer();
m_free_windows.emplace_back(std::move(window), DynamicSelectionList{ buffer, std::move(selections) });
}
void ClientManager::ensure_no_client_uses_buffer(Buffer& buffer)
{
for (auto& client : m_clients)
{
2013-01-28 13:48:34 +01:00
client->context().forget_jumps_to_buffer(buffer);
2013-01-28 13:48:34 +01:00
if (&client->context().buffer() != &buffer)
continue;
if (client->context().is_editing())
throw runtime_error("client '" + client->context().name() + "' is inserting in '" +
buffer.display_name() + '\'');
// 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)
{
client->context().change_buffer(*buf);
break;
}
}
}
auto end = std::remove_if(m_free_windows.begin(), m_free_windows.end(),
[&buffer](const WindowAndSelections& ws)
{ return &std::get<0>(ws)->buffer() == &buffer; });
m_free_windows.erase(end, m_free_windows.end());
}
2013-09-13 00:01:47 +02:00
bool ClientManager::validate_client_name(const String& name) const
{
2013-09-13 00:01:47 +02:00
auto it = find_if(m_clients, [&](const std::unique_ptr<Client>& client)
{ return client->context().name() == name; });
2013-09-13 00:01:47 +02:00
return it == m_clients.end();
}
Client* ClientManager::get_client_ifp(const String& name)
{
for (auto& client : m_clients)
{
if (client->context().name() == name)
return client.get();
}
return nullptr;
}
Client& ClientManager::get_client(const String& name)
{
Client* client = get_client_ifp(name);
if (not client)
throw runtime_error("no client named: " + name);
return *client;
}
void ClientManager::redraw_clients() const
{
for (auto& client : m_clients)
client->redraw_ifn();
}
}