#include <linux/input.h>
#include <csignal>
tools{tools}
{
}
{
auto const session = session_under(cursor);
select_active_surface(session, surface);
}
{
update_tiles(session_info, displays);
}
{
update_tiles(session_info, displays);
}
{
if (auto const session = session_under(cursor))
{
if (session == session_under(old_cursor))
{
if (
auto const surface = select_active_surface(session, tools->
surface_at(old_cursor)))
{
}
}
}
}
std::shared_ptr<ms::Session> const& session,
{
auto parameters = request_parameters;
parameters.top_left = parameters.top_left + (tile.
top_left -
Point{0, 0});
if (auto const parent = parameters.parent.lock())
{
auto const width = parameters.size.width.as_int();
auto const height = parameters.size.height.as_int();
if (parameters.aux_rect.is_set() && parameters.edge_attachment.is_set())
{
auto const edge_attachment = parameters.edge_attachment.value();
auto const aux_rect = parameters.aux_rect.value();
auto const parent_top_left = parent->top_left();
auto const top_left = aux_rect.top_left -
Point{} + parent_top_left;
auto const top_right= aux_rect.top_right() -
Point{} + parent_top_left;
auto const bot_left = aux_rect.bottom_left()-
Point{} + parent_top_left;
{
{
parameters.top_left = top_right;
}
{
}
}
{
{
parameters.top_left = bot_left;
}
{
}
}
}
else
{
auto const parent_top_left = parent->top_left();
auto const centred = parent_top_left
+ 0.5*(as_displacement(parent->size()) - as_displacement(parameters.size))
parameters.top_left = centred;
}
}
clip_to_tile(parameters, tile);
return parameters;
}
std::shared_ptr<ms::Session> const&,
std::shared_ptr<ms::Surface> const&,
{
}
{
tools->
info_for(session).surfaces.push_back(surface);
auto& surface_info = tools->
info_for(surface);
if (auto const parent = surface_info.parent.lock())
{
tools->
info_for(parent).children.push_back(surface);
}
if (surface_info.can_be_active())
{
surface->add_observer(std::make_shared<shell::SurfaceReadyObserver>(
[this](std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
{ select_active_surface(session, surface); },
session,
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());
}
{
if (auto const parent = info.parent.lock())
{
auto& siblings = tools->
info_for(parent).children;
for (
auto i =
begin(siblings); i !=
end(siblings); ++i)
{
if (surface.lock() == i->lock())
{
siblings.erase(i);
break;
}
}
}
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;
}
}
session->destroy_surface(surface);
{
}
}
{
switch (value)
{
break;
default:
return info.state;
}
{
}
if (info.state == value)
{
return info.state;
}
auto const& tile = tools->
info_for(info.session).tile;
switch (value)
{
surface->
resize(info.restore_rect.size);
drag(surface, info.restore_rect.top_left, surface->
top_left(), tile);
break;
break;
surface->
resize({tile.size.width, info.restore_rect.size.height});
drag(surface, {tile.top_left.x, info.restore_rect.top_left.y}, surface->
top_left(), tile);
break;
surface->
resize({info.restore_rect.size.width, tile.size.height});
drag(surface, {info.restore_rect.top_left.x, tile.top_left.y}, surface->
top_left(), tile);
break;
default:
break;
}
return info.state = value;
}
{
if (auto const session = session_under(cursor))
{
if (session == session_under(old_cursor))
{
if (
auto const surface = select_active_surface(session, tools->
surface_at(old_cursor)))
{
drag(surface, cursor, old_cursor, tools->
info_for(session).tile);
}
}
}
}
std::shared_ptr<ms::Session> const& session,
std::shared_ptr<ms::Surface> const& surface)
{
select_active_surface(session, surface);
}
{
{
switch (modifiers & modifier_mask)
{
return true;
return true;
return true;
default:
break;
}
}
{
{
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)
{
return true;
}
scan_code == KEY_GRAVE)
{
{
if (auto const surface = app->surface_after(prev))
{
select_active_surface(app, 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;
}
}
bool consumes_event = false;
if (is_drag)
{
switch (count)
{
case 2:
consumes_event = true;
break;
case 3:
consumes_event = true;
break;
}
}
old_cursor = cursor;
return consumes_event;
}
{
bool consumes_event = false;
{
}
{
{
consumes_event = true;
}
{
consumes_event = true;
}
}
old_cursor = cursor;
return consumes_event;
}
{
{
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([&](SessionInfo
const& info) {
return info.tile.contains(position);});
}
void me::TilingWindowManagerPolicy::update_tiles(
{
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)
{
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 movement = to - from;
constrained_move(surface, movement, bounds);
for (
auto const& child: tools->
info_for(surface).children)
{
auto move = movement;
constrained_move(child.lock(), move, bounds);
}
}
}
void me::TilingWindowManagerPolicy::constrained_move(
std::shared_ptr<scene::Surface> const& surface,
{
auto const top_left = surface->
top_left();
auto const surface_size = surface->
size();
auto const bottom_right = top_left + as_displacement(surface_size);
movement.
dx = std::max(movement.
dx, (bounds.
top_left - top_left).dx);
movement.
dy = std::max(movement.
dy, (bounds.
top_left - top_left).dy);
auto new_pos = surface->
top_left() + movement;
}
{
{
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;
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;
}
}
std::shared_ptr<ms::Surface> me::TilingWindowManagerPolicy::select_active_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
{
if (!surface)
{
return surface;
}
auto const& info_for = tools->
info_for(surface);
if (info_for.can_be_active())
{
return surface;
}
else
{
if (auto const parent = info_for.parent.lock())
return select_active_surface(session, parent);
return {};
}
}