coco
3344 lines
94 KiB
C++
3344 lines
94 KiB
C++
// 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_
|
|
|