genode/repos/os/src/server/nitpicker/view_stack.h

/*
 * \brief  Nitpicker view stack
 * \author Norman Feske
 * \date   2006-08-08
 */

/*
 * Copyright (C) 2006-2013 Genode Labs GmbH
 *
 * This file is part of the Genode OS framework, which is distributed
 * under the terms of the GNU General Public License version 2.
 */

#ifndef _VIEW_STACK_H_
#define _VIEW_STACK_H_

#include "view.h"
#include "canvas.h"

class Session;


class View_stack
{
	private:

		Area                           _size;
		Mode                          &_mode;
		Genode::List<View_stack_elem>  _views;
		View                          *_default_background = nullptr;
		Dirty_rect mutable             _dirty_rect;

		/**
		 * Return outline geometry of a view
		 *
		 * This geometry depends on the view geometry and the currently active
		 * Nitpicker mode. In non-flat modes, we incorporate the surrounding
		 * frame.
		 */
		Rect _outline(View const &view) const;

		/**
		 * Return top-most view of the view stack
		 */
		View const *_first_view_const() const { return static_cast<View const *>(_views.first()); }

		View *_first_view() { return static_cast<View *>(_views.first()); }

		/**
		 * Find position in view stack for inserting a view
		 */
		View const *_target_stack_position(View const *neighbor, bool behind);

		/**
		 * Find best visible label position
		 */
		void _optimize_label_rec(View const *cv, View const *lv, Rect rect, Rect *optimal);

		/**
		 * Position labels that are affected by specified area
		 */
		void _place_labels(Rect);

		/**
		 * Return view following the specified view in the view stack
		 *
		 * The function is a template to capture both const and non-const
		 * usage.
		 */
		template <typename VIEW>
		VIEW *_next_view(VIEW &view) const;

		/**
		 * Schedule 'rect' to be redrawn
		 */
		void _mark_view_as_dirty(View &view, Rect rect)
		{
			_dirty_rect.mark_as_dirty(rect);
		}

	public:

		/**
		 * Constructor
		 */
		View_stack(Area size, Mode &mode) : _size(size), _mode(mode)
		{
			_dirty_rect.mark_as_dirty(Rect(Point(0, 0), _size));
		}

		/**
		 * Return size
		 */
		Area size() const { return _size; }

		void size(Area size)
		{
			_size = size;
			_dirty_rect.mark_as_dirty(Rect(Point(0, 0), _size));
		}

		/**
		 * Draw views in specified area (recursivly)
		 *
		 * \param view  current view in view stack
		 */
		void draw_rec(Canvas_base &, View const *view, Rect) const;

		/**
		 * Draw dirty areas
		 */
		Dirty_rect draw(Canvas_base &canvas) const
		{
			Dirty_rect result = _dirty_rect;

			_dirty_rect.flush([&] (Rect const &rect) {
				draw_rec(canvas, _first_view_const(), rect); });

			return result;
		}

		/**
		 * Trigger redraw of the whole view stack
		 */
		void update_all_views()
		{
			_place_labels(Rect(Point(), _size));
			_dirty_rect.mark_as_dirty(Rect(Point(), _size));
		}

		/**
		 * Mark all views belonging to the specified session as dirty
		 *
		 * \param Session  Session that created the view
		 * \param Rect     Buffer area to update
		 */
		void mark_session_views_as_dirty(Session const &session, Rect rect)
		{
			for (View *view = _first_view(); view; view = view->view_stack_next()) {

				if (!view->belongs_to(session))
					continue;

				/*
				 * Determine view portion that displays the buffer portion
				 * specified by 'rect'.
				 */
				Point const offset = view->abs_position() + view->buffer_off();
				Rect const r = Rect::intersect(Rect(rect.p1() + offset,
				                                    rect.p2() + offset),
				                               view->abs_geometry());

				_mark_view_as_dirty(*view, r);
			}
		}

		/**
		 * Refresh area within a view
		 *
		 * \param view  view that should be updated on screen
		 */
		void refresh_view(View const &view, Rect);

		/**
		 * Define view geometry
		 *
		 * \param rect  new geometry of view on screen
		 */
		void geometry(View &view, Rect rect);

		/**
		 * Define buffer offset of view
		 *
		 * \param buffer_off  view offset of displayed buffer
		 */
		void buffer_offset(View &view, Point buffer_off);

		/**
		 * Insert view at specified position in view stack
		 *
		 * \param behind  insert view in front (true) or
		 *                behind (false) the specified neighbor
		 *
		 * To insert a view at the top of the view stack, specify
		 * neighbor = 0 and behind = true. To insert a view at the
		 * bottom of the view stack, specify neighbor = 0 and
		 * behind = false.
		 */
		void stack(View const &view, View const *neighbor = 0, bool behind = true);

		/**
		 * Set view title
		 */
		void title(View &view, char const *title);

		/**
		 * Find view at specified position
		 */
		View *find_view(Point);

		/**
		 * Remove view from view stack
		 */
		void remove_view(View const &, bool redraw = true);

		/**
		 * Define default background
		 */
		void default_background(View &view) { _default_background = &view; }

		/**
		 * Return true if view is the default background
		 */
		bool is_default_background(View const &view) const { return &view == _default_background; }

		/**
		 * Remove all views of specified session from view stack
		 *
		 * Rather than removing the views from the view stack, this function moves
		 * the session views out of the visible screen area.
		 */
		void lock_out_session(Session const &session)
		{
			View const *view = _first_view(), *next_view = view->view_stack_next();
			while (view) {
				if (view->belongs_to(session)) remove_view(*view);
				view = next_view;
				next_view = view ? view->view_stack_next() : 0;
			}
		}
};

#endif