spice/client/screen.cpp

/*
   Copyright (C) 2009 Red Hat, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "common.h"
#include "screen.h"
#include "application.h"
#include "screen_layer.h"
#include "utils.h"
#include "debug.h"
#include "monitor.h"
#include "red_pixmap_cairo.h"
#include "resource.h"
#include "icon.h"

class UpdateEvent: public Event {
public:
    UpdateEvent(int screen) : _screen (screen) {}

    virtual void response(AbstractProcessLoop& events_loop)
    {
        Application* app = static_cast<Application*>(events_loop.get_owner());
        RedScreen* screen = app->find_screen(_screen);
        if (screen) {
            screen->update();
        }
    }

private:
    int _screen;
};

class LayerChangedEvent: public Event {
public:
    LayerChangedEvent (int screen) : _screen (screen) {}

    virtual void response(AbstractProcessLoop& events_loop)
    {
        Application* app = static_cast<Application*>(events_loop.get_owner());
        RedScreen* screen = app->find_screen(_screen);
        if (screen) {
            Lock lock(screen->_layer_changed_lock);
            screen->_active_layer_change_event = false;
            lock.unlock();
            if (screen->_pointer_on_screen) {
                screen->update_pointer_layer();
            }
        }
    }

private:
    int _screen;
};


void UpdateTimer::response(AbstractProcessLoop& events_loop)
{
    _screen->periodic_update();
}

RedScreen::RedScreen(Application& owner, int id, const std::wstring& name, int width, int height)
    : _owner (owner)
    , _id (id)
    , _refs (1)
    , _window (*this)
    , _active (false)
    , _full_screen (false)
    , _out_of_sync (false)
    , _frame_area (false)
    , _periodic_update (false)
    , _key_interception (false)
    , _update_by_timer (true)
    , _size_locked (false)
    , _forec_update_timer (0)
    , _update_timer (new UpdateTimer(this))
    , _composit_area (NULL)
    , _update_mark (1)
    , _monitor (NULL)
    , _default_cursor (NULL)
    , _inactive_cursor (NULL)
    , _pixel_format_index (0)
    , _update_interrupt_trigger (NULL)
    , _pointer_layer (NULL)
    , _mouse_captured (false)
    , _active_layer_change_event (false)
    , _pointer_on_screen (false)
{
    region_init(&_dirty_region);
    set_name(name);
    _size.x = width;
    _size.y = height;
    _origin.x = _origin.y = 0;
    create_composit_area();
    _window.resize(_size.x, _size.y);
    save_position();
    if ((_default_cursor = Platform::create_default_cursor()) == NULL) {
        THROW("create default cursor failed");
    }
    if ((_inactive_cursor = Platform::create_inactive_cursor()) == NULL) {
        THROW("create inactive cursor failed");
    }
    _window.set_cursor(_default_cursor);
    AutoRef<Menu> menu(_owner.get_app_menu());
    _window.set_menu(*menu);
    AutoRef<Icon> icon(Platform::load_icon(RED_ICON_RES_ID));
    _window.set_icon(*icon);
    _window.start_key_interception();
}

RedScreen::~RedScreen()
{
    bool captured = is_mouse_captured();
    _window.stop_key_interception();
    relase_mouse();
    destroy_composit_area();
    _owner.deactivate_interval_timer(*_update_timer);
    _owner.on_screen_destroyed(_id, captured);
    region_destroy(&_dirty_region);
    if (_default_cursor) {
        _default_cursor->unref();
    }

    if (_inactive_cursor) {
        _inactive_cursor->unref();
    }
}

void RedScreen::show(bool activate, RedScreen* pos)
{
    _window.position_after((pos) ? &pos->_window : NULL);
    show();
    if (activate) {
        _window.activate();
    }
}

RedScreen* RedScreen::ref()
{
    ++_refs;
    return this;
}

void RedScreen::unref()
{
    if (!--_refs) {
        delete this;
    }
}

void RedScreen::destroy_composit_area()
{
    if (_composit_area) {
        delete _composit_area;
        _composit_area = NULL;
    }
}

void RedScreen::create_composit_area()
{
    destroy_composit_area();
    _composit_area = new RedPixmapCairo(_size.x, _size.y, RedPixmap::RGB32,
                                        false, NULL, NULL);
}

void RedScreen::adjust_window_rect(int x, int y)
{
    _window.move_and_resize(x, y, _size.x, _size.y);
}

void RedScreen::resize(int width, int height)
{
    RecurciveLock lock(_update_lock);
    _size.x = width;
    _size.y = height;
    create_composit_area();
    if (_full_screen) {
        bool cuptur = _owner.rearrange_monitors(*this);
        __show_full_screen();
        if (cuptur) {
            capture_mouse();
        }
    } else {
        bool cuptur = is_mouse_captured();
        if (cuptur) {
            relase_mouse();
        }
        _window.resize(_size.x, _size.y);
        if (_active && cuptur) {
            capture_mouse();
        }
    }
    notify_new_size();
}

void RedScreen::lock_size()
{
    ASSERT(!_size_locked);
    _size_locked = true;
}

void RedScreen::unlock_size()
{
    _size_locked = false;
    _owner.on_screen_unlocked(*this);
}

void RedScreen::set_name(const std::wstring& name)
{
    if (!name.empty()) {
        wstring_printf(_name, name.c_str(), _id);
    }
    _window.set_title(_name);
}

void RedScreen::on_layer_changed(ScreenLayer& layer)
{
    Lock lock(_layer_changed_lock);
    if (_active_layer_change_event) {
        return;
    }
    _active_layer_change_event = true;
    AutoRef<LayerChangedEvent> change_event(new LayerChangedEvent(_id));
    _owner.push_event(*change_event);
}

void RedScreen::attach_layer(ScreenLayer& layer)
{
    RecurciveLock lock(_update_lock);
    int order = layer.z_order();

    if ((int)_layes.size() < order + 1) {
        _layes.resize(order + 1);
    }
    if (_layes[order]) {
        THROW("layer in use");
    }
    layer.set_screen(this);
    _layes[order] = &layer;
    ref();
    lock.unlock();
    layer.invalidate();
    if (_pointer_on_screen) {
        update_pointer_layer();
    }
}

void RedScreen::detach_layer(ScreenLayer& layer)
{
    bool need_pointer_layer_update = false;
    if (_pointer_layer == &layer) {
        _pointer_layer->on_pointer_leave();
        _pointer_layer = NULL;
        need_pointer_layer_update = true;
    }

    RecurciveLock lock(_update_lock);

    int order = layer.z_order();

    if ((int)_layes.size() < order + 1 || _layes[order] != &layer) {
        THROW("not found");
    }
    QRegion layer_area;
    region_clone(&layer_area, &layer.area());
    _layes[order]->set_screen(NULL);
    _layes[order] = NULL;
    lock.unlock();
    invalidate(layer_area);
    region_destroy(&layer_area);
    unref();
    if (need_pointer_layer_update && !update_pointer_layer()) {
        _window.set_cursor(_inactive_cursor);
    }
}

void RedScreen::composit_to_screen(RedDrawable& win_dc, const QRegion& region)
{
    for (int i = 0; i < (int)region.num_rects; i++) {
        Rect* r = &region.rects[i];
        win_dc.copy_pixels(*_composit_area, r->left, r->top, *r);
    }
}

void RedScreen::notify_new_size()
{
    for (int i = 0; i < (int)_layes.size(); i++) {
        if (!_layes[i]) {
            continue;
        }
        _layes[i]->on_size_changed();
    }
}

inline void RedScreen::begin_update(QRegion& direct_rgn, QRegion& composit_rgn,
                                    QRegion& frame_rgn)
{
    region_init(&composit_rgn);
    RecurciveLock lock(_update_lock);
    region_clone(&direct_rgn, &_dirty_region);
    region_clear(&_dirty_region);
    _update_mark++;
    lock.unlock();

    QRegion rect_rgn;
    Rect r;
    r.top = r.left = 0;
    r.right = _size.x;
    r.bottom = _size.y;
    region_init(&rect_rgn);
    region_add(&rect_rgn, &r);

    if (_frame_area) {
        region_clone(&frame_rgn, &direct_rgn);
        region_exclude(&frame_rgn, &rect_rgn);
    }
    region_and(&direct_rgn, &rect_rgn);
    region_destroy(&rect_rgn);

    for (int i = _layes.size() - 1; i >= 0; i--) {
        ScreenLayer* layer;

        if (!(layer = _layes[i])) {
            continue;
        }
        layer->begin_update(direct_rgn, composit_rgn);
    }
}

inline void RedScreen::update_done()
{
    for (unsigned int i = 0; i < _layes.size(); i++) {
        ScreenLayer* layer;

        if (!(layer = _layes[i])) {
            continue;
        }
        layer->on_update_completion(_update_mark - 1);
    }
}

inline void RedScreen::update_composit(QRegion& composit_rgn)
{
    erase_background(*_composit_area, composit_rgn);
    for (int i = 0; i < (int)_layes.size(); i++) {
        ScreenLayer* layer;

        if (!(layer = _layes[i])) {
            continue;
        }
        QRegion& dest_region = layer->composit_area();
        region_or(&composit_rgn, &dest_region);
        layer->copy_pixels(dest_region, *_composit_area);
    }
}

inline void RedScreen::draw_direct(RedDrawable& win_dc, QRegion& direct_rgn, QRegion& composit_rgn,
                                   QRegion& frame_rgn)
{
    erase_background(win_dc, direct_rgn);

    if (_frame_area) {
        erase_background(win_dc, frame_rgn);
        region_destroy(&frame_rgn);
    }

    for (int i = 0; i < (int)_layes.size(); i++) {
        ScreenLayer* layer;

        if (!(layer = _layes[i])) {
            continue;
        }
        QRegion& dest_region = layer->direct_area();
        layer->copy_pixels(dest_region, win_dc);
    }
}

void RedScreen::periodic_update()
{
    bool need_update;
    RecurciveLock lock(_update_lock);
    if (is_dirty()) {
        need_update = true;
    } else {
        if (!_forec_update_timer) {
            _owner.deactivate_interval_timer(*_update_timer);
            _periodic_update = false;
        }
        need_update = false;
    }
    lock.unlock();

    if (need_update) {
        if (update_by_interrupt()) {
            interrupt_update();
        } else {
            update();
        }
    }
}

void RedScreen::activate_timer()
{
    RecurciveLock lock(_update_lock);
    if (_periodic_update) {
        return;
    }
    _periodic_update = true;
    lock.unlock();
    _owner.activate_interval_timer(*_update_timer, 1000 / 30);
}

void RedScreen::update()
{
    if (is_out_of_sync()) {
        return;
    }

    QRegion direct_rgn;
    QRegion composit_rgn;
    QRegion frame_rgn;

    begin_update(direct_rgn, composit_rgn, frame_rgn);
    update_composit(composit_rgn);
    draw_direct(_window, direct_rgn, composit_rgn, frame_rgn);
    composit_to_screen(_window, composit_rgn);
    update_done();
    region_destroy(&direct_rgn);
    region_destroy(&composit_rgn);

    if (_update_by_timer) {
        activate_timer();
    }
}

bool RedScreen::_invalidate(const Rect& rect, bool urgent, uint64_t& update_mark)
{
    RecurciveLock lock(_update_lock);
    bool update_triger = !is_dirty() && (urgent || !_periodic_update);
    region_add(&_dirty_region, &rect);
    update_mark = _update_mark;
    return update_triger;
}

uint64_t RedScreen::invalidate(const Rect& rect, bool urgent)
{
    uint64_t update_mark;
    if (_invalidate(rect, urgent, update_mark)) {
        if (!urgent && _update_by_timer) {
            activate_timer();
        } else {
            if (update_by_interrupt()) {
                interrupt_update();
            } else {
                AutoRef<UpdateEvent> update_event(new UpdateEvent(_id));
                _owner.push_event(*update_event);
            }
        }
    }
    return update_mark;
}

void RedScreen::invalidate(const QRegion &region)
{
    Rect *r = region.rects;
    Rect *end = r + region.num_rects;
    while (r != end) {
        invalidate(*r++, false);
    }
}

inline void RedScreen::erase_background(RedDrawable& dc, const QRegion& composit_rgn)
{
    for (int i = 0; i < (int)composit_rgn.num_rects; i++) {
        dc.fill_rect(composit_rgn.rects[i], 0);
    }
}

void RedScreen::reset_mouse_pos()
{
    _window.set_mouse_position(_mouse_anchor_point.x, _mouse_anchor_point.y);
}

void RedScreen::capture_mouse()
{
    if (_mouse_captured || !_window.get_mouse_anchor_point(_mouse_anchor_point)) {
        return;
    }

    if (_pointer_layer) {
        _pointer_layer->on_pointer_leave();
        _pointer_layer = NULL;
    }
    _pointer_on_screen = false;
    _mouse_captured = true;
    _window.hide_cursor();
    reset_mouse_pos();
    _window.cupture_mouse();
}

void RedScreen::relase_mouse()
{
    if (!_mouse_captured) {
        return;
    }
    _mouse_captured = false;
    _window.release_mouse();
    update_pointer_layer();
}

void RedScreen::set_cursor(LocalCursor* cursor)
{
    if (_mouse_captured) {
        return;
    }

    _window.set_cursor(cursor);
}

void RedScreen::hide_cursor()
{
    _window.hide_cursor();
}

ScreenLayer* RedScreen::find_pointer_layer()
{
    for (int i = _layes.size() - 1; i >= 0; i--) {
        ScreenLayer* layer;

        if (!(layer = _layes[i])) {
            continue;
        }

        if (layer->pointer_test(_pointer_pos.x, _pointer_pos.y)) {
            return layer;
        }
    }
    return NULL;
}

bool RedScreen::update_pointer_layer()
{
    ASSERT(!_mouse_captured);

    ScreenLayer* now = find_pointer_layer();

    if (now == _pointer_layer) {
        return false;
    }

    if (_pointer_layer) {
        _pointer_layer->on_pointer_leave();
    }

    _pointer_layer = find_pointer_layer();

    if (_pointer_layer) {
        _pointer_layer->on_pointer_enter(_pointer_pos.x, _pointer_pos.y, _mouse_botton_state);
    } else {
        set_cursor(_inactive_cursor);
    }

    return true;
}

void RedScreen::on_pointer_enter(int x, int y, unsigned int buttons_state)
{
    if (_mouse_captured) {
        return;
    }

    _pointer_on_screen = true;
    _pointer_pos.x = x;
    _pointer_pos.y = y;
    _mouse_botton_state = buttons_state;

    ScreenLayer* layer = find_pointer_layer();
    if (!layer) {
        set_cursor(_inactive_cursor);
        return;
    }

    _pointer_layer = layer;
    _pointer_layer->on_pointer_enter(_pointer_pos.x, _pointer_pos.y, buttons_state);

    if (_full_screen) {
        /* allowing enterance to key interception mode without
           requiring the user to press the window
        */
        activate();
    }
}

void RedScreen::on_mouse_motion(int x, int y, unsigned int buttons_state)
{
    if (x != _mouse_anchor_point.x || y != _mouse_anchor_point.y) {
        _owner.on_mouse_motion(x - _mouse_anchor_point.x,
                               y - _mouse_anchor_point.y,
                               buttons_state);
        reset_mouse_pos();
    }
}

void RedScreen::on_pointer_motion(int x, int y, unsigned int buttons_state)
{
    if (_mouse_captured) {
        on_mouse_motion(x, y, buttons_state);
        return;
    }

    _pointer_pos.x = x;
    _pointer_pos.y = y;
    _mouse_botton_state = buttons_state;

    if (update_pointer_layer() || !_pointer_layer) {
        return;
    }

    _pointer_layer->on_pointer_motion(x, y, buttons_state);
}

void RedScreen::on_mouse_button_press(RedButton button, unsigned int buttons_state)
{
    if (_mouse_captured) {
        _owner.on_mouse_down(button, buttons_state);
        return;
    }

    if (!_pointer_layer) {
        return;
    }

    _pointer_layer->on_mouse_button_press(button, buttons_state);
}

void RedScreen::on_mouse_button_release(RedButton button, unsigned int buttons_state)
{
    if (_mouse_captured) {
        _owner.on_mouse_up(button, buttons_state);
        return;
    }

    if (!_pointer_layer) {
        return;
    }
    _pointer_layer->on_mouse_button_release(button, buttons_state);
}

void RedScreen::on_pointer_leave()
{
    ASSERT(!_mouse_captured);

    if (_pointer_layer) {
        _pointer_layer->on_pointer_leave();
        _pointer_layer = NULL;
    }
    _pointer_on_screen = false;
}

void RedScreen::on_key_press(RedKey key)
{
    _owner.on_key_down(key);
}

void RedScreen::on_key_release(RedKey key)
{
    _owner.on_key_up(key);
}

void RedScreen::on_char(uint32_t ch)
{
    _owner.on_char(ch);
}

void RedScreen::on_deactivate()
{
    relase_mouse();
    _active = false;
    _owner.on_deactivate_screen(this);
}

void RedScreen::on_activate()
{
    _active = true;
    _owner.on_activate_screen(this);
}

void RedScreen::on_start_key_interception()
{
    _key_interception = true;
    _owner.on_start_screen_key_interception(this);
}

void RedScreen::on_stop_key_interception()
{
    _key_interception = false;
    _owner.on_stop_screen_key_interception(this);
}

void RedScreen::enter_modal_loop()
{
    _forec_update_timer++;
    activate_timer();
}

void RedScreen::exit_modal_loop()
{
    ASSERT(_forec_update_timer > 0)
    _forec_update_timer--;
}

void RedScreen::pre_migrate()
{
    for (int i = 0; i < (int)_layes.size(); i++) {
        if (!_layes[i]) {
            continue;
        }
        _layes[i]->pre_migrate();
    }
}

void RedScreen::post_migrate()
{
    for (int i = 0; i < (int)_layes.size(); i++) {
        if (!_layes[i]) {
            continue;
        }
        _layes[i]->post_migrate();
    }
}

void RedScreen::exit_full_screen()
{
    if (!_full_screen) {
        return;
    }
    RecurciveLock lock(_update_lock);
    _window.hide();
    region_clear(&_dirty_region);
    _window.set_type(RedWindow::TYPE_NORMAL);
    adjust_window_rect(_save_pos.x, _save_pos.y);
    _origin.x = _origin.y = 0;
    _window.set_origin(0, 0);
    show();
    _full_screen = false;
    _out_of_sync = false;
    _frame_area = false;
}

void RedScreen::save_position()
{
    _save_pos = _window.get_position();
}

void RedScreen::__show_full_screen()
{
    if (!_monitor) {
        hide();
        return;
    }
    Point position = _monitor->get_position();
    Point monitor_size = _monitor->get_size();
    _frame_area = false;
    region_clear(&_dirty_region);
    _window.set_type(RedWindow::TYPE_FULLSCREEN);
    _window.move_and_resize(position.x, position.y, monitor_size.x, monitor_size.y);

    if (!(_out_of_sync = _monitor->is_out_of_sync())) {
        ASSERT(monitor_size.x >= _size.x);
        ASSERT(monitor_size.y >= _size.y);
        _origin.x = (monitor_size.x - _size.x) / 2;
        _origin.y = (monitor_size.y - _size.y) / 2;
        _frame_area = monitor_size.x != _size.x || monitor_size.y != _size.y;
    } else {
        _origin.x = _origin.y = 0;
    }
    _window.set_origin(_origin.x, _origin.y);
    show();
}

void RedScreen::show_full_screen()
{
    if (_full_screen) {
        return;
    }
    RecurciveLock lock(_update_lock);
    hide();
    save_position();
    _full_screen = true;
    __show_full_screen();
}

void RedScreen::minimize()
{
    _window.minimize();
}

void RedScreen::position_full_screen(const Point& position)
{
    if (!_full_screen) {
        return;
    }

    _window.move(position.x, position.y);
}

void RedScreen::hide()
{
    _window.hide();
}

void RedScreen::show()
{
    RecurciveLock lock(_update_lock);
    _window.show(_monitor ? _monitor->get_screen_id() : 0);
}

void RedScreen::activate()
{
    _window.activate();
}

void RedScreen::external_show()
{
    DBG(0, "Entry");
    _window.external_show();
}

void RedScreen::on_exposed_rect(const Rect& area)
{
    if (is_out_of_sync()) {
        _window.fill_rect(area, rgb32_make(0xff, 0xff, 0xff));
        return;
    }
    invalidate(area, false);
}

int RedScreen::get_screen_id()
{
    return _monitor ? _monitor->get_screen_id() : 0;
}

#ifdef USE_OGL
void RedScreen::untouch_context()
{
    _window.untouch_context();
}

bool RedScreen::need_recreate_context_gl()
{
    if (_full_screen) {
        return true;
    }
    return false;
}

#endif

void RedScreen::set_update_interrupt_trigger(EventSources::Trigger *trigger)
{
    _update_interrupt_trigger = trigger;
}

bool RedScreen::update_by_interrupt()
{
    return _update_interrupt_trigger != NULL;
}

void RedScreen::interrupt_update()
{
    _update_interrupt_trigger->trigger();
}

void RedScreen::set_type_gl()
{
    _window.set_type_gl();
}

void RedScreen::unset_type_gl()
{
    _window.unset_type_gl();
}