299 lines
8.4 KiB
C++
299 lines
8.4 KiB
C++
/*
|
|
* A Picture Implementation
|
|
* Copyright(C) 2003-2013 Jinhao(cnjinhao@hotmail.com)
|
|
*
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE_1_0.txt or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*
|
|
* @file: nana/gui/widgets/picture.cpp
|
|
* @description:
|
|
* Used for showing a picture
|
|
*/
|
|
|
|
#include <nana/gui/widgets/picture.hpp>
|
|
#include <nana/paint/image.hpp>
|
|
|
|
namespace nana
|
|
{
|
|
namespace xpicture
|
|
{
|
|
|
|
//class picture_drawer
|
|
picture_drawer::picture_drawer():graph_(nullptr)
|
|
{
|
|
bground_.horizontal = true;
|
|
backimg_.arg = nana::arrange::unknown;
|
|
backimg_.beg = backimg_.end = 0;
|
|
}
|
|
|
|
void picture_drawer::attached(widget_reference& widget, graph_reference graph)
|
|
{
|
|
widget_ = &widget;
|
|
graph_ = &graph;
|
|
}
|
|
|
|
void picture_drawer::load(const nana::char_t* file)
|
|
{
|
|
backimg_.image.open(file);
|
|
}
|
|
|
|
void picture_drawer::load(const nana::paint::image& img)
|
|
{
|
|
backimg_.image = img;
|
|
}
|
|
|
|
void picture_drawer::set_shadow_background(const ::nana::color& from, const ::nana::color& to, bool horizontal)
|
|
{
|
|
bground_.gradual_from = from;
|
|
bground_.gradual_to = to;
|
|
bground_.horizontal = horizontal;
|
|
|
|
_m_draw_background();
|
|
}
|
|
|
|
bool picture_drawer::bgstyle(bool is_stretch, nana::arrange arg, int beg, int end)
|
|
{
|
|
if(backimg_.image)
|
|
{
|
|
backimg_.is_stretch = is_stretch;
|
|
backimg_.arg = arg;
|
|
|
|
if(arg == nana::arrange::horizontal_vertical) return false;
|
|
|
|
if(beg < 0) beg = 0;
|
|
if(end < beg) end = beg;
|
|
if((backimg_.beg == beg) && (backimg_.end == end)) return false;
|
|
|
|
nana::size imgsize = backimg_.image.size();
|
|
unsigned scale = (arg == nana::arrange::horizontal ? imgsize.width : imgsize.height);
|
|
|
|
if(beg < 0)
|
|
beg = 0;
|
|
else if(static_cast<unsigned>(beg) >= scale)
|
|
beg = static_cast<int>(scale) - 1;
|
|
|
|
if(end < beg)
|
|
end = beg;
|
|
else if(static_cast<unsigned>(end) >= scale)
|
|
end = static_cast<int>(scale) - 1;
|
|
|
|
backimg_.beg = beg;
|
|
backimg_.end = end;
|
|
return true;
|
|
}
|
|
|
|
backimg_.arg = nana::arrange::unknown;
|
|
return false;
|
|
}
|
|
|
|
void picture_drawer::refresh(graph_reference graph)
|
|
{
|
|
if(graph.changed())
|
|
{
|
|
_m_draw_background();
|
|
if(backimg_.image.empty() == false)
|
|
{
|
|
nana::size imgsize = backimg_.image.size();
|
|
nana::size gsize = graph.size();
|
|
|
|
switch(backimg_.arg)
|
|
{
|
|
case nana::arrange::unknown:
|
|
backimg_.image.paste(graph, 0, 0);
|
|
break;
|
|
case nana::arrange::horizontal:
|
|
if(backimg_.beg < backimg_.end)
|
|
{
|
|
unsigned block_tail = imgsize.width - backimg_.end;
|
|
|
|
if(backimg_.beg)
|
|
backimg_.image.paste(nana::rectangle(0, 0, backimg_.beg, imgsize.height), graph, nana::point());
|
|
|
|
if(block_tail)
|
|
backimg_.image.paste(nana::rectangle(static_cast<int>(imgsize.width - block_tail), 0, block_tail, imgsize.height), graph, nana::point(gsize.width - block_tail, 0));
|
|
|
|
if(backimg_.beg < backimg_.end)
|
|
{
|
|
unsigned fixed_size = backimg_.beg + block_tail;
|
|
if(fixed_size < gsize.width)
|
|
{
|
|
if(false == backimg_.is_stretch)
|
|
{
|
|
unsigned imgarea = backimg_.end - backimg_.beg;
|
|
fixed_size = gsize.width - fixed_size;
|
|
|
|
nana::rectangle r(backimg_.beg, 0, imgarea, imgsize.height);
|
|
nana::point p_dst(backimg_.beg, 0);
|
|
|
|
while(imgarea < fixed_size)
|
|
{
|
|
backimg_.image.paste(r, graph, p_dst);
|
|
p_dst.x += static_cast<int>(imgarea);
|
|
fixed_size -= imgarea;
|
|
}
|
|
if(fixed_size)
|
|
{
|
|
r.width = fixed_size;
|
|
backimg_.image.paste(r, graph, p_dst);
|
|
}
|
|
}
|
|
else
|
|
backimg_.image.stretch(nana::rectangle(backimg_.beg, 0, imgsize.width - fixed_size, imgsize.height), graph, nana::rectangle(backimg_.beg, 0, gsize.width - fixed_size, imgsize.height));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(false == backimg_.is_stretch)
|
|
{
|
|
int x = 0;
|
|
while(x < static_cast<int>(gsize.width))
|
|
{
|
|
backimg_.image.paste(graph, x, 0);
|
|
x += static_cast<int>(imgsize.width);
|
|
}
|
|
}
|
|
else
|
|
backimg_.image.stretch(imgsize, graph, nana::size(gsize.width, imgsize.height));
|
|
}
|
|
break;
|
|
case nana::arrange::vertical:
|
|
if(backimg_.beg < backimg_.end)
|
|
{
|
|
unsigned block_tail = imgsize.height - backimg_.end;
|
|
|
|
if(backimg_.beg)
|
|
backimg_.image.paste(nana::rectangle(0, 0, imgsize.width, static_cast<unsigned>(backimg_.beg)), graph, nana::point());
|
|
|
|
if(block_tail)
|
|
backimg_.image.paste(nana::rectangle(0, static_cast<int>(imgsize.height - block_tail), imgsize.width, block_tail), graph, nana::point(0, gsize.height - block_tail));
|
|
|
|
if(backimg_.beg < backimg_.end)
|
|
{
|
|
unsigned fixed_size = backimg_.beg + block_tail;
|
|
if(fixed_size < gsize.height)
|
|
{
|
|
if(false == backimg_.is_stretch)
|
|
{
|
|
unsigned imgarea = backimg_.end - backimg_.beg;
|
|
fixed_size = gsize.height - fixed_size;
|
|
|
|
nana::rectangle r(0, backimg_.beg, imgsize.width, imgarea);
|
|
nana::point pos(0, backimg_.beg);
|
|
|
|
while(imgarea < fixed_size)
|
|
{
|
|
backimg_.image.paste(r, graph, pos);
|
|
pos.y += static_cast<int>(imgarea);
|
|
fixed_size -= imgarea;
|
|
}
|
|
if(fixed_size)
|
|
{
|
|
r.height = fixed_size;
|
|
backimg_.image.paste(r, graph, pos);
|
|
}
|
|
}
|
|
else
|
|
backimg_.image.stretch(nana::rectangle(0, backimg_.beg, imgsize.width, imgsize.height - fixed_size), graph, nana::rectangle(0, backimg_.beg, imgsize.width, gsize.height - fixed_size));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(false == backimg_.is_stretch)
|
|
{
|
|
int y = 0;
|
|
while(y < static_cast<int>(gsize.height))
|
|
{
|
|
backimg_.image.paste(graph, 0, y);
|
|
y += static_cast<int>(imgsize.height);
|
|
}
|
|
}
|
|
else
|
|
backimg_.image.stretch(imgsize, graph, nana::rectangle(0, 0, imgsize.width, gsize.height));
|
|
}
|
|
break;
|
|
case nana::arrange::horizontal_vertical:
|
|
if(backimg_.is_stretch == false)
|
|
{
|
|
int y = 0;
|
|
while(y < static_cast<int>(gsize.height))
|
|
{
|
|
int x = 0;
|
|
while(x < static_cast<int>(gsize.width))
|
|
{
|
|
backimg_.image.paste(graph, x, y);
|
|
x += static_cast<int>(imgsize.width);
|
|
}
|
|
y += static_cast<int>(imgsize.height);
|
|
}
|
|
}
|
|
else
|
|
backimg_.image.stretch(imgsize, graph, gsize);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void picture_drawer::_m_draw_background()
|
|
{
|
|
if(graph_ && (bground_mode::basic != API::effects_bground_mode(*widget_)))
|
|
{
|
|
if (bground_.gradual_from.invisible() || bground_.gradual_to.invisible())
|
|
graph_->rectangle(true, widget_->bgcolor());
|
|
else if(bground_.gradual_from == bground_.gradual_to)
|
|
graph_->rectangle(true, bground_.gradual_from);
|
|
else
|
|
graph_->gradual_rectangle(graph_->size(), bground_.gradual_from, bground_.gradual_to, !bground_.horizontal);
|
|
}
|
|
}
|
|
//end class picture_drawer
|
|
}//end namespace xpicture
|
|
|
|
//class picture
|
|
picture::picture(){}
|
|
|
|
picture::picture(window wd, bool visible)
|
|
{
|
|
create(wd, rectangle(), visible);
|
|
}
|
|
|
|
picture::picture(window wd, const nana::rectangle& r, bool visible)
|
|
{
|
|
create(wd, r, visible);
|
|
}
|
|
|
|
void picture::load(const nana::paint::image& img)
|
|
{
|
|
get_drawer_trigger().load(img);
|
|
API::refresh_window(*this);
|
|
}
|
|
|
|
void picture::bgstyle(bool stretchable, nana::arrange arg, int beg, int end)
|
|
{
|
|
if(get_drawer_trigger().bgstyle(stretchable, arg, beg, end))
|
|
API::refresh_window(*this);
|
|
}
|
|
|
|
void picture::set_gradual_background(const ::nana::color& from, const ::nana::color& to, bool horizontal)
|
|
{
|
|
get_drawer_trigger().set_shadow_background(from, to, horizontal);
|
|
}
|
|
|
|
void picture::transparent(bool enabled)
|
|
{
|
|
if(enabled)
|
|
API::effects_bground(*this, effects::bground_transparent(0), 0.0);
|
|
else
|
|
API::effects_bground_remove(*this);
|
|
}
|
|
|
|
bool picture::transparent() const
|
|
{
|
|
return (bground_mode::basic == API::effects_bground_mode(*this));
|
|
}
|
|
//end class picture
|
|
}//end namespace nana
|