2220 lines
53 KiB
C++
2220 lines
53 KiB
C++
/*
|
|
* An Implementation of Place for Layout
|
|
* Nana C++ Library(http://www.nanapro.org)
|
|
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
|
|
*
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE_1_0.txt or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*
|
|
* @file: nana/gui/place.cpp
|
|
*/
|
|
#include <sstream>
|
|
#include <cfloat>
|
|
#include <cmath>
|
|
#include <stdexcept>
|
|
#include <cstring>
|
|
#include <nana/gui/place.hpp>
|
|
#include <nana/gui/programming_interface.hpp>
|
|
#include <nana/gui/widgets/label.hpp>
|
|
#include <nana/gui/dragger.hpp>
|
|
|
|
#include <memory>
|
|
#include <limits>
|
|
|
|
namespace nana
|
|
{
|
|
namespace place_parts
|
|
{
|
|
void check_field_name(const char* name)
|
|
{
|
|
//check the name
|
|
if (*name && (*name != '_' && !(('a' <= *name && *name <= 'z') || ('A' <= *name && *name <= 'Z'))))
|
|
throw std::invalid_argument("place.field: bad field name");
|
|
}
|
|
|
|
class splitter_interface
|
|
{
|
|
public:
|
|
virtual ~splitter_interface(){}
|
|
};
|
|
|
|
class splitter_dtrigger
|
|
: public drawer_trigger
|
|
{
|
|
};
|
|
|
|
template<bool IsLite>
|
|
class splitter
|
|
: public widget_object <typename std::conditional<IsLite, category::lite_widget_tag, category::widget_tag>::type, splitter_dtrigger>,
|
|
public splitter_interface
|
|
{
|
|
};
|
|
|
|
//number_t is used for storing a number type variable
|
|
//such as integer, real and percent. Essentially, percent is a typo of real.
|
|
class number_t
|
|
{
|
|
public:
|
|
enum class kind{ none, integer, real, percent };
|
|
|
|
number_t()
|
|
: kind_(kind::none)
|
|
{
|
|
value_.integer = 0;
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
kind_ = kind::none;
|
|
value_.integer = 0;
|
|
}
|
|
|
|
bool is_negative() const
|
|
{
|
|
switch (kind_)
|
|
{
|
|
case kind::integer:
|
|
return (value_.integer < 0);
|
|
case kind::real:
|
|
case kind::percent:
|
|
return (value_.real < 0);
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool is_none() const
|
|
{
|
|
return (kind::none == kind_);
|
|
}
|
|
|
|
bool is_not_none() const
|
|
{
|
|
return (kind::none != kind_);
|
|
}
|
|
|
|
kind kind_of() const
|
|
{
|
|
return kind_;
|
|
}
|
|
|
|
double get_value(int ref_percent) const
|
|
{
|
|
switch (kind_)
|
|
{
|
|
case kind::integer:
|
|
return value_.integer;
|
|
case kind::real:
|
|
return value_.real;
|
|
case kind::percent:
|
|
return value_.real * ref_percent;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int integer() const
|
|
{
|
|
if (kind::integer == kind_)
|
|
return value_.integer;
|
|
return static_cast<int>(value_.real);
|
|
}
|
|
|
|
double real() const
|
|
{
|
|
if (kind::integer == kind_)
|
|
return value_.integer;
|
|
return value_.real;
|
|
}
|
|
|
|
void assign(int i)
|
|
{
|
|
kind_ = kind::integer;
|
|
value_.integer = i;
|
|
}
|
|
|
|
void assign(double d)
|
|
{
|
|
kind_ = kind::real;
|
|
value_.real = d;
|
|
}
|
|
|
|
void assign_percent(double d)
|
|
{
|
|
kind_ = kind::percent;
|
|
value_.real = d / 100;
|
|
}
|
|
private:
|
|
kind kind_;
|
|
union valueset
|
|
{
|
|
int integer;
|
|
double real;
|
|
}value_;
|
|
};//end class number_t
|
|
|
|
class margin
|
|
{
|
|
public:
|
|
margin& operator=(margin&& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
all_edges_ = rhs.all_edges_;
|
|
margins_ = std::move(rhs.margins_);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
all_edges_ = true;
|
|
margins_.clear();
|
|
}
|
|
|
|
void push(const number_t& v)
|
|
{
|
|
margins_.emplace_back(v);
|
|
}
|
|
|
|
void set_value(const number_t& v)
|
|
{
|
|
clear();
|
|
margins_.emplace_back(v);
|
|
}
|
|
|
|
void set_array(const std::vector<number_t>& v)
|
|
{
|
|
all_edges_ = false;
|
|
margins_ = v;
|
|
}
|
|
|
|
nana::rectangle area(const ::nana::rectangle& field_area) const
|
|
{
|
|
if (margins_.empty())
|
|
return field_area;
|
|
|
|
auto r = field_area;
|
|
if (all_edges_)
|
|
{
|
|
auto px = static_cast<int>(margins_.back().get_value(static_cast<int>(r.width)));
|
|
const auto dbl_px = static_cast<unsigned>(px << 1);
|
|
r.x += px;
|
|
r.width = (r.width < dbl_px ? 0 : r.width - dbl_px);
|
|
|
|
r.y += px;
|
|
r.height = (r.height < dbl_px ? 0 : r.height - dbl_px);
|
|
}
|
|
else
|
|
{
|
|
int il{ -1 }, ir{ -1 }, it{ -1 }, ib{ -1 }; //index of four corners in margin
|
|
switch (margins_.size())
|
|
{
|
|
case 0: break;
|
|
case 1: //top
|
|
it = 0;
|
|
break;
|
|
case 2://top,bottom and left,right
|
|
it = ib = 0;
|
|
il = ir = 1;
|
|
break;
|
|
default:
|
|
il = 3; //left
|
|
case 3: //top, right, bottom
|
|
it = 0;
|
|
ir = 1;
|
|
ib = 2;
|
|
}
|
|
|
|
typedef decltype(r.height) px_type;
|
|
auto calc = [](px_type a, px_type b)
|
|
{
|
|
return (a > b ? a - b : 0);
|
|
};
|
|
|
|
if (0 == it) //top
|
|
{
|
|
auto px = static_cast<int>(margins_[it].get_value(static_cast<int>(field_area.height)));
|
|
r.y += px;
|
|
r.height = calc(r.height, static_cast<px_type>(px));
|
|
}
|
|
|
|
if (-1 != ib) //bottom
|
|
{
|
|
auto px = static_cast<int>(margins_[ib].get_value(static_cast<int>(field_area.height)));
|
|
r.height = calc(r.height, static_cast<px_type>(px));
|
|
}
|
|
|
|
if (-1 != il) //left
|
|
{
|
|
auto px = static_cast<px_type>(margins_[il].get_value(static_cast<int>(field_area.width)));
|
|
r.x += px;
|
|
r.width = calc(r.width, static_cast<px_type>(px));
|
|
}
|
|
|
|
if (-1 != ir) //right
|
|
{
|
|
auto px = static_cast<int>(margins_[ir].get_value(static_cast<int>(field_area.width)));
|
|
r.width = calc(r.width, static_cast<px_type>(px));
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
private:
|
|
bool all_edges_ = true;
|
|
std::vector<number_t> margins_;
|
|
};//end class margin
|
|
|
|
class repeated_array
|
|
{
|
|
public:
|
|
|
|
//A workaround for VC2013, becuase it does not generated an implicit declared move-constructor as defaulted.
|
|
repeated_array() = default;
|
|
|
|
repeated_array(repeated_array && other)
|
|
: repeated_{other.repeated_},
|
|
values_(std::move(other.values_))
|
|
{
|
|
}
|
|
|
|
repeated_array& operator=(repeated_array&& other)
|
|
{
|
|
if(this != &other)
|
|
{
|
|
repeated_ = other.repeated_;
|
|
other.repeated_ = false;
|
|
values_ = std::move(other.values_);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void assign(std::vector<number_t>&& c)
|
|
{
|
|
values_ = std::move(c);
|
|
}
|
|
|
|
bool empty() const
|
|
{
|
|
return values_.empty();
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
repeated_ = false;
|
|
values_.clear();
|
|
}
|
|
|
|
void repeated()
|
|
{
|
|
repeated_ = true;
|
|
}
|
|
|
|
void push(const number_t& n)
|
|
{
|
|
values_.emplace_back(n);
|
|
}
|
|
|
|
number_t at(std::size_t pos) const
|
|
{
|
|
if (values_.empty())
|
|
return{};
|
|
|
|
if (repeated_)
|
|
pos %= values_.size();
|
|
else if (pos >= values_.size())
|
|
return{};
|
|
|
|
return values_[pos];
|
|
}
|
|
private:
|
|
bool repeated_ = false;
|
|
std::vector<number_t> values_;
|
|
};
|
|
}//end namespace place_parts
|
|
|
|
typedef place_parts::number_t number_t;
|
|
typedef place_parts::repeated_array repeated_array;
|
|
|
|
namespace place_parts
|
|
{
|
|
class tokenizer
|
|
{
|
|
public:
|
|
enum class token
|
|
{
|
|
div_start, div_end, splitter,
|
|
identifier, vert, grid, number, array, reparray,
|
|
weight, gap, margin, arrange, variable, repeated, min_px, max_px,
|
|
collapse, parameters,
|
|
equal,
|
|
eof, error
|
|
};
|
|
|
|
tokenizer(const char* p)
|
|
: divstr_(p), sp_(p)
|
|
{}
|
|
|
|
const std::string& idstr() const
|
|
{
|
|
return idstr_;
|
|
}
|
|
|
|
number_t number() const
|
|
{
|
|
return number_;
|
|
}
|
|
|
|
std::vector<number_t>& array()
|
|
{
|
|
return array_;
|
|
}
|
|
|
|
repeated_array&& reparray()
|
|
{
|
|
return std::move(reparray_);
|
|
}
|
|
|
|
std::vector<number_t>& parameters()
|
|
{
|
|
return parameters_;
|
|
}
|
|
|
|
token read()
|
|
{
|
|
sp_ = _m_eat_whitespace(sp_);
|
|
|
|
std::size_t readbytes = 0;
|
|
switch (*sp_)
|
|
{
|
|
case '\0':
|
|
return token::eof;
|
|
case '|':
|
|
++sp_;
|
|
readbytes = _m_number(sp_, false);
|
|
sp_ += readbytes;
|
|
return token::splitter;
|
|
case '=':
|
|
++sp_;
|
|
return token::equal;
|
|
case '<':
|
|
++sp_;
|
|
return token::div_start;
|
|
case '>':
|
|
++sp_;
|
|
return token::div_end;
|
|
case '[':
|
|
array_.clear();
|
|
sp_ = _m_eat_whitespace(sp_ + 1);
|
|
if (*sp_ == ']')
|
|
{
|
|
++sp_;
|
|
return token::array;
|
|
}
|
|
|
|
{
|
|
//When search the repeated.
|
|
bool repeated = false;
|
|
|
|
while (true)
|
|
{
|
|
sp_ = _m_eat_whitespace(sp_);
|
|
auto tk = read();
|
|
if (token::number != tk && token::variable != tk && token::repeated != tk)
|
|
_m_throw_error("invalid array element");
|
|
|
|
if (!repeated)
|
|
{
|
|
switch (tk)
|
|
{
|
|
case token::number:
|
|
array_.push_back(number_);
|
|
break;
|
|
case token::variable:
|
|
array_.push_back({});
|
|
break;
|
|
default:
|
|
repeated = true;
|
|
reparray_.repeated();
|
|
reparray_.assign(std::move(array_));
|
|
}
|
|
}
|
|
|
|
sp_ = _m_eat_whitespace(sp_);
|
|
char ch = *sp_++;
|
|
|
|
if (ch == ']')
|
|
return (repeated ? token::reparray : token::array);
|
|
|
|
if (ch != ',')
|
|
_m_throw_error("invalid array");
|
|
}
|
|
}
|
|
break;
|
|
case '(':
|
|
parameters_.clear();
|
|
sp_ = _m_eat_whitespace(sp_ + 1);
|
|
if (*sp_ == ')')
|
|
{
|
|
++sp_;
|
|
return token::parameters;
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
if (token::number == read())
|
|
parameters_.push_back(number_);
|
|
else
|
|
_m_throw_error("invalid parameter.");
|
|
|
|
sp_ = _m_eat_whitespace(sp_);
|
|
char ch = *sp_++;
|
|
|
|
if (ch == ')')
|
|
return token::parameters;
|
|
|
|
if (ch != ',')
|
|
_m_throw_error("invalid parameter.");
|
|
}
|
|
break;
|
|
case '.': case '-':
|
|
if (*sp_ == '-')
|
|
{
|
|
readbytes = _m_number(sp_ + 1, true);
|
|
if (readbytes)
|
|
++readbytes;
|
|
}
|
|
else
|
|
readbytes = _m_number(sp_, false);
|
|
|
|
if (readbytes)
|
|
{
|
|
sp_ += readbytes;
|
|
return token::number;
|
|
}
|
|
else
|
|
_m_throw_error(*sp_);
|
|
break;
|
|
default:
|
|
if ('0' <= *sp_ && *sp_ <= '9')
|
|
{
|
|
readbytes = _m_number(sp_, false);
|
|
if (readbytes)
|
|
{
|
|
sp_ += readbytes;
|
|
return token::number;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ('_' == *sp_ || isalpha(*sp_))
|
|
{
|
|
const char * idstart = sp_++;
|
|
|
|
while ('_' == *sp_ || isalpha(*sp_) || isalnum(*sp_))
|
|
++sp_;
|
|
|
|
idstr_.assign(idstart, sp_);
|
|
|
|
if ("weight" == idstr_ || "min" == idstr_ || "max" == idstr_)
|
|
{
|
|
auto ch = idstr_[1];
|
|
_m_attr_number_value();
|
|
switch (ch)
|
|
{
|
|
case 'e': return token::weight;
|
|
case 'i': return token::min_px;
|
|
case 'a': return token::max_px;
|
|
}
|
|
}
|
|
else if ("vertical" == idstr_ || "vert" == idstr_)
|
|
return token::vert;
|
|
else if ("variable" == idstr_ || "repeated" == idstr_)
|
|
return ('v' == idstr_[0] ? token::variable : token::repeated);
|
|
else if ("arrange" == idstr_ || "gap" == idstr_)
|
|
{
|
|
auto ch = idstr_[0];
|
|
_m_attr_reparray();
|
|
return ('a' == ch ? token::arrange : token::gap);
|
|
}
|
|
else if ("grid" == idstr_ || "margin" == idstr_)
|
|
{
|
|
auto idstr = idstr_;
|
|
if (token::equal != read())
|
|
_m_throw_error("an equal sign is required after '" + idstr + "'");
|
|
|
|
return ('g' == idstr[0] ? token::grid : token::margin);
|
|
}
|
|
else if ("collapse" == idstr_)
|
|
{
|
|
if (token::parameters != read())
|
|
_m_throw_error("a parameter list is required after 'collapse'");
|
|
return token::collapse;
|
|
}
|
|
return token::identifier;
|
|
}
|
|
|
|
std::string err = "an invalid character '";
|
|
err += *sp_;
|
|
err += "'";
|
|
|
|
_m_throw_error(err);
|
|
return token::error; //Useless, just for syntax correction.
|
|
}
|
|
private:
|
|
void _m_throw_error(char err_char)
|
|
{
|
|
std::stringstream ss;
|
|
ss << "place: invalid character '" << err_char << "' at " << static_cast<unsigned>(sp_ - divstr_);
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
|
|
void _m_attr_number_value()
|
|
{
|
|
if (token::equal != read())
|
|
_m_throw_error("an equal sign is required after '" + idstr_ + "'");
|
|
|
|
const char* p = sp_;
|
|
for (; *p == ' '; ++p);
|
|
|
|
auto neg_ptr = p;
|
|
if ('-' == *p)
|
|
++p;
|
|
|
|
auto len = _m_number(p, neg_ptr != p);
|
|
if (0 == len)
|
|
_m_throw_error("the '" + idstr_ + "' requires a number(integer or real or percent)");
|
|
|
|
sp_ += len + (p - sp_);
|
|
}
|
|
|
|
void _m_attr_reparray()
|
|
{
|
|
auto idstr = idstr_;
|
|
if (token::equal != read())
|
|
_m_throw_error("an equal sign is required after '" + idstr + "'");
|
|
|
|
const char* p = sp_;
|
|
for (; *p == ' ' || *p == '\t'; ++p);
|
|
|
|
reparray_.reset();
|
|
auto tk = read();
|
|
switch (tk)
|
|
{
|
|
case token::number:
|
|
reparray_.push(number());
|
|
reparray_.repeated();
|
|
break;
|
|
case token::array:
|
|
reparray_.assign(std::move(array_));
|
|
break;
|
|
case token::reparray:
|
|
break;
|
|
default:
|
|
_m_throw_error("a (repeated) array is required after '" + idstr + "'");
|
|
}
|
|
}
|
|
|
|
void _m_throw_error(const std::string& err)
|
|
{
|
|
std::stringstream ss;
|
|
ss << "place: " << err << " at " << static_cast<unsigned>(sp_ - divstr_);
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
|
|
const char* _m_eat_whitespace(const char* sp)
|
|
{
|
|
while (*sp && !isgraph(*sp))
|
|
++sp;
|
|
return sp;
|
|
}
|
|
|
|
std::size_t _m_number(const char* sp, bool negative)
|
|
{
|
|
const char* allstart = sp;
|
|
sp = _m_eat_whitespace(sp);
|
|
|
|
number_.assign(0);
|
|
|
|
bool gotcha = false;
|
|
int integer = 0;
|
|
double real = 0;
|
|
//read the integral part.
|
|
const char* istart = sp;
|
|
while ('0' <= *sp && *sp <= '9')
|
|
{
|
|
integer = integer * 10 + (*sp - '0');
|
|
++sp;
|
|
}
|
|
const char* iend = sp;
|
|
|
|
if ('.' == *sp)
|
|
{
|
|
double div = 1;
|
|
const char* rstart = ++sp;
|
|
while ('0' <= *sp && *sp <= '9')
|
|
{
|
|
real += (*sp - '0') / (div *= 10);
|
|
++sp;
|
|
}
|
|
|
|
if (rstart != sp)
|
|
{
|
|
real += integer;
|
|
number_.assign(negative ? -real : real);
|
|
gotcha = true;
|
|
}
|
|
}
|
|
else if (istart != iend)
|
|
{
|
|
number_.assign(negative ? -integer : integer);
|
|
gotcha = true;
|
|
}
|
|
|
|
if (gotcha)
|
|
{
|
|
for (; *sp == ' ' || *sp == '\t'; ++sp);
|
|
if ('%' == *sp)
|
|
{
|
|
if (number_t::kind::integer == number_.kind_of())
|
|
number_.assign_percent(number_.integer());
|
|
return sp - allstart + 1;
|
|
}
|
|
return sp - allstart;
|
|
}
|
|
number_.reset();
|
|
return 0;
|
|
}
|
|
private:
|
|
const char* divstr_;
|
|
const char* sp_;
|
|
std::string idstr_;
|
|
number_t number_;
|
|
std::vector<number_t> array_;
|
|
repeated_array reparray_;
|
|
std::vector<number_t> parameters_;
|
|
}; //end class tokenizer
|
|
}
|
|
|
|
|
|
//struct implement
|
|
struct place::implement
|
|
{
|
|
class field_impl;
|
|
class division;
|
|
class div_arrange;
|
|
class div_grid;
|
|
class div_splitter;
|
|
|
|
window window_handle{nullptr};
|
|
event_handle event_size_handle{nullptr};
|
|
std::unique_ptr<division> root_division;
|
|
std::map<std::string, field_impl*> fields;
|
|
|
|
//The following functions are defined behind the definition of class division.
|
|
//because the class division here is an incomplete type.
|
|
~implement();
|
|
static division * search_div_name(division* start, const std::string&);
|
|
std::unique_ptr<division> scan_div(place_parts::tokenizer&);
|
|
}; //end struct implement
|
|
|
|
class place::implement::field_impl
|
|
: public place::field_interface
|
|
{
|
|
public:
|
|
struct element_t
|
|
{
|
|
window handle;
|
|
event_handle evt_destroy;
|
|
|
|
element_t(window h, event_handle event_destroy)
|
|
:handle(h), evt_destroy(event_destroy)
|
|
{}
|
|
};
|
|
|
|
field_impl(place * p)
|
|
: place_ptr_(p)
|
|
{}
|
|
|
|
~field_impl()
|
|
{
|
|
for (auto & e : elements)
|
|
API::umake_event(e.evt_destroy);
|
|
|
|
for (auto & e : fastened)
|
|
API::umake_event(e.evt_destroy);
|
|
}
|
|
|
|
void visible(bool vsb)
|
|
{
|
|
for (auto & e : elements)
|
|
API::show_window(e.handle, vsb);
|
|
|
|
for (auto & e : fastened)
|
|
API::show_window(e.handle, vsb);
|
|
}
|
|
private:
|
|
//The defintion is moved after the definition of class division
|
|
template<typename Function>
|
|
void _m_for_each(division*, Function);
|
|
|
|
//Listen to destroy of a window
|
|
//It will delete the element and recollocate when the window destroyed.
|
|
event_handle _m_make_destroy(window wd)
|
|
{
|
|
return API::events(wd).destroy.connect([this](const arg_destroy& arg)
|
|
{
|
|
for (auto i = elements.begin(), end = elements.end(); i != end; ++i)
|
|
{
|
|
if (arg.window_handle == i->handle)
|
|
{
|
|
elements.erase(i);
|
|
break;
|
|
}
|
|
}
|
|
place_ptr_->collocate();
|
|
});
|
|
}
|
|
|
|
field_interface& operator<<(const nana::char_t* label_text) override
|
|
{
|
|
return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text ? label_text : L""));
|
|
}
|
|
|
|
virtual field_interface& operator<<(nana::string label_text) override
|
|
{
|
|
return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text));
|
|
}
|
|
|
|
field_interface& operator<<(window wd) override
|
|
{
|
|
if (API::empty_window(wd))
|
|
throw std::invalid_argument("Place: An invalid window handle.");
|
|
|
|
if (API::get_parent_window(wd) != place_ptr_->window_handle())
|
|
throw std::invalid_argument("Place: the window is not a child of place bind window");
|
|
|
|
auto evt = _m_make_destroy(wd);
|
|
elements.emplace_back(wd, evt);
|
|
return *this;
|
|
}
|
|
|
|
field_interface& fasten(window wd) override
|
|
{
|
|
if (API::empty_window(wd))
|
|
throw std::invalid_argument("Place: An invalid window handle.");
|
|
|
|
if (API::get_parent_window(wd) != place_ptr_->window_handle())
|
|
throw std::invalid_argument("Place: the window is not a child of place bind window");
|
|
|
|
//Listen to destroy of a window. The deleting a fastened window
|
|
//does not change the layout.
|
|
auto evt = API::events(wd).destroy([this](const arg_destroy& arg)
|
|
{
|
|
auto destroyed_wd = arg.window_handle;
|
|
auto i = std::find_if(fastened.begin(), fastened.end(), [destroyed_wd](element_t& e){
|
|
return (e.handle == destroyed_wd);
|
|
});
|
|
|
|
if (i != fastened.end())
|
|
fastened.erase(i);
|
|
});
|
|
|
|
fastened.emplace_back(wd, evt);
|
|
return *this;
|
|
}
|
|
|
|
void _m_add_agent(const detail::place_agent& ag) override
|
|
{
|
|
widgets_.emplace_back(ag.create(place_ptr_->window_handle()));
|
|
this->operator<<(widgets_.back()->handle());
|
|
}
|
|
public:
|
|
division* attached{ nullptr };
|
|
std::vector<std::unique_ptr<nana::widget>> widgets_;
|
|
std::vector<element_t> elements;
|
|
std::vector<element_t> fastened;
|
|
private:
|
|
place * place_ptr_;
|
|
};//end class field_impl
|
|
|
|
class place::implement::division
|
|
{
|
|
public:
|
|
enum class kind{ arrange, vertical_arrange, grid, splitter };
|
|
|
|
division(kind k, std::string&& n)
|
|
: kind_of_division(k),
|
|
name(std::move(n)),
|
|
field(nullptr),
|
|
div_next(nullptr),
|
|
div_owner(nullptr)
|
|
{}
|
|
|
|
virtual ~division()
|
|
{
|
|
//detach the field
|
|
if (field)
|
|
field->attached = nullptr;
|
|
}
|
|
|
|
void set_visible(bool vsb)
|
|
{
|
|
if (field)
|
|
field->visible(vsb);
|
|
|
|
_m_visible_for_child(this, vsb);
|
|
visible = vsb;
|
|
}
|
|
|
|
void set_display(bool dsp)
|
|
{
|
|
if (field)
|
|
field->visible(dsp);
|
|
|
|
_m_visible_for_child(this, dsp);
|
|
visible = dsp;
|
|
display = dsp;
|
|
}
|
|
|
|
bool is_back(const division* div) const
|
|
{
|
|
for (auto i = children.crbegin(); i != children.crend(); ++i)
|
|
{
|
|
if (!(i->get()->display))
|
|
continue;
|
|
|
|
return (div == i->get());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static double limit_px(const division* div, double px, unsigned area_px)
|
|
{
|
|
if (div->min_px.is_not_none())
|
|
{
|
|
auto v = div->min_px.get_value(static_cast<int>(area_px));
|
|
if (px < v)
|
|
return v;
|
|
}
|
|
if (div->max_px.is_not_none())
|
|
{
|
|
auto v = div->max_px.get_value(static_cast<int>(area_px));
|
|
if (px > v)
|
|
return v;
|
|
}
|
|
return px;
|
|
}
|
|
|
|
bool is_fixed() const
|
|
{
|
|
return (weight.kind_of() == number_t::kind::integer);
|
|
}
|
|
|
|
bool is_percent() const
|
|
{
|
|
return (weight.kind_of() == number_t::kind::percent);
|
|
}
|
|
|
|
nana::rectangle margin_area() const
|
|
{
|
|
return margin.area(field_area);
|
|
}
|
|
public:
|
|
void _m_visible_for_child(division * div, bool vsb)
|
|
{
|
|
for (auto & child : div->children)
|
|
{
|
|
if (child->field)
|
|
{
|
|
if (vsb)
|
|
{
|
|
if (child->visible)
|
|
child->field->visible(true);
|
|
}
|
|
else
|
|
child->field->visible(false);
|
|
}
|
|
_m_visible_for_child(child.get(), vsb);
|
|
}
|
|
}
|
|
//Collocate the division and its children divisions,
|
|
//The window parameter is specified for the window which the place object binded.
|
|
virtual void collocate(window) = 0;
|
|
|
|
public:
|
|
kind kind_of_division;
|
|
bool display{ true };
|
|
bool visible{ true };
|
|
const std::string name;
|
|
std::vector<std::unique_ptr<division>> children;
|
|
|
|
nana::rectangle field_area;
|
|
number_t weight;
|
|
number_t min_px, max_px;
|
|
|
|
place_parts::margin margin;
|
|
place_parts::repeated_array gap;
|
|
field_impl * field;
|
|
division * div_next, *div_owner;
|
|
};//end class division
|
|
|
|
template<typename Function>
|
|
void place::implement::field_impl::_m_for_each(division * div, Function fn)
|
|
{
|
|
for (auto & up : div->children) //The element of children is unique_ptr
|
|
fn(up.get());
|
|
}
|
|
|
|
|
|
class place::implement::div_arrange
|
|
: public division
|
|
{
|
|
public:
|
|
div_arrange(bool vert, std::string&& name, place_parts::repeated_array&& arr)
|
|
: division((vert ? kind::vertical_arrange : kind::arrange), std::move(name)),
|
|
arrange_(std::move(arr))
|
|
{}
|
|
|
|
void collocate(window wd) override
|
|
{
|
|
const bool vert = (kind::arrange != kind_of_division);
|
|
|
|
auto area_margined = margin_area();
|
|
area_rotator area(vert, area_margined);
|
|
auto area_px = area.w();
|
|
|
|
auto fa = _m_fixed_and_adjustable(kind_of_division, area_px);
|
|
|
|
double adjustable_px = _m_revise_adjustable(fa, area_px);
|
|
|
|
double position = area.x();
|
|
std::vector<division*> delay_collocates;
|
|
double precise_px = 0;
|
|
for (auto& child_ptr : children) /// First collocate child div's !!!
|
|
{
|
|
auto child = child_ptr.get();
|
|
if(!child->display) //Ignore the division if the corresponding field is not displayed.
|
|
continue;
|
|
|
|
area_rotator child_area(vert, child->field_area);
|
|
child_area.x_ref() = static_cast<int>(position);
|
|
child_area.y_ref() = area.y();
|
|
child_area.h_ref() = area.h();
|
|
|
|
double child_px; /// and calculate this div.
|
|
if (!child->is_fixed()) /// with is fixed for fixed div
|
|
{
|
|
if (child->is_percent()) /// and calculated for others: if the child div is percent - simple take it full
|
|
child_px = area_px * child->weight.real() + precise_px;
|
|
else
|
|
child_px = adjustable_px;
|
|
|
|
child_px = limit_px(child, child_px, area_px);
|
|
auto npx = static_cast<unsigned>(child_px);
|
|
precise_px = child_px - npx;
|
|
child_px = npx;
|
|
}
|
|
else
|
|
child_px = static_cast<unsigned>(child->weight.integer());
|
|
|
|
//Use 'endpos' to calc width is to avoid deviation
|
|
int endpos = static_cast<int>(position + child_px);
|
|
if ((!child->is_fixed()) && child->max_px.is_none() && is_back(child) && (endpos != area.right()))
|
|
endpos = area.right();
|
|
|
|
child_area.w_ref() = static_cast<unsigned>(endpos - child_area.x());
|
|
|
|
child->field_area = child_area.result();
|
|
position += child_px;
|
|
|
|
if (child->kind_of_division == kind::splitter)
|
|
delay_collocates.emplace_back(child);
|
|
else
|
|
child->collocate(wd); /// The child div have full position. Now we can collocate inside it the child fields and child-div.
|
|
}
|
|
|
|
for (auto child : delay_collocates)
|
|
child->collocate(wd);
|
|
|
|
if (visible && display && field)
|
|
{
|
|
auto element_r = area;
|
|
std::size_t index = 0;
|
|
double precise_px = 0;
|
|
|
|
for (auto & el : field->elements)
|
|
{
|
|
element_r.x_ref() = static_cast<int>(position);
|
|
auto px = _m_calc_number(arrange_.at(index), area_px, adjustable_px, precise_px);
|
|
|
|
element_r.w_ref() = px;
|
|
API::move_window(el.handle, element_r.result());
|
|
|
|
if (index + 1 < field->elements.size())
|
|
{
|
|
position += px;
|
|
position += _m_calc_number(gap.at(index), area_px, 0, precise_px);
|
|
}
|
|
++index;
|
|
}
|
|
|
|
for (auto & fsn : field->fastened)
|
|
API::move_window(fsn.handle, area_margined);
|
|
}
|
|
}
|
|
private:
|
|
unsigned _m_calc_number(const place_parts::number_t& number, unsigned area_px, double adjustable_px, double& precise_px)
|
|
{
|
|
switch (number.kind_of())
|
|
{
|
|
case number_t::kind::integer:
|
|
return static_cast<unsigned>(number.integer());
|
|
case number_t::kind::real:
|
|
return static_cast<unsigned>(number.real());
|
|
case number_t::kind::percent:
|
|
adjustable_px = area_px * number.real();
|
|
case number_t::kind::none:
|
|
{
|
|
auto fpx = adjustable_px + precise_px;
|
|
auto px = static_cast<unsigned>(fpx);
|
|
precise_px = fpx - px;
|
|
return px;
|
|
}
|
|
break;
|
|
}
|
|
return 0; //Useless
|
|
}
|
|
|
|
std::pair<unsigned, std::size_t> _m_calc_fa(const place_parts::number_t& number, unsigned area_px, double& precise_px) const
|
|
{
|
|
std::pair<unsigned, std::size_t> result;
|
|
switch (number.kind_of())
|
|
{
|
|
case number_t::kind::integer:
|
|
result.first = static_cast<unsigned>(number.integer());
|
|
break;
|
|
case number_t::kind::real:
|
|
result.first = static_cast<unsigned>(number.real());
|
|
break;
|
|
case number_t::kind::percent:
|
|
{
|
|
double px = number.real() * area_px + precise_px;
|
|
auto npx = static_cast<unsigned>(px);
|
|
result.first = npx;
|
|
precise_px = px - npx;
|
|
}
|
|
break;
|
|
case number_t::kind::none:
|
|
++result.second;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//Returns the fixed pixels and the number of adjustable items.
|
|
std::pair<unsigned, std::size_t> _m_fixed_and_adjustable(kind match_kind, unsigned area_px) const
|
|
{
|
|
std::pair<unsigned, std::size_t> result;
|
|
if (field && (kind_of_division == match_kind))
|
|
{
|
|
//Calculate fixed and adjustable of elements
|
|
double precise_px = 0;
|
|
auto count = field->elements.size();
|
|
for (decltype(count) i = 0; i < count; ++i)
|
|
{
|
|
auto fa = _m_calc_fa(arrange_.at(i), area_px, precise_px);
|
|
result.first += fa.first;
|
|
result.second += fa.second;
|
|
|
|
if (i + 1 < count)
|
|
{
|
|
fa = _m_calc_fa(gap.at(i), area_px, precise_px);
|
|
result.first += fa.first;
|
|
//fa.second is ignored for gap, because the it has not the adjustable gap.
|
|
}
|
|
}
|
|
}
|
|
|
|
double children_fixed_px = 0;
|
|
for (auto& child : children)
|
|
{
|
|
if (!child->display) //Ignore the division if the corresponding field is not displayed.
|
|
continue;
|
|
|
|
if (child->weight.is_not_none())
|
|
children_fixed_px += child->weight.get_value(area_px);
|
|
else
|
|
++result.second;
|
|
}
|
|
result.first += static_cast<unsigned>(children_fixed_px);
|
|
return result;
|
|
}
|
|
|
|
double _m_revise_adjustable(std::pair<unsigned, std::size_t>& fa, unsigned area_px)
|
|
{
|
|
if (fa.first >= area_px || 0 == fa.second)
|
|
return 0;
|
|
|
|
double var_px = area_px - fa.first;
|
|
|
|
struct revise_t
|
|
{
|
|
division * div;
|
|
double min_px;
|
|
double max_px;
|
|
};
|
|
|
|
std::size_t min_count = 0;
|
|
double sum_min_px = 0;
|
|
std::vector<revise_t> revises;
|
|
for (auto& child : children)
|
|
{
|
|
if (child->weight.is_not_none() || !child->display)
|
|
continue;
|
|
|
|
double min_px = std::numeric_limits<double>::lowest(), max_px = std::numeric_limits<double>::lowest();
|
|
|
|
if (child->min_px.is_not_none())
|
|
{
|
|
min_px = child->min_px.get_value(static_cast<int>(area_px));
|
|
sum_min_px += min_px;
|
|
++min_count;
|
|
}
|
|
|
|
if (child->max_px.is_not_none())
|
|
max_px = child->max_px.get_value(static_cast<int>(area_px));
|
|
|
|
if (min_px >= 0 && max_px >= 0 && min_px > max_px)
|
|
{
|
|
if (child->min_px.kind_of() == number_t::kind::percent)
|
|
min_px = std::numeric_limits<double>::lowest();
|
|
else if (child->max_px.kind_of() == number_t::kind::percent)
|
|
max_px = std::numeric_limits<double>::lowest();
|
|
}
|
|
|
|
if (min_px >= 0 || max_px >= 0)
|
|
revises.push_back({ child.get(), min_px, max_px });
|
|
}
|
|
|
|
if (revises.empty())
|
|
return var_px / fa.second;
|
|
|
|
auto find_lowest = [&revises](double level_px)
|
|
{
|
|
double v = std::numeric_limits<double>::max();
|
|
for (auto i = revises.begin(); i != revises.end(); ++i)
|
|
{
|
|
if (i->min_px >= 0 && i->min_px < v && i->min_px > level_px)
|
|
v = i->min_px;
|
|
else if (i->max_px >= 0 && i->max_px < v)
|
|
v = i->max_px;
|
|
}
|
|
return v;
|
|
};
|
|
|
|
auto remove_full = [&revises](double value, std::size_t& full_count)
|
|
{
|
|
full_count = 0;
|
|
std::size_t reached_mins = 0;
|
|
auto i = revises.begin();
|
|
while(i != revises.end())
|
|
{
|
|
if (i->max_px == value)
|
|
{
|
|
++full_count;
|
|
i = revises.erase(i);
|
|
}
|
|
else
|
|
{
|
|
if (i->min_px == value)
|
|
++reached_mins;
|
|
++i;
|
|
}
|
|
}
|
|
return reached_mins;
|
|
};
|
|
|
|
double block_px = 0;
|
|
double level_px = 0;
|
|
auto rest_px = var_px - sum_min_px;
|
|
std::size_t blocks = fa.second;
|
|
|
|
while ((rest_px > 0) && blocks)
|
|
{
|
|
auto lowest = find_lowest(level_px);
|
|
double fill_px = 0;
|
|
//blocks may be equal to min_count. E.g, all child divisions have min/max attribute.
|
|
if (blocks > min_count)
|
|
{
|
|
fill_px = rest_px / (blocks - min_count);
|
|
if (fill_px + level_px <= lowest)
|
|
{
|
|
block_px += fill_px;
|
|
break;
|
|
}
|
|
}
|
|
|
|
block_px = lowest;
|
|
|
|
if (blocks > min_count)
|
|
rest_px -= (lowest-level_px) * (blocks - min_count);
|
|
|
|
std::size_t full_count;
|
|
min_count -= remove_full(lowest, full_count);
|
|
blocks -= full_count;
|
|
level_px = lowest;
|
|
}
|
|
|
|
return block_px;
|
|
}
|
|
private:
|
|
place_parts::repeated_array arrange_;
|
|
};
|
|
|
|
class place::implement::div_grid
|
|
: public division
|
|
{
|
|
public:
|
|
div_grid(std::string&& name, place_parts::repeated_array&& arrange, std::vector<rectangle>&& collapses)
|
|
: division(kind::grid, std::move(name)),
|
|
arrange_(std::move(arrange)),
|
|
collapses_(std::move(collapses))
|
|
{
|
|
dimension.first = dimension.second = 0;
|
|
}
|
|
|
|
void revise_collapses()
|
|
{
|
|
if (collapses_.empty())
|
|
return;
|
|
|
|
for (auto i = collapses_.begin(); i != collapses_.end();)
|
|
{
|
|
if (i->x >= static_cast<int>(dimension.first) || i->y >= static_cast<int>(dimension.second))
|
|
i = collapses_.erase(i);
|
|
else
|
|
++i;
|
|
}
|
|
|
|
//Remove the overlapped collapses
|
|
for (std::size_t i = 0; i < collapses_.size() - 1; ++i)
|
|
{
|
|
auto & col = collapses_[i];
|
|
for (auto u = i + 1; u != collapses_.size();)
|
|
{
|
|
auto & z = collapses_[u];
|
|
if (col.is_hit(z.x, z.y) || col.is_hit(z.right(), z.y) || col.is_hit(z.x, z.bottom()) || col.is_hit(z.right(), z.bottom()))
|
|
collapses_.erase(collapses_.begin() + u);
|
|
else
|
|
++u;
|
|
}
|
|
}
|
|
|
|
for (auto & col : collapses_)
|
|
{
|
|
if (col.right() >= static_cast<int>(dimension.first))
|
|
col.width = dimension.first - static_cast<unsigned>(col.x);
|
|
|
|
if (col.bottom() >= static_cast<int>(dimension.second))
|
|
col.height = dimension.second - static_cast<unsigned>(col.y);
|
|
}
|
|
}
|
|
|
|
void collocate(window wd) override
|
|
{
|
|
|
|
if (!field || !(visible && display))
|
|
return;
|
|
|
|
auto area = margin_area();
|
|
|
|
unsigned gap_size = 0;
|
|
auto gap_number = gap.at(0);
|
|
if (gap_number.is_not_none())
|
|
{
|
|
gap_size = (gap_number.kind_of() == number_t::kind::percent ?
|
|
static_cast<unsigned>(area.width * gap_number.real()) : static_cast<unsigned>(gap_number.integer()));
|
|
}
|
|
|
|
//When the amount pixels of gaps is out of the area bound.
|
|
if ((gap_size * dimension.first >= area.width) || (gap_size * dimension.second >= area.height))
|
|
{
|
|
for (auto & el : field->elements)
|
|
API::window_size(el.handle, size{ 0, 0 });
|
|
return;
|
|
}
|
|
|
|
if (dimension.first <= 1 && dimension.second <= 1)
|
|
{
|
|
auto n_of_wd = field->elements.size();
|
|
std::size_t edge;
|
|
switch (n_of_wd)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
edge = 1; break;
|
|
case 2: case 3: case 4:
|
|
edge = 2; break;
|
|
default:
|
|
edge = static_cast<std::size_t>(std::sqrt(n_of_wd));
|
|
if ((edge * edge) < n_of_wd) ++edge;
|
|
}
|
|
|
|
bool exit_for = false;
|
|
double y = area.y;
|
|
double block_w = area.width / double(edge);
|
|
double block_h = area.height / double((n_of_wd / edge) + (n_of_wd % edge ? 1 : 0));
|
|
unsigned uns_block_w = static_cast<unsigned>(block_w);
|
|
unsigned uns_block_h = static_cast<unsigned>(block_h);
|
|
unsigned height = (uns_block_h > gap_size ? uns_block_h - gap_size : uns_block_h);
|
|
|
|
auto i = field->elements.cbegin(), end = field->elements.cend();
|
|
std::size_t arr_pos = 0;
|
|
for (std::size_t u = 0; u < edge; ++u)
|
|
{
|
|
double x = area.x;
|
|
for (std::size_t v = 0; v < edge; ++v)
|
|
{
|
|
if (i == end)
|
|
{
|
|
exit_for = true;
|
|
break;
|
|
}
|
|
|
|
unsigned value = 0;
|
|
auto arr = arrange_.at(arr_pos++);
|
|
|
|
if (arr.is_none())
|
|
value = static_cast<decltype(value)>(block_w);
|
|
else
|
|
value = static_cast<decltype(value)>(arr.get_value(static_cast<int>(area.width)));
|
|
|
|
unsigned width = (value > uns_block_w ? uns_block_w : value);
|
|
if (width > gap_size) width -= gap_size;
|
|
API::move_window(i->handle, rectangle{ static_cast<int>(x), static_cast<int>(y), width, height });
|
|
x += block_w;
|
|
++i;
|
|
}
|
|
if (exit_for) break;
|
|
y += block_h;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double block_w = int(area.width - gap_size * (dimension.first - 1)) / double(dimension.first);
|
|
double block_h = int(area.height - gap_size * (dimension.second - 1)) / double(dimension.second);
|
|
|
|
std::unique_ptr<char[]> table_ptr(new char[dimension.first * dimension.second]);
|
|
|
|
char *table = table_ptr.get();
|
|
std::memset(table, 0, dimension.first * dimension.second);
|
|
|
|
std::size_t lbp = 0;
|
|
bool exit_for = false;
|
|
|
|
auto i = field->elements.cbegin(), end = field->elements.cend();
|
|
|
|
double precise_h = 0;
|
|
for (std::size_t c = 0; c < dimension.second; ++c)
|
|
{
|
|
unsigned block_height_px = static_cast<unsigned>(block_h + precise_h);
|
|
precise_h = (block_h + precise_h) - block_height_px;
|
|
|
|
double precise_w = 0;
|
|
for (std::size_t l = 0; l < dimension.first; ++l)
|
|
{
|
|
if (table[l + lbp])
|
|
{
|
|
precise_w += block_w;
|
|
auto px = static_cast<int>(precise_w);
|
|
precise_w -= px;
|
|
continue;
|
|
}
|
|
|
|
if (i == end)
|
|
{
|
|
exit_for = true;
|
|
break;
|
|
}
|
|
|
|
std::pair<unsigned, unsigned> room{ 1, 1 };
|
|
|
|
_m_find_collapse(static_cast<int>(l), static_cast<int>(c), room);
|
|
|
|
int pos_x = area.x + static_cast<int>(l * (block_w + gap_size));
|
|
int pos_y = area.y + static_cast<int>(c * (block_h + gap_size));
|
|
|
|
unsigned result_h;
|
|
if (room.first <= 1 && room.second <= 1)
|
|
{
|
|
precise_w += block_w;
|
|
result_h = block_height_px;
|
|
table[l + lbp] = 1;
|
|
}
|
|
else
|
|
{
|
|
precise_w += block_w * room.first + (room.first - 1) * gap_size;
|
|
result_h = static_cast<unsigned>(block_h * room.second + precise_h + (room.second - 1) * gap_size);
|
|
|
|
for (unsigned y = 0; y < room.second; ++y)
|
|
for (unsigned x = 0; x < room.first; ++x)
|
|
table[l + x + lbp + y * dimension.first] = 1;
|
|
}
|
|
|
|
unsigned result_w = static_cast<unsigned>(precise_w);
|
|
precise_w -= result_w;
|
|
|
|
API::move_window(i->handle, rectangle{ pos_x, pos_y, result_w, result_h });
|
|
++i;
|
|
}
|
|
|
|
if (exit_for)
|
|
{
|
|
size empty_sz;
|
|
for (; i != end; ++i)
|
|
API::window_size(i->handle, empty_sz);
|
|
break;
|
|
}
|
|
lbp += dimension.first;
|
|
}
|
|
}
|
|
|
|
for (auto & fsn : field->fastened)
|
|
API::move_window(fsn.handle, area);
|
|
}
|
|
public:
|
|
std::pair<unsigned, unsigned> dimension;
|
|
private:
|
|
void _m_find_collapse(int x, int y, std::pair<unsigned, unsigned>& collapse) const
|
|
{
|
|
for (auto & col : collapses_)
|
|
{
|
|
if (col.x == x && col.y == y)
|
|
{
|
|
collapse.first = col.width;
|
|
collapse.second = col.height;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
private:
|
|
place_parts::repeated_array arrange_;
|
|
std::vector<rectangle> collapses_;
|
|
};//end class div_grid
|
|
|
|
class place::implement::div_splitter
|
|
: public division
|
|
{
|
|
struct div_block
|
|
{
|
|
division * div;
|
|
int pixels;
|
|
double scale;
|
|
|
|
div_block(division* d, int px)
|
|
: div(d), pixels(px)
|
|
{}
|
|
};
|
|
|
|
enum{splitter_px = 4};
|
|
public:
|
|
div_splitter(place_parts::number_t init_weight)
|
|
: division(kind::splitter, std::string()),
|
|
splitter_cursor_(cursor::arrow),
|
|
leaf_left_(nullptr), leaf_right_(nullptr),
|
|
pause_move_collocate_(false),
|
|
init_weight_(init_weight)
|
|
{
|
|
this->weight.assign(splitter_px);
|
|
}
|
|
|
|
void leaf_left(division * d)
|
|
{
|
|
leaf_left_ = d;
|
|
}
|
|
|
|
void leaf_right(division * d)
|
|
{
|
|
leaf_right_ = d;
|
|
}
|
|
|
|
void direction(bool horizontal)
|
|
{
|
|
splitter_cursor_ = (horizontal ? cursor::size_we : cursor::size_ns);
|
|
}
|
|
private:
|
|
void collocate(window wd) override
|
|
{
|
|
if (splitter_.empty())
|
|
{
|
|
splitter_.create(wd);
|
|
splitter_.cursor(splitter_cursor_);
|
|
|
|
dragger_.trigger(splitter_);
|
|
splitter_.events().mouse_down.connect([this](const arg_mouse& arg)
|
|
{
|
|
if (false == arg.left_button)
|
|
return;
|
|
|
|
begin_point_ = splitter_.pos();
|
|
|
|
auto px_ptr = &nana::rectangle::width;
|
|
|
|
auto area_left = leaf_left_->margin_area();
|
|
auto area_right = leaf_right_->margin_area();
|
|
|
|
if (nana::cursor::size_we != splitter_cursor_)
|
|
{
|
|
left_pos_ = area_left.y;
|
|
right_pos_ = area_right.bottom();
|
|
px_ptr = &nana::rectangle::height;
|
|
}
|
|
else
|
|
{
|
|
left_pos_ = area_left.x;
|
|
right_pos_ = area_right.right();
|
|
}
|
|
|
|
left_pixels_ = area_left.*px_ptr;
|
|
right_pixels_ = area_right.*px_ptr;
|
|
});
|
|
|
|
splitter_.events().mouse_move.connect([this](const arg_mouse& arg)
|
|
{
|
|
if (false == arg.left_button)
|
|
return;
|
|
|
|
const bool vert = (::nana::cursor::size_we != splitter_cursor_);
|
|
auto area_px = area_rotator(vert, div_owner->margin_area()).w();
|
|
int delta = (vert ? splitter_.pos().y - begin_point_.y : splitter_.pos().x - begin_point_.x);
|
|
|
|
int total_pixels = static_cast<int>(left_pixels_ + right_pixels_);
|
|
|
|
auto left_px = static_cast<int>(left_pixels_)+delta;
|
|
if (left_px > total_pixels)
|
|
left_px = total_pixels;
|
|
else if (left_px < 0)
|
|
left_px = 0;
|
|
|
|
double imd_rate = 100.0 / area_px;
|
|
left_px = static_cast<int>(limit_px(leaf_left_, left_px, area_px));
|
|
leaf_left_->weight.assign_percent(imd_rate * left_px);
|
|
|
|
auto right_px = static_cast<int>(right_pixels_)-delta;
|
|
if (right_px > total_pixels)
|
|
right_px = total_pixels;
|
|
else if (right_px < 0)
|
|
right_px = 0;
|
|
|
|
right_px = static_cast<int>(limit_px(leaf_right_, right_px, area_px));
|
|
leaf_right_->weight.assign_percent(imd_rate * right_px);
|
|
|
|
pause_move_collocate_ = true;
|
|
div_owner->collocate(splitter_.parent());
|
|
|
|
//After the collocating, the splitter keeps the calculated weight of left division,
|
|
//and clear the weight of right division.
|
|
leaf_right_->weight.reset();
|
|
|
|
pause_move_collocate_ = false;
|
|
});
|
|
}
|
|
|
|
auto limited_range = _m_update_splitter_range();
|
|
|
|
if (init_weight_.is_not_none())
|
|
{
|
|
const bool vert = (::nana::cursor::size_we != splitter_cursor_);
|
|
|
|
area_rotator left(vert, leaf_left_->field_area);
|
|
area_rotator right(vert, leaf_right_->field_area);
|
|
auto area_px = right.right() - left.x();
|
|
auto right_px = static_cast<int>(limit_px(leaf_right_, init_weight_.get_value(area_px), static_cast<unsigned>(area_px)));
|
|
|
|
auto pos = area_px - right_px - splitter_px; //New position of splitter
|
|
if (pos < limited_range.x())
|
|
pos = limited_range.x();
|
|
else if (pos > limited_range.right())
|
|
pos = limited_range.right();
|
|
|
|
area_rotator sp_r(vert, field_area);
|
|
sp_r.x_ref() = pos;
|
|
|
|
left.w_ref() = static_cast<unsigned>(pos - left.x());
|
|
|
|
auto right_pos = right.right();
|
|
right.x_ref() = (pos + splitter_px);
|
|
right.w_ref() = static_cast<unsigned>(right_pos - pos - splitter_px);
|
|
|
|
field_area = sp_r.result();
|
|
leaf_left_->field_area = left.result();
|
|
leaf_right_->field_area = right.result();
|
|
leaf_left_->collocate(wd);
|
|
leaf_right_->collocate(wd);
|
|
|
|
//Set the leafs' weight
|
|
area_rotator area(vert, div_owner->field_area);
|
|
|
|
double imd_rate = 100.0 / static_cast<int>(area.w());
|
|
leaf_left_->weight.assign_percent(imd_rate * static_cast<int>(left.w()));
|
|
leaf_right_->weight.assign_percent(imd_rate * static_cast<int>(right.w()));
|
|
|
|
splitter_.move(this->field_area);
|
|
|
|
init_weight_.reset();
|
|
}
|
|
|
|
if (false == pause_move_collocate_)
|
|
splitter_.move(this->field_area);
|
|
}
|
|
private:
|
|
area_rotator _m_update_splitter_range()
|
|
{
|
|
const bool vert = (cursor::size_ns == splitter_cursor_);
|
|
|
|
area_rotator area(vert, div_owner->margin_area());
|
|
|
|
area_rotator left(vert, leaf_left_->field_area);
|
|
area_rotator right(vert, leaf_right_->field_area);
|
|
|
|
const int left_base = left.x(), right_base = right.right();
|
|
int pos = left_base;
|
|
int endpos = right_base;
|
|
|
|
if (leaf_left_->min_px.is_not_none())
|
|
{
|
|
auto v = leaf_left_->min_px.get_value(area.w());
|
|
pos += static_cast<int>(v);
|
|
}
|
|
if (leaf_left_->max_px.is_not_none())
|
|
{
|
|
auto v = leaf_left_->max_px.get_value(area.w());
|
|
endpos = left_base + static_cast<int>(v);
|
|
}
|
|
|
|
if (leaf_right_->min_px.is_not_none())
|
|
{
|
|
auto v = leaf_right_->min_px.get_value(area.w());
|
|
auto x = right_base - static_cast<int>(v);
|
|
if (x < endpos)
|
|
endpos = x;
|
|
}
|
|
if (leaf_right_->max_px.is_not_none())
|
|
{
|
|
auto v = leaf_right_->max_px.get_value(area.w());
|
|
auto x = right_base - static_cast<int>(v);
|
|
if (x > pos)
|
|
pos = x;
|
|
}
|
|
|
|
area.x_ref() = pos;
|
|
area.w_ref() = unsigned(endpos - pos + splitter_px);
|
|
|
|
dragger_.target(splitter_, area.result(), (vert ? nana::arrange::vertical : nana::arrange::horizontal));
|
|
|
|
return area;
|
|
}
|
|
private:
|
|
nana::cursor splitter_cursor_;
|
|
place_parts::splitter<true> splitter_;
|
|
nana::point begin_point_;
|
|
division * leaf_left_;
|
|
division * leaf_right_;
|
|
int left_pos_, right_pos_;
|
|
unsigned left_pixels_, right_pixels_;
|
|
dragger dragger_;
|
|
bool pause_move_collocate_; //A flag represents whether do move when collocating.
|
|
place_parts::number_t init_weight_;
|
|
};
|
|
|
|
place::implement::~implement()
|
|
{
|
|
API::umake_event(event_size_handle);
|
|
root_division.reset();
|
|
for (auto & pair : fields)
|
|
delete pair.second;
|
|
}
|
|
|
|
//search_div_name
|
|
//search a division with the specified name.
|
|
place::implement::division * place::implement::search_div_name(division* start, const std::string& name)
|
|
{
|
|
if (start)
|
|
{
|
|
if (start->name == name)
|
|
return start;
|
|
|
|
for (auto& child : start->children)
|
|
{
|
|
auto div = search_div_name(child.get(), name);
|
|
if (div)
|
|
return div;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
auto place::implement::scan_div(place_parts::tokenizer& tknizer) -> std::unique_ptr<division>
|
|
{
|
|
typedef place_parts::tokenizer::token token;
|
|
|
|
std::unique_ptr<division> div;
|
|
token div_type = token::eof;
|
|
|
|
//These variables stand for the new division's attributes
|
|
std::string name;
|
|
number_t weight, min_px, max_px;
|
|
place_parts::repeated_array arrange, gap;
|
|
place_parts::margin margin;
|
|
std::vector<number_t> array;
|
|
std::vector<rectangle> collapses;
|
|
std::vector<std::unique_ptr<division>> children;
|
|
|
|
for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
|
|
{
|
|
bool exit_for = false;
|
|
switch (tk)
|
|
{
|
|
case token::splitter:
|
|
//Ignore the splitter when there is not a division.
|
|
if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
|
|
{
|
|
auto splitter = new div_splitter(tknizer.number());
|
|
splitter->leaf_left(children.back().get());
|
|
children.back()->div_next = splitter;
|
|
children.emplace_back(splitter);
|
|
}
|
|
break;
|
|
case token::div_start:
|
|
{
|
|
auto div = scan_div(tknizer);
|
|
if (children.size())
|
|
{
|
|
children.back()->div_next = div.get();
|
|
if (division::kind::splitter == children.back()->kind_of_division)
|
|
dynamic_cast<div_splitter&>(*children.back()).leaf_right(div.get());
|
|
}
|
|
children.emplace_back(div.release());
|
|
}
|
|
break;
|
|
case token::vert:
|
|
div_type = tk;
|
|
break;
|
|
case token::grid:
|
|
div_type = tk;
|
|
switch (tknizer.read())
|
|
{
|
|
case token::number:
|
|
array.push_back(tknizer.number());
|
|
array.push_back(tknizer.number());
|
|
break;
|
|
case token::array:
|
|
tknizer.array().swap(array);
|
|
break;
|
|
case token::reparray:
|
|
array.push_back(tknizer.reparray().at(0));
|
|
array.push_back(tknizer.reparray().at(1));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case token::collapse:
|
|
if (tknizer.parameters().size() == 4)
|
|
{
|
|
auto get_number = [](const number_t & arg, const std::string& nth)
|
|
{
|
|
if (arg.kind_of() == number_t::kind::integer)
|
|
return arg.integer();
|
|
else if (arg.kind_of() == number_t::kind::real)
|
|
return static_cast<int>(arg.real());
|
|
|
|
throw std::runtime_error("place: the type of the "+ nth +" parameter for collapse should be integer.");
|
|
};
|
|
|
|
::nana::rectangle col;
|
|
auto arg = tknizer.parameters().at(0);
|
|
col.x = get_number(arg, "1st");
|
|
|
|
arg = tknizer.parameters().at(1);
|
|
col.y = get_number(arg, "2nd");
|
|
|
|
arg = tknizer.parameters().at(2);
|
|
col.width = static_cast<decltype(col.width)>(get_number(arg, "3rd"));
|
|
|
|
arg = tknizer.parameters().at(3);
|
|
col.height = static_cast<decltype(col.height)>(get_number(arg, "4th"));
|
|
|
|
//Check the collapse area.
|
|
//Ignore this collapse if its area is less than 2(col.width * col.height < 2)
|
|
if (!col.empty() && (col.width > 1 || col.height > 1) && (col.x >= 0 && col.y >= 0))
|
|
{
|
|
//Overwrite if a exist_col in collapses has same position as the col.
|
|
bool use_col = true;
|
|
for (auto & exist_col : collapses)
|
|
{
|
|
if (exist_col.x == col.x && exist_col.y == col.y)
|
|
{
|
|
exist_col = col;
|
|
use_col = false;
|
|
break;
|
|
}
|
|
}
|
|
if (use_col)
|
|
collapses.emplace_back(col);
|
|
}
|
|
}
|
|
else
|
|
throw std::runtime_error("place: collapse requires 4 parameters.");
|
|
break;
|
|
case token::weight: case token::min_px: case token::max_px:
|
|
{
|
|
auto n = tknizer.number();
|
|
//If n is the type of real, convert it to integer.
|
|
//the integer and percent are allowed for weight/min/max.
|
|
if (n.kind_of() == number_t::kind::real)
|
|
n.assign(static_cast<int>(n.real()));
|
|
|
|
switch (tk)
|
|
{
|
|
case token::weight: weight = n; break;
|
|
case token::min_px: min_px = n; break;
|
|
case token::max_px: max_px = n; break;
|
|
default: break; //Useless
|
|
}
|
|
}
|
|
break;
|
|
case token::arrange:
|
|
arrange = tknizer.reparray();
|
|
break;
|
|
case token::gap:
|
|
gap = tknizer.reparray();
|
|
break;
|
|
case token::margin:
|
|
margin.clear();
|
|
switch (tknizer.read())
|
|
{
|
|
case token::number:
|
|
margin.set_value(tknizer.number());
|
|
break;
|
|
case token::array:
|
|
margin.set_array(tknizer.array());
|
|
break;
|
|
case token::reparray:
|
|
for (std::size_t i = 0; i < 4; ++i)
|
|
{
|
|
auto n = tknizer.reparray().at(i);
|
|
if (n.is_none()) n.assign(0);
|
|
margin.push(n);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case token::div_end:
|
|
exit_for = true;
|
|
break;
|
|
case token::identifier:
|
|
name = tknizer.idstr();
|
|
break;
|
|
default: break;
|
|
}
|
|
if (exit_for)
|
|
break;
|
|
}
|
|
|
|
field_impl * attached_field = nullptr;
|
|
if (name.size())
|
|
{
|
|
//find the field with specified name.
|
|
//the field may not be created.
|
|
auto i = fields.find(name);
|
|
if (fields.end() != i)
|
|
{
|
|
attached_field = i->second;
|
|
//the field is attached to a division, it means there is another division with same name.
|
|
if (attached_field->attached)
|
|
throw std::runtime_error("place, the name '" + name + "' is redefined.");
|
|
}
|
|
}
|
|
|
|
switch (div_type)
|
|
{
|
|
case token::eof:
|
|
case token::vert:
|
|
div.reset(new div_arrange(token::vert == div_type, std::move(name), std::move(arrange)));
|
|
break;
|
|
case token::grid:
|
|
{
|
|
std::unique_ptr<div_grid> p(new div_grid(std::move(name), std::move(arrange), std::move(collapses)));
|
|
|
|
if (array.size())
|
|
p->dimension.first = array[0].integer();
|
|
|
|
if (array.size() > 1)
|
|
p->dimension.second = array[1].integer();
|
|
|
|
if (0 == p->dimension.first)
|
|
p->dimension.first = 1;
|
|
|
|
if (0 == p->dimension.second)
|
|
p->dimension.second = 1;
|
|
|
|
p->revise_collapses();
|
|
div = std::move(p);
|
|
}
|
|
break;
|
|
default:
|
|
throw std::runtime_error("nana.place: invalid division type.");
|
|
}
|
|
|
|
//Requirements for min/max
|
|
//1, min and max != negative
|
|
//2, max >= min
|
|
if (min_px.is_negative()) min_px.reset();
|
|
if (max_px.is_negative()) max_px.reset();
|
|
if (min_px.is_not_none() && max_px.is_not_none() && (min_px.get_value(100) > max_px.get_value(100)))
|
|
{
|
|
min_px.reset();
|
|
max_px.reset();
|
|
}
|
|
|
|
//The weight will be ignored if one of min and max is specified.
|
|
if (min_px.is_none() && max_px.is_none())
|
|
{
|
|
div->weight = weight;
|
|
}
|
|
else
|
|
{
|
|
div->min_px = min_px;
|
|
div->max_px = max_px;
|
|
}
|
|
|
|
div->gap = std::move(gap);
|
|
|
|
//attach the field to the division
|
|
div->field = attached_field;
|
|
if (attached_field)
|
|
attached_field->attached = div.get();
|
|
|
|
if (children.size())
|
|
{
|
|
if (division::kind::splitter == children.back()->kind_of_division)
|
|
{
|
|
children.pop_back();
|
|
if (children.size())
|
|
children.back()->div_next = nullptr;
|
|
}
|
|
|
|
for (auto& child : children)
|
|
{
|
|
child->div_owner = div.get();
|
|
if (division::kind::splitter == child->kind_of_division)
|
|
dynamic_cast<div_splitter&>(*child).direction(div_type != token::vert);
|
|
}
|
|
}
|
|
|
|
div->children.swap(children);
|
|
div->margin = std::move(margin);
|
|
return div;
|
|
}
|
|
|
|
//class place
|
|
place::place()
|
|
: impl_(new implement)
|
|
{}
|
|
|
|
place::place(window wd)
|
|
: impl_(new implement)
|
|
{
|
|
bind(wd);
|
|
}
|
|
|
|
place::~place()
|
|
{
|
|
delete impl_;
|
|
}
|
|
|
|
void place::bind(window wd)
|
|
{
|
|
if (impl_->window_handle)
|
|
throw std::runtime_error("place.bind: it has already binded to a window.");
|
|
|
|
impl_->window_handle = wd;
|
|
impl_->event_size_handle = API::events(wd).resized.connect([this](const arg_resized& arg)
|
|
{
|
|
if (impl_->root_division)
|
|
{
|
|
impl_->root_division->field_area = ::nana::size(arg.width, arg.height);
|
|
impl_->root_division->collocate(arg.window_handle);
|
|
}
|
|
});
|
|
}
|
|
|
|
window place::window_handle() const
|
|
{
|
|
return impl_->window_handle;
|
|
}
|
|
|
|
void place::div(const char* s)
|
|
{
|
|
place_parts::tokenizer tknizer(s);
|
|
impl_->root_division.reset(); //clear atachments div-fields
|
|
impl_->scan_div(tknizer).swap(impl_->root_division);
|
|
}
|
|
|
|
place::field_reference place::field(const char* name)
|
|
{
|
|
if (nullptr == name)
|
|
name = "";
|
|
|
|
//May throw std::invalid_argument
|
|
place_parts::check_field_name(name);
|
|
|
|
//get the field with specified name, if no such field with specified name
|
|
//then create one.
|
|
auto & p = impl_->fields[name];
|
|
if (nullptr == p)
|
|
p = new implement::field_impl(this);
|
|
|
|
if ((!p->attached) && impl_->root_division)
|
|
{
|
|
//search the division with the specified name,
|
|
//and attached the division to the field
|
|
implement::division * div = implement::search_div_name(impl_->root_division.get(), name);
|
|
if (div)
|
|
{
|
|
if (div->field && (div->field != p))
|
|
throw std::runtime_error("nana.place: unexpected error, the division attachs a unexpected field.");
|
|
|
|
div->field = p;
|
|
p->attached = div;
|
|
}
|
|
}
|
|
return *p;
|
|
}
|
|
|
|
void place::field_visible(const char* name, bool vsb)
|
|
{
|
|
if (!name) name = "";
|
|
|
|
//May throw std::invalid_argument
|
|
place_parts::check_field_name(name);
|
|
|
|
auto div = impl_->search_div_name(impl_->root_division.get(), name);
|
|
if (div)
|
|
div->set_visible(vsb);
|
|
}
|
|
|
|
bool place::field_visible(const char* name) const
|
|
{
|
|
if (!name) name = "";
|
|
|
|
//May throw std::invalid_argument
|
|
place_parts::check_field_name(name);
|
|
|
|
auto div = impl_->search_div_name(impl_->root_division.get(), name);
|
|
return (div && div->visible);
|
|
}
|
|
|
|
void place::field_display(const char* name, bool dsp)
|
|
{
|
|
if (!name) name = "";
|
|
|
|
//May throw std::invalid_argument
|
|
place_parts::check_field_name(name);
|
|
|
|
auto div = impl_->search_div_name(impl_->root_division.get(), name);
|
|
if (div)
|
|
div->set_display(dsp);
|
|
}
|
|
|
|
bool place::field_display(const char* name) const
|
|
{
|
|
if (!name) name = "";
|
|
|
|
//May throw std::invalid_argument
|
|
place_parts::check_field_name(name);
|
|
|
|
auto div = impl_->search_div_name(impl_->root_division.get(), name);
|
|
return (div && div->display);
|
|
}
|
|
|
|
void place::collocate()
|
|
{
|
|
if (impl_->root_division && impl_->window_handle)
|
|
{
|
|
impl_->root_division->field_area = API::window_size(impl_->window_handle);
|
|
impl_->root_division->collocate(impl_->window_handle);
|
|
|
|
for (auto & field : impl_->fields)
|
|
{
|
|
bool is_show = false;
|
|
if (field.second->attached && field.second->attached->visible && field.second->attached->display)
|
|
{
|
|
is_show = true;
|
|
auto div = field.second->attached->div_owner;
|
|
while (div)
|
|
{
|
|
if (!div->visible || !div->display)
|
|
{
|
|
is_show = false;
|
|
break;
|
|
}
|
|
div = div->div_owner;
|
|
}
|
|
}
|
|
|
|
for (auto & el : field.second->elements)
|
|
API::show_window(el.handle, is_show);
|
|
}
|
|
}
|
|
}
|
|
|
|
void place::erase(window handle)
|
|
{
|
|
bool recollocate = false;
|
|
for (auto & fld : impl_->fields)
|
|
{
|
|
auto & elements = fld.second->elements;
|
|
for (auto i = elements.begin(); i != elements.end();)
|
|
{
|
|
if (i->handle == handle)
|
|
{
|
|
API::umake_event(i->evt_destroy);
|
|
i = elements.erase(i);
|
|
recollocate |= (nullptr != fld.second->attached);
|
|
}
|
|
else
|
|
++i;
|
|
}
|
|
|
|
auto i = std::find_if(fld.second->fastened.begin(), fld.second->fastened.end(), [handle](implement::field_impl::element_t& e)
|
|
{
|
|
return (e.handle == handle);
|
|
});
|
|
|
|
if (i != fld.second->fastened.end())
|
|
{
|
|
API::umake_event(i->evt_destroy);
|
|
fld.second->fastened.erase(i);
|
|
}
|
|
}
|
|
|
|
if (recollocate)
|
|
collocate();
|
|
}
|
|
|
|
place::field_reference place::operator[](const char* name)
|
|
{
|
|
return field(name);
|
|
}
|
|
//end class place
|
|
}//end namespace nana
|