int min_height( tree * t )
{
if( t == NULL )
return 0;
else
return 1 + MIN( min_height( (*t).left ), min_height( (*t).right ) );
}
void PackageCanvas::check_size() {
used_color = (itscolor == UmlDefaultColor)
? the_canvas()->browser_diagram()->get_color(UmlPackage)
: itscolor;
const QPixmap * px =
ProfiledStereotypes::diagramPixmap(browser_node->get_data()->get_stereotype(),
the_canvas()->zoom());
if (px != 0) {
QFontMetrics fm(the_canvas()->get_font(UmlNormalBoldFont));
int wi = fm.width(browser_node->get_name());
if (wi < px->width())
wi = px->width();
// force odd width and height for line alignment
DiagramCanvas::resize(wi | 1, (px->height() + fm.height()) | 1);
}
else {
int wi = min_width();
int he = min_height();
// warning : do NOT check if ((width() < wi) || (height() < he))
// because te resize must be done to set data on scale change
// Force odd width and height for line alignment
DiagramCanvas::resize((width() > wi) ? width() : wi | 1,
(height() > he) ? height() : he | 1);
}
}
/*
* Update current scrollbar view w.r.t. slider heights, etc.
*/
int
scrollBar_t::show (int refresh)
{
int ret;
if (!state)
return 0;
if (refresh)
{
int sb_top = term->view_start - term->top_row;
int sb_bot = sb_top + (term->nrow - 1);
int sb_len = max (term->nrow - 1 - term->top_row, 1);
int sb_size = (sb_bot - sb_top) * size ();
top = beg + (sb_top * size ()) / sb_len;
bot = top + sb_size / sb_len + min_height () + (sb_size % sb_len > 0);
/* no change */
if (top == last_top
&& bot == last_bot
&& (state == last_state
|| !(state == STATE_UP || state == STATE_DOWN)))
return 0;
}
ret = (this->*update) (refresh);
last_top = top;
last_bot = bot;
last_state = state;
return ret;
}
void is_balanced( tree * t )
{
int m, mm;
m = max_height( t );
mm = min_height( t );
printf("m = %d, mm = %d\n", m, mm);
if( m - mm <= 1 )
printf("balanced\n");
else
printf("unbalanced\n");
}
void DeploymentNodeCanvas::check_size() {
DeploymentDiagramSettings dflt;
dflt.write_horizontally = write_horizontally;
the_canvas()->browser_diagram()->get_deploymentdiagramsettings(dflt);
horiz = (dflt.write_horizontally == UmlYes);
show_properties = (dflt.componentdrawingsettings.show_stereotype_properties == UmlYes);
const QPixmap * px =
ProfiledStereotypes::diagramPixmap(browser_node->get_data()->get_stereotype(),
the_canvas()->zoom());
if (px != 0) {
QFontMetrics fm(the_canvas()->get_font(UmlNormalBoldFont));
int w;
int h = px->height() + fm.height();
if (horiz)
w = fm.width(iname + ":" + browser_node->get_name());
else {
w = fm.width(browser_node->get_name());
int iw = fm.width(iname + ":");
if (iw > w)
w = iw;
h += fm.height() + (int) (3 * the_canvas()->zoom());
}
if (w < px->width())
w = px->width();
// force odd width and height for line alignment
DiagramCanvas::resize(w | 1, h | 1);
}
else {
int wi = min_width();
int he = min_height();
// warning : do NOT check if ((width() < wi) || (height() < he))
// because te resize must be done to set data on scale change
DiagramCanvas::resize((width() < wi) ? wi : width(),
(height() < he) ? he : height());
}
}
void CSSParserMinHeight::parse(const std::string &name, const std::vector<CSSToken> &tokens, std::vector<std::unique_ptr<CSSPropertyValue> > &inout_values)
{
std::unique_ptr<CSSValueMinHeight> min_height(new CSSValueMinHeight());
size_t pos = 0;
CSSToken token = next_token(pos, tokens);
if (token.type == CSSToken::type_ident && pos == tokens.size())
{
if (equals(token.value, "inherit"))
min_height->type = CSSValueMinHeight::type_inherit;
else if (equals(token.value, "auto"))
min_height->type = CSSValueMinHeight::type_auto;
else
return;
}
else if (is_length(token) && pos == tokens.size())
{
CSSLength length;
if (parse_length(token, length))
{
min_height->type = CSSValueMinHeight::type_length;
min_height->length = length;
}
else
{
return;
}
}
else if (token.type == CSSToken::type_percentage && pos == tokens.size())
{
min_height->type = CSSValueMinHeight::type_percentage;
min_height->percentage = StringHelp::text_to_float(token.value);
}
else
{
return;
}
inout_values.push_back(std::move(min_height));
}
void DeploymentNodeCanvas::resize(const QSize & sz, bool w, bool h) {
DiagramCanvas::resize(sz, w, h, min_width(), min_height(), TRUE);
}
void DeploymentNodeCanvas::resize(aCorner c, int dx, int dy, QPoint & o) {
DiagramCanvas::resize(c, dx, dy, o, min_width(), min_height(), TRUE);
}
int main(void)
{
t_set set;
t_test *const nodes = NEW_N(t_test, TEST_SIZE);
set = SET(&test_cmp, 0);
{
uint32_t i;
uint32_t occur;
i = 0;
while (i < TEST_SIZE)
{
nodes[i] = TEST(ft_rand(-TEST_SIZE/2, TEST_SIZE/2));
occur = count_occur(&set, nodes[i].key);
ft_set_insert(&set, &nodes[i], &nodes[i].key);
ASSERT(occur == count_occur(&set, nodes[i].key) - 1, "INSERT ERROR");
i++;
}
}
ASSERT(test_order_count(&set) == TEST_SIZE, "COUNT ERROR");
test_get(&set);
test_begin(&set);
ASSERT(max_height(set.root) <= min_height(set.root) * 2, "BALANCE ERROR");
TRACE("INSERT OK");
t_vec2u range;
range.x = ft_rand(0, TEST_SIZE / 2);
range.y = ft_rand(TEST_SIZE / 2, TEST_SIZE);
{
uint32_t i;
uint32_t occur;
i = range.x;
while (i < range.y)
{
occur = count_occur(&set, nodes[i].key);
ft_set_remove(&set, &nodes[i]);
ASSERT(occur == count_occur(&set, nodes[i].key) + 1, "REMOVE ERROR");
i++;
}
}
test_order_count(&set);
test_get(&set);
test_begin(&set);
ASSERT(max_height(set.root) <= min_height(set.root) * 2, "BALANCE ERROR");
TRACE("REMOVE OK");
{
uint32_t i;
i = range.y;
while (--i >= range.x)
{
nodes[i].key = range.x;
ft_set_insert(&set, &nodes[i], &nodes[i].key);
}
}
test_order_count(&set);
test_get(&set);
test_begin(&set);
ASSERT(max_height(set.root) <= min_height(set.root) * 2, "BALANCE ERROR");
TRACE("INSERT REV SORTED OK");
{
uint32_t i;
i = 0;
while (i < TEST_SIZE)
{
ft_set_remove(&set, &nodes[0]);
nodes[0].key = i;
ft_set_insert(&set, &nodes[0], &nodes[0].key);
i++;
}
}
test_order_count(&set);
test_get(&set);
test_begin(&set);
ASSERT(max_height(set.root) <= min_height(set.root) * 2, "BALANCE ERROR");
TRACE("INSERT SORTED OK");
{
#define DUP_COUNT 100000
uint32_t i;
t_test *before;
t_test *tmp;
t_test *const insert = NEW_N(t_test, DUP_COUNT);
before = ft_set_get(&set, &nodes[ft_rand(0, TEST_SIZE - 1)].key);
i = 0;
while (i < DUP_COUNT)
{
while ((tmp = ft_set_prev(before)) != NULL && tmp->key == before->key)
before = tmp;
insert[i] = TEST(before->key - 1);
ft_set_insert_before(&set, &insert[i], before);
tmp = ft_set_prev(before);
ASSERT(tmp == &insert[i], "INSERT_BEFORE (prev) ERROR");
tmp = ft_set_next(&insert[i]);
ASSERT(tmp == before, "INSERT_BEFORE (next) ERROR");
before = &insert[i];
i++;
}
}
test_order_count(&set);
test_get(&set);
test_begin(&set);
ASSERT(max_height(set.root) <= min_height(set.root) * 2, "BALANCE ERROR");
TRACE("INSERT_BEFORE OK");
// print_tree(set.root);
// print_iter(&set);
return (0);
}
int TextWidget::max_height() const {
return min_height();
}
int SelectWidget::max_height() const {
return min_height();
}
void PackageCanvas::resize(const QSize & sz, bool w, bool h) {
DiagramCanvas::resize(sz, w, h, min_width(), min_height(), TRUE);
}
void PackageCanvas::resize(aCorner c, int dx, int dy, QPoint & o) {
DiagramCanvas::resize(c, dx, dy, o, min_width(), min_height(), TRUE);
}
