void tpanel::impl_draw_background(surface& frame_buffer)
{
DBG_GUI_D << LOG_HEADER
<< " size " << get_rectangle()
<< ".\n";
canvas(0).blit(frame_buffer, get_rectangle());
}
void widget::set_visible_rectangle(const SDL_Rect& rectangle)
{
clipping_rectangle_ = sdl::intersect_rects(rectangle, get_rectangle());
if(clipping_rectangle_ == get_rectangle()) {
redraw_action_ = redraw_action::full;
} else if(clipping_rectangle_ == sdl::empty_rect) {
redraw_action_ = redraw_action::none;
} else {
redraw_action_ = redraw_action::partly;
}
}
void twidget::draw_debug_border(surface& frame_buffer)
{
SDL_Rect r = redraw_action_ == tredraw_action::partly
? clipping_rectangle_
: get_rectangle();
switch(debug_border_mode_) {
case 0:
/* DO NOTHING */
break;
case 1:
draw_rectangle(
r.x
, r.y
, r.w
, r.h
, debug_border_colour_
, frame_buffer);
break;
case 2:
sdl_fill_rect(frame_buffer, &r, debug_border_colour_);
break;
default:
assert(false);
}
}
void tpanel::impl_draw_background(surface& frame_buffer, int x_offset, int y_offset)
{
DBG_GUI_D << LOG_HEADER << " size " << get_rectangle() << ".\n";
canvas(0).blit(frame_buffer,
calculate_blitting_rectangle(x_offset, y_offset));
}
void query_pointer(xcb_window_t *win, xcb_point_t *pt)
{
xcb_query_pointer_reply_t *qpr = xcb_query_pointer_reply(dpy, xcb_query_pointer(dpy, root), NULL);
if (qpr != NULL) {
if (win != NULL) {
*win = qpr->child;
xcb_point_t pt = {qpr->root_x, qpr->root_y};
for (stacking_list_t *s = stack_tail; s != NULL; s = s->prev) {
if (!s->node->client->shown || s->node->hidden) {
continue;
}
xcb_rectangle_t rect = get_rectangle(NULL, s->node);
if (is_inside(pt, rect)) {
if (s->node->id == qpr->child || is_presel_window(qpr->child)) {
*win = s->node->id;
}
break;
}
}
}
if (pt != NULL) {
*pt = (xcb_point_t) {qpr->root_x, qpr->root_y};
}
}
free(qpr);
}
void ungrab_pointer(void)
{
if (frozen_pointer->action != ACTION_NONE) {
xcb_rectangle_t r = get_rectangle(frozen_pointer->desktop, frozen_pointer->node);
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%X 0x%X 0x%X %ux%u+%i+%i\n", frozen_pointer->monitor->id, frozen_pointer->desktop->id, frozen_pointer->window, r.width, r.height, r.x, r.y);
}
frozen_pointer->action = ACTION_NONE;
}
void ungrab_pointer(void)
{
if (frozen_pointer->action != ACTION_NONE) {
xcb_rectangle_t r = get_rectangle(frozen_pointer->monitor, frozen_pointer->client);
put_status(SBSC_MASK_WINDOW_GEOMETRY, "window_geometry %s %s 0x%X %ux%u+%i+%i\n", frozen_pointer->monitor->name, frozen_pointer->desktop->name, frozen_pointer->window, r.width, r.height, r.x, r.y);
}
frozen_pointer->action = ACTION_NONE;
}
SDL_Rect widget::calculate_blitting_rectangle(const int x_offset,
const int y_offset)
{
SDL_Rect result = get_rectangle();
result.x += x_offset;
result.y += y_offset;
return result;
}
bool widget::is_at(const point& coordinate, const bool must_be_active) const
{
if(!recursive_is_visible(this, must_be_active)) {
return false;
}
return sdl::point_in_rect(coordinate, get_rectangle());
}
void styled_widget::impl_draw_background(surface& frame_buffer,
int x_offset,
int y_offset)
{
DBG_GUI_D << LOG_HEADER << " label '" << debug_truncate(label_) << "' size "
<< get_rectangle() << ".\n";
get_canvas(get_state()).blit(frame_buffer,
calculate_blitting_rectangle(x_offset, y_offset));
}
void tminimap::impl_draw_background(surface& frame_buffer)
{
if(!terrain_)
return;
assert(terrain_);
DBG_GUI_D << LOG_HEADER << " size " << get_rectangle() << ".\n";
if(map_data_.empty()) {
return;
}
SDL_Rect rect = get_rectangle();
assert(rect.w > 0 && rect.h > 0);
const ::surface surf = get_image(rect.w, rect.h);
if(surf) {
sdl_blit(surf, NULL, frame_buffer, &rect);
}
}
void BlockGibEntity::tick()
{
PhysicsEntity::tick();
auto world = get_world();
if (world) {
const auto collision_info = world->blocks_test_rectangle_collision(get_rectangle());
if (collision_info.first || get_position().y > static_cast<float>(Constants::VIDEO_HEIGHT))
mark_for_deletion();
}
}
void styled_widget::signal_handler_show_helptip(const event::ui_event event,
bool& handled,
const point& location)
{
DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n";
if(!help_message_.empty()) {
event::message_show_helptip message(help_message_, location, get_rectangle());
handled = fire(event::MESSAGE_SHOW_HELPTIP, *this, message);
}
}
SDL_Rect tpanel::get_client_rect() const
{
boost::intrusive_ptr<const tpanel_definition::tresolution> conf =
boost::dynamic_pointer_cast<const tpanel_definition::tresolution>(config());
assert(conf);
SDL_Rect result = get_rectangle();
result.x += conf->left_border;
result.y += conf->top_border;
result.w -= conf->left_border + conf->right_border;
result.h -= conf->top_border + conf->bottom_border;
return result;
}
SDL_Rect tpanel::get_client_rect() const
{
std::shared_ptr<const tpanel_definition::tresolution> conf
= std::static_pointer_cast<const tpanel_definition::tresolution>(
config());
assert(conf);
SDL_Rect result = get_rectangle();
result.x += conf->left_border;
result.y += conf->top_border;
result.w -= conf->left_border + conf->right_border;
result.h -= conf->top_border + conf->bottom_border;
return result;
}
resize_handle_t get_handle(node_t *n, xcb_point_t pos, pointer_action_t pac)
{
resize_handle_t rh = HANDLE_BOTTOM_RIGHT;
xcb_rectangle_t rect = get_rectangle(NULL, NULL, n);
if (pac == ACTION_RESIZE_SIDE) {
float W = rect.width;
float H = rect.height;
float ratio = W / H;
float x = pos.x - rect.x;
float y = pos.y - rect.y;
float diag_a = ratio * y;
float diag_b = W - diag_a;
if (x < diag_a) {
if (x < diag_b) {
rh = HANDLE_LEFT;
} else {
rh = HANDLE_BOTTOM;
}
} else {
if (x < diag_b) {
rh = HANDLE_TOP;
} else {
rh = HANDLE_RIGHT;
}
}
} else if (pac == ACTION_RESIZE_CORNER) {
int16_t mid_x = rect.x + (rect.width / 2);
int16_t mid_y = rect.y + (rect.height / 2);
if (pos.x > mid_x) {
if (pos.y > mid_y) {
rh = HANDLE_BOTTOM_RIGHT;
} else {
rh = HANDLE_TOP_RIGHT;
}
} else {
if (pos.y > mid_y) {
rh = HANDLE_BOTTOM_LEFT;
} else {
rh = HANDLE_TOP_LEFT;
}
}
}
return rh;
}
void widget::draw_debug_border()
{
SDL_Rect r = redraw_action_ == redraw_action::partly ? clipping_rectangle_
: get_rectangle();
switch(debug_border_mode_) {
case 0:
/* DO NOTHING */
break;
case 1:
sdl::draw_rectangle(r, debug_border_color_);
break;
case 2:
sdl::fill_rectangle(r, debug_border_color_);
break;
default:
assert(false);
}
}
void styled_widget::signal_handler_show_tooltip(const event::ui_event event,
bool& handled,
const point& location)
{
DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n";
if(!tooltip_.empty()) {
std::string tip = tooltip_;
if(!help_message_.empty()) {
utils::string_map symbols;
symbols["hotkey"] = hotkey::get_names(
hotkey::hotkey_command::get_command_by_command(
hotkey::GLOBAL__HELPTIP).command);
tip = tooltip_ + utils::interpolate_variables_into_string(
settings::has_helptip_message, &symbols);
}
event::message_show_tooltip message(tip, location, get_rectangle());
handled = fire(event::MESSAGE_SHOW_TOOLTIP, *this, message);
}
}
void widget::place(const point& origin, const point& size)
{
assert(size.x >= 0);
assert(size.y >= 0);
x_ = origin.x;
y_ = origin.y;
width_ = size.x;
height_ = size.y;
#if 0
std::cerr
<< "Id " << id()
<< " rect " << get_rectangle()
<< " parent "
<< (parent ? parent->get_x() : 0)
<< ','
<< (parent ? parent->get_y() : 0)
<< " screen origin " << x_ << ',' << y_
<< ".\n";
#endif
set_is_dirty(true);
}
SDL_Rect tcontainer_::get_client_rect() const
{
return get_rectangle();
}
void tpanel::impl_draw_foreground(surface& frame_buffer)
{
canvas(1).blit(frame_buffer, get_rectangle());
}
bool resize_client(coordinates_t *loc, resize_handle_t rh, int dx, int dy)
{
node_t *n = loc->node;
if (n == NULL || n->client == NULL || n->client->state == STATE_FULLSCREEN) {
return false;
}
node_t *horizontal_fence = NULL, *vertical_fence = NULL;
xcb_rectangle_t rect = get_rectangle(NULL, n);
uint16_t width = rect.width, height = rect.height;
int16_t x = rect.x, y = rect.y;
if (n->client->state == STATE_TILED) {
if (rh & HANDLE_LEFT) {
vertical_fence = find_fence(n, DIR_WEST);
} else if (rh & HANDLE_RIGHT) {
vertical_fence = find_fence(n, DIR_EAST);
}
if (rh & HANDLE_TOP) {
horizontal_fence = find_fence(n, DIR_NORTH);
} else if (rh & HANDLE_BOTTOM) {
horizontal_fence = find_fence(n, DIR_SOUTH);
}
if (vertical_fence == NULL && horizontal_fence == NULL) {
return false;
}
if (vertical_fence != NULL) {
double sr = vertical_fence->split_ratio + (double) dx / vertical_fence->rectangle.width;
sr = MAX(0, sr);
sr = MIN(1, sr);
vertical_fence->split_ratio = sr;
}
if (horizontal_fence != NULL) {
double sr = horizontal_fence->split_ratio + (double) dy / horizontal_fence->rectangle.height;
sr = MAX(0, sr);
sr = MIN(1, sr);
horizontal_fence->split_ratio = sr;
}
arrange(loc->monitor, loc->desktop);
} else {
int w = width + dx * (rh & HANDLE_LEFT ? -1 : (rh & HANDLE_RIGHT ? 1 : 0));
int h = height + dy * (rh & HANDLE_TOP ? -1 : (rh & HANDLE_BOTTOM ? 1 : 0));
width = MAX(1, w);
height = MAX(1, h);
apply_size_hints(n->client, &width, &height);
if (rh & HANDLE_LEFT) {
x += rect.width - width;
}
if (rh & HANDLE_TOP) {
y += rect.height - height;
}
n->client->floating_rectangle = (xcb_rectangle_t) {x, y, width, height};
if (n->client->state == STATE_FLOATING) {
if (focus_follows_pointer) {
listen_enter_notify(loc->desktop->root, false);
}
window_move_resize(n->id, x, y, width, height);
if (focus_follows_pointer) {
listen_enter_notify(loc->desktop->root, true);
}
if (!grabbing) {
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc->monitor->id, loc->desktop->id, loc->node->id, width, height, x, y);
}
} else {
arrange(loc->monitor, loc->desktop);
}
}
return true;
}
void track_pointer(coordinates_t loc, pointer_action_t pac, xcb_point_t pos)
{
node_t *n = loc.node;
resize_handle_t rh = get_handle(loc.node, pos, pac);
uint16_t last_motion_x = pos.x, last_motion_y = pos.y;
xcb_timestamp_t last_motion_time = 0;
xcb_generic_event_t *evt = NULL;
grabbing = true;
grabbed_node = n;
do {
free(evt);
while ((evt = xcb_wait_for_event(dpy)) == NULL) {
xcb_flush(dpy);
}
uint8_t resp_type = XCB_EVENT_RESPONSE_TYPE(evt);
if (resp_type == XCB_MOTION_NOTIFY) {
xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t*) evt;
uint32_t dtime = e->time - last_motion_time;
if (dtime < pointer_motion_interval) {
continue;
}
last_motion_time = e->time;
int16_t dx = e->root_x - last_motion_x;
int16_t dy = e->root_y - last_motion_y;
if (pac == ACTION_MOVE) {
move_client(&loc, dx, dy);
} else {
resize_client(&loc, rh, e->root_x, e->root_y, false);
}
last_motion_x = e->root_x;
last_motion_y = e->root_y;
xcb_flush(dpy);
} else if (resp_type == XCB_BUTTON_RELEASE) {
grabbing = false;
} else {
handle_event(evt);
}
} while (grabbing && grabbed_node != NULL);
free(evt);
xcb_ungrab_pointer(dpy, XCB_CURRENT_TIME);
if (grabbed_node == NULL) {
grabbing = false;
return;
}
if (pac == ACTION_MOVE) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X move end\n", loc.monitor->id, loc.desktop->id, n->id);
} else if (pac == ACTION_RESIZE_CORNER) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X resize_corner end\n", loc.monitor->id, loc.desktop->id, n->id);
} else if (pac == ACTION_RESIZE_SIDE) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X resize_side end\n", loc.monitor->id, loc.desktop->id, n->id);
}
xcb_rectangle_t r = get_rectangle(NULL, NULL, n);
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, loc.node->id, r.width, r.height, r.x, r.y);
if ((pac == ACTION_MOVE && IS_TILED(n->client)) ||
((pac == ACTION_RESIZE_CORNER || pac == ACTION_RESIZE_SIDE) &&
n->client->state == STATE_TILED)) {
for (node_t *f = first_extrema(loc.desktop->root); f != NULL; f = next_leaf(f, loc.desktop->root)) {
if (f == n || f->client == NULL || !IS_TILED(f->client)) {
continue;
}
xcb_rectangle_t r = f->client->tiled_rectangle;
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, f->id, r.width, r.height, r.x, r.y);
}
}
}
void BlockGibEntity::render(sf::RenderTarget& target)
{
if (block_)
block_->render(target, get_position(), sf::Vector2f(get_rectangle().width, get_rectangle().height));
}
void configure_request(xcb_generic_event_t *evt)
{
xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
coordinates_t loc;
bool is_managed = locate_window(e->window, &loc);
client_t *c = (is_managed ? loc.node->client : NULL);
int w = 0, h = 0;
if (is_managed && !IS_FLOATING(c)) {
if (e->value_mask & XCB_CONFIG_WINDOW_X) {
c->floating_rectangle.x = e->x;
}
if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
c->floating_rectangle.y = e->y;
}
if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
w = e->width;
}
if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
h = e->height;
}
if (w != 0) {
restrain_floating_width(c, &w);
c->floating_rectangle.width = w;
}
if (h != 0) {
restrain_floating_height(c, &h);
c->floating_rectangle.height = h;
}
xcb_configure_notify_event_t evt;
unsigned int bw = c->border_width;
xcb_rectangle_t rect = get_rectangle(loc.desktop, loc.node);
evt.response_type = XCB_CONFIGURE_NOTIFY;
evt.event = e->window;
evt.window = e->window;
evt.above_sibling = XCB_NONE;
evt.x = rect.x;
evt.y = rect.y;
evt.width = rect.width;
evt.height = rect.height;
evt.border_width = bw;
evt.override_redirect = false;
xcb_send_event(dpy, false, e->window, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char *) &evt);
if (c->state == STATE_PSEUDO_TILED) {
arrange(loc.monitor, loc.desktop);
}
} else {
uint16_t mask = 0;
uint32_t values[7];
unsigned short i = 0;
if (e->value_mask & XCB_CONFIG_WINDOW_X) {
mask |= XCB_CONFIG_WINDOW_X;
values[i++] = e->x;
if (is_managed) {
c->floating_rectangle.x = e->x;
}
}
if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
mask |= XCB_CONFIG_WINDOW_Y;
values[i++] = e->y;
if (is_managed) {
c->floating_rectangle.y = e->y;
}
}
if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
mask |= XCB_CONFIG_WINDOW_WIDTH;
w = e->width;
if (is_managed) {
restrain_floating_width(c, &w);
c->floating_rectangle.width = w;
}
values[i++] = w;
}
if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
mask |= XCB_CONFIG_WINDOW_HEIGHT;
h = e->height;
if (is_managed) {
restrain_floating_height(c, &h);
c->floating_rectangle.height = h;
}
values[i++] = h;
}
if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
values[i++] = e->border_width;
}
if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
mask |= XCB_CONFIG_WINDOW_SIBLING;
values[i++] = e->sibling;
}
if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
mask |= XCB_CONFIG_WINDOW_STACK_MODE;
values[i++] = e->stack_mode;
}
xcb_configure_window(dpy, e->window, mask, values);
if (is_managed && mask & XCB_CONFIG_WINDOW_X_Y_WIDTH_HEIGHT) {
xcb_rectangle_t r = c->floating_rectangle;
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%X 0x%X 0x%X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, e->window, r.width, r.height, r.x, r.y);
}
}
if (is_managed) {
monitor_t *m = monitor_from_client(c);
adapt_geometry(&m->rectangle, &loc.monitor->rectangle, loc.node);
}
}
SDL_Rect widget::get_dirty_rectangle() const
{
return redraw_action_ == redraw_action::full ? get_rectangle()
: clipping_rectangle_;
}
