#include <linux/input.h>
#include <csignal>
std::shared_ptr<scene::Session> const& session,
std::shared_ptr<scene::Surface> const& surface,
scene::SurfaceCreationParameters const& ) :
session{session},
restore_rect{surface->top_left(), surface->size()}
{
}
tools{tools}
{
}
{
auto const session = session_under(cursor);
old_cursor = cursor;
}
{
update_tiles(session_info, displays);
}
{
update_tiles(session_info, displays);
}
{
if (auto const session = session_under(cursor))
{
if (session == session_under(old_cursor))
{
auto const& info = tools->info_for(session);
if (resize(tools->focused_surface(), cursor, old_cursor, info.tile))
{
}
else
{
auto const new_surface = tools->surface_at(old_cursor);
if (new_surface && tools->info_for(new_surface).session.lock() == session)
{
if (resize(new_surface, cursor, old_cursor, info.tile))
{
tools->set_focus_to(session, new_surface);
if (auto const surface = tools->focused_surface())
tools->raise({surface});
}
}
}
}
}
old_cursor = cursor;
}
std::shared_ptr<ms::Session> const& session,
{
auto parameters = request_parameters;
Rectangle const& tile = tools->info_for(session).tile;
clip_to_tile(parameters, tile);
return parameters;
}
std::shared_ptr<ms::Session> const&,
std::shared_ptr<ms::Surface> const&,
TilingSurfaceInfoMap&,
{
}
{
tools->info_for(session).surfaces.push_back(surface);
}
std::shared_ptr<scene::Session> const& ,
std::shared_ptr<scene::Surface> const& surface,
shell::SurfaceSpecification const& modifications)
{
if (modifications.name.is_set())
surface->rename(modifications.name.value());
}
{
auto& surfaces = tools->info_for(session).surfaces;
for (auto i = begin(surfaces); i != end(surfaces); ++i)
{
if (surface.lock() == i->lock())
{
surfaces.erase(i);
break;
}
}
if (surfaces.empty() && session == tools->focused_session())
{
tools->focus_next_session();
if (auto const surface = tools->focused_surface())
tools->raise({surface});
}
}
{
auto& info = tools->info_for(surface);
switch (value)
{
break;
default:
return info.state;
}
{
info.restore_rect = {surface->top_left(), surface->size()};
}
if (info.state == value)
{
return info.state;
}
auto const& tile = tools->info_for(info.session).tile;
switch (value)
{
surface->move_to(info.restore_rect.top_left);
surface->resize(info.restore_rect.size);
break;
surface->resize(tile.
size);
break;
surface->move_to({tile.
top_left.
x, info.restore_rect.top_left.y});
surface->resize({tile.
size.
width, info.restore_rect.size.height});
break;
surface->move_to({info.restore_rect.top_left.x, tile.
top_left.
y});
surface->resize({info.restore_rect.size.width, tile.
size.
height});
break;
default:
break;
}
return info.state = value;
}
{
if (auto const session = session_under(cursor))
{
if (session == session_under(old_cursor))
{
auto const& info = tools->info_for(session);
if (drag(tools->focused_surface(), cursor, old_cursor, info.tile))
{
}
else
{
auto const new_surface = tools->surface_at(old_cursor);
if (new_surface && tools->info_for(new_surface).session.lock() == session)
{
if (resize(new_surface, cursor, old_cursor, info.tile))
{
tools->set_focus_to(session, new_surface);
if (auto const surface = tools->focused_surface())
tools->raise({surface});
}
}
}
}
}
old_cursor = cursor;
}
{
{
switch (modifiers & modifier_mask)
{
return true;
return true;
return true;
default:
break;
}
}
{
if (auto const session = tools->focused_session())
{
switch (modifiers & modifier_mask)
{
kill(session->process_id(), SIGTERM);
return true;
if (auto const surf = session->default_surface())
{
surf->request_client_surface_close();
return true;
}
default:
break;
}
}
}
scan_code == KEY_TAB)
{
tools->focus_next_session();
if (auto const surface = tools->focused_surface())
tools->raise({surface});
return true;
}
scan_code == KEY_GRAVE)
{
if (auto const prev = tools->focused_surface())
{
if (auto const app = tools->focused_session())
if (auto const surface = app->surface_after(prev))
{
tools->set_focus_to(app, surface);
tools->raise({surface});
}
}
return true;
}
return false;
}
{
long total_x = 0;
long total_y = 0;
for (auto i = 0U; i != count; ++i)
{
}
Point const cursor{total_x/count, total_y/count};
bool is_drag = true;
for (auto i = 0U; i != count; ++i)
{
{
return false;
is_drag = false;
continue;
}
}
if (is_drag && count == 3)
{
drag(cursor);
return true;
}
else
{
click(cursor);
return false;
}
}
{
{
click(cursor);
return false;
}
{
{
drag(cursor);
return true;
}
{
resize(cursor);
return true;
}
}
return false;
}
{
if (auto const session = tools->focused_session())
{
if (auto const surface = session->default_surface())
{
if (surface->state() == state)
}
}
}
std::shared_ptr<ms::Session> me::TilingWindowManagerPolicy::session_under(
Point position)
{
return tools->find_session([&](TilingSessionInfo const& info) { return info.tile.contains(position);});
}
void me::TilingWindowManagerPolicy::update_tiles(
TilingSessionInfoMap& session_info,
{
if (session_info.size() < 1 || displays.
size() < 1)
return;
auto const sessions = session_info.size();
auto const total_height = bounding_rect.size.height.as_int();
auto index = 0;
for (auto& info : session_info)
{
auto const x = (total_width*index)/sessions;
++index;
auto const dx = (total_width*index)/sessions - x;
auto const old_tile = info.second.tile;
Rectangle const new_tile{{x, 0}, {dx, total_height}};
update_surfaces(info.first, old_tile, new_tile);
info.second.tile = new_tile;
}
}
void me::TilingWindowManagerPolicy::update_surfaces(std::weak_ptr<ms::Session>
const& session,
Rectangle const& old_tile,
Rectangle const& new_tile)
{
auto& info = tools->info_for(session);
for (auto const& ps : info.surfaces)
{
if (auto const surface = ps.lock())
{
auto const old_pos = surface->top_left();
surface->move_to(old_pos + displacement);
fit_to_new_tile(*surface, old_tile, new_tile);
}
}
}
{
}
{
auto const old_size = surface.
size();
auto const scaled_height = old_size.height == old_tile.
size.
height ? new_tile.
size.
height : old_size.height;
auto width = std::min(new_tile.
size.
width.
as_int()-displacement.dx.as_int(), scaled_width.as_int());
auto height = std::min(new_tile.
size.
height.
as_int()-displacement.dy.as_int(), scaled_height.as_int());
}
{
if (surface && surface->input_area_contains(from))
{
auto const top_left = surface->top_left();
auto const surface_size = surface->size();
auto const bottom_right = top_left + as_displacement(surface_size);
auto movement = to - from;
movement.dx = std::max(movement.dx, (bounds.
top_left - top_left).dx);
movement.dy = std::max(movement.dy, (bounds.
top_left - top_left).dy);
movement.dx = std::min(movement.dx, (bounds.
bottom_right() - bottom_right).dx);
movement.dy = std::min(movement.dy, (bounds.
bottom_right() - bottom_right).dy);
auto new_pos = surface->top_left() + movement;
surface->move_to(new_pos);
return true;
}
return false;
}
{
if (surface && surface->input_area_contains(old_cursor))
{
auto const top_left = surface->top_left();
auto const old_displacement = old_cursor - top_left;
auto const new_displacement = cursor - top_left;
auto const scale_x = new_displacement.dx.as_float()/std::max(1.0f, old_displacement.dx.as_float());
auto const scale_y = new_displacement.dy.as_float()/std::max(1.0f, old_displacement.dy.as_float());
if (scale_x <= 0.0f || scale_y <= 0.0f) return false;
auto const old_size = surface->size();
Size new_size{scale_x*old_size.
width, scale_y*old_size.height};
auto const size_limits = as_size(bounds.
bottom_right() - top_left);
if (new_size.width > size_limits.width)
new_size.width = size_limits.width;
if (new_size.height > size_limits.height)
new_size.height = size_limits.height;
surface->resize(new_size);
return true;
}
return false;
}