region_eval.h

彩信浏览器

/*
 * This file is part of Ambulant Player, www.ambulantplayer.org.
 *
 * Copyright (C) 2003-2007 Stichting CWI, 
 * Kruislaan 413, 1098 SJ Amsterdam, The Netherlands.
 *
 * Ambulant Player is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * Ambulant Player 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Ambulant Player; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/* 
 * @$Id: region_eval.h,v 1.17 2007/02/12 14:14:09 jackjansen Exp $ 
 */

#ifndef AMBULANT_COMMON_REGION_EVAL_H
#define AMBULANT_COMMON_REGION_EVAL_H

#include "ambulant/config/config.h"

// should go to config.h
#ifdef min
#undef min
#endif

#include "ambulant/config/config.h"
#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 97
#include "ambulant/compat/limits"
#else
#include <limits>
#endif
#include <cassert>
#include "ambulant/lib/gtypes.h"
#include "ambulant/common/region_dim.h"

namespace ambulant {

namespace common {

using namespace lib;

namespace detail {
/// const representing auto internally.
const int auto_int = std::numeric_limits<int>::min();
}

/// A simple utility for evaluating regions positioning attributes.
/// This utility may be used as a helper while building the layout tree. 
/// This utility is just a calculator and its not appropriate for holding region pos attrs.  

class region_evaluator {

  public:
	/// Constructor.
	/// argument w and h are the width and height of the parent region in pixels
	/// e.g parent.get_width(), parent.get_height().
	region_evaluator(int w, int h) : m_refw(w), m_refh(h) {
		reset();
	}
	
	/// Copy constructor.
	region_evaluator(const region_evaluator& re) 
	:	m_refw(re.get_ref_width()), m_refh(re.get_ref_height()) {
		reset();
	}
	
	/// Reset all parameters to auto.
	void reset() {
		m_horz[0] = m_horz[1] = m_horz[2] = detail::auto_int;
		m_vert[0] = m_vert[1] = m_vert[2] = detail::auto_int;
		m_eval = false;
	}
	
	/// Set all parameters from a region_dim_spec.
	void set(const region_dim_spec& rds) {
		set_left(rds.left);set_width(rds.width);set_right(rds.right);
		set_top(rds.top);set_height(rds.height);set_bottom(rds.bottom);
	}
	
	/// Set all parameters from a region_dim array.
	void set(const region_dim *prd) {
		set_horz(prd[0], 0); set_horz(prd[1], 1); set_horz(prd[2], 2);
		set_vert(prd[3], 0); set_vert(prd[4], 1); set_vert(prd[5], 2);
	}
	
	/// Sets one parameter.
	void set_left(const region_dim& rd) { set_horz(rd, 0);}
	/// Sets one parameter.
	void set_width(const region_dim& rd) { set_horz(rd, 1);}
	/// Sets one parameter.
	void set_right(const region_dim& rd) { set_horz(rd, 2);}
	
	/// Sets one parameter.
	void set_top(const region_dim& rd) { set_vert(rd, 0);}
	/// Sets one parameter.
	void set_height(const region_dim& rd) { set_vert(rd, 1);}
	/// Sets one parameter.
	void set_bottom(const region_dim& rd) { set_vert(rd, 2);}
	
	/// Sets one parameter.
	void set_left(int v) { m_horz[0] = v;}
	/// Sets one parameter.
	void set_width(int v) { m_horz[1] = v;}
	/// Sets one parameter.
	void set_right(int v) { m_horz[2] = v;}
	
	/// Sets one parameter.
	void set_top(int v) { m_vert[0] = v;}
	/// Sets one parameter.
	void set_height(int v) { m_vert[1] = v;}
	/// Sets one parameter.
	void set_bottom(int v) { m_vert[2] = v;}
	
	/// Sets one parameter.
	void set_left(double p) { set_horz(p, 0);}
	/// Sets one parameter.
	void set_width(double p) { set_horz(p, 1);}
	/// Sets one parameter.
	void set_right(double p) { set_horz(p, 2);}
	
	/// Sets one parameter.
	void set_top(double p) { set_vert(p, 0);}
	/// Sets one parameter.
	void set_height(double p) { set_vert(p, 1);}
	/// Sets one parameter.
	void set_bottom(double p) { set_vert(p, 2);}
		
	/// Evaluate (if needed) and return left parameter.
	int get_left() { 
		if(!m_eval) evaluate();
		return m_horz[0];
	}
		
	/// Evaluate (if needed) and return width parameter.
	int get_width() { 
		if(!m_eval) evaluate();
		return m_horz[1];
	}
		
	/// Evaluate (if needed) and return right parameter.
	int get_right() { 
		if(!m_eval) evaluate();
		return  m_horz[2];
	}
		
	/// Evaluate (if needed) and return top parameter.
	int get_top() { 
		if(!m_eval) evaluate();
		return m_vert[0];
	}
		
	/// Evaluate (if needed) and return height parameter.
	int get_height() { 
		if(!m_eval) evaluate();
		return m_vert[1];
	}
		
	/// Evaluate (if needed) and return bottom parameter.
	int get_bottom() { 
		if(!m_eval) evaluate();
		return m_vert[2];
	}
	
	/// Return parent width.
	int get_ref_width() const { 
		return m_refw;
	}
	
	/// Return parent height.
	int get_ref_height() const { 
		return m_refh;
	}
	
	/// Evaluate (if needed) and return rectangle.
	rect get_rect() {
		return rect(point(get_left(), get_top()),
			size(get_width(), get_height()));
	}
	
	/// Evaluate (if needed) and return (left, top) point.
	point get_origin() {
		return point(get_left(), get_top());
	}
	
	/// Evaluate (if needed) and return (width, height) size.
	size get_size() {
		return size(get_width(), get_height());
	}
	
	// get clipped box
	// ...
	
  private:	
	bool is_defined(int v) { return v != detail::auto_int;}
	bool is_auto(int v) { return v == detail::auto_int;}
	void eval_third(int dim[], int w);
	int count_defined(int dim[]);
	void eval_linear_dim(int dim[], int w);
	void set_horz(double p, int ix) {
		m_horz[ix] = int(floor(m_refw*p + 0.5));
	}
	void set_vert(double p, int ix) {
		m_vert[ix] = int(floor(m_refh*p + 0.5));
	}
	
	void set_horz(const region_dim& rd, int i) {
		assert(i>=0 && i<3);
		if(rd.absolute()) m_horz[i] = rd.get_as_int(); 
		else if(rd.relative()) m_horz[i] = rd.get(m_refw);
		else m_horz[i] = detail::auto_int;
	}
	
	void set_vert(const region_dim& rd, int i) {
		assert(i>=0 && i<3);
		if(rd.absolute()) m_vert[i] = rd.get_as_int(); 
		else if(rd.relative()) m_vert[i] = rd.get(m_refh);
		else m_vert[i] = detail::auto_int;
	}
	
	void evaluate() {
		if(!m_eval) {
			eval_linear_dim(m_horz, m_refw);
			eval_linear_dim(m_vert, m_refh);
			m_eval = true;
		}
	}
	
	int m_horz[3];
	int m_vert[3];
	int m_refw;
	int m_refh;
	bool m_eval;
};


inline void region_evaluator::eval_third(int dim[], int w) {
	if(is_auto(dim[0])) dim[0] = w - dim[1] - dim[2];
	else if(is_auto(dim[1])) dim[1] = w - dim[0] - dim[2];
	else if(is_auto(dim[2])) dim[2] = w - dim[0] - dim[1];
}

inline int region_evaluator::count_defined(int dim[]) {
	int nd = 0;
	if(is_defined(dim[0])) nd++;
	if(is_defined(dim[1])) nd++;
	if(is_defined(dim[2])) nd++;
	return nd;
}

inline void region_evaluator::eval_linear_dim(int dim[], int w) {
	int nd = count_defined(dim);
	switch(nd) {
		case 0:
			dim[0] = dim[2] = 0;
			dim[1] = w;
			return;
		case 2:
			eval_third(dim, w);
			return;
		case 3:
			dim[2] = w - dim[0] - dim[1];
			return;
	}
	assert(nd == 1);
	if(is_auto(dim[0])) {
		dim[0] = 0;
		eval_third(dim, w);
	} else {
		dim[2] = 0;
		dim[1] = w - dim[0];
	}
}
 
} // namespace common
 
} // namespace ambulant

#endif // AMBULANT_COMMON_REGION_EVAL_H