// Copyright (C) 2005 Davis E. King (davis@dlib.net), Keita Mochizuki
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_BASE_WIDGETs_CPP_
#define DLIB_BASE_WIDGETs_CPP_
#include <iostream>
#include <memory>
#include "base_widgets.h"
#include "../assert.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// button object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
void button::
set_size (
unsigned long width,
unsigned long height
)
{
auto_mutex M(m);
rectangle min_rect = style->get_min_size(name_,*mfont);
// only change the size if it isn't going to be too small to fit the name
if (height >= min_rect.height() &&
width >= min_rect.width())
{
rectangle old(rect);
rect = resize_rect(rect,width,height);
parent.invalidate_rectangle(style->get_invalidation_rect(rect+old));
btn_tooltip.set_size(width,height);
}
}
// ----------------------------------------------------------------------------------------
void button::
show (
)
{
button_action::show();
btn_tooltip.show();
}
// ----------------------------------------------------------------------------------------
void button::
hide (
)
{
button_action::hide();
btn_tooltip.hide();
}
// ----------------------------------------------------------------------------------------
void button::
enable (
)
{
button_action::enable();
btn_tooltip.enable();
}
// ----------------------------------------------------------------------------------------
void button::
disable (
)
{
button_action::disable();
btn_tooltip.disable();
}
// ----------------------------------------------------------------------------------------
void button::
set_tooltip_text (
const std::string& text
)
{
btn_tooltip.set_text(text);
}
// ----------------------------------------------------------------------------------------
void button::
set_tooltip_text (
const std::wstring& text
)
{
btn_tooltip.set_text(text);
}
// ----------------------------------------------------------------------------------------
void button::
set_tooltip_text (
const ustring& text
)
{
btn_tooltip.set_text(text);
}
// ----------------------------------------------------------------------------------------
const std::string button::
tooltip_text (
) const
{
return btn_tooltip.text();
}
const std::wstring button::
tooltip_wtext (
) const
{
return btn_tooltip.wtext();
}
const dlib::ustring button::
tooltip_utext (
) const
{
return btn_tooltip.utext();
}
// ----------------------------------------------------------------------------------------
void button::
set_main_font (
const std::shared_ptr<font>& f
)
{
auto_mutex M(m);
mfont = f;
set_name(name_);
}
// ----------------------------------------------------------------------------------------
void button::
set_pos (
long x,
long y
)
{
auto_mutex M(m);
button_action::set_pos(x,y);
btn_tooltip.set_pos(x,y);
}
// ----------------------------------------------------------------------------------------
void button::
set_name (
const std::string& name
)
{
set_name(convert_mbstring_to_wstring(name));
}
void button::
set_name (
const std::wstring& name
)
{
set_name(convert_wstring_to_utf32(name));
}
void button::
set_name (
const ustring& name
)
{
auto_mutex M(m);
name_ = name;
// do this to get rid of any reference counting that may be present in
// the std::string implementation.
name_[0] = name_[0];
rectangle old(rect);
rect = move_rect(style->get_min_size(name,*mfont),rect.left(),rect.top());
btn_tooltip.set_size(rect.width(),rect.height());
parent.invalidate_rectangle(style->get_invalidation_rect(rect+old));
}
// ----------------------------------------------------------------------------------------
const std::string button::
name (
) const
{
auto_mutex M(m);
std::string temp = convert_wstring_to_mbstring(wname());
// do this to get rid of any reference counting that may be present in
// the std::string implementation.
char c = temp[0];
temp[0] = c;
return temp;
}
const std::wstring button::
wname (
) const
{
auto_mutex M(m);
std::wstring temp = convert_utf32_to_wstring(uname());
// do this to get rid of any reference counting that may be present in
// the std::wstring implementation.
wchar_t w = temp[0];
temp[0] = w;
return temp;
}
const dlib::ustring button::
uname (
) const
{
auto_mutex M(m);
dlib::ustring temp = name_;
// do this to get rid of any reference counting that may be present in
// the dlib::ustring implementation.
temp[0] = name_[0];
return temp;
}
// ----------------------------------------------------------------------------------------
void button::
on_button_up (
bool mouse_over
)
{
if (mouse_over)
{
// this is a valid button click
if (event_handler.is_set())
event_handler();
if (event_handler_self.is_set())
event_handler_self(*this);
}
if (button_up_handler.is_set())
button_up_handler(mouse_over);
if (button_up_handler_self.is_set())
button_up_handler_self(mouse_over,*this);
}
// ----------------------------------------------------------------------------------------
void button::
on_button_down (
)
{
if (button_down_handler.is_set())
button_down_handler();
if (button_down_handler_self.is_set())
button_down_handler_self(*this);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// draggable object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
draggable::~draggable() {}
// ----------------------------------------------------------------------------------------
void draggable::
on_mouse_move (
unsigned long state,
long x,
long y
)
{
if (drag && (state & base_window::LEFT) && enabled && !hidden)
{
// the user is trying to drag this object. we should calculate the new
// x and y positions for the upper left corner of this object's rectangle
long new_x = x - this->x;
long new_y = y - this->y;
// make sure these points are inside the draggable area.
if (new_x < area.left())
new_x = area.left();
if (new_x + static_cast<long>(rect.width()) - 1 > area.right())
new_x = area.right() - rect.width() + 1;
if (new_y + static_cast<long>(rect.height()) - 1 > area.bottom())
new_y = area.bottom() - rect.height() + 1;
if (new_y < area.top())
new_y = area.top();
// now make the new rectangle for this object
rectangle new_rect(
new_x,
new_y,
new_x + rect.width() - 1,
new_y + rect.height() - 1
);
// only do anything if this is a new rectangle and it is inside area
if (new_rect != rect && area.intersect(new_rect) == new_rect)
{
parent.invalidate_rectangle(new_rect + rect);
rect = new_rect;
// call the on_drag() event handler
on_drag();
}
}
else
{
drag = false;
on_drag_stop();
}
}
// ----------------------------------------------------------------------------------------
void draggable::
on_mouse_up (
unsigned long ,
unsigned long state,
long ,
long
)
{
if (drag && (state & base_window::LEFT) == 0)
{
drag = false;
on_drag_stop();
}
}
// ----------------------------------------------------------------------------------------
void draggable::
on_mouse_down (
unsigned long btn,
unsigned long ,
long x,
long y,
bool
)
{
if (enabled && !hidden && rect.contains(x,y) && btn == base_window::LEFT)
{
drag = true;
this->x = x - rect.left();
this->y = y - rect.top();
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// mouse_over_event object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
mouse_over_event::~mouse_over_event() {}
// ----------------------------------------------------------------------------------------
void mouse_over_event::
on_mouse_leave (
)
{
if (is_mouse_over_)
{
is_mouse_over_ = false;
on_mouse_not_over();
}
}
// ----------------------------------------------------------------------------------------
void mouse_over_event::
on_mouse_move (
unsigned long ,
long x,
long y
)
{
if (rect.contains(x,y) == false)
{
if (is_mouse_over_)
{
is_mouse_over_ = false;
on_mouse_not_over();
}
}
else if (is_mouse_over_ == false)
{
is_mouse_over_ = true;
if (enabled && !hidden)
on_mouse_over();
}
}
// ----------------------------------------------------------------------------------------
bool mouse_over_event::
is_mouse_over (
) const
{
// check if the mouse is still really over this button
if (is_mouse_over_ && rect.contains(lastx,lasty) == false)
{
// trigger a user event to call on_mouse_not_over() and repaint this object.
// we must do this in another event because someone might call is_mouse_over()
// from draw() and you don't want this function to end up calling
// parent.invalidate_rectangle(). It would lead to draw() being called over
// and over.
parent.trigger_user_event((void*)this,drawable::next_free_user_event_number());
return false;
}
return is_mouse_over_;
}
// ----------------------------------------------------------------------------------------
void mouse_over_event::
on_user_event (
int num
)
{
if (is_mouse_over_ && num == drawable::next_free_user_event_number())
{
is_mouse_over_ = false;
on_mouse_not_over();
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// button_action object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
button_action::~button_action() {}
// ----------------------------------------------------------------------------------------
void button_action::
on_mouse_down (
unsigned long btn,
unsigned long ,
long x,
long y,
bool
)
{
if (enabled && !hidden && btn == base_window::LEFT && rect.contains(x,y))
{
is_depressed_ = true;
seen_click = true;
parent.invalidate_rectangle(rect);
on_button_down();
}
}
// ----------------------------------------------------------------------------------------
void button_action::
on_mouse_not_over (
)
{
if (is_depressed_)
{
is_depressed_ = false;
parent.invalidate_rectangle(rect);
on_button_up(false);
}
}
// ----------------------------------------------------------------------------------------
void button_action::
on_mouse_move (
unsigned long state,
long x,
long y
)
{
// forward event to the parent class so it can do it's thing as well as us
mouse_over_event::on_mouse_move(state,x,y);
if (enabled == false || hidden == true)
return;
if ((state & base_window::LEFT) == 0)
{
seen_click = false;
if (is_depressed_)
{
is_depressed_ = false;
parent.invalidate_rectangle(rect);
on_button_up(false);
}
// the left button isn't down so we don't care about anything else
return;
}
if (rect.contains(x,y) == false)
{
if (is_depressed_)
{
is_depressed_ = false;
parent.invalidate_rectangle(rect);
on_button_up(false);
}
}
else if (is_depressed_ == false && seen_click)
{
is_depressed_ = true;
parent.invalidate_rectangle(rect);
on_button_down();
}
}
// ----------------------------------------------------------------------------------------
void button_action::
on_mouse_up (
unsigned long btn,
unsigned long,
long x,
long y
)
{
if (enabled && !hidden && btn == base_window::LEFT)
{
if (is_depressed_)
{
is_depressed_ = false;
parent.invalidate_rectangle(rect);
if (rect.contains(x,y))
{
on_button_up(true);
}
else
{
on_button_up(false);
}
}
else if (seen_click && rect.contains(x,y))
{
// this case here covers the unlikly event that you click on a button,
// move the mouse off the button and then move it back very quickly and
// release the mouse button. It is possible that this mouse up event
// will occur before any mouse move event so you might not have set
// that the button is depressed yet.
// So we should say that this triggers an on_button_down() event and
// then an on_button_up(true) event.
parent.invalidate_rectangle(rect);
on_button_down();
on_button_up(true);
}
seen_click = false;
}
}
// ----------------------------------------------------------------------------------------
bool button_action::
is_depressed (
) const
{
// check if the mouse is still really over this button
if (enabled && !hidden && is_depressed_ && rect.contains(lastx,lasty) == false)
{
// trigger a user event to call on_button_up() and repaint this object.
// we must do this in another event because someone might call is_depressed()
// from draw() and you don't want this function to end up calling
// parent.invalidate_rectangle(). It would lead to draw() being called over
// and over.
parent.trigger_user_event((void*)this,mouse_over_event::next_free_user_event_number());
return false;
}
return is_depressed_;
}
// ----------------------------------------------------------------------------------------
void button_action::
on_user_event (
int num
)
{
// forward event to the parent class so it can do it's thing as well as us
mouse_over_event::on_user_event(num);
if (is_depressed_ && num == mouse_over_event::next_free_user_event_number())
{
is_depressed_ = false;
parent.invalidate_rectangle(rect);
on_button_up(false);
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// scroll_bar object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
scroll_bar::
scroll_bar(
drawable_window& w,
bar_orientation orientation
) :
drawable(w),
b1(w),
b2(w),
slider(w,*this,&scroll_bar::on_slider_drag),
ori(orientation),
top_filler(w,*this,&scroll_bar::top_filler_down,&scroll_bar::top_filler_up),
bottom_filler(w,*this,&scroll_bar::bottom_filler_down,&scroll_bar::bottom_filler_up),
pos(0),
max_pos(0),
js(10),
b1_timer(*this,&scroll_bar::b1_down_t),
b2_timer(*this,&scroll_bar::b2_down_t),
top_filler_timer(*this,&scroll_bar::top_filler_down_t),
bottom_filler_timer(*this,&scroll_bar::bottom_filler_down_t)
{
set_style(scroll_bar_style_default());
// don't show the slider when there is no place it can move.
slider.hide();
set_length(100);
b1.set_button_down_handler(*this,&scroll_bar::b1_down);
b2.set_button_down_handler(*this,&scroll_bar::b2_down);
b1.set_button_up_handler(*this,&scroll_bar::b1_up);
b2.set_button_up_handler(*this,&scroll_bar::b2_up);
b1.disable();
b2.disable();
enable_events();
}
// ----------------------------------------------------------------------------------------
scroll_bar::
~scroll_bar(
)
{
disable_events();
parent.invalidate_rectangle(rect);
// wait for all the timers to be stopped
b1_timer.stop_and_wait();
b2_timer.stop_and_wait();
top_filler_timer.stop_and_wait();
bottom_filler_timer.stop_and_wait();
}
// ----------------------------------------------------------------------------------------
scroll_bar::bar_orientation scroll_bar::
orientation (
) const
{
auto_mutex M(m);
return ori;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
set_length (
unsigned long length
)
{
auto_mutex M(m);
// make the min length be at least 1
if (length == 0)
{
length = 1;
}
parent.invalidate_rectangle(rect);
if (ori == HORIZONTAL)
{
rect.set_right(rect.left() + length - 1);
rect.set_bottom(rect.top() + style->get_width() - 1);
const long btn_size = style->get_button_length(rect.width(), max_pos);
b1.set_size(btn_size,style->get_width());
b2.set_size(btn_size,style->get_width());
slider.set_size(get_slider_size(),style->get_width());
}
else
{
rect.set_right(rect.left() + style->get_width() - 1);
rect.set_bottom(rect.top() + length - 1);
const long btn_size = style->get_button_length(rect.height(), max_pos);
b1.set_size(style->get_width(),btn_size);
b2.set_size(style->get_width(),btn_size);
slider.set_size(style->get_width(),get_slider_size());
}
// call this to put everything is in the right spot.
set_pos (rect.left(),rect.top());
if ((b2.get_rect().top() - b1.get_rect().bottom() - 1 <= 8 && ori == VERTICAL) ||
(b2.get_rect().left() - b1.get_rect().right() - 1 <= 8 && ori == HORIZONTAL) ||
max_pos == 0)
{
hide_slider();
}
else if (enabled && !hidden)
{
show_slider();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
set_pos (
long x,
long y
)
{
auto_mutex M(m);
drawable::set_pos(x,y);
b1.set_pos(rect.left(),rect.top());
if (ori == HORIZONTAL)
{
// make the b2 button appear at the end of the scroll_bar
b2.set_pos(rect.right()-b2.get_rect().width() + 1,rect.top());
if (max_pos != 0)
{
double range = b2.get_rect().left() - b1.get_rect().right() - slider.get_rect().width() - 1;
double slider_pos = pos;
slider_pos /= max_pos;
slider_pos *= range;
slider.set_pos(
static_cast<long>(slider_pos)+rect.left() + b1.get_rect().width(),
rect.top()
);
// move the draggable area for the slider to the new location
rectangle area = rect;
area.set_left(area.left() + style->get_width());
area.set_right(area.right() - style->get_width());
slider.set_draggable_area(area);
}
}
else
{
// make the b2 button appear at the end of the scroll_bar
b2.set_pos(rect.left(), rect.bottom() - b2.get_rect().height() + 1);
if (max_pos != 0)
{
double range = b2.get_rect().top() - b1.get_rect().bottom() - slider.get_rect().height() - 1;
double slider_pos = pos;
slider_pos /= max_pos;
slider_pos *= range;
slider.set_pos(
rect.left(),
static_cast<long>(slider_pos) + rect.top() + b1.get_rect().height()
);
// move the draggable area for the slider to the new location
rectangle area = rect;
area.set_top(area.top() + style->get_width());
area.set_bottom(area.bottom() - style->get_width());
slider.set_draggable_area(area);
}
}
adjust_fillers();
}
// ----------------------------------------------------------------------------------------
unsigned long scroll_bar::
get_slider_size (
) const
{
if (ori == HORIZONTAL)
return style->get_slider_length(rect.width(),max_pos);
else
return style->get_slider_length(rect.height(),max_pos);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
adjust_fillers (
)
{
rectangle top(rect), bottom(rect);
if (ori == HORIZONTAL)
{
if (slider.is_hidden())
{
top.set_left(b1.get_rect().right()+1);
top.set_right(b2.get_rect().left()-1);
bottom.set_left(1);
bottom.set_right(-1);
}
else
{
top.set_left(b1.get_rect().right()+1);
top.set_right(slider.get_rect().left()-1);
bottom.set_left(slider.get_rect().right()+1);
bottom.set_right(b2.get_rect().left()-1);
}
}
else
{
if (slider.is_hidden())
{
top.set_top(b1.get_rect().bottom()+1);
top.set_bottom(b2.get_rect().top()-1);
bottom.set_top(1);
bottom.set_bottom(-1);
}
else
{
top.set_top(b1.get_rect().bottom()+1);
top.set_bottom(slider.get_rect().top()-1);
bottom.set_top(slider.get_rect().bottom()+1);
bottom.set_bottom(b2.get_rect().top()-1);
}
}
top_filler.rect = top;
bottom_filler.rect = bottom;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
hide_slider (
)
{
rectangle top(rect), bottom(rect);
slider.hide();
top_filler.disable();
bottom_filler.disable();
bottom_filler.hide();
if (ori == HORIZONTAL)
{
top.set_left(b1.get_rect().right()+1);
top.set_right(b2.get_rect().left()-1);
}
else
{
top.set_top(b1.get_rect().bottom()+1);
top.set_bottom(b2.get_rect().top()-1);
}
top_filler.rect = top;
bottom_filler.rect = bottom;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
show_slider (
)
{
if ((b2.get_rect().top() - b1.get_rect().bottom() - 1 <= 8 && ori == VERTICAL) ||
(b2.get_rect().left() - b1.get_rect().right() - 1 <= 8 && ori == HORIZONTAL) ||
max_pos == 0)
return;
rectangle top(rect), bottom(rect);
slider.show();
top_filler.enable();
bottom_filler.enable();
bottom_filler.show();
if (ori == HORIZONTAL)
{
top.set_left(b1.get_rect().right()+1);
top.set_right(slider.get_rect().left()-1);
bottom.set_left(slider.get_rect().right()+1);
bottom.set_right(b2.get_rect().left()-1);
}
else
{
top.set_top(b1.get_rect().bottom()+1);
top.set_bottom(slider.get_rect().top()-1);
bottom.set_top(slider.get_rect().bottom()+1);
bottom.set_bottom(b2.get_rect().top()-1);
}
top_filler.rect = top;
bottom_filler.rect = bottom;
}
// ----------------------------------------------------------------------------------------
long scroll_bar::
max_slider_pos (
) const
{
auto_mutex M(m);
return max_pos;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
set_max_slider_pos (
long mpos
)
{
auto_mutex M(m);
max_pos = mpos;
if (pos > mpos)
pos = mpos;
if (ori == HORIZONTAL)
set_length(rect.width());
else
set_length(rect.height());
if (mpos != 0 && enabled)
{
b1.enable();
b2.enable();
}
else
{
b1.disable();
b2.disable();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
set_slider_pos (
long pos
)
{
auto_mutex M(m);
if (pos < 0)
pos = 0;
if (pos > max_pos)
pos = max_pos;
this->pos = pos;
// move the slider object to its new position
set_pos(rect.left(),rect.top());
}
// ----------------------------------------------------------------------------------------
long scroll_bar::
slider_pos (
) const
{
auto_mutex M(m);
return pos;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
on_slider_drag (
)
{
if (ori == HORIZONTAL)
{
double slider_pos = slider.get_rect().left() - b1.get_rect().right() - 1;
double range = b2.get_rect().left() - b1.get_rect().right() - slider.get_rect().width() - 1;
slider_pos /= range;
slider_pos *= max_pos;
pos = static_cast<unsigned long>(slider_pos);
}
else
{
double slider_pos = slider.get_rect().top() - b1.get_rect().bottom() - 1;
double range = b2.get_rect().top() - b1.get_rect().bottom() - slider.get_rect().height() - 1;
slider_pos /= range;
slider_pos *= max_pos;
pos = static_cast<unsigned long>(slider_pos);
}
adjust_fillers();
if (scroll_handler.is_set())
scroll_handler();
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
draw (
const canvas&
) const
{
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b1_down (
)
{
if (pos != 0)
{
set_slider_pos(pos-1);
if (scroll_handler.is_set())
scroll_handler();
if (b1_timer.delay_time() == 1000)
b1_timer.set_delay_time(500);
else
b1_timer.set_delay_time(50);
b1_timer.start();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b1_up (
bool
)
{
b1_timer.stop();
b1_timer.set_delay_time(1000);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b2_down (
)
{
if (pos != max_pos)
{
set_slider_pos(pos+1);
if (scroll_handler.is_set())
scroll_handler();
if (b2_timer.delay_time() == 1000)
b2_timer.set_delay_time(500);
else
b2_timer.set_delay_time(50);
b2_timer.start();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b2_up (
bool
)
{
b2_timer.stop();
b2_timer.set_delay_time(1000);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
top_filler_down (
)
{
// ignore this if the mouse is now outside this object. This could happen
// since the timers are also calling this function.
if (top_filler.rect.contains(lastx,lasty) == false)
{
top_filler_up(false);
return;
}
if (pos != 0)
{
if (pos < js)
{
// if there is less than jump_size() space left then jump the remaining
// amount.
delayed_set_slider_pos(0);
}
else
{
delayed_set_slider_pos(pos-js);
}
if (top_filler_timer.delay_time() == 1000)
top_filler_timer.set_delay_time(500);
else
top_filler_timer.set_delay_time(50);
top_filler_timer.start();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
top_filler_up (
bool
)
{
top_filler_timer.stop();
top_filler_timer.set_delay_time(1000);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
bottom_filler_down (
)
{
// ignore this if the mouse is now outside this object. This could happen
// since the timers are also calling this function.
if (bottom_filler.rect.contains(lastx,lasty) == false)
{
bottom_filler_up(false);
return;
}
if (pos != max_pos)
{
if (max_pos - pos < js)
{
// if there is less than jump_size() space left then jump the remaining
// amount.
delayed_set_slider_pos(max_pos);
}
else
{
delayed_set_slider_pos(pos+js);
}
if (bottom_filler_timer.delay_time() == 1000)
bottom_filler_timer.set_delay_time(500);
else
bottom_filler_timer.set_delay_time(50);
bottom_filler_timer.start();
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
bottom_filler_up (
bool
)
{
bottom_filler_timer.stop();
bottom_filler_timer.set_delay_time(1000);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
set_jump_size (
long js_
)
{
auto_mutex M(m);
if (js_ < 1)
js = 1;
else
js = js_;
}
// ----------------------------------------------------------------------------------------
long scroll_bar::
jump_size (
) const
{
auto_mutex M(m);
return js;
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
on_user_event (
int i
)
{
switch (i)
{
case 0:
b1_down();
break;
case 1:
b2_down();
break;
case 2:
top_filler_down();
break;
case 3:
bottom_filler_down();
break;
case 4:
// if the position we are supposed to switch the slider too isn't
// already set
if (delayed_pos != pos)
{
set_slider_pos(delayed_pos);
if (scroll_handler.is_set())
scroll_handler();
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
delayed_set_slider_pos (
unsigned long dpos
)
{
delayed_pos = dpos;
parent.trigger_user_event(this,4);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b1_down_t (
)
{
parent.trigger_user_event(this,0);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
b2_down_t (
)
{
parent.trigger_user_event(this,1);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
top_filler_down_t (
)
{
parent.trigger_user_event(this,2);
}
// ----------------------------------------------------------------------------------------
void scroll_bar::
bottom_filler_down_t (
)
{
parent.trigger_user_event(this,3);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// widget_group object methods
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
void widget_group::
empty (
)
{
auto_mutex M(m);
widgets.clear();
wg_widgets.clear();
}
// ----------------------------------------------------------------------------------------
void widget_group::
add (
drawable& widget,
unsigned long x,
unsigned long y
)
{
auto_mutex M(m);
drawable* w = &widget;
relpos rp;
rp.x = x;
rp.y = y;
if (widgets.is_in_domain(w))
{
widgets[w].x = x;
widgets[w].y = y;
}
else
{
widgets.add(w,rp);
}
if (is_hidden())
widget.hide();
else
widget.show();
if (is_enabled())
widget.enable();
else
widget.disable();
widget.set_z_order(z_order());
widget.set_pos(x+rect.left(),y+rect.top());
}
// ----------------------------------------------------------------------------------------
void widget_group::
add (
widget_group& widget,
unsigned long x,
unsigned long y
)
{
auto_mutex M(m);
drawable& w = widget;
add(w, x, y);
widget_group* wg = &widget;
wg_widgets.add(wg);
}
// ----------------------------------------------------------------------------------------
bool widget_group::
is_member (
const drawable& widget
) const
{
auto_mutex M(m);
drawable* w = const_cast<drawable*>(&widget);
return widgets.is_in_domain(w);
}
// ----------------------------------------------------------------------------------------
void widget_group::
remove (
const drawable& widget
)
{
auto_mutex M(m);
drawable* w = const_cast<drawable*>(&widget);
if (widgets.is_in_domain(w))
{
widgets.destroy(w);
// check if we also have an entry in the wg_widgets set and if
// so then remove that too
widget_group* wg = reinterpret_cast<widget_group*>(w);
if (wg_widgets.is_member(wg))
{
wg_widgets.destroy(wg);
}
}
}
// ----------------------------------------------------------------------------------------
size_t widget_group::
size (
) const
{
auto_mutex M(m);
return widgets.size();
}
// ----------------------------------------------------------------------------------------
void widget_group::
set_pos (
long x,
long y
)
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
{
const unsigned long rx = widgets.element().value().x;
const unsigned long ry = widgets.element().value().y;
widgets.element().key()->set_pos(x+rx,y+ry);
}
drawable::set_pos(x,y);
}
// ----------------------------------------------------------------------------------------
void widget_group::
set_z_order (
long order
)
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
widgets.element().key()->set_z_order(order);
drawable::set_z_order(order);
}
// ----------------------------------------------------------------------------------------
void widget_group::
show (
)
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
widgets.element().key()->show();
drawable::show();
}
// ----------------------------------------------------------------------------------------
void widget_group::
hide (
)
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
widgets.element().key()->hide();
drawable::hide();
}
// ----------------------------------------------------------------------------------------
void widget_group::
enable (
)
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
widgets.element().key()->enable();
drawable::enable();
}
// ----------------------------------------------------------------------------------------
void widget_group::
disable ()
{
auto_mutex M(m);
widgets.reset();
while (widgets.move_next())
widgets.element().key()->disable();
drawable::disable();
}
// ----------------------------------------------------------------------------------------
void widget_group::
fit_to_contents (
)
{
auto_mutex M(m);
// call fit_to_contents on all the widget_groups we contain
wg_widgets.reset();
while (wg_widgets.move_next())
wg_widgets.element()->fit_to_contents();
// now accumulate a rectangle that contains everything in this widget_group
rectangle r;
widgets.reset();
while (widgets.move_next())
r = r + widgets.element().key()->get_rect();
if (r.is_empty())
{
// make sure it is still empty after we set it at the correct position
r.set_right(rect.left()-1);
r.set_bottom(rect.top()-1);
}
r.set_left(rect.left());
r.set_top(rect.top());
rect = r;
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// class popup_menu
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
popup_menu::
popup_menu (
) :
base_window(false,true),
pad(2),
item_pad(3),
cur_rect(pad,pad,pad-1,pad-1),
left_width(0),
middle_width(0),
selected_item(0),
submenu_open(false)
{
}
// ----------------------------------------------------------------------------------------
void popup_menu::
enable_menu_item (
unsigned long idx
)
{
DLIB_ASSERT ( idx < size() ,
"\tvoid popup_menu::enable_menu_item()"
<< "\n\tidx: " << idx
<< "\n\tsize(): " << size()
);
auto_mutex M(wm);
item_enabled[idx] = true;
invalidate_rectangle(cur_rect);
}
// ----------------------------------------------------------------------------------------
void popup_menu::
disable_menu_item (
unsigned long idx
)
{
DLIB_ASSERT ( idx < size() ,
"\tvoid popup_menu::enable_menu_item()"
<< "\n\tidx: " << idx
<< "\n\tsize(): " << size()
);
auto_mutex M(wm);
item_enabled[idx] = false;
invalidate_rectangle(cur_rect);
}
// ----------------------------------------------------------------------------------------
size_t popup_menu::
size (
) const
{
auto_mutex M(wm);
return items.size();
}
// ----------------------------------------------------------------------------------------
void popup_menu::
clear (
)
{
auto_mutex M(wm);
hide();
cur_rect = rectangle(pad,pad,pad-1,pad-1);
win_rect = rectangle();
left_width = 0;
middle_width = 0;
items.clear();
item_enabled.clear();
left_rects.clear();
middle_rects.clear();
right_rects.clear();
line_rects.clear();
submenus.clear();
selected_item = 0;
submenu_open = false;
}
// ----------------------------------------------------------------------------------------
void popup_menu::
show (
)
{
auto_mutex M(wm);
selected_item = submenus.size();
base_window::show();
}
// ----------------------------------------------------------------------------------------
void popup_menu::
hide (
)
{
auto_mutex M(wm);
// hide ourselves
close_submenu();
selected_item = submenus.size();
base_window::hide();
}
// ----------------------------------------------------------------------------------------
void popup_menu::
select_first_item (
)
{
auto_mutex M(wm);
close_submenu();
selected_item = items.size();
for (unsigned long i = 0; i < items.size(); ++i)
{
if ((items[i]->has_click_event() || submenus[i]) && item_enabled[i])
{
selected_item = i;
break;
}
}
invalidate_rectangle(cur_rect);
}
// ----------------------------------------------------------------------------------------
bool popup_menu::
forwarded_on_keydown (
unsigned long key,
bool is_printable,
unsigned long state
)
{
auto_mutex M(wm);
// do nothing if this popup menu is empty
if (items.size() == 0)
return false;
// check if the selected item is a submenu
if (selected_item != submenus.size() && submenus[selected_item] != 0 && submenu_open)
{
// send the key to the submenu and return if that menu used the key
if (submenus[selected_item]->forwarded_on_keydown(key,is_printable,state) == true)
return true;
}
if (key == KEY_UP)
{
for (unsigned long i = 0; i < items.size(); ++i)
{
selected_item = (selected_item + items.size() - 1)%items.size();
// only stop looking if this one is enabled and has a click event or is a submenu
if (item_enabled[selected_item] && (items[selected_item]->has_click_event() || submenus[selected_item]) )
break;
}
invalidate_rectangle(cur_rect);
return true;
}
else if (key == KEY_DOWN)
{
for (unsigned long i = 0; i < items.size(); ++i)
{
selected_item = (selected_item + 1)%items.size();
// only stop looking if this one is enabled and has a click event or is a submenu
if (item_enabled[selected_item] && (items[selected_item]->has_click_event() || submenus[selected_item]))
break;
}
invalidate_rectangle(cur_rect);
return true;
}
else if (key == KEY_RIGHT && submenu_open == false && display_selected_submenu())
{
submenus[selected_item]->select_first_item();
return true;
}
else if (key == KEY_LEFT && selected_item != submenus.size() &&
submenus[selected_item] != 0 && submenu_open)
{
close_submenu();
return true;
}
else if (key == '\n')
{
if (selected_item != submenus.size() && (items[selected_item]->has_click_event() || submenus[selected_item]))
{
const long idx = selected_item;
// only hide this popup window if this isn't a submenu
if (submenus[idx] == 0)
{
hide();
hide_handlers.reset();
while (hide_handlers.move_next())
hide_handlers.element()();
}
else
{
display_selected_submenu();
submenus[idx]->select_first_item();
}
items[idx]->on_click();
return true;
}
}
else if (is_printable)
{
// check if there is a hotkey for this key
for (unsigned long i = 0; i < items.size(); ++i)
{
if (std::tolower(key) == std::tolower(items[i]->get_hot_key()) &&
(items[i]->has_click_event() || submenus[i]) && item_enabled[i] )
{
// only hide this popup window if this isn't a submenu
if (submenus[i] == 0)
{
hide();
hide_handlers.reset();
while (hide_handlers.move_next())
hide_handlers.element()();
}
else
{
if (selected_item != items.size())
invalidate_rectangle(line_rects[selected_item]);
selected_item = i;
display_selected_submenu();
invalidate_rectangle(line_rects[i]);
submenus[i]->select_first_item();
}
items[i]->on_click();
}
}
// always say we use a printable key for hotkeys
return true;
}
return false;
}
// ----------------------------------------------------------------------------------------
void popup_menu::
on_submenu_hide (
)
{
hide();
hide_handlers.reset();
while (hide_handlers.move_next())
hide_handlers.element()();
}
// ----------------------------------------------------------------------------------------
void popup_menu::
on_window_resized(
)
{
invalidate_rectangle(win_rect);
}
// ----------------------------------------------------------------------------------------
void popup_menu::
on_mouse_up (
unsigned long btn,
unsigned long,
long x,
long y
)
{
if (cur_rect.contains(x,y) && btn == LEFT)
{
// figure out which item this was on
for (unsigned long i = 0; i < items.size(); ++i)
{
if (line_rects[i].contains(x,y) && item_enabled[i] && items[i]->has_click_event())
{
// only hide this popup window if this isn't a submenu
if (submenus[i] == 0)
{
hide();
hide_handlers.reset();
while (hide_handlers.move_next())
hide_handlers.element()();
}
items[i]->on_click();
break;
}
}
}
}
// ----------------------------------------------------------------------------------------
void popup_menu::
on_mouse_move (
unsigned long ,
long x,
long y
)
{
if (cur_rect.contains(x,y))
{
// check if the mouse is still in the same rect it was in last time
rectangle last_rect;
if (selected_item != submenus.size())
{
last_rect = line_rects[selected_item];
}
// if the mouse isn't in the same rectangle any more
if (last_rect.contains(x,y) == false)
{
if (selected_item != submenus.size())
{
invalidate_rectangle(last_rect);
close_submenu();
selected_item = submenus.size();
}
// figure out if we should redraw any menu items
for (unsigned long i = 0; i < items.size(); ++i)
{
if (items[i]->has_click_event() || submenus[i])
{
if (line_rects[i].contains(x,y))
{
selected_item = i;
break;
}
}
}
// if we found a rectangle that contains the mouse then
// tell it to redraw itself
if (selected_item != submenus.size())
{
display_selected_submenu();
invalidate_rectangle(line_rects[selected_item]);
}
}
}
}
// ----------------------------------------------------------------------------------------
void popup_menu::
close_submenu (
)
{
if (selected_item != submenus.size() && submenus[selected_item] && submenu_open)
{
submenus[selected_item]->hide();
submenu_open = false;
}
}
// ----------------------------------------------------------------------------------------
bool popup_menu::
display_selected_submenu (
)
{
// show the submenu if one exists
if (selected_item != submenus.size() && submenus[selected_item])
{
long wx, wy;
get_pos(wx,wy);
wx += line_rects[selected_item].right();
wy += line_rects[selected_item].top();
submenus[selected_item]->set_pos(wx+1,wy-2);
submenus[selected_item]->show();
submenu_open = true;
return true;
}
return false;
}
// ----------------------------------------------------------------------------------------
void popup_menu::
on_mouse_leave (
)
{
if (selected_item != submenus.size())
{
// only unhighlight a menu item if it isn't a submenu item
if (submenus[selected_item] == 0)
{
invalidate_rectangle(line_rects[selected_item]);
selected_item = submenus.size();
}
}
}
// ----------------------------------------------------------------------------------------
void popup_menu::
paint (
const canvas& c
)
{
c.fill(200,200,200);
draw_rectangle(c, win_rect);
for (unsigned long i = 0; i < items.size(); ++i)
{
bool is_selected = false;
if (selected_item != submenus.size() && i == selected_item &&
item_enabled[i])
is_selected = true;
items[i]->draw_background(c,line_rects[i], item_enabled[i], is_selected);
items[i]->draw_left(c,left_rects[i], item_enabled[i], is_selected);
items[i]->draw_middle(c,middle_rects[i], item_enabled[i], is_selected);
items[i]->draw_right(c,right_rects[i], item_enabled[i], is_selected);
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// class zoomable_region
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
zoomable_region::
zoomable_region (
drawable_window& w,
unsigned long events
) :
drawable(w,MOUSE_CLICK | MOUSE_WHEEL | MOUSE_MOVE | events),
min_scale(0.15),
max_scale(1.0),
zoom_increment_(0.90),
vsb(w, scroll_bar::VERTICAL),
hsb(w, scroll_bar::HORIZONTAL)
{
scale = 1;
mouse_drag_screen = false;
style.reset(new scrollable_region_style_default());
hsb.set_scroll_handler(*this,&zoomable_region::on_h_scroll);
vsb.set_scroll_handler(*this,&zoomable_region::on_v_scroll);
}
// ----------------------------------------------------------------------------------------
zoomable_region::
~zoomable_region()
{
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_pos (
long x,
long y
)
{
auto_mutex M(m);
drawable::set_pos(x,y);
const long border_size = style->get_border_size();
vsb.set_pos(rect.right()-border_size+1-vsb.width(),rect.top()+border_size);
hsb.set_pos(rect.left()+border_size,rect.bottom()-border_size+1-hsb.height());
display_rect_ = rectangle(rect.left()+border_size,
rect.top()+border_size,
rect.right()-border_size-vsb.width(),
rect.bottom()-border_size-hsb.height());
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_zoom_increment (
double zi
)
{
DLIB_ASSERT(0.0 < zi && zi < 1.0,
"\tvoid zoomable_region::set_zoom_increment(zi)"
<< "\n\t the zoom increment must be between 0 and 1"
<< "\n\t zi: " << zi
<< "\n\t this: " << this
);
auto_mutex M(m);
zoom_increment_ = zi;
}
// ----------------------------------------------------------------------------------------
double zoomable_region::
zoom_increment (
) const
{
auto_mutex M(m);
return zoom_increment_;
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_max_zoom_scale (
double ms
)
{
DLIB_ASSERT(ms > 0,
"\tvoid zoomable_region::set_max_zoom_scale(ms)"
<< "\n\t the max zoom scale must be greater than 0"
<< "\n\t ms: " << ms
<< "\n\t this: " << this
);
auto_mutex M(m);
max_scale = ms;
if (scale > ms)
{
scale = max_scale;
lr_point = gui_to_graph_space(point(display_rect_.right(),display_rect_.bottom()));
redraw_graph();
}
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_min_zoom_scale (
double ms
)
{
DLIB_ASSERT(ms > 0,
"\tvoid zoomable_region::set_min_zoom_scale(ms)"
<< "\n\t the min zoom scale must be greater than 0"
<< "\n\t ms: " << ms
<< "\n\t this: " << this
);
auto_mutex M(m);
min_scale = ms;
if (scale < ms)
{
scale = min_scale;
}
// just call set_size so that everything gets redrawn right
set_size(rect.width(), rect.height());
}
// ----------------------------------------------------------------------------------------
double zoomable_region::
min_zoom_scale (
) const
{
auto_mutex M(m);
return min_scale;
}
// ----------------------------------------------------------------------------------------
double zoomable_region::
max_zoom_scale (
) const
{
auto_mutex M(m);
return max_scale;
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_size (
unsigned long width,
unsigned long height
)
{
auto_mutex M(m);
rectangle old(rect);
const long border_size = style->get_border_size();
rect = resize_rect(rect,width,height);
vsb.set_pos(rect.right()-border_size+1-vsb.width(), rect.top()+border_size);
hsb.set_pos(rect.left()+border_size, rect.bottom()-border_size+1-hsb.height());
display_rect_ = rectangle(rect.left()+border_size,
rect.top()+border_size,
rect.right()-border_size-vsb.width(),
rect.bottom()-border_size-hsb.height());
vsb.set_length(display_rect_.height());
hsb.set_length(display_rect_.width());
parent.invalidate_rectangle(rect+old);
const double old_scale = scale;
const vector<double,2> old_gr_orig(gr_orig);
scale = min_scale;
gr_orig = vector<double,2>(0,0);
lr_point = gui_to_graph_space(point(display_rect_.right(),display_rect_.bottom()));
scale = old_scale;
// call adjust_origin() so that the scroll bars get their max slider positions
// setup right
const point rect_corner(display_rect_.left(), display_rect_.top());
adjust_origin(rect_corner, old_gr_orig);
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
show (
)
{
auto_mutex M(m);
drawable::show();
hsb.show();
vsb.show();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
hide (
)
{
auto_mutex M(m);
drawable::hide();
hsb.hide();
vsb.hide();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
enable (
)
{
auto_mutex M(m);
drawable::enable();
hsb.enable();
vsb.enable();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
disable (
)
{
auto_mutex M(m);
drawable::disable();
hsb.disable();
vsb.disable();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_z_order (
long order
)
{
auto_mutex M(m);
drawable::set_z_order(order);
hsb.set_z_order(order);
vsb.set_z_order(order);
}
// ----------------------------------------------------------------------------------------
point zoomable_region::
graph_to_gui_space (
const vector<double,2>& p
) const
{
const point rect_corner(display_rect_.left(), display_rect_.top());
return (p - gr_orig)*scale + rect_corner;
}
// ----------------------------------------------------------------------------------------
vector<double,2> zoomable_region::
gui_to_graph_space (
const point& p
) const
{
const point rect_corner(display_rect_.left(), display_rect_.top());
return (p - rect_corner)/scale + gr_orig;
}
// ----------------------------------------------------------------------------------------
point zoomable_region::
max_graph_point (
) const
{
return lr_point;
}
// ----------------------------------------------------------------------------------------
rectangle zoomable_region::
display_rect (
) const
{
return display_rect_;
}
// ----------------------------------------------------------------------------------------
double zoomable_region::
zoom_scale (
) const
{
return scale;
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
set_zoom_scale (
double new_scale
)
{
// if new_scale isn't in the right range then put it back in range before we do the
// rest of this function
if (!(min_scale <= new_scale && new_scale <= max_scale))
{
if (new_scale > max_scale)
new_scale = max_scale;
else
new_scale = min_scale;
}
// find the point in the center of the graph area
point center((display_rect_.left()+display_rect_.right())/2, (display_rect_.top()+display_rect_.bottom())/2);
point graph_p(gui_to_graph_space(center));
scale = new_scale;
adjust_origin(center, graph_p);
redraw_graph();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
center_display_at_graph_point (
const vector<double,2>& p
)
{
// find the point in the center of the graph area
point center((display_rect_.left()+display_rect_.right())/2, (display_rect_.top()+display_rect_.bottom())/2);
adjust_origin(center, p);
redraw_graph();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_wheel_down (
unsigned long
)
{
// zoom out
if (enabled && !hidden && scale > min_scale && display_rect_.contains(lastx,lasty))
{
point gui_p(lastx,lasty);
point graph_p(gui_to_graph_space(gui_p));
const double old_scale = scale;
scale *= zoom_increment_;
if (scale < min_scale)
scale = min_scale;
redraw_graph();
adjust_origin(gui_p, graph_p);
if (scale != old_scale)
on_view_changed();
}
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_wheel_up (
unsigned long
)
{
// zoom in
if (enabled && !hidden && scale < max_scale && display_rect_.contains(lastx,lasty))
{
point gui_p(lastx,lasty);
point graph_p(gui_to_graph_space(gui_p));
const double old_scale = scale;
scale /= zoom_increment_;
if (scale > max_scale)
scale = max_scale;
redraw_graph();
adjust_origin(gui_p, graph_p);
if (scale != old_scale)
on_view_changed();
}
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_mouse_move (
unsigned long state,
long x,
long y
)
{
if (enabled && !hidden && mouse_drag_screen)
{
adjust_origin(point(x,y), drag_screen_point);
redraw_graph();
on_view_changed();
}
// check if the mouse isn't being dragged anymore
if ((state & base_window::LEFT) == 0)
{
mouse_drag_screen = false;
}
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_mouse_up (
unsigned long ,
unsigned long ,
long ,
long
)
{
mouse_drag_screen = false;
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_mouse_down (
unsigned long btn,
unsigned long ,
long x,
long y,
bool
)
{
if (enabled && !hidden && display_rect_.contains(x,y) && btn == base_window::LEFT)
{
mouse_drag_screen = true;
drag_screen_point = gui_to_graph_space(point(x,y));
}
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
draw (
const canvas& c
) const
{
style->draw_scrollable_region_border(c, rect, enabled);
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_h_scroll (
)
{
gr_orig.x() = hsb.slider_pos();
redraw_graph();
on_view_changed();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
on_v_scroll (
)
{
gr_orig.y() = vsb.slider_pos();
redraw_graph();
on_view_changed();
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
redraw_graph (
)
{
parent.invalidate_rectangle(display_rect_);
}
// ----------------------------------------------------------------------------------------
void zoomable_region::
adjust_origin (
const point& gui_p,
const vector<double,2>& graph_p
)
{
const point rect_corner(display_rect_.left(), display_rect_.top());
const dlib::vector<double,2> v(gui_p - rect_corner);
gr_orig = graph_p - v/scale;
// make sure the origin isn't outside the point (0,0)
if (gr_orig.x() < 0)
gr_orig.x() = 0;
if (gr_orig.y() < 0)
gr_orig.y() = 0;
// make sure the lower right corner of the display_rect_ doesn't map to a point beyond lr_point
point lr_rect_corner(display_rect_.right(), display_rect_.bottom());
point p = graph_to_gui_space(lr_point);
vector<double,2> lr_rect_corner_graph_space(gui_to_graph_space(lr_rect_corner));
vector<double,2> delta(lr_point - lr_rect_corner_graph_space);
if (lr_rect_corner.x() > p.x())
{
gr_orig.x() += delta.x();
}
if (lr_rect_corner.y() > p.y())
{
gr_orig.y() += delta.y();
}
const vector<double,2> ul_rect_corner_graph_space(gui_to_graph_space(rect_corner));
lr_rect_corner_graph_space = gui_to_graph_space(lr_rect_corner);
// now adjust the scroll bars
hsb.set_max_slider_pos((unsigned long)std::max(lr_point.x()-(lr_rect_corner_graph_space.x()-ul_rect_corner_graph_space.x()),0.0));
vsb.set_max_slider_pos((unsigned long)std::max(lr_point.y()-(lr_rect_corner_graph_space.y()-ul_rect_corner_graph_space.y()),0.0));
// adjust slider position now.
hsb.set_slider_pos(static_cast<long>(ul_rect_corner_graph_space.x()));
vsb.set_slider_pos(static_cast<long>(ul_rect_corner_graph_space.y()));
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// class scrollable_region
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
scrollable_region::
scrollable_region (
drawable_window& w,
unsigned long events
) :
drawable(w, MOUSE_WHEEL|events|MOUSE_CLICK|MOUSE_MOVE),
hsb(w,scroll_bar::HORIZONTAL),
vsb(w,scroll_bar::VERTICAL),
hscroll_bar_inc(1),
vscroll_bar_inc(1),
h_wheel_scroll_bar_inc(1),
v_wheel_scroll_bar_inc(1),
mouse_drag_enabled_(false),
user_is_dragging_mouse(false)
{
style.reset(new scrollable_region_style_default());
hsb.set_scroll_handler(*this,&scrollable_region::on_h_scroll);
vsb.set_scroll_handler(*this,&scrollable_region::on_v_scroll);
}
// ----------------------------------------------------------------------------------------
scrollable_region::
~scrollable_region (
)
{
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
show (
)
{
auto_mutex M(m);
drawable::show();
if (need_h_scroll())
hsb.show();
if (need_v_scroll())
vsb.show();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
hide (
)
{
auto_mutex M(m);
drawable::hide();
hsb.hide();
vsb.hide();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
enable (
)
{
auto_mutex M(m);
drawable::enable();
hsb.enable();
vsb.enable();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
disable (
)
{
auto_mutex M(m);
drawable::disable();
hsb.disable();
vsb.disable();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_z_order (
long order
)
{
auto_mutex M(m);
drawable::set_z_order(order);
hsb.set_z_order(order);
vsb.set_z_order(order);
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_size (
unsigned long width,
unsigned long height
)
{
auto_mutex M(m);
rectangle old(rect);
rect = resize_rect(rect,width,height);
vsb.set_pos(rect.right()-style->get_border_size()-vsb.width()+1, rect.top()+style->get_border_size());
hsb.set_pos(rect.left()+style->get_border_size(), rect.bottom()-style->get_border_size()-hsb.height()+1);
// adjust the display_rect_
if (need_h_scroll() && need_v_scroll())
{
// both scroll bars aren't hidden
if (!hidden)
{
vsb.show();
hsb.show();
}
display_rect_ = rectangle( rect.left()+style->get_border_size(),
rect.top()+style->get_border_size(),
rect.right()-style->get_border_size()-vsb.width(),
rect.bottom()-style->get_border_size()-hsb.height());
// figure out how many scroll bar positions there should be
unsigned long hdelta = total_rect_.width()-display_rect_.width();
unsigned long vdelta = total_rect_.height()-display_rect_.height();
hdelta = (hdelta+hscroll_bar_inc-1)/hscroll_bar_inc;
vdelta = (vdelta+vscroll_bar_inc-1)/vscroll_bar_inc;
hsb.set_max_slider_pos(hdelta);
vsb.set_max_slider_pos(vdelta);
vsb.set_jump_size((display_rect_.height()+vscroll_bar_inc-1)/vscroll_bar_inc/2+1);
hsb.set_jump_size((display_rect_.width()+hscroll_bar_inc-1)/hscroll_bar_inc/2+1);
}
else if (need_h_scroll())
{
// only hsb is hidden
if (!hidden)
{
hsb.show();
vsb.hide();
}
display_rect_ = rectangle( rect.left()+style->get_border_size(),
rect.top()+style->get_border_size(),
rect.right()-style->get_border_size(),
rect.bottom()-style->get_border_size()-hsb.height());
// figure out how many scroll bar positions there should be
unsigned long hdelta = total_rect_.width()-display_rect_.width();
hdelta = (hdelta+hscroll_bar_inc-1)/hscroll_bar_inc;
hsb.set_max_slider_pos(hdelta);
vsb.set_max_slider_pos(0);
hsb.set_jump_size((display_rect_.width()+hscroll_bar_inc-1)/hscroll_bar_inc/2+1);
}
else if (need_v_scroll())
{
// only vsb is hidden
if (!hidden)
{
hsb.hide();
vsb.show();
}
display_rect_ = rectangle( rect.left()+style->get_border_size(),
rect.top()+style->get_border_size(),
rect.right()-style->get_border_size()-vsb.width(),
rect.bottom()-style->get_border_size());
unsigned long vdelta = total_rect_.height()-display_rect_.height();
vdelta = (vdelta+vscroll_bar_inc-1)/vscroll_bar_inc;
hsb.set_max_slider_pos(0);
vsb.set_max_slider_pos(vdelta);
vsb.set_jump_size((display_rect_.height()+vscroll_bar_inc-1)/vscroll_bar_inc/2+1);
}
else
{
// both are hidden
if (!hidden)
{
hsb.hide();
vsb.hide();
}
display_rect_ = rectangle( rect.left()+style->get_border_size(),
rect.top()+style->get_border_size(),
rect.right()-style->get_border_size(),
rect.bottom()-style->get_border_size());
hsb.set_max_slider_pos(0);
vsb.set_max_slider_pos(0);
}
vsb.set_length(display_rect_.height());
hsb.set_length(display_rect_.width());
// adjust the total_rect_ position by trigging the scroll events
on_h_scroll();
on_v_scroll();
parent.invalidate_rectangle(rect+old);
}
// ----------------------------------------------------------------------------------------
unsigned long scrollable_region::
horizontal_mouse_wheel_scroll_increment (
) const
{
auto_mutex M(m);
return h_wheel_scroll_bar_inc;
}
// ----------------------------------------------------------------------------------------
unsigned long scrollable_region::
vertical_mouse_wheel_scroll_increment (
) const
{
auto_mutex M(m);
return v_wheel_scroll_bar_inc;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_horizontal_mouse_wheel_scroll_increment (
unsigned long inc
)
{
auto_mutex M(m);
h_wheel_scroll_bar_inc = inc;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_vertical_mouse_wheel_scroll_increment (
unsigned long inc
)
{
auto_mutex M(m);
v_wheel_scroll_bar_inc = inc;
}
// ----------------------------------------------------------------------------------------
unsigned long scrollable_region::
horizontal_scroll_increment (
) const
{
auto_mutex M(m);
return hscroll_bar_inc;
}
// ----------------------------------------------------------------------------------------
unsigned long scrollable_region::
vertical_scroll_increment (
) const
{
auto_mutex M(m);
return vscroll_bar_inc;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_horizontal_scroll_increment (
unsigned long inc
)
{
auto_mutex M(m);
hscroll_bar_inc = inc;
// call set_size to reset the scroll bars
set_size(rect.width(),rect.height());
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_vertical_scroll_increment (
unsigned long inc
)
{
auto_mutex M(m);
vscroll_bar_inc = inc;
// call set_size to reset the scroll bars
set_size(rect.width(),rect.height());
}
// ----------------------------------------------------------------------------------------
long scrollable_region::
horizontal_scroll_pos (
) const
{
auto_mutex M(m);
return hsb.slider_pos();
}
// ----------------------------------------------------------------------------------------
long scrollable_region::
vertical_scroll_pos (
) const
{
auto_mutex M(m);
return vsb.slider_pos();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_horizontal_scroll_pos (
long pos
)
{
auto_mutex M(m);
hsb.set_slider_pos(pos);
on_h_scroll();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_vertical_scroll_pos (
long pos
)
{
auto_mutex M(m);
vsb.set_slider_pos(pos);
on_v_scroll();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_pos (
long x,
long y
)
{
auto_mutex M(m);
drawable::set_pos(x,y);
vsb.set_pos(rect.right()-style->get_border_size()-vsb.width()+1, rect.top()+style->get_border_size());
hsb.set_pos(rect.left()+style->get_border_size(), rect.bottom()-style->get_border_size()-hsb.height()+1);
const long delta_x = total_rect_.left() - display_rect_.left();
const long delta_y = total_rect_.top() - display_rect_.top();
display_rect_ = move_rect(display_rect_, rect.left()+style->get_border_size(), rect.top()+style->get_border_size());
total_rect_ = move_rect(total_rect_, display_rect_.left()+delta_x, display_rect_.top()+delta_y);
}
// ----------------------------------------------------------------------------------------
bool scrollable_region::
mouse_drag_enabled (
) const
{
auto_mutex M(m);
return mouse_drag_enabled_;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
enable_mouse_drag (
)
{
auto_mutex M(m);
mouse_drag_enabled_ = true;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
disable_mouse_drag (
)
{
auto_mutex M(m);
mouse_drag_enabled_ = false;
}
// ----------------------------------------------------------------------------------------
const rectangle& scrollable_region::
display_rect (
) const
{
return display_rect_;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
set_total_rect_size (
unsigned long width,
unsigned long height
)
{
DLIB_ASSERT((width > 0 && height > 0) || (width == 0 && height == 0),
"\tvoid scrollable_region::set_total_rect_size(width,height)"
<< "\n\twidth and height must be > 0 or both == 0"
<< "\n\twidth: " << width
<< "\n\theight: " << height
<< "\n\tthis: " << this
);
total_rect_ = move_rect(rectangle(width,height),
display_rect_.left()-static_cast<long>(hsb.slider_pos()),
display_rect_.top()-static_cast<long>(vsb.slider_pos()));
// call this just to reconfigure the scroll bars
set_size(rect.width(),rect.height());
}
// ----------------------------------------------------------------------------------------
const rectangle& scrollable_region::
total_rect (
) const
{
return total_rect_;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
scroll_to_rect (
const rectangle& r_
)
{
const rectangle r(total_rect_.intersect(r_));
const rectangle old(total_rect_);
// adjust the horizontal scroll bar so that r fits as best as possible
if (r.left() < display_rect_.left())
{
long distance = (r.left()-total_rect_.left())/hscroll_bar_inc;
hsb.set_slider_pos(distance);
}
else if (r.right() > display_rect_.right())
{
long distance = (r.right()-total_rect_.left()-display_rect_.width()+hscroll_bar_inc)/hscroll_bar_inc;
hsb.set_slider_pos(distance);
}
// adjust the vertical scroll bar so that r fits as best as possible
if (r.top() < display_rect_.top())
{
long distance = (r.top()-total_rect_.top())/vscroll_bar_inc;
vsb.set_slider_pos(distance);
}
else if (r.bottom() > display_rect_.bottom())
{
long distance = (r.bottom()-total_rect_.top()-display_rect_.height()+vscroll_bar_inc)/vscroll_bar_inc;
vsb.set_slider_pos(distance);
}
// adjust total_rect_ so that it matches where the scroll bars are now
total_rect_ = move_rect(total_rect_,
display_rect_.left()-hscroll_bar_inc*hsb.slider_pos(),
display_rect_.top()-vscroll_bar_inc*vsb.slider_pos());
// only redraw if we actually changed something
if (total_rect_ != old)
{
parent.invalidate_rectangle(display_rect_);
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_wheel_down (
unsigned long
)
{
if (rect.contains(lastx,lasty) && enabled && !hidden)
{
if (need_v_scroll())
{
long pos = vsb.slider_pos();
vsb.set_slider_pos(pos+(long)v_wheel_scroll_bar_inc);
on_v_scroll();
}
else if (need_h_scroll())
{
long pos = hsb.slider_pos();
hsb.set_slider_pos(pos+(long)h_wheel_scroll_bar_inc);
on_h_scroll();
}
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_mouse_move (
unsigned long state,
long x,
long y
)
{
if (enabled && !hidden && user_is_dragging_mouse && state==base_window::LEFT)
{
point current_delta = point(x,y) - point(total_rect().left(), total_rect().top());
rectangle new_rect(translate_rect(display_rect(), drag_origin - current_delta));
new_rect = centered_rect(new_rect, new_rect.width()-hscroll_bar_inc, new_rect.height()-vscroll_bar_inc);
scroll_to_rect(new_rect);
on_view_changed();
}
else
{
user_is_dragging_mouse = false;
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_mouse_down (
unsigned long btn,
unsigned long ,
long x,
long y,
bool
)
{
if (mouse_drag_enabled_ && enabled && !hidden && display_rect().contains(x,y) && (btn==base_window::LEFT))
{
drag_origin = point(x,y) - point(total_rect().left(), total_rect().top());
user_is_dragging_mouse = true;
}
else
{
user_is_dragging_mouse = false;
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_mouse_up (
unsigned long ,
unsigned long ,
long ,
long
)
{
user_is_dragging_mouse = false;
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_wheel_up (
unsigned long
)
{
if (rect.contains(lastx,lasty) && enabled && !hidden)
{
if (need_v_scroll())
{
long pos = vsb.slider_pos();
vsb.set_slider_pos(pos-(long)v_wheel_scroll_bar_inc);
on_v_scroll();
}
else if (need_h_scroll())
{
long pos = hsb.slider_pos();
hsb.set_slider_pos(pos-(long)h_wheel_scroll_bar_inc);
on_h_scroll();
}
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
draw (
const canvas& c
) const
{
style->draw_scrollable_region_border(c, rect, enabled);
}
// ----------------------------------------------------------------------------------------
bool scrollable_region::
need_h_scroll (
) const
{
if (total_rect_.width() > rect.width()-style->get_border_size()*2)
{
return true;
}
else
{
// check if we would need a vertical scroll bar and if adding one would make us need
// a horizontal one
if (total_rect_.height() > rect.height()-style->get_border_size()*2 &&
total_rect_.width() > rect.width()-style->get_border_size()*2-vsb.width())
return true;
else
return false;
}
}
// ----------------------------------------------------------------------------------------
bool scrollable_region::
need_v_scroll (
) const
{
if (total_rect_.height() > rect.height()-style->get_border_size()*2)
{
return true;
}
else
{
// check if we would need a horizontal scroll bar and if adding one would make us need
// a vertical_scroll_pos one
if (total_rect_.width() > rect.width()-style->get_border_size()*2 &&
total_rect_.height() > rect.height()-style->get_border_size()*2-hsb.height())
return true;
else
return false;
}
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_h_scroll (
)
{
total_rect_ = move_rect(total_rect_, display_rect_.left()-hscroll_bar_inc*hsb.slider_pos(), total_rect_.top());
parent.invalidate_rectangle(display_rect_);
if (events_are_enabled())
on_view_changed();
}
// ----------------------------------------------------------------------------------------
void scrollable_region::
on_v_scroll (
)
{
total_rect_ = move_rect(total_rect_, total_rect_.left(), display_rect_.top()-vscroll_bar_inc*vsb.slider_pos());
parent.invalidate_rectangle(display_rect_);
if (events_are_enabled())
on_view_changed();
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// class popup_menu_region
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
popup_menu_region::
popup_menu_region(
drawable_window& w
) :
drawable(w,MOUSE_CLICK | KEYBOARD_EVENTS | FOCUS_EVENTS | WINDOW_MOVED),
popup_menu_shown(false)
{
menu_.set_on_hide_handler(*this,&popup_menu_region::on_menu_becomes_hidden);
enable_events();
}
// ----------------------------------------------------------------------------------------
popup_menu_region::
~popup_menu_region(
)
{
disable_events();
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
set_size (
unsigned long width,
unsigned long height
)
{
auto_mutex M(m);
rect = resize_rect(rect,width,height);
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
set_rect (
const rectangle& new_rect
)
{
auto_mutex M(m);
rect = new_rect;
}
// ----------------------------------------------------------------------------------------
popup_menu& popup_menu_region::
menu (
)
{
return menu_;
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
hide (
)
{
auto_mutex M(m);
drawable::hide();
menu_.hide();
popup_menu_shown = false;
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
disable (
)
{
auto_mutex M(m);
drawable::disable();
menu_.hide();
popup_menu_shown = false;
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_keydown (
unsigned long key,
bool is_printable,
unsigned long state
)
{
if (enabled && !hidden && popup_menu_shown)
{
menu_.forwarded_on_keydown(key, is_printable, state);
}
else if (popup_menu_shown)
{
menu_.hide();
popup_menu_shown = false;
}
if (key == (unsigned long)base_window::KEY_ESC)
{
menu_.hide();
popup_menu_shown = false;
}
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_menu_becomes_hidden (
)
{
popup_menu_shown = false;
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_focus_lost (
)
{
if (popup_menu_shown)
{
menu_.hide();
popup_menu_shown = false;
}
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_focus_gained (
)
{
if (popup_menu_shown)
{
menu_.hide();
popup_menu_shown = false;
}
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_window_moved(
)
{
if (popup_menu_shown)
{
menu_.hide();
popup_menu_shown = false;
}
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
on_mouse_down (
unsigned long btn,
unsigned long ,
long x,
long y,
bool
)
{
if (enabled && !hidden && rect.contains(x,y) && btn == base_window::RIGHT)
{
long orig_x, orig_y;
parent.get_pos(orig_x, orig_y);
menu_.set_pos(orig_x+x, orig_y+y);
menu_.show();
popup_menu_shown = true;
}
else if (popup_menu_shown)
{
menu_.hide();
popup_menu_shown = false;
}
}
// ----------------------------------------------------------------------------------------
void popup_menu_region::
draw (
const canvas&
) const
{
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_BASE_WIDGETs_CPP_