mewin/nana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Jinhao 2016-09-25 22:24:22 +08:00
commit 61832c0a7c
62 changed files with 1910 additions and 1430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -43,3 +43,5 @@ CMakeFiles/
cmake_install.cmake
*.DS_Store
*.db
*.opendb

14
include/nana/detail/win32/platform_spec.hpp
View File

@ -17,13 +17,11 @@
#ifndef NANA_DETAIL_PLATFORM_SPEC_HPP
#define NANA_DETAIL_PLATFORM_SPEC_HPP
#include <nana/deploy.hpp>
#include <nana/gui/basis.hpp>
#include <nana/paint/image.hpp>
#include <nana/gui/detail/event_code.hpp>
#include <windows.h>
#include <map>
#include <memory>
#include <functional>
@ -174,6 +172,12 @@ namespace detail
class platform_spec
{
platform_spec();
platform_spec(const platform_spec&) = delete;
platform_spec& operator=(const platform_spec&) = delete;
platform_spec(platform_spec&&) = delete;
platform_spec& operator=(platform_spec&&) = delete;
public:
typedef drawable_impl_type::font_ptr_t font_ptr_t;
typedef ::nana::event_code event_code;
@ -194,7 +198,7 @@ namespace detail
::nana::paint::image big_icon;
};
platform_spec();
~platform_spec();
const font_ptr_t& default_native_font() const;
void default_native_font(const font_ptr_t&);
@ -207,8 +211,8 @@ namespace detail
void keep_window_icon(native_window_type, const paint::image&sml_icon, const paint::image& big_icon);
void release_window_icon(native_window_type);
private:
font_ptr_t def_font_ptr_;
std::map<native_window_type, window_icons> iconbase_;
struct implementation;
implementation * const impl_;
};
}//end namespace detail

27
include/nana/gui/detail/element_store.hpp
View File

@ -1,7 +1,7 @@
/*
* The Store for the Storage Of Elements
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -16,9 +16,7 @@
#include <nana/gui/element.hpp>
#include <nana/pat/cloneable.hpp>
#include <map>
#include <string>
#include <nana/push_ignore_diagnostic>
@ -28,27 +26,20 @@ namespace detail
{
class element_store
{
typedef ::nana::element::element_interface element_interface;
typedef pat::cloneable< ::nana::element::element_interface> cloneable_element;
using element_interface = ::nana::element::element_interface;
using cloneable_element = pat::cloneable< ::nana::element::element_interface>;
struct data
{
cloneable_element object;
::nana::element::element_interface * fast_ptr;
data();
};
struct store
{
std::map<std::string, data> table;
};
struct data;
public:
element_store();
~element_store();
element_interface * const * bground(const std::string&);
void bground(const std::string&, const pat::cloneable<element_interface>&);
void bground(const std::string&, pat::cloneable<element_interface>&&);
private:
store bground_;
struct implementation;
std::unique_ptr<implementation> impl_;
};
}//end namespace detail
}

153
include/nana/gui/detail/inner_fwd_implement.hpp
View File

@ -1,7 +1,7 @@
/*
* Implementations of Inner Forward Declaration
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2015 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -26,87 +26,32 @@ namespace nana{
{
class shortkey_container
{
struct item_type
{
window handle;
std::vector<unsigned long> keys;
};
struct item_type;
//Noncopyable
shortkey_container(const shortkey_container&) = delete;
shortkey_container& operator=(const shortkey_container&) = delete;
shortkey_container& operator=(shortkey_container&&) = delete;
public:
void clear()
{
keybase_.clear();
}
shortkey_container();
bool make(window wd, unsigned long key)
{
if (wd == nullptr) return false;
if (key < 0x61) key += (0x61 - 0x41);
shortkey_container(shortkey_container&&);
for (auto & m : keybase_)
{
if (m.handle == wd)
{
m.keys.push_back(key);
return true;
}
}
~shortkey_container();
item_type m;
m.handle = wd;
m.keys.push_back(key);
keybase_.push_back(m);
void clear();
return true;
}
bool make(window wd, unsigned long key);
void umake(window wd)
{
if (wd == nullptr) return;
void umake(window wd);
for (auto i = keybase_.begin(), end = keybase_.end(); i != end; ++i)
{
if (i->handle == wd)
{
keybase_.erase(i);
break;
}
}
}
std::vector<unsigned long> keys(window wd) const;
std::vector<unsigned long> keys(window wd) const
{
std::vector<unsigned long> v;
if (wd)
{
for (auto & m : keybase_)
{
if (m.handle == wd)
{
v = m.keys;
break;
}
}
}
return v;
}
window find(unsigned long key) const
{
if (key < 0x61) key += (0x61 - 0x41);
for (auto & m : keybase_)
{
for (auto n : m.keys)
{
if (key == n)
return m.handle;
}
}
return nullptr;
}
window find(unsigned long key) const;
private:
std::vector<item_type> keybase_;
struct implementation;
implementation * impl_;
};
@ -118,57 +63,39 @@ namespace nana{
struct condition_rep
{
bool ignore_tab{ false }; //ignore tab when the focus is changed by TAB key.
basic_window* pressed{ nullptr }; //The handle to a window which has been pressed by mouse left button.
basic_window* pressed_by_space{ nullptr }; //The handle to a window which has been pressed by SPACEBAR key.
basic_window* hovered{ nullptr }; //the latest window that mouse moved
bool ignore_tab; //ignore tab when the focus is changed by TAB key.
basic_window* pressed; //The handle to a window which has been pressed by mouse left button.
basic_window* pressed_by_space; //The handle to a window which has been pressed by SPACEBAR key.
basic_window* hovered; //the latest window that mouse moved
}condition;
root_misc(basic_window * wd, unsigned width, unsigned height)
: window(wd),
root_graph({ width, height })
{}
root_misc(root_misc&&);
root_misc(basic_window * wd, unsigned width, unsigned height);
};//end struct root_misc
class root_register
{
//Noncopyable
root_register(const root_register&) = delete;
root_register& operator=(const root_register&) = delete;
//Nonmovable
root_register(root_register&&) = delete;
root_register& operator=(root_register&&) = delete;
public:
root_misc* insert(native_window_type wd, const root_misc& misc)
{
recent_ = wd;
auto ret = table_.insert(std::make_pair(wd, misc));
misc_ptr_ = &(ret.first->second);
return misc_ptr_;
}
root_register();
~root_register();
root_misc * find(native_window_type wd)
{
if (wd == recent_)
return misc_ptr_;
root_misc* insert(native_window_type, root_misc&&);
recent_ = wd;
auto i = table_.find(wd);
if (i != table_.end())
misc_ptr_ = &(i->second);
else
misc_ptr_ = nullptr;
root_misc * find(native_window_type);
return misc_ptr_;
}
void erase(native_window_type wd)
{
table_.erase(wd);
recent_ = wd;
misc_ptr_ = nullptr;
}
void erase(native_window_type);
private:
//Cached
mutable native_window_type recent_{nullptr};
mutable root_misc * misc_ptr_{nullptr};
std::map<native_window_type, root_misc> table_;
struct implementation;
implementation * const impl_;
};
}
}//end namespace nana

25
include/nana/gui/detail/window_manager.hpp
View File

@ -20,18 +20,11 @@
#include <nana/push_ignore_diagnostic>
#include <vector>
#include "window_layout.hpp"
#include "event_code.hpp"
#include "inner_fwd.hpp"
#include <functional>
#if defined(STD_THREAD_NOT_SUPPORTED)
#include <nana/std_mutex.hpp>
#else
#include <mutex>
#endif
namespace nana
{
class widget; //forward declaration
@ -51,15 +44,14 @@ namespace detail
class window_manager
{
class revertible_mutex
: public std::recursive_mutex
{
struct thr_refcnt
{
unsigned tid;
std::size_t refcnt;
};
revertible_mutex(const revertible_mutex&) = delete;
revertible_mutex& operator=(const revertible_mutex&) = delete;
revertible_mutex(revertible_mutex&&) = delete;
revertible_mutex& operator=(revertible_mutex&&) = delete;
public:
revertible_mutex();
~revertible_mutex();
void lock();
bool try_lock();
@ -68,8 +60,8 @@ namespace detail
void revert();
void forward();
private:
thr_refcnt thr_;
std::vector<thr_refcnt> stack_;
struct implementation;
implementation * const impl_;
};
public:
using native_window = native_window_type;
@ -90,7 +82,6 @@ namespace detail
bool available(core_window_t*);
bool available(core_window_t *, core_window_t*);
bool available(native_window_type);
core_window_t* create_root(core_window_t*, bool nested, rectangle, const appearance&, widget*);
core_window_t* create_widget(core_window_t*, const rectangle&, bool is_lite, widget*);
@ -157,7 +148,7 @@ namespace detail
bool calc_window_point(core_window_t*, nana::point&);
root_misc* root_runtime(native_window_type) const;
root_misc* root_runtime(native_window) const;
bool register_shortkey(core_window_t*, unsigned long key);
void unregister_shortkey(core_window_t*, bool with_children);

10
include/nana/gui/element.hpp
View File

@ -16,7 +16,6 @@
#include <nana/paint/graphics.hpp>
#include <nana/pat/cloneable.hpp>
#include <vector>
#include <map>
namespace nana
{
@ -338,13 +337,8 @@ namespace nana
struct draw_image;
struct draw_graph;
draw_method * method_;
bool vertical_;
nana::rectangle valid_area_;
std::vector<element_state> states_;
std::map<element_state, element_state> join_;
bool stretch_all_;
unsigned left_, top_, right_, bottom_;
struct implementation;
std::unique_ptr<implementation> impl_;
}; //end class bground
}//end namespace element
}//end namespace nana

1
include/nana/gui/place.hpp
View File

@ -17,7 +17,6 @@
#define NANA_GUI_PLACE_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/basis.hpp>
#include <utility>
#include <memory>
#include <functional>

3
include/nana/gui/programming_interface.hpp
View File

@ -347,7 +347,8 @@ namespace API
* When you are finished with the caret, be sure to reset the pointer.
*
* @param window_handle A handle to a window whose caret is to be retrieved
* @return a pointer to the caret proxy. nullptr if the window doesn't have a caret.
* @return a pointer to the caret proxy.
* @except throws std::runtime if the window doesn't have a caret when disable_throw is false
*/
::std::unique_ptr<caret_interface> open_caret(window window_handle, bool disable_throw = false);

13
include/nana/gui/widgets/detail/inline_widget.hpp
View File

@ -1,7 +1,7 @@
/**
* A Inline Widget Interface Definition
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2015 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -35,6 +35,9 @@ namespace nana
/// Returns the host widget of the indicator
virtual ::nana::widget& host() const = 0;
/// Returns the position of column
virtual std::size_t column() const = 0;
/// Modifies the value of a item specified by pos
virtual void modify(index_type pos, const value_type&) const = 0;
@ -45,7 +48,7 @@ namespace nana
virtual void hovered(index_type) = 0;
};
template<typename Index, typename Value>
template<typename Index, typename Status, typename Value>
class inline_widget_notifier_interface
{
public:
@ -55,6 +58,9 @@ namespace nana
/// A type to the value of the item
using value_type = Value;
/// A type to the status
using status_type = Status;
/// A typedef name of a inline widget indicator
using inline_indicator = inline_widget_indicator<index_type, value_type>;
@ -70,6 +76,9 @@ namespace nana
/// A message to activate the inline widget to attach a specified item
virtual void activate(inline_indicator&, index_type) = 0;
/// A message to change the status
virtual void notify_status(status_type, bool) = 0;
/// A message to resize the inline widget
virtual void resize(const size&) = 0;

14
include/nana/gui/widgets/listbox.hpp
View File

@ -676,8 +676,14 @@ namespace nana
using index_pairs = ::std::vector<index_pair>;
using inline_notifier_interface = detail::inline_widget_notifier_interface<index_pair, ::std::string>;
enum class inline_widget_status{
checked,
checking,
selected,
selecting
};
using inline_notifier_interface = detail::inline_widget_notifier_interface<index_pair, inline_widget_status, ::std::string>;
// struct essence
//@brief: this struct gives many data for listbox,
@ -720,7 +726,7 @@ namespace nana
class iresolver
{
public:
iresolver(const std::vector<cell>&);
iresolver(std::vector<cell>);
iresolver& operator>>(bool&);
iresolver& operator>>(short&);
@ -740,7 +746,7 @@ namespace nana
iresolver& operator>>(cell&);
iresolver& operator>>(std::nullptr_t);
private:
const std::vector<cell>& cells_;
std::vector<cell> cells_;
std::size_t pos_{0};
};
@ -918,7 +924,7 @@ namespace nana
//Undocumented method
essence * _m_ess() const;
private:
std::vector<cell> & _m_cells() const;
std::vector<cell> _m_cells() const;
nana::any * _m_value(bool alloc_if_empty);
const nana::any * _m_value() const;
private:

188
include/nana/gui/widgets/skeletons/text_editor.hpp
View File

@ -17,109 +17,26 @@
#include "textbase.hpp"
#include "text_editor_part.hpp"
#include <nana/gui/widgets/scroll.hpp>
#include <nana/unicode_bidi.hpp>
//#include <nana/paint/graphics.hpp>
#include <nana/gui/detail/general_events.hpp>
#include <functional>
namespace nana
{
namespace paint
{
// Forward declaration
class graphics;
}
}
namespace nana{ namespace widgets
{
namespace skeletons
{
template<typename EnumCommand>
class undoable_command_interface
{
public:
virtual ~undoable_command_interface() = default;
virtual EnumCommand get() const = 0;
virtual bool merge(const undoable_command_interface&) = 0;
virtual void execute(bool redo) = 0;
};
template<typename EnumCommand>
class undoable
{
public:
using command = EnumCommand;
using container = std::deque < std::unique_ptr<undoable_command_interface<command>> >;
void clear()
{
commands_.clear();
pos_ = 0;
}
void max_steps(std::size_t maxs)
{
max_steps_ = maxs;
if (maxs && (commands_.size() >= maxs))
commands_.erase(commands_.begin(), commands_.begin() + (commands_.size() - maxs + 1));
}
std::size_t max_steps() const
{
return max_steps_;
}
void enable(bool enb)
{
enabled_ = enb;
if (!enb)
clear();
}
bool enabled() const
{
return enabled_;
}
void push(std::unique_ptr<undoable_command_interface<command>> && ptr)
{
if (!ptr || !enabled_)
return;
if (pos_ < commands_.size())
commands_.erase(commands_.begin() + pos_, commands_.end());
else if (max_steps_ && (commands_.size() >= max_steps_))
commands_.erase(commands_.begin(), commands_.begin() + (commands_.size() - max_steps_ + 1));
pos_ = commands_.size();
if (!commands_.empty())
{
if (commands_.back().get()->merge(*ptr))
return;
}
commands_.emplace_back(std::move(ptr));
++pos_;
}
std::size_t count(bool is_undo) const
{
return (is_undo ? pos_ : commands_.size() - pos_);
}
void undo()
{
if (pos_ > 0)
{
--pos_;
commands_[pos_].get()->execute(false);
}
}
void redo()
{
if (pos_ != commands_.size())
commands_[pos_++].get()->execute(true);
}
private:
container commands_;
bool enabled_{ true };
std::size_t max_steps_{ 30 };
std::size_t pos_{ 0 };
};
class text_editor
{
struct attributes;
@ -136,9 +53,14 @@ namespace nana{ namespace widgets
class undo_input_text;
class undo_move_text;
struct keywords;
class keyword_parser;
class helper_pencil;
text_editor(const text_editor&) = delete;
text_editor& operator=(const text_editor&) = delete;
text_editor(text_editor&&) = delete;
text_editor& operator=(text_editor&&) = delete;
public:
using char_type = wchar_t;
using size_type = textbase<char_type>::size_type;
@ -148,9 +70,10 @@ namespace nana{ namespace widgets
using graph_reference = ::nana::paint::graphics&;
struct ext_renderer_tag
struct renderers
{
std::function<void(graph_reference, const nana::rectangle& text_area, const ::nana::color&)> background;
std::function<void(graph_reference, const nana::rectangle& text_area, const ::nana::color&)> background; ///< a customized background renderer
std::function<void(graph_reference, const ::nana::color&)> border; ///< a customized border renderer
};
enum class accepts
@ -178,11 +101,10 @@ namespace nana{ namespace widgets
/// Determine whether the text_editor is line wrapped.
bool line_wrapped() const;
/// Set the text_editor whether it is line wrapped, it returns false if the state is not changed.
bool line_wrapped(bool);
void border_renderer(std::function<void(graph_reference, const ::nana::color& bgcolor)>);
bool load(const char*);
/// Sets the text area.
@ -196,7 +118,13 @@ namespace nana{ namespace widgets
const attributes & attr() const;
bool multi_lines(bool);
void editable(bool);
/// Enables/disables the editability of text_editor
/**
* @param enable Indicates whether to enable or disable the editability
* @param enable_cart Indicates whether to show or hide the caret when the text_editor is not editable. It is ignored if enable is false.
*/
void editable(bool enable, bool enable_caret);
void enable_background(bool);
void enable_background_counterpart(bool);
@ -205,7 +133,7 @@ namespace nana{ namespace widgets
void undo_max_steps(std::size_t);
std::size_t undo_max_steps() const;
ext_renderer_tag& ext_renderer() const;
renderers& customized_renderers();
unsigned line_height() const;
unsigned screen_lines() const;
@ -215,7 +143,11 @@ namespace nana{ namespace widgets
std::wstring text() const;
/// Sets caret position through text coordinate.
void move_caret(const upoint&);
/**
* @param pos the text position
* @param reset indicates whether to reset the text position by the pos. If this parameter is true, the text position is set by pos. If the parameter is false, it only moves the UI caret to the specified position.
*/
bool move_caret(const upoint& pos, bool reset = false);
void move_caret_end();
void reset_caret_pixels() const;
void reset_caret();
@ -223,6 +155,8 @@ namespace nana{ namespace widgets
bool selected() const;
bool select(bool);
bool get_select_points(nana::upoint&, nana::upoint&) const;
/// Sets the end position of a selected string.
void set_end_caret();
@ -254,6 +188,7 @@ namespace nana{ namespace widgets
void del();
void backspace(bool record_undo = true);
void undo(bool reverse);
void set_undo_queue_length(std::size_t len);
void move_ns(bool to_north); //Moves up and down
void move_left();
void move_right();
@ -267,8 +202,8 @@ namespace nana{ namespace widgets
bool mouse_move(bool left_button, const point& screen_pos);
bool mouse_pressed(const arg_mouse& arg);
skeletons::textbase<wchar_t>& textbase();
const skeletons::textbase<wchar_t>& textbase() const;
skeletons::textbase<char_type>& textbase();
const skeletons::textbase<char_type>& textbase() const;
private:
void _m_pre_calc_lines(std::size_t line_off, std::size_t lines);
@ -276,7 +211,9 @@ namespace nana{ namespace widgets
::nana::color _m_bgcolor() const;
bool _m_scroll_text(bool vertical);
void _m_scrollbar();
::nana::size _m_text_area() const;
::nana::rectangle _m_text_area() const;
void _m_get_scrollbar_size();
void _m_reset();
::nana::upoint _m_put(::std::wstring);
@ -295,9 +232,6 @@ namespace nana{ namespace widgets
int _m_text_top_base() const;
/// Returns the right/bottom point of text area.
int _m_end_pos(bool right) const;
void _m_draw_parse_string(const keyword_parser&, bool rtl, ::nana::point pos, const ::nana::color& fgcolor, const wchar_t*, std::size_t len) const;
//_m_draw_string
//@brief: Draw a line of string
@ -306,54 +240,35 @@ namespace nana{ namespace widgets
//@brief: redraw whole line specified by caret pos.
//@return: true if caret overs the border
bool _m_update_caret_line(std::size_t secondary_before);
bool _m_get_sort_select_points(nana::upoint&, nana::upoint&) const;
void _m_offset_y(int y);
unsigned _m_char_by_pixels(const unicode_bidi::entity&, unsigned pos);
unsigned _m_pixels_by_char(const ::std::wstring&, ::std::size_t pos) const;
void _handle_move_key(const arg_keyboard& arg);
void _m_handle_move_key(const arg_keyboard& arg);
void _m_draw_border();
private:
std::unique_ptr<editor_behavior_interface> behavior_;
undoable<command> undo_;
struct implementation;
implementation * const impl_;
nana::window window_;
std::unique_ptr<caret_interface> caret_;
graph_reference graph_;
const text_editor_scheme* scheme_;
event_interface * event_handler_{ nullptr };
std::unique_ptr<keywords> keywords_;
skeletons::textbase<wchar_t> textbase_;
wchar_t mask_char_{0};
mutable ext_renderer_tag ext_renderer_;
std::vector<upoint> text_position_; //position of text from last rendering.
struct indent_rep
{
bool enabled{ false };
std::function<std::string()> generator;
}indent_;
struct attributes
{
accepts acceptive{ accepts::no_restrict };
std::function<bool(char_type)> pred_acceptive;
::std::string tip_string;
bool line_wrapped{false};
bool multi_lines{true};
bool editable{true};
bool enable_caret{ true }; ///< Indicates whether to show or hide caret when text_editor is not editable
bool enable_background{true};
bool enable_counterpart{false};
nana::paint::graphics counterpart; //this is used to keep the background that painted by external part.
std::unique_ptr<nana::scroll<true>> vscroll;
std::unique_ptr<nana::scroll<false>> hscroll;
}attributes_;
struct text_area_type
@ -365,7 +280,6 @@ namespace nana{ namespace widgets
unsigned scroll_pixels;
unsigned vscroll;
unsigned hscroll;
std::function<void(nana::paint::graphics&, const ::nana::color&)> border_renderer;
}text_area_;
struct selection

4
include/nana/gui/widgets/slider.hpp
View File

@ -1,7 +1,7 @@
/**
* A Slider Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2015 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -134,7 +134,7 @@ namespace nana
}//end namespace drawerbase
/// A slider widget wich the user can drag for tracking \todo add scheme ?
/// A slider widget wich the user can drag for tracking
class slider
: public widget_object<category::widget_tag, drawerbase::slider::trigger, drawerbase::slider::slider_events, drawerbase::slider::scheme_impl>
{

15
include/nana/gui/widgets/textbox.hpp
View File

@ -184,6 +184,9 @@ namespace nana
bool editable() const;
textbox& editable(bool);
/// Enables the caret if the textbox currently is not editable
textbox& enable_caret();
void set_accept(std::function<bool(wchar_t)>);
textbox& tip_string(::std::string);
@ -197,6 +200,12 @@ namespace nana
/// Selects/unselects all text.
void select(bool);
/// Returns the bounds of a text selection
/**
* @return no selection if pair.first == pair.second.
*/
std::pair<upoint, upoint> selection() const;
void copy() const; ///< Copies the selected text into shared memory, such as clipboard under Windows.
void paste(); ///< Pastes the text from shared memory.
void del();
@ -228,6 +237,12 @@ namespace nana
/// E.g. Whether caret moves to left of selected content or moves to left of last position when left arrow key is pressed.
/// @param move_to_end determines whether to move caret to left of selected_content or to left of last position.
void select_behavior(bool move_to_end);
/// Sets the undo/redo queue length
/**
* @param len The length of the queue. If this parameter is zero, the undo/redo is disabled.
*/
void set_undo_queue_length(std::size_t len);
protected:
//Overrides widget's virtual functions
native_string_type _m_caption() const throw() override;

69
include/nana/gui/widgets/widget.hpp
View File

@ -28,14 +28,25 @@ namespace nana
/// Abstract class for defining the capacity interface.
class widget
: nana::noncopyable, nana::nonmovable
{
friend class detail::widget_notifier_interface;
class inner_widget_notifier;
typedef void(*dummy_bool_type)(widget* (*)(const widget&));
//Noncopyable
widget(const widget&) = delete;
widget& operator=(const widget&) = delete;
//Nonmovable
widget(widget&&) = delete;
widget& operator=(widget&&) = delete;
public:
using native_string_type = detail::native_string_type;
widget() = default;
virtual ~widget() = default;
virtual window handle() const = 0; ///< Returns the handle of window, returns 0 if window is not created.
bool empty() const; ///< Determines whether the manipulator is handling a window.
@ -147,11 +158,9 @@ namespace nana
: public widget
{
public:
~widget_base();
window handle() const override;
private:
void _m_notify_destroy() override final;
protected:
void _m_notify_destroy() override;
protected:
window handle_{ nullptr };
};
@ -172,6 +181,11 @@ namespace nana
scheme_{ API::dev::make_scheme<Scheme>() }
{}
~widget_object()
{
API::close_window(handle());
}
event_type& events() const
{
return *events_;
@ -228,6 +242,13 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
widget_base::_m_notify_destroy();
events_ = std::make_shared<Events>();
API::dev::set_events(handle_, events_);
}
private:
DrawerTrigger trigger_;
std::shared_ptr<Events> events_;
@ -248,6 +269,11 @@ namespace nana
: events_{ std::make_shared<Events>() }, scheme_{ API::dev::make_scheme<scheme_type>() }
{}
~widget_object()
{
API::close_window(handle());
}
event_type& events() const
{
return *events_;
@ -281,6 +307,13 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
widget_base::_m_notify_destroy();
events_ = std::make_shared<Events>();
API::dev::set_events(handle_, events_);
}
private:
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
@ -298,15 +331,8 @@ namespace nana
using event_type = Events;
widget_object()
: widget_object(nullptr, false, API::make_center(300, 150), appearance(), this)
{
handle_ = API::dev::create_window(nullptr, false, API::make_center(300, 150), appearance(), this);
_m_bind_and_attach();
}
widget_object(const rectangle& r, const appearance& apr = {})
{
handle_ = API::dev::create_window(nullptr, false, r, apr, this);
_m_bind_and_attach();
}
widget_object(window owner, bool nested, const rectangle& r = {}, const appearance& apr = {})
@ -315,6 +341,11 @@ namespace nana
_m_bind_and_attach();
}
~widget_object()
{
API::close_window(handle());
}
event_type& events() const
{
return *events_;
@ -415,6 +446,13 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
widget_base::_m_notify_destroy();
events_ = std::make_shared<Events>();
API::dev::set_events(handle_, events_);
}
private:
DrawerTrigger trigger_;
std::shared_ptr<Events> events_;
@ -440,6 +478,11 @@ namespace nana
: events_{ std::make_shared<Events>() }, scheme_{ API::dev::make_scheme<scheme_type>() }
{}
~widget_object()
{
API::close_window(handle());
}
event_type& events() const
{
return *events_;

3
include/nana/internationalization.hpp
View File

@ -12,7 +12,6 @@
#ifndef NANA_INTERNATIONALIZATION_HPP
#define NANA_INTERNATIONALIZATION_HPP
#include "basic_types.hpp"
#include <vector>
#include <sstream>
#include <functional>
@ -186,9 +185,7 @@ namespace nana
void _m_add_args(const std::string&);
void _m_add_args(std::string&&);
void _m_add_args(std::wstring&);
void _m_add_args(const std::wstring&);
void _m_add_args(std::wstring&&);
private:
std::string msgid_;
std::vector<std::unique_ptr<eval_arg>> args_;

35
include/nana/paint/graphics.hpp
View File

@ -1,7 +1,7 @@
/*
* Paint Graphics Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -17,7 +17,6 @@
#include "../basic_types.hpp"
#include "../gui/basis.hpp"
#include "pixel_buffer.hpp"
namespace nana
{
@ -72,12 +71,16 @@ namespace nana
class graphics
{
public:
typedef ::nana::native_window_type native_window_type;
graphics();
graphics(const ::nana::size&); ///< size in pixel
graphics(const graphics&); ///< the resource is not copyed, the two graphics objects refer to the *SAME* resource
graphics& operator=(const graphics&);
graphics(graphics&&);
graphics& operator=(graphics&&);
~graphics();
bool changed() const; ///< Returns true if the graphics object is operated
bool empty() const; ///< Returns true if the graphics object does not refer to any resource.
operator const void*() const;
@ -129,10 +132,10 @@ namespace nana
void flush();
unsigned width() const;
unsigned height() const; ///< Returns the height of the off-screen buffer.
unsigned width() const; ///< Returns the width of the off-screen buffer.
unsigned height() const; ///< Returns the height of the off-screen buffer.
::nana::size size() const;
void setsta(); ///< Clears the status if the graphics object had been changed
void setsta(); ///< Clears the status if the graphics object had been changed
void set_changed();
void release();
@ -172,12 +175,18 @@ namespace nana
void gradual_rectangle(const ::nana::rectangle&, const color& from, const color& to, bool vertical);
void round_rectangle(const ::nana::rectangle&, unsigned radius_x, unsigned radius_y, const color&, bool solid, const color& color_if_solid);
private:
std::shared_ptr< ::nana::detail::drawable_impl_type> dwptr_;
font font_shadow_;
drawable_type handle_;
::nana::size size_;
pixel_buffer pxbuf_;
bool changed_;
struct implementation;
std::unique_ptr<implementation> impl_;
};
class draw
{
public:
draw(graphics& graph);
void corner(const rectangle& r, unsigned pixels);
private:
graphics& graph_;
};
}//end namespace paint
} //end namespace nana

61
include/nana/pat/abstract_factory.hpp
View File

@ -1,7 +1,7 @@
/*
* A Generic Abstract Factory Pattern Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -15,6 +15,8 @@
#define NANA_PAT_ABSFACTORY_HPP
#include "cloneable.hpp"
#include <memory>
#include <tuple>
#include <type_traits>
namespace nana
{
@ -43,21 +45,68 @@ namespace nana
namespace detail
{
template<typename T, typename Interface>
template<typename Useless, std::size_t ...Index>
struct pack{
using type = pack;
};
template<bool Negative, bool Zero, class IntConst, class Pack>
struct make_pack_helper
{ // explodes gracefully below 0
static_assert(!Negative,
"make_integer_sequence<T, N> requires N to be non-negative.");
};
template<typename Useless, std::size_t ... Vals>
struct make_pack_helper<false, true,
std::integral_constant<std::size_t, 0>,
pack<Useless, Vals...> >
: pack<Useless, Vals...>
{ // ends recursion at 0
};
template<typename Useless, std::size_t X, std::size_t... Vals>
struct make_pack_helper<false, false,
std::integral_constant<std::size_t, X>,
pack<Useless, Vals...> >
: make_pack_helper<false, X == 1,
std::integral_constant<std::size_t, X - 1>,
pack<Useless, X - 1, Vals...> >
{ // counts down to 0
};
template<std::size_t Size>
using make_pack = typename make_pack_helper<Size < 0, Size == 0, std::integral_constant<std::size_t, Size>, pack<int> >::type;
template<typename T, typename Interface, typename ...Args>
class abs_factory
: public abstract_factory<Interface>
{
std::unique_ptr<Interface> create() override
{
return std::unique_ptr<Interface>{ new T };
constexpr auto Size = std::tuple_size<decltype(args_)>::value;
return std::unique_ptr<Interface>{ _m_new(make_pack<Size>{}) };
}
template<std::size_t ... Index>
Interface* _m_new(const pack<int, Index...> &)
{
return new T(std::get<Index>(args_)...);
}
public:
abs_factory(const Args&... args)
: args_(args...)
{
}
private:
std::tuple<Args...> args_;
};
}//end namespace detail
template<typename Type>
pat::cloneable<abstract_factory<typename Type::factory_interface>> make_factory()
template<typename Type, typename ...Args>
pat::cloneable<abstract_factory<typename Type::factory_interface>> make_factory(Args &&... args)
{
return detail::abs_factory<Type, typename Type::factory_interface>();
return detail::abs_factory<Type, typename Type::factory_interface, typename std::decay<Args>::type...>(std::forward<Args>(args)...);
}
}//end namespace pat
}//end namespace nana

6
include/nana/pat/cloneable.hpp
View File

@ -1,7 +1,7 @@
/*
* A Generic Cloneable Pattern Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -106,8 +106,8 @@ namespace nana{ namespace pat{
template<typename T, typename member_enabled<T>::type* = nullptr>
cloneable(T&& t)
: cwrapper_(new detail::cloneable_wrapper<typename std::remove_cv<typename std::remove_reference<T>::type>::type>(std::forward<T>(t)), detail::cloneable_interface_deleter()),
fast_ptr_(reinterpret_cast<typename std::remove_cv<typename std::remove_reference<T>::type>::type*>(cwrapper_->get()))
: cwrapper_(new detail::cloneable_wrapper<typename std::decay<T>::type>(std::forward<T>(t)), detail::cloneable_interface_deleter()),
fast_ptr_(reinterpret_cast<typename std::decay<T>::type*>(cwrapper_->get()))
{}
cloneable(const cloneable& r)

2
source/audio/detail/audio_device.cpp
View File

@ -184,7 +184,7 @@ namespace nana{namespace audio
{
#if defined(NANA_WINDOWS)
std::lock_guard<decltype(queue_lock_)> lock(queue_lock_);
done_queue_.push_back(m);
done_queue_.emplace_back(m);
if(m->dwFlags & WHDR_PREPARED)
wave_native_if.out_unprepare(handle_, m, sizeof(WAVEHDR));

6
source/audio/detail/buffer_preparation.cpp
View File

@ -30,7 +30,7 @@ namespace nana{ namespace audio
m->bufsize = ck.nAvgBytesPerSec;
m->buf = rawbuf + sizeof(meta);
#endif
prepared_.push_back(m);
prepared_.emplace_back(m);
}
thr_ = std::move(std::thread([this](){this->_m_prepare_routine();}));
@ -79,7 +79,7 @@ namespace nana{ namespace audio
{
std::lock_guard<decltype(token_prepared_)> lock(token_prepared_);
bool if_signal = prepared_.empty();
prepared_.push_back(m);
prepared_.emplace_back(m);
if(if_signal)
cond_prepared_.notify_one();
}
@ -148,7 +148,7 @@ namespace nana{ namespace audio
m->bufsize = buffered;
#endif
std::lock_guard<decltype(token_buffer_)> lock(token_buffer_);
buffer_.push_back(m);
buffer_.emplace_back(m);
if(wait_for_buffer_)
{
cond_buffer_.notify_one();

1
source/detail/platform_spec_posix.cpp
View File

@ -29,6 +29,7 @@
#include <nana/gui/detail/basic_window.hpp>
#include <nana/gui/detail/window_manager.hpp>
#include <nana/system/platform.hpp>
#include <nana/paint/pixel_buffer.hpp>
#include <errno.h>
#include <sstream>

28
source/detail/platform_spec_windows.cpp
View File

@ -16,10 +16,10 @@
#if defined(NANA_WINDOWS)
#include <shellapi.h>
#include <stdexcept>
#include <map>
#include <shellapi.h>
///////////////////////////////////////////////////////////////////////////////////////////////////////
@ -352,7 +352,14 @@ namespace detail
}
}
struct platform_spec::implementation
{
font_ptr_t def_font_ptr;
std::map<native_window_type, window_icons> iconbase;
};
platform_spec::platform_spec()
: impl_{ new implementation}
{
//Create default font object.
NONCLIENTMETRICS metrics = {};
@ -370,17 +377,22 @@ namespace detail
#endif
#endif
::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof metrics, &metrics, 0);
def_font_ptr_ = make_native_font(to_utf8(metrics.lfMessageFont.lfFaceName).c_str(), font_size_to_height(9), 400, false, false, false);
impl_->def_font_ptr = make_native_font(to_utf8(metrics.lfMessageFont.lfFaceName).c_str(), font_size_to_height(9), 400, false, false, false);
}
platform_spec::~platform_spec()
{
delete impl_;
}
const platform_spec::font_ptr_t& platform_spec::default_native_font() const
{
return def_font_ptr_;
return impl_->def_font_ptr;
}
void platform_spec::default_native_font(const font_ptr_t& fp)
{
def_font_ptr_ = fp;
impl_->def_font_ptr = fp;
}
unsigned platform_spec::font_size_to_height(unsigned size) const
@ -409,7 +421,7 @@ namespace detail
if (name && *name)
std::wcscpy(logfont.lfFaceName, to_wstring(name).c_str());
else
std::wcscpy(logfont.lfFaceName, def_font_ptr_->name.c_str());
std::wcscpy(logfont.lfFaceName, impl_->def_font_ptr->name.c_str());
logfont.lfCharSet = DEFAULT_CHARSET;
HDC hdc = ::GetDC(0);
@ -448,14 +460,14 @@ namespace detail
void platform_spec::keep_window_icon(native_window_type wd, const paint::image& sml_icon, const paint::image& big_icon)
{
auto & icons = iconbase_[wd];
auto & icons = impl_->iconbase[wd];
icons.sml_icon = sml_icon;
icons.big_icon = big_icon;
}
void platform_spec::release_window_icon(native_window_type wd)
{
iconbase_.erase(wd);
impl_->iconbase.erase(wd);
}
}//end namespace detail
}//end namespace nana

4
source/gui/detail/basic_window.cpp
View File

@ -402,7 +402,7 @@ namespace nana
root = agrparent->root;
root_graph = agrparent->root_graph;
index = static_cast<unsigned>(agrparent->children.size());
agrparent->children.push_back(this);
agrparent->children.emplace_back(this);
}
predef_cursor = cursor::arrow;
@ -442,8 +442,6 @@ namespace nana
bool basic_window::set_events(const std::shared_ptr<general_events>& p)
{
if (annex.events_ptr)
return false;
annex.events_ptr = p;
return true;
}

5
source/gui/detail/bedrock_pi.cpp
View File

@ -17,7 +17,7 @@
#include <sstream>
#include <nana/system/timepiece.hpp>
#include <nana/gui/wvl.hpp>
#include <nana/gui/detail/inner_fwd_implement.hpp>
#include <nana/gui/detail/basic_window.hpp>
#include <nana/gui/detail/native_window_interface.hpp>
#include <nana/gui/layout_utility.hpp>
#include <nana/gui/detail/element_store.hpp>
@ -25,6 +25,7 @@
namespace nana
{
//class internal_scope_guard
internal_scope_guard::internal_scope_guard()
{
@ -600,7 +601,7 @@ namespace nana
{
root = wd->root;
if (roots.cend() == std::find(roots.cbegin(), roots.cend(), root))
roots.push_back(root);
roots.emplace_back(root);
}
}

30
source/gui/detail/bedrock_posix.cpp
View File

@ -626,30 +626,38 @@ namespace detail
if(pressed_wd_space)
break;
msgwnd = wd_manager.find_window(native_window, xevent.xbutton.x, xevent.xbutton.y);
if(nullptr == msgwnd)
break;
if(xevent.xbutton.button == Button4 || xevent.xbutton.button == Button5)
{
//The hovered window receives the message, unlike in Windows, no redirection is required.
nana::point mspos{xevent.xbutton.x, xevent.xbutton.y};
while(msgwnd)
auto evt_wd = msgwnd;
while(evt_wd)
{
if(msgwnd->annex.events_ptr->mouse_wheel.length() != 0)
if(evt_wd->annex.events_ptr->mouse_wheel.length() != 0)
{
mspos -= msgwnd->pos_root;
arg_wheel arg;
arg.which = arg_wheel::wheel::vertical;
assign_arg(arg, msgwnd, xevent);
brock.emit(event_code::mouse_wheel, msgwnd, arg, true, &context);
assign_arg(arg, evt_wd, xevent);
brock.emit(event_code::mouse_wheel, evt_wd, arg, true, &context);
break;
}
msgwnd = msgwnd->parent;
evt_wd = evt_wd->parent;
}
if(msgwnd && (nullptr == evt_wd))
{
arg_wheel arg;
arg.which = arg_wheel::wheel::vertical;
assign_arg(arg, msgwnd, xevent);
draw_invoker(&drawer::mouse_wheel, msgwnd, arg, &context);
wd_manager.do_lazy_refresh(msgwnd, false);
}
}
else
{
msgwnd = wd_manager.find_window(native_window, xevent.xbutton.x, xevent.xbutton.y);
if(nullptr == msgwnd)
break;
msgwnd->set_action(mouse_action::normal);
if(msgwnd->flags.enabled)
{

5
source/gui/detail/bedrock_windows.cpp
View File

@ -1124,8 +1124,6 @@ namespace detail
if (evt_wd->annex.events_ptr->mouse_wheel.length() != 0)
{
def_window_proc = false;
nana::point mspos{ scr_pos.x, scr_pos.y };
wd_manager.calc_window_point(evt_wd, mspos);
arg_wheel arg;
arg.which = (WM_MOUSEHWHEEL == message ? arg_wheel::wheel::horizontal : arg_wheel::wheel::vertical);
@ -1138,9 +1136,6 @@ namespace detail
if (scrolled_wd && (nullptr == evt_wd))
{
nana::point mspos{ scr_pos.x, scr_pos.y };
wd_manager.calc_window_point(scrolled_wd, mspos);
arg_wheel arg;
arg.which = (WM_MOUSEHWHEEL == message ? arg_wheel::wheel::horizontal : arg_wheel::wheel::vertical);
assign_arg(arg, scrolled_wd, pmdec);

6
source/gui/detail/drawer.cpp
View File

@ -13,9 +13,9 @@
#include <nana/config.hpp>
#include <nana/gui/detail/bedrock.hpp>
#include <nana/gui/detail/drawer.hpp>
#include <nana/gui/detail/dynamic_drawing_object.hpp>
#include <nana/gui/detail/effects_renderer.hpp>
#include <nana/gui/detail/basic_window.hpp>
#include "dynamic_drawing_object.hpp"
#if defined(NANA_X11)
#include <nana/detail/linux_X11/platform_spec.hpp>
@ -338,7 +338,7 @@ namespace nana
for (auto p : data_impl_->draws)
{
if(p->diehard())
then.push_back(p);
then.emplace_back(p);
else
delete p;
}
@ -351,7 +351,7 @@ namespace nana
if(f)
{
auto p = new dynamic_drawing::user_draw_function(std::move(f), diehard);
data_impl_->draws.push_back(p);
data_impl_->draws.emplace_back(p);
return (diehard ? p : nullptr);
}
return nullptr;

0
include/nana/gui/detail/dynamic_drawing_object.hpp → source/gui/detail/dynamic_drawing_object.hpp
View File

38
source/gui/detail/element_store.cpp
View File

@ -1,7 +1,7 @@
/*
* The Store for the Storage Of Elements
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -11,35 +11,53 @@
*/
#include <nana/gui/detail/element_store.hpp>
#include <map>
namespace nana
{
namespace detail
{
//class element_store
element_store::data::data()
: fast_ptr(nullptr)
struct element_store::data
{
cloneable_element entity;
::nana::element::element_interface * fast_ptr{ nullptr };
};
struct element_store::implementation
{
std::map<std::string, data> table;
};
element_store::element_store()
: impl_(new implementation)
{}
//Empty destructor for instance of impl
element_store::~element_store()
{}
nana::element::element_interface * const * element_store::bground(const std::string& name)
{
element_interface * const * addr = &(bground_.table[name].fast_ptr);
element_interface * const * addr = &(impl_->table[name].fast_ptr);
return addr;
}
void element_store::bground(const std::string& name, const pat::cloneable<element_interface>& rhs)
{
auto & store = bground_.table[name];
auto & store = impl_->table[name];
store.object = rhs;
store.fast_ptr = store.object.get();
store.entity = rhs;
store.fast_ptr = store.entity.get();
}
void element_store::bground(const std::string& name, pat::cloneable<element_interface>&& rv)
{
auto & store = bground_.table[name];
auto & store = impl_->table[name];
store.object = std::move(rv);
store.fast_ptr = store.object.get();
store.entity = std::move(rv);
store.fast_ptr = store.entity.get();
}
}//end namespace detail
}

6
source/gui/detail/window_layout.cpp
View File

@ -221,8 +221,8 @@ namespace nana
continue;
core_window_t * term = ((i + 1 != layers_rend) ? *(i + 1) : wd);
r.x = wd->pos_root.x - pre->pos_root.x;
r.y = wd->pos_root.y - pre->pos_root.y;
r.position(wd->pos_root - pre->pos_root);
for (auto child : pre->children)
{
if (child->index >= term->index)
@ -253,7 +253,7 @@ namespace nana
if (child->visible && overlap(r_of_wd, rectangle{ child->pos_owner, child->dimension }, ovlp))
{
if (category::flags::lite_widget != child->other.category)
glass_buffer.bitblt(nana::rectangle{ ovlp.x - wd->pos_owner.x, ovlp.y - wd->pos_owner.y, ovlp.width, ovlp.height }, child->drawer.graphics, nana::point(ovlp.x - child->pos_owner.x, ovlp.y - child->pos_owner.y));
glass_buffer.bitblt(nana::rectangle{ ovlp.x - wd->pos_owner.x, ovlp.y - wd->pos_owner.y, ovlp.width, ovlp.height }, child->drawer.graphics, {ovlp.position() - child->pos_owner});
ovlp.x += wd->pos_root.x;
ovlp.y += wd->pos_root.y;

378
source/gui/detail/window_manager.cpp
View File

@ -23,9 +23,187 @@
#include <stdexcept>
#include <algorithm>
#if defined(STD_THREAD_NOT_SUPPORTED)
#include <nana/std_mutex.hpp>
#else
#include <mutex>
#endif
namespace nana
{
namespace detail
{
//class shortkey_container
struct shortkey_rep
{
window handle;
std::vector<unsigned long> keys;
};
struct shortkey_container::implementation
{
std::vector<shortkey_rep> base;
};
shortkey_container::shortkey_container()
:impl_(new implementation)
{}
shortkey_container::shortkey_container(shortkey_container&& other)
: impl_(other.impl_)
{
other.impl_ = nullptr;
}
shortkey_container::~shortkey_container()
{
delete impl_;
}
void shortkey_container::clear()
{
impl_->base.clear();
}
bool shortkey_container::make(window wd, unsigned long key)
{
if (wd == nullptr) return false;
if (key < 0x61) key += (0x61 - 0x41);
for (auto & m : impl_->base)
{
if (m.handle == wd)
{
m.keys.emplace_back(key);
return true;
}
}
impl_->base.emplace_back();
auto & rep = impl_->base.back();
rep.handle = wd;
rep.keys.emplace_back(key);
return true;
}
void shortkey_container::umake(window wd)
{
if (wd == nullptr) return;
for (auto i = impl_->base.begin(); i != impl_->base.end(); ++i)
{
if (i->handle == wd)
{
impl_->base.erase(i);
break;
}
}
}
std::vector<unsigned long> shortkey_container::keys(window wd) const
{
if (wd)
{
for (auto & m : impl_->base)
{
if (m.handle == wd)
return m.keys;
}
}
return{};
}
window shortkey_container::find(unsigned long key) const
{
if (key < 0x61) key += (0x61 - 0x41);
for (auto & m : impl_->base)
{
for (auto n : m.keys)
{
if (key == n)
return m.handle;
}
}
return nullptr;
}
//end class shortkey_container
//struct root_misc
root_misc::root_misc(root_misc&& other):
window(other.window),
root_graph(std::move(other.root_graph)),
shortkeys(std::move(other.shortkeys)),
condition(std::move(other.condition))
{
}
root_misc::root_misc(basic_window * wd, unsigned width, unsigned height)
: window(wd),
root_graph({ width, height })
{
condition.ignore_tab = false;
condition.pressed = nullptr;
condition.pressed_by_space = nullptr;
condition.hovered = nullptr;
}
//end struct root_misc
//class root_register
struct root_register::implementation
{
//Cached
native_window_type recent_access{ nullptr };
root_misc * misc_ptr{ nullptr };
std::map<native_window_type, root_misc> table;
};
root_register::root_register()
: impl_(new implementation)
{}
root_register::~root_register()
{
delete impl_;
}
root_misc* root_register::insert(native_window_type wd, root_misc&& misc)
{
impl_->recent_access = wd;
auto ret = impl_->table.emplace(wd, std::move(misc));
impl_->misc_ptr = &(ret.first->second);
return impl_->misc_ptr;
}
root_misc * root_register::find(native_window_type wd)
{
if (wd == impl_->recent_access)
return impl_->misc_ptr;
impl_->recent_access = wd;
auto i = impl_->table.find(wd);
if (i != impl_->table.end())
impl_->misc_ptr = &(i->second);
else
impl_->misc_ptr = nullptr;
return impl_->misc_ptr;
}
void root_register::erase(native_window_type wd)
{
impl_->table.erase(wd);
impl_->recent_access = wd;
impl_->misc_ptr = nullptr;
}
//end class root_register
}
namespace detail
{
template<typename Key, typename Value>
@ -36,9 +214,7 @@ namespace detail
Key first;
Value second;
key_value_rep()
: first{}, second{}
{}
key_value_rep() = default;
key_value_rep(const Key& k)
: first(k), second{}
@ -69,19 +245,9 @@ namespace detail
return table_.end();
}
iterator erase(iterator pos)
std::vector<key_value_rep>& table()
{
return table_.erase(pos);
}
iterator begin()
{
return table_.begin();
}
iterator end()
{
return table_.end();
return table_;
}
private:
std::vector<key_value_rep> table_;
@ -109,27 +275,50 @@ namespace detail
//end struct wdm_private_impl
//class revertible_mutex
window_manager::revertible_mutex::revertible_mutex()
struct thread_refcount
{
thr_.tid = 0;
thr_.refcnt = 0;
unsigned tid;
std::size_t ref;
};
struct window_manager::revertible_mutex::implementation
{
std::recursive_mutex mutex;
thread_refcount thread;
std::vector<thread_refcount> invoke_stack;
};
window_manager::revertible_mutex::revertible_mutex()
: impl_(new implementation)
{
impl_->thread.tid = 0;
impl_->thread.ref = 0;
}
window_manager::revertible_mutex::~revertible_mutex()
{
delete impl_;
}
void window_manager::revertible_mutex::lock()
{
std::recursive_mutex::lock();
if(0 == thr_.tid)
thr_.tid = nana::system::this_thread_id();
++thr_.refcnt;
impl_->mutex.lock();
if(0 == impl_->thread.tid)
impl_->thread.tid = nana::system::this_thread_id();
++(impl_->thread.ref);
}
bool window_manager::revertible_mutex::try_lock()
{
if(std::recursive_mutex::try_lock())
if(impl_->mutex.try_lock())
{
if(0 == thr_.tid)
thr_.tid = nana::system::this_thread_id();
++thr_.refcnt;
if (0 == impl_->thread.tid)
impl_->thread.tid = nana::system::this_thread_id();
++(impl_->thread.ref);
return true;
}
return false;
@ -137,44 +326,45 @@ namespace detail
void window_manager::revertible_mutex::unlock()
{
if(thr_.tid == nana::system::this_thread_id())
if(0 == --thr_.refcnt)
thr_.tid = 0;
std::recursive_mutex::unlock();
if(impl_->thread.tid == nana::system::this_thread_id())
if(0 == --(impl_->thread.ref))
impl_->thread.tid = 0;
impl_->mutex.unlock();
}
void window_manager::revertible_mutex::revert()
{
if(thr_.refcnt && (thr_.tid == nana::system::this_thread_id()))
if(impl_->thread.ref && (impl_->thread.tid == nana::system::this_thread_id()))
{
std::size_t cnt = thr_.refcnt;
std::size_t cnt = impl_->thread.ref;
stack_.push_back(thr_);
thr_.tid = 0;
thr_.refcnt = 0;
impl_->invoke_stack.push_back(impl_->thread);
impl_->thread.tid = 0;
impl_->thread.ref = 0;
for(std::size_t i = 0; i < cnt; ++i)
std::recursive_mutex::unlock();
for (std::size_t i = 0; i < cnt; ++i)
impl_->mutex.unlock();
}
}
void window_manager::revertible_mutex::forward()
{
std::recursive_mutex::lock();
if(stack_.size())
impl_->mutex.lock();
if(impl_->invoke_stack.size())
{
auto thr = stack_.back();
auto thr = impl_->invoke_stack.back();
if(thr.tid == nana::system::this_thread_id())
{
stack_.pop_back();
for(std::size_t i = 0; i < thr.refcnt; ++i)
std::recursive_mutex::lock();
thr_ = thr;
impl_->invoke_stack.pop_back();
for (std::size_t i = 0; i < thr.ref; ++i)
impl_->mutex.lock();
impl_->thread = thr;
}
else
throw std::runtime_error("Nana.GUI: The forward is not matched.");
}
std::recursive_mutex::unlock();
impl_->mutex.unlock();
}
//end class revertible_mutex
@ -254,23 +444,13 @@ namespace detail
return (impl_->wd_register.available(a) && impl_->wd_register.available(b));
}
bool window_manager::available(native_window_type wd)
{
if(wd)
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return (impl_->misc_register.find(wd) != nullptr);
}
return false;
}
window_manager::core_window_t* window_manager::create_root(core_window_t* owner, bool nested, rectangle r, const appearance& app, widget* wdg)
{
native_window_type native = nullptr;
if (owner)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(owner))
{
@ -306,11 +486,10 @@ namespace detail
wd->title = native_interface::window_caption(result.native_handle);
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
//create Root graphics Buffer and manage it
root_misc misc(wd, result.width, result.height);
auto* value = impl_->misc_register.insert(result.native_handle, misc);
auto* value = impl_->misc_register.insert(result.native_handle, root_misc(wd, result.width, result.height));
wd->bind_native_window(result.native_handle, result.width, result.height, result.extra_width, result.extra_height, value->root_graph);
impl_->wd_register.insert(wd, wd->thread_id);
@ -331,7 +510,7 @@ namespace detail
window_manager::core_window_t* window_manager::create_frame(core_window_t* parent, const rectangle& r, widget* wdg)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(parent) == false) return nullptr;
@ -350,7 +529,7 @@ namespace detail
if(frame)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if(category::flags::frame == frame->other.category)
frame->other.attribute.frame->attach.push_back(wd);
return true;
@ -363,7 +542,7 @@ namespace detail
if(frame)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if(category::flags::frame == frame->other.category)
{
if (impl_->wd_register.available(wd) && (category::flags::root == wd->other.category) && wd->root != frame->root)
@ -380,7 +559,7 @@ namespace detail
window_manager::core_window_t* window_manager::create_widget(core_window_t* parent, const rectangle& r, bool is_lite, widget* wdg)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(parent) == false)
throw std::invalid_argument("invalid parent/owner handle");
@ -401,7 +580,7 @@ namespace detail
void window_manager::close(core_window_t *wd)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) == false) return;
if (wd->flags.destroying)
@ -443,7 +622,7 @@ namespace detail
void window_manager::destroy(core_window_t* wd)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) == false) return;
rectangle update_area(wd->pos_owner, wd->dimension);
@ -467,7 +646,7 @@ namespace detail
void window_manager::destroy_handle(core_window_t* wd)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) == false) return;
#ifndef WIDGET_FRAME_DEPRECATED
@ -491,7 +670,7 @@ namespace detail
{
if(!big_icon.empty() || !small_icon.empty())
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
if(category::flags::root == wd->other.category)
@ -505,7 +684,7 @@ namespace detail
bool window_manager::show(core_window_t* wd, bool visible)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return false;
@ -548,7 +727,7 @@ namespace detail
if((false == attr_.capture.ignore_children) || (nullptr == attr_.capture.window) || (attr_.capture.window->root != root))
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
auto rrt = root_runtime(root);
point pos{ x, y };
if (rrt && _m_effective(rrt->window, pos))
@ -561,7 +740,7 @@ namespace detail
bool window_manager::move(core_window_t* wd, int x, int y, bool passive)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
if (category::flags::root != wd->other.category)
@ -606,7 +785,7 @@ namespace detail
bool window_manager::move(core_window_t* wd, const rectangle& r)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return false;
@ -680,7 +859,7 @@ namespace detail
bool window_manager::size(core_window_t* wd, nana::size sz, bool passive, bool ask_update)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return false;
@ -767,7 +946,7 @@ namespace detail
if(cache.first == wd) return cache.second;
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
auto rrt = root_runtime(wd);
if(rrt)
@ -783,7 +962,7 @@ namespace detail
void window_manager::map(core_window_t* wd, bool forced, const rectangle* update_area)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) && !wd->is_draw_through())
{
auto parent = wd->parent;
@ -805,7 +984,7 @@ namespace detail
bool window_manager::update(core_window_t* wd, bool redraw, bool forced, const rectangle* update_area)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) == false) return false;
if (wd->displayed())
@ -837,7 +1016,7 @@ namespace detail
void window_manager::refresh_tree(core_window_t* wd)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
//It's not worthy to redraw if visible is false
if (impl_->wd_register.available(wd) && wd->displayed())
@ -850,7 +1029,7 @@ namespace detail
bool window_manager::do_lazy_refresh(core_window_t* wd, bool force_copy_to_screen, bool refresh_tree)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (false == impl_->wd_register.available(wd))
return false;
@ -888,7 +1067,7 @@ namespace detail
bool window_manager::get_graphics(core_window_t* wd, nana::paint::graphics& result)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return false;
@ -901,7 +1080,7 @@ namespace detail
bool window_manager::get_visual_rectangle(core_window_t* wd, nana::rectangle& r)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
return (impl_->wd_register.available(wd) ?
window_layer::read_visual_rectangle(wd, r) :
false);
@ -909,7 +1088,7 @@ namespace detail
std::vector<window_manager::core_window_t*> window_manager::get_children(core_window_t* wd) const
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
return wd->children;
return{};
@ -918,7 +1097,7 @@ namespace detail
bool window_manager::set_parent(core_window_t* wd, core_window_t* newpa)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return false;
@ -945,7 +1124,7 @@ namespace detail
window_manager::core_window_t* window_manager::set_focus(core_window_t* wd, bool root_has_been_focused, arg_focus::reason reason)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return nullptr;
@ -1051,7 +1230,7 @@ namespace detail
if(wd != attr_.capture.window)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
@ -1112,7 +1291,7 @@ namespace detail
void window_manager::enable_tabstop(core_window_t* wd)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) && (detail::tab_type::none == wd->flags.tab))
{
wd->root_widget->other.attribute.root->tabstop.push_back(wd);
@ -1156,7 +1335,7 @@ namespace detail
auto window_manager::tabstop(core_window_t* wd, bool forward) const -> core_window_t*
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!impl_->wd_register.available(wd))
return nullptr;
@ -1198,7 +1377,7 @@ namespace detail
bool window_manager::enable_effects_bground(core_window_t* wd, bool enabled)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
return window_layer::enable_effects_bground(wd, enabled);
@ -1208,7 +1387,7 @@ namespace detail
bool window_manager::calc_window_point(core_window_t* wd, nana::point& pos)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
if(native_interface::calc_window_point(wd->root, pos))
@ -1220,7 +1399,7 @@ namespace detail
return false;
}
root_misc* window_manager::root_runtime(native_window_type native_wd) const
root_misc* window_manager::root_runtime(native_window native_wd) const
{
return impl_->misc_register.find(native_wd);
}
@ -1228,7 +1407,7 @@ namespace detail
bool window_manager::register_shortkey(core_window_t* wd, unsigned long key)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
auto object = root_runtime(wd->root);
@ -1241,7 +1420,7 @@ namespace detail
void window_manager::unregister_shortkey(core_window_t* wd, bool with_children)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd) == false) return;
auto root_rt = root_runtime(wd->root);
@ -1261,7 +1440,7 @@ namespace detail
std::vector<std::pair<core_window_t*, unsigned long>> result;
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (impl_->wd_register.available(wd))
{
auto root_rt = root_runtime(wd->root);
@ -1290,7 +1469,7 @@ namespace detail
if(native_window)
{
//Thread-Safe Required!
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
auto object = root_runtime(native_window);
if(object)
return reinterpret_cast<core_window_t*>(object->shortkeys.find(key));
@ -1302,7 +1481,7 @@ namespace detail
{
if (fn)
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
if (!available(wd))
return;
@ -1312,21 +1491,21 @@ namespace detail
void window_manager::call_safe_place(unsigned thread_id)
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
std::lock_guard<mutex_type> lock(mutex_);
for (auto i = impl_->safe_place.begin(); i != impl_->safe_place.end();)
auto& safe_place = impl_->safe_place.table();
for (auto i = safe_place.begin(); i != safe_place.end();)
{
if (i->first->thread_id == thread_id)
{
for (auto & fn : i->second)
fn();
i = impl_->safe_place.erase(i);
i = safe_place.erase(i);
}
else
++i;
}
}
bool check_tree(basic_window* wd, basic_window* const cond)
@ -1535,6 +1714,11 @@ namespace detail
wd->annex.caret_ptr = nullptr;
}
using effect_renderer = detail::edge_nimbus_renderer<basic_window>;
//remove the window from edge nimbus effect when it is destroying
effect_renderer::instance().erase(wd);
arg_destroy arg;
arg.window_handle = reinterpret_cast<window>(wd);
brock.emit(event_code::destroy, wd, arg, true, brock.get_thread_context());

2
source/gui/dragger.cpp
View File

@ -159,7 +159,7 @@ namespace nana
}
});
triggers_.push_back(tg);
triggers_.emplace_back(tg);
}
private:
static void _m_check_restrict_area(nana::point & pos, const nana::size & size, const nana::rectangle& restr_area)

4
source/gui/drawing.cpp
View File

@ -80,7 +80,9 @@ namespace nana
void drawing::erase(diehard_t d)
{
if(API::empty_window(handle_))
//Fixed by Tumiz
//https://github.com/cnjinhao/nana/issues/153
if(!API::empty_window(handle_))
restrict::get_drawer(handle_).erase(d);
}

259
source/gui/element.cpp
View File

@ -15,7 +15,6 @@
#include <nana/gui/detail/element_store.hpp>
#include <nana/paint/image.hpp>
#include <map>
#include <string>
#if defined(STD_THREAD_NOT_SUPPORTED)
#include <nana/std_mutex.hpp>
@ -599,7 +598,6 @@ namespace nana
{
using element_type = ElementInterface;
using factory_interface = pat::cloneable<element::detail::factory_abstract>;
public:
~element_object()
{
@ -1156,46 +1154,48 @@ namespace nana
}
};
struct bground::implementation
{
draw_method * method{ nullptr };
bool vert{ false };
rectangle valid_area;
std::vector<element_state> states;
std::map<element_state, element_state> join;
bool stretch_all{ true };
unsigned left{ 0 }, top{ 0 }, right{ 0 }, bottom{ 0 };
};
bground::bground()
: method_(nullptr),
vertical_(false),
stretch_all_(true),
left_(0), top_(0), right_(0), bottom_(0)
: impl_{ new implementation }
{
reset_states();
}
bground::bground(const bground& rhs)
: method_(rhs.method_ ? rhs.method_->clone() : nullptr),
vertical_(rhs.vertical_),
valid_area_(rhs.valid_area_),
states_(rhs.states_),
join_(rhs.join_),
stretch_all_(rhs.stretch_all_),
left_(rhs.left_), top_(rhs.top_), right_(rhs.right_), bottom_(rhs.bottom_)
: impl_{ new implementation(*rhs.impl_) }
{
if (impl_->method)
impl_->method = impl_->method->clone();
}
bground::~bground()
{
delete method_;
delete impl_->method;
}
bground& bground::operator=(const bground& rhs)
{
if (this != &rhs)
{
delete method_;
method_ = (rhs.method_ ? rhs.method_->clone() : nullptr);
vertical_ = rhs.vertical_;
valid_area_ = rhs.valid_area_;
states_ = rhs.states_;
join_ = rhs.join_;
stretch_all_ = rhs.stretch_all_;
left_ = rhs.left_;
top_ = rhs.top_;
right_ = rhs.right_;
bottom_ = rhs.bottom_;
delete impl_->method;
impl_.reset(new implementation(*rhs.impl_));
if (impl_->method)
impl_->method = impl_->method->clone();
}
return *this;
}
@ -1203,106 +1203,110 @@ namespace nana
//Set a picture for the background
bground& bground::image(const paint::image& img, bool vertical, const nana::rectangle& valid_area)
{
delete method_;
method_ = new draw_image(img);
vertical_ = vertical;
delete impl_->method;
impl_->method = new draw_image(img);
impl_->vert = vertical;
if (valid_area.width && valid_area.height)
valid_area_ = valid_area;
impl_->valid_area = valid_area;
else
valid_area_ = nana::rectangle(img.size());
impl_->valid_area = nana::rectangle(img.size());
return *this;
}
bground& bground::image(const paint::graphics& graph, bool vertical, const nana::rectangle& valid_area)
{
delete method_;
method_ = new draw_graph(graph);
vertical_ = vertical;
delete impl_->method;
impl_->method = new draw_graph(graph);
impl_->vert = vertical;
if (valid_area.width && valid_area.height)
valid_area_ = valid_area;
impl_->valid_area = valid_area;
else
valid_area_ = nana::rectangle(graph.size());
impl_->valid_area = nana::rectangle(graph.size());
return *this;
}
//Set the state sequence of the background picture.
void bground::states(const std::vector<element_state> & s)
{
states_ = s;
impl_->states = s;
}
void bground::states(std::vector<element_state> && s)
{
states_ = std::move(s);
impl_->states = std::move(s);
}
void bground::reset_states()
{
states_.clear();
states_.push_back(element_state::normal);
states_.push_back(element_state::hovered);
states_.push_back(element_state::focus_normal);
states_.push_back(element_state::focus_hovered);
states_.push_back(element_state::pressed);
states_.push_back(element_state::disabled);
join_.clear();
auto & st = impl_->states;
st.clear();
st.push_back(element_state::normal);
st.push_back(element_state::hovered);
st.push_back(element_state::focus_normal);
st.push_back(element_state::focus_hovered);
st.push_back(element_state::pressed);
st.push_back(element_state::disabled);
impl_->join.clear();
}
void bground::join(element_state target, element_state joiner)
{
join_[joiner] = target;
impl_->join[joiner] = target;
}
void bground::stretch_parts(unsigned left, unsigned top, unsigned right, unsigned bottom)
{
left_ = left;
top_ = top;
right_ = right;
bottom_ = bottom;
impl_->left = left;
impl_->right = right;
impl_->top = top;
impl_->bottom = bottom;
stretch_all_ = !(left || right || top || bottom);
impl_->stretch_all = !(left || right || top || bottom);
}
//Implement the methods of bground_interface.
bool bground::draw(graph_reference dst, const ::nana::color&, const ::nana::color&, const nana::rectangle& to_r, element_state state)
{
if (nullptr == method_)
const auto method = impl_->method;
if (nullptr == method)
return false;
auto mi = join_.find(state);
if (mi != join_.end())
auto mi = impl_->join.find(state);
if (mi != impl_->join.end())
state = mi->second;
std::size_t pos = 0;
for (; pos < states_.size(); ++pos)
for (; pos < impl_->states.size(); ++pos)
{
if (states_[pos] == state)
if (impl_->states[pos] == state)
break;
}
if (pos == states_.size())
if (pos == impl_->states.size())
return false;
nana::rectangle from_r = valid_area_;
if (vertical_)
nana::rectangle from_r = impl_->valid_area;
if (impl_->vert)
{
from_r.height /= static_cast<unsigned>(states_.size());
from_r.height /= static_cast<unsigned>(impl_->states.size());
from_r.y += static_cast<int>(from_r.height * pos);
}
else
{
from_r.width /= static_cast<unsigned>(states_.size());
from_r.width /= static_cast<unsigned>(impl_->states.size());
from_r.x += static_cast<int>(from_r.width * pos);
}
if (stretch_all_)
if (impl_->stretch_all)
{
if (from_r.width == to_r.width && from_r.height == to_r.height)
method_->paste(from_r, dst, to_r.position());
method->paste(from_r, dst, to_r.position());
else
method_->stretch(from_r, dst, to_r);
method->stretch(from_r, dst, to_r);
return true;
}
@ -1311,118 +1315,123 @@ namespace nana
auto perf_from_r = from_r;
auto perf_to_r = to_r;
if (left_ + right_ < to_r.width)
const auto left = impl_->left;
const auto right = impl_->right;
const auto top = impl_->top;
const auto bottom = impl_->bottom;
if (left + right < to_r.width)
{
nana::rectangle src_r = from_r;
src_r.y += static_cast<int>(top_);
src_r.height -= top_ + bottom_;
src_r.y += static_cast<int>(top);
src_r.height -= top + bottom;
nana::rectangle dst_r = to_r;
dst_r.y += static_cast<int>(top_);
dst_r.height -= top_ + bottom_;
dst_r.y += static_cast<int>(top);
dst_r.height -= top + bottom;
if (left_)
if (left)
{
src_r.width = left_;
dst_r.width = left_;
src_r.width = left;
dst_r.width = left;
method_->stretch(src_r, dst, dst_r);
method->stretch(src_r, dst, dst_r);
perf_from_r.x += static_cast<int>(left_);
perf_from_r.width -= left_;
perf_to_r.x += static_cast<int>(left_);
perf_to_r.width -= left_;
perf_from_r.x += static_cast<int>(left);
perf_from_r.width -= left;
perf_to_r.x += static_cast<int>(left);
perf_to_r.width -= left;
}
if (right_)
if (right)
{
src_r.x += (static_cast<int>(from_r.width) - static_cast<int>(right_));
src_r.width = right_;
src_r.x += (static_cast<int>(from_r.width) - static_cast<int>(right));
src_r.width = right;
dst_r.x += (static_cast<int>(to_r.width) - static_cast<int>(right_));
dst_r.width = right_;
dst_r.x += (static_cast<int>(to_r.width) - static_cast<int>(right));
dst_r.width = right;
method_->stretch(src_r, dst, dst_r);
method->stretch(src_r, dst, dst_r);
perf_from_r.width -= right_;
perf_to_r.width -= right_;
perf_from_r.width -= right;
perf_to_r.width -= right;
}
}
if (top_ + bottom_ < to_r.height)
if (top + bottom < to_r.height)
{
nana::rectangle src_r = from_r;
src_r.x += static_cast<int>(left_);
src_r.width -= left_ + right_;
src_r.x += static_cast<int>(left);
src_r.width -= left + right;
nana::rectangle dst_r = to_r;
dst_r.x += static_cast<int>(left_);
dst_r.width -= left_ + right_;
dst_r.x += static_cast<int>(left);
dst_r.width -= left + right;
if (top_)
if (top)
{
src_r.height = top_;
dst_r.height = top_;
src_r.height = top;
dst_r.height = top;
method_->stretch(src_r, dst, dst_r);
method->stretch(src_r, dst, dst_r);
perf_from_r.y += static_cast<int>(top_);
perf_to_r.y += static_cast<int>(top_);
perf_from_r.y += static_cast<int>(top);
perf_to_r.y += static_cast<int>(top);
}
if (bottom_)
if (bottom)
{
src_r.y += static_cast<int>(from_r.height - bottom_);
src_r.height = bottom_;
src_r.y += static_cast<int>(from_r.height - bottom);
src_r.height = bottom;
dst_r.y += static_cast<int>(to_r.height - bottom_);
dst_r.height = bottom_;
dst_r.y += static_cast<int>(to_r.height - bottom);
dst_r.height = bottom;
method_->stretch(src_r, dst, dst_r);
method->stretch(src_r, dst, dst_r);
}
perf_from_r.height -= (top_ + bottom_);
perf_to_r.height -= (top_ + bottom_);
perf_from_r.height -= (top + bottom);
perf_to_r.height -= (top + bottom);
}
if (left_)
if (left)
{
nana::rectangle src_r = from_r;
src_r.width = left_;
if (top_)
src_r.width = left;
if (top)
{
src_r.height = top_;
method_->paste(src_r, dst, to_r.position());
src_r.height = top;
method->paste(src_r, dst, to_r.position());
}
if (bottom_)
if (bottom)
{
src_r.y += static_cast<int>(from_r.height) - static_cast<int>(bottom_);
src_r.height = bottom_;
method_->paste(src_r, dst, nana::point(to_r.x, to_r.y + static_cast<int>(to_r.height - bottom_)));
src_r.y += static_cast<int>(from_r.height) - static_cast<int>(bottom);
src_r.height = bottom;
method->paste(src_r, dst, nana::point(to_r.x, to_r.y + static_cast<int>(to_r.height - bottom)));
}
}
if (right_)
if (right)
{
const int to_x = to_r.x + int(to_r.width - right_);
const int to_x = to_r.x + int(to_r.width - right);
nana::rectangle src_r = from_r;
src_r.x += static_cast<int>(src_r.width) - static_cast<int>(right_);
src_r.width = right_;
if (top_)
src_r.x += static_cast<int>(src_r.width) - static_cast<int>(right);
src_r.width = right;
if (top)
{
src_r.height = top_;
method_->paste(src_r, dst, nana::point(to_x, to_r.y));
src_r.height = top;
method->paste(src_r, dst, nana::point(to_x, to_r.y));
}
if (bottom_)
if (bottom)
{
src_r.y += (static_cast<int>(from_r.height) - static_cast<int>(bottom_));
src_r.height = bottom_;
method_->paste(src_r, dst, nana::point(to_x, to_r.y + int(to_r.height - bottom_)));
src_r.y += (static_cast<int>(from_r.height) - static_cast<int>(bottom));
src_r.height = bottom;
method->paste(src_r, dst, nana::point(to_x, to_r.y + int(to_r.height - bottom)));
}
}
method_->stretch(perf_from_r, dst, perf_to_r);
method->stretch(perf_from_r, dst, perf_to_r);
return true;
}
//end class bground

24
source/gui/filebox.cpp
View File

@ -498,24 +498,26 @@ namespace nana
if(name.empty() || (name.front() == '.'))
continue;
auto fpath = i->path().native();
auto fattr = fs::status(fpath);
item_fs m;
m.name = name;
m.directory = fs::is_directory(fattr);
auto fattr = fs::status(path + m.name);
if(fattr.type() != fs::file_type::not_found && fattr.type() != fs::file_type::unknown)
{
m.bytes = fs::file_size(path + m.name);
m.directory = fs::is_directory(fattr);
fs_ext::modified_file_time(path + m.name, m.modified_time);
}
else
switch(fattr.type())
{
case fs::file_type::not_found:
case fs::file_type::unknown:
case fs::file_type::directory:
m.bytes = 0;
m.directory = fs::is_directory(*i);
fs_ext::modified_file_time(path + i->path().filename().native(), m.modified_time);
break;
default:
m.bytes = fs::file_size(fpath);
}
fs_ext::modified_file_time(fpath, m.modified_time);
file_container_.push_back(m);
if(m.directory)

10
source/gui/msgbox.cpp
View File

@ -1,7 +1,7 @@
/*
* A Message Box Class
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2015 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@ -61,14 +61,14 @@ namespace nana
{
_m_click(arg);
});
yes_.caption("OK");
yes_.i18n(i18n_eval("OK"));
width_pixel += 77;
if(msgbox::yes_no == btn || msgbox::yes_no_cancel == btn)
{
yes_.caption("Yes");
yes_.i18n(i18n_eval("Yes"));
no_.create(*this);
no_.caption("No");
no_.i18n(i18n_eval("No"));
no_.events().click.connect_unignorable([this](const arg_click& arg)
{
_m_click(arg);
@ -79,7 +79,7 @@ namespace nana
if(msgbox::yes_no_cancel == btn)
{
cancel_.create(*this);
cancel_.caption("Cancel");
cancel_.i18n(i18n_eval("Cancel"));
cancel_.events().click.connect_unignorable([this](const arg_click& arg)
{
_m_click(arg);

10
source/gui/place.cpp
View File

@ -15,6 +15,7 @@
#include <cmath>
#include <map>
#include <deque>
#include <algorithm>
#include <nana/push_ignore_diagnostic>
#include <nana/deploy.hpp>
#include <nana/gui/place.hpp>
@ -661,13 +662,14 @@ namespace nana
//This is a splitter, it only checks when it is being displayed
if (dsp)
{
//Left field of splitterbar
auto left = this->previous();
if (left && !left->display)
left->set_display(true);
auto right = div_next;
if (right && !right->display)
right->set_display(true);
//Right field of splitterbar
if (div_next && !div_next->display)
div_next->set_display(true);
}
}
}
@ -816,7 +818,7 @@ namespace nana
if ((!child->is_fixed()) && child->max_px.empty() && is_back(child) && (endpos != area.right()))
endpos = area.right();
child_area.w_ref() = static_cast<unsigned>(endpos - child_area.x());
child_area.w_ref() = static_cast<unsigned>((std::max)(endpos - child_area.x(), 0));
child->field_area = child_area.result();
position += child_px;

6
source/gui/programming_interface.cpp
View File

@ -104,7 +104,7 @@ namespace API
{
if (iwd->effect.edge_nimbus == effects::edge_nimbus::none)
{
cont.push_back(basic_window::edge_nimbus_action{ iwd, false});
cont.emplace_back(basic_window::edge_nimbus_action{ iwd, false});
}
iwd->effect.edge_nimbus = static_cast<effects::edge_nimbus>(static_cast<unsigned>(en) | static_cast<unsigned>(iwd->effect.edge_nimbus));
}
@ -365,7 +365,7 @@ namespace API
}
if (!exists)
roots.push_back(root);
roots.emplace_back(root);
}
}
@ -401,7 +401,7 @@ namespace API
}
if (!exists)
roots.push_back(root);
roots.emplace_back(root);
}
}

3
source/gui/timer.cpp
View File

@ -47,8 +47,7 @@ namespace nana
friend class timer_core;
timer_driver()
{}
timer_driver() = default;
public:
static timer_driver& instance()
{

2
source/gui/tooltip.cpp
View File

@ -60,7 +60,7 @@ namespace nana
typedef widget_object<category::root_tag, drawer> base_type;
public:
tip_form()
: base_type(nana::rectangle(), appear::bald<appear::floating>()),
: base_type(nullptr, false, rectangle(), appear::bald<appear::floating>()),
duration_(0)
{
API::take_active(this->handle(), false, nullptr);

17
source/gui/widgets/button.cpp
View File

@ -235,7 +235,7 @@ namespace nana{ namespace drawerbase
if(shortkey)
{
unsigned off_w = (shortkey_pos ? graph.text_extent_size(mbstr.c_str(), static_cast<unsigned>(shortkey_pos)).width : 0);
unsigned off_w = (shortkey_pos ? graph.text_extent_size(mbstr.c_str(), shortkey_pos).width : 0);
wchar_t keystr[2] = {nana::utf::char_at(mbstr.c_str() + shortkey_pos, 0, 0), 0};
auto shortkey_size = graph.text_extent_size(keystr, 1);
@ -287,14 +287,6 @@ namespace nana{ namespace drawerbase
graph.gradual_rectangle(r, from, to, true);
}
void draw_corner_point(::nana::paint::graphics& graph, const rectangle& r)
{
graph.set_pixel(r.x, r.y);
graph.set_pixel(r.right() - 1, r.y);
graph.set_pixel(r.right() - 1, r.bottom() - 1);
graph.set_pixel(r.x, r.bottom() - 1);
}
void trigger::_m_draw_border(graph_reference graph)
{
nana::rectangle r(graph.size());
@ -303,10 +295,13 @@ namespace nana{ namespace drawerbase
graph.frame_rectangle(r, lt, lt, rb, rb);
graph.palette(false, colors::button_face);
draw_corner_point(graph, r);
paint::draw draw(graph);
draw.corner(r, 1);
graph.palette(false, static_cast<color_rgb>(0x919191));
draw_corner_point(graph, r.pare_off(1));
draw.corner(r.pare_off(1), 1);
if (element_state::pressed == attr_.e_state)
graph.rectangle(r, false, static_cast<color_rgb>(0xc3c3c3));

3
source/gui/widgets/checkbox.cpp
View File

@ -285,8 +285,7 @@ namespace nana{ namespace drawerbase
}
});
ui_container_.push_back(el);
ui_container_.emplace_back(el);
}
std::size_t radio_group::checked() const

6
source/gui/widgets/combox.cpp
View File

@ -170,11 +170,11 @@ namespace nana
{
if(editor_)
{
editor_->editable(enb);
editor_->editable(enb, false);
editor_->show_caret(enb);
if (!enb)
{
editor_->ext_renderer().background = [this](graph_reference graph, const ::nana::rectangle&, const ::nana::color&)
editor_->customized_renderers().background = [this](graph_reference graph, const ::nana::rectangle&, const ::nana::color&)
{
auto clr_from = colors::button_face_shadow_start;
auto clr_to = colors::button_face_shadow_end;
@ -190,7 +190,7 @@ namespace nana
};
}
else
editor_->ext_renderer().background = nullptr;
editor_->customized_renderers().background = nullptr;
editor_->enable_background(enb);
editor_->enable_background_counterpart(!enb);

2
source/gui/widgets/date_chooser.cpp
View File

@ -393,7 +393,7 @@ namespace nana
int n = trace_.logic_pos.y * rows + trace_.logic_pos.x + 1;
if (page_mode::date == page)
{
if (n < 8) return false; //Here is week title bar
if (n < 8) return 0; //Here is week title bar
int dw = nana::date::day_of_week(view_month_.year, view_month_.month, 1);
n -= (dw ? dw + 7 : 14);
}

68
source/gui/widgets/float_listbox.cpp
View File

@ -13,6 +13,8 @@
#include <nana/gui/widgets/float_listbox.hpp>
#include <nana/gui/widgets/scroll.hpp>
#include <nana/gui/layout_utility.hpp>
namespace nana
{
namespace drawerbase{
@ -34,28 +36,20 @@ namespace nana
{
if (state == StateHighlighted)
{
::nana::color clr(static_cast<color_rgb>(0xafc7e3));
graph.rectangle(r, false, clr);
graph.rectangle(r, false, static_cast<color_rgb>(0xafc7e3));
auto right = r.right() - 1;
auto bottom = r.bottom() - 1;
graph.palette(false, colors::white);
graph.set_pixel(r.x, r.y);
graph.set_pixel(right, r.y);
graph.set_pixel(r.x, bottom);
graph.set_pixel(right, bottom);
--right;
--bottom;
graph.palette(false, clr);
graph.set_pixel(r.x + 1, r.y + 1);
graph.set_pixel(right, r.y + 1);
graph.set_pixel(r.x + 1, bottom);
graph.set_pixel(right, bottom);
paint::draw draw{ graph };
draw.corner(r, 1);
nana::rectangle po_r(r);
graph.rectangle(po_r.pare_off(1), false, static_cast<color_rgb>(0xEBF4FB));
graph.gradual_rectangle(po_r.pare_off(1), static_cast<color_rgb>(0xDDECFD), static_cast<color_rgb>(0xC2DCFD), true);
graph.palette(false, static_cast<color_rgb>(0xafc7e3));
auto inner_r = r;
draw.corner(inner_r.pare_off(1), 1);
graph.rectangle(inner_r, false, static_cast<color_rgb>(0xEBF4FB));
graph.gradual_rectangle(inner_r.pare_off(1), static_cast<color_rgb>(0xDDECFD), static_cast<color_rgb>(0xC2DCFD), true);
}
else
graph.rectangle(r, true, colors::white);
@ -66,35 +60,7 @@ namespace nana
unsigned vpix = (r.height - 4);
if(item->image())
{
nana::size imgsz = item->image().size();
if(imgsz.width > image_pixels_)
{
unsigned new_h = image_pixels_ * imgsz.height / imgsz.width;
if(new_h > vpix)
{
imgsz.width = vpix * imgsz.width / imgsz.height;
imgsz.height = vpix;
}
else
{
imgsz.width = image_pixels_;
imgsz.height = new_h;
}
}
else if(imgsz.height > vpix)
{
unsigned new_w = vpix * imgsz.width / imgsz.height;
if(new_w > image_pixels_)
{
imgsz.height = image_pixels_ * imgsz.height / imgsz.width;
imgsz.width = image_pixels_;
}
else
{
imgsz.height = vpix;
imgsz.width = new_w;
}
}
auto imgsz = nana::fit_zoom(item->image().size(), {image_pixels_, vpix});
nana::point to_pos(x, r.y + 2);
to_pos.x += (image_pixels_ - imgsz.width) / 2;
@ -109,7 +75,9 @@ namespace nana
unsigned item_pixels(graph_reference graph) const
{
return graph.text_extent_size(L"jHWn/?\\{[(0569").height + 4;
unsigned ascent, descent, ileading;
graph.text_metrics(ascent, descent, ileading);
return ascent + descent + 4;
}
};//end class item_renderer
@ -187,7 +155,7 @@ namespace nana
--(state_.index);
else if(recycle)
{
state_.index = static_cast<unsigned>(module_->items.size() - 1);
state_.index = module_->items.size() - 1;
state_.offset_y = last_offset_y;
}
@ -205,7 +173,7 @@ namespace nana
}
if(state_.index >= state_.offset_y + module_->max_items)
state_.offset_y = static_cast<unsigned>(state_.index - module_->max_items + 1);
state_.offset_y = state_.index - module_->max_items + 1;
}
}
else

22
source/gui/widgets/label.cpp
View File

@ -206,15 +206,13 @@ namespace nana
{
if(fbp->target.size() || fbp->url.size())
{
traceable tr;
traceable_.emplace_back();
auto & tr = traceable_.back();
tr.r.x = x;
tr.r.y = y;
tr.r.width = sz.width;
tr.r.height = sz.height;
tr.r.dimension(sz);
tr.target = fbp->target;
tr.url = fbp->url;
traceable_.push_back(tr);
}
}
@ -331,7 +329,7 @@ namespace nana
px.pixels = def_line_pixels;
px.x_base = 0;
rs.pixels.push_back(px);
rs.pixels.emplace_back(px);
return 0;
}
@ -374,7 +372,7 @@ namespace nana
if(max_ascent < as) max_ascent = as;
if(max_descent < ds) max_descent = ds;
if(max_px < sz.height) max_px = sz.height;
line_values.push_back(i);
line_values.emplace_back(i);
}
else
{
@ -393,13 +391,13 @@ namespace nana
px.baseline = max_ascent;
px.values.swap(line_values);
rs.pixels.push_back(px);
rs.pixels.emplace_back(px);
w = sz.width;
max_px = sz.height;
max_ascent = as;
max_descent = ds;
line_values.push_back(i);
line_values.emplace_back(i);
}
else
{
@ -409,9 +407,9 @@ namespace nana
px.pixels = sz.height;
px.baseline = as;
px.values.push_back(i);
px.values.emplace_back(i);
rs.pixels.push_back(px);
rs.pixels.emplace_back(px);
max_px = 0;
max_ascent = max_descent = 0;
}
@ -432,7 +430,7 @@ namespace nana
px.pixels = max_px;
px.baseline = max_ascent;
px.values.swap(line_values);
rs.pixels.push_back(px);
rs.pixels.emplace_back(px);
}
return total_w;
}

304
source/gui/widgets/listbox.cpp
View File

@ -32,6 +32,7 @@
#include <nana/system/dataexch.hpp>
#include <cassert>
#include <mutex>
#include <map>
namespace nana
{
@ -678,6 +679,16 @@ namespace nana
}
};
struct inline_pane
{
::nana::panel<false> pane_bottom; //pane for pane_widget
::nana::panel<false> pane_widget; //pane for placing user-define widget
std::unique_ptr<inline_notifier_interface> inline_ptr;
inline_indicator * indicator;
index_pair item_pos; //The item index of the inline widget
std::size_t column_pos;
};
class es_lister
{
public:
@ -726,6 +737,40 @@ namespace nana
std::string to_string(const export_options& exp_opt) const;
std::vector<inline_pane*> get_inline_pane(const index_pair& item_pos)
{
std::vector<inline_pane*> panes;
for (auto p : active_panes_)
{
if (p && (p->item_pos == item_pos))
{
panes.emplace_back(p);
}
}
return panes;
}
void emit_checked(index_pair pos)
{
item_proxy i(ess_, pos);
arg_listbox arg{ i };
wd_ptr()->events().checked.emit(arg, wd_ptr()->handle());
auto panes = get_inline_pane(pos);
for (auto p : panes)
p->inline_ptr->notify_status(inline_widget_status::checking, i.checked());
}
void emit_selected(index_pair pos)
{
item_proxy i(ess_, pos);
arg_listbox arg{ i };
wd_ptr()->events().selected.emit(arg, wd_ptr()->handle());
auto panes = get_inline_pane(pos);
for (auto p : panes)
p->inline_ptr->notify_status(inline_widget_status::selecting, i.selected());
}
// Definition is provided after struct essence
unsigned column_content_pixels(size_type pos) const;
@ -746,7 +791,7 @@ namespace nana
if (cat.model_ptr)
{
std::sort(bi, ei, [&cat, &weak_ordering_comp, this](std::size_t x, std::size_t y){
std::stable_sort(bi, ei, [&cat, &weak_ordering_comp, this](std::size_t x, std::size_t y){
//The predicate must be a strict weak ordering.
//!comp(x, y) != comp(x, y)
auto & mx = cat.items[x];
@ -773,7 +818,7 @@ namespace nana
}
else
{
std::sort(bi, ei, [&cat, &weak_ordering_comp, this](std::size_t x, std::size_t y){
std::stable_sort(bi, ei, [&cat, &weak_ordering_comp, this](std::size_t x, std::size_t y){
//The predicate must be a strict weak ordering.
//!comp(x, y) != comp(x, y)
@ -804,7 +849,7 @@ namespace nana
{
if (cat.model_ptr)
{
std::sort(std::begin(cat.sorted), std::end(cat.sorted), [&cat, this](std::size_t x, std::size_t y){
std::stable_sort(std::begin(cat.sorted), std::end(cat.sorted), [&cat, this](std::size_t x, std::size_t y){
auto mx_cells = cat.model_ptr->container()->to_cells(x);
auto my_cells = cat.model_ptr->container()->to_cells(y);
@ -828,7 +873,7 @@ namespace nana
}
else
{
std::sort(std::begin(cat.sorted), std::end(cat.sorted), [&cat, this](std::size_t x, std::size_t y){
std::stable_sort(std::begin(cat.sorted), std::end(cat.sorted), [&cat, this](std::size_t x, std::size_t y){
auto & mx = cat.items[x];
auto & my = cat.items[y];
@ -972,6 +1017,7 @@ namespace nana
if (catobj.model_ptr)
{
throw_if_immutable_model(catobj.model_ptr.get());
auto container = catobj.model_ptr->container();
std::size_t item_index;
//
@ -1120,6 +1166,14 @@ namespace nana
return get(pos.cat)->items.at(index);
}
void append_active_panes(inline_pane* p)
{
if (nullptr == p)
active_panes_.clear();
else
active_panes_.push_back(p);
}
// Removes all items of a specified category
// It throws when the category is out of range or has an immutable model.
void clear(size_type cat)
@ -1249,28 +1303,17 @@ namespace nana
return n;
}
std::vector<cell>& get_cells(category_t * cat, std::size_t pos) const
std::vector<cell> get_cells(category_t * cat, std::size_t pos) const
{
if (!cat)
throw std::out_of_range("nana::listbox: category is null");
if (cat->model_ptr)
throw std::runtime_error("nana::listbox disallow to get item cells, because there are model cells");
return cat->model_ptr->container()->to_cells(pos);
return *(cat->items.at(pos).cells);
}
std::vector<cell> get_model_cells(category_t* cat, std::size_t pos) const
{
if (!cat)
throw std::out_of_range("nana::listbox: category is null");
if (!(cat->model_ptr))
throw std::runtime_error("nana::listbox: the category hasn't a model");
return cat->model_ptr->container()->to_cells(pos);
}
void text(category_t* cat, size_type pos, size_type col, cell&& cl, size_type columns)
{
if ((col < columns) && (pos < cat->items.size()))
@ -1462,9 +1505,7 @@ namespace nana
if(m.flags.checked != ck)
{
m.flags.checked = ck;
arg_listbox arg{ item_proxy{ess_, pos}};
wd_ptr()->events().checked.emit(arg, wd_ptr()->handle());
emit_checked(pos);
}
++pos.item;
}
@ -1489,10 +1530,15 @@ namespace nana
void select_display_range(index_pair fr_abs, index_pair to_dpl, bool sel)
{
const auto already_selected = this->pick_items(true);
index_pair fr_dpl (fr_abs.cat, this->display_order(fr_abs.cat, fr_abs.item));
if (fr_dpl > to_dpl)
std::swap(fr_dpl, to_dpl);
const auto begin = fr_dpl;
const auto last = to_dpl;
for (; fr_dpl != to_dpl; forward(fr_dpl, 1, fr_dpl))
{
if (fr_dpl.is_item())
@ -1501,6 +1547,14 @@ namespace nana
if (to_dpl.is_item())
item_proxy(ess_, index_pair(to_dpl.cat, absolute( to_dpl ) )).select(sel);
//Unselects the already selected which is out of range [begin, last]
for (auto index : already_selected)
{
index_pair disp_order{ index.cat, this->display_order(index.cat, index.item) };
if (begin > disp_order || disp_order > last)
item_proxy(ess_, index_pair(index.cat, absolute(disp_order))).select(false);
}
}
bool select_for_all(bool sel)
@ -1517,8 +1571,7 @@ namespace nana
changed = true;
m.flags.selected = sel;
arg_listbox arg{ item_proxy(ess_, i) };
wd_ptr()->events().selected.emit(arg, wd_ptr()->handle());
this->emit_selected(i);
if (m.flags.selected)
last_selected_abs = i;
@ -1608,18 +1661,17 @@ namespace nana
return (for_selection ? m.flags.selected : m.flags.checked);
};
auto do_cancel = [this, for_selection](category_t::container::value_type& m, std::size_t cat_pos, std::size_t item_pos)
auto do_cancel = [this, for_selection](category_t::container::value_type& m, const index_pair& item_pos)
{
arg_listbox arg{ item_proxy(ess_, index_pair(cat_pos, item_pos)) };
if (for_selection)
{
m.flags.selected = false;
widget_->events().selected.emit(arg, widget_->handle());
this->emit_selected(item_pos);
}
else
{
m.flags.checked = false;
widget_->events().checked.emit(arg, widget_->handle());
this->emit_checked(item_pos);
}
};
@ -1631,7 +1683,7 @@ namespace nana
for (auto & m : i->items)
{
if ((item_pos != except.item) && pred(m))
do_cancel(m, except.cat, item_pos);
do_cancel(m, index_pair{ except.cat, item_pos });
++item_pos;
}
@ -1647,7 +1699,7 @@ namespace nana
for (auto & m : cat.items)
{
if (pred(m))
do_cancel(m, cat_pos, item_pos);
do_cancel(m, index_pair{ cat_pos, item_pos });
++item_pos;
}
}
@ -1657,7 +1709,7 @@ namespace nana
for (auto & m : cat.items)
{
if ((item_pos != except.item) && pred(m))
do_cancel(m, cat_pos, item_pos);
do_cancel(m, index_pair{ cat_pos, item_pos });
++item_pos;
}
}
@ -1691,18 +1743,17 @@ namespace nana
return (for_selection ? m.flags.selected : m.flags.checked);
};
auto cancel = [this, for_selection](category_t::container::value_type& m, std::size_t cat_pos, std::size_t item_pos)
auto cancel = [this, for_selection](category_t::container::value_type& m, const index_pair& item_pos)
{
arg_listbox arg{ item_proxy(ess_, index_pair(cat_pos, item_pos)) };
if (for_selection)
{
m.flags.selected = false;
widget_->events().selected.emit(arg, widget_->handle());
this->emit_selected(item_pos);
}
else
{
m.flags.checked = false;
widget_->events().checked.emit(arg, widget_->handle());
this->emit_checked(item_pos);
}
};
@ -1718,7 +1769,7 @@ namespace nana
for (auto end = cat.items.end(); i != end; ++i)
{
if (pred(*i))
cancel(*i, cat_pos, i - cat.items.begin());
cancel(*i, index_pair{ cat_pos, static_cast<size_type>(i - cat.items.begin()) });
}
}
++cat_pos;
@ -1741,7 +1792,7 @@ namespace nana
for (++i; i != end; ++i)
{
if (pred(*i))
cancel(*i, cat_pos, i - cat.items.begin());
cancel(*i, index_pair{ cat_pos, static_cast<std::size_t>(i - cat.items.begin()) });
}
}
}
@ -1753,7 +1804,7 @@ namespace nana
for (auto & m : cat.items)
{
if (pred(m))
cancel(m, cat_pos, item_pos);
cancel(m, index_pair{ cat_pos, item_pos });
++item_pos;
}
@ -1800,10 +1851,7 @@ namespace nana
if(m.flags.checked != ck)
{
m.flags.checked = ck;
arg_listbox arg{ item_proxy(ess_, index_pair(cat, index)) };
wd_ptr()->events().checked.emit(arg, widget_->handle());
this->emit_checked(index_pair{cat, index});
changed = true;
}
++index;
@ -2059,7 +2107,7 @@ namespace nana
return i;
}
public:
index_pair last_selected_abs, last_selected_dpl;
index_pair last_selected_abs;
private:
essence * ess_{nullptr};
nana::listbox * widget_{nullptr};
@ -2074,6 +2122,8 @@ namespace nana
bool single_selection_category_limited_{ false };
bool single_check_{ false };
bool single_check_category_limited_{ false };
std::vector<inline_pane*> active_panes_;
};//end class es_lister
@ -2117,17 +2167,6 @@ namespace nana
}scroll;
struct inline_pane
{
::nana::panel<false> pane_bottom; //pane for pane_widget
::nana::panel<false> pane_widget; //pane for placing user-define widget
std::unique_ptr<inline_notifier_interface> inline_ptr;
inline_indicator * indicator;
index_pair item_pos; //The item index of the inline widget
std::size_t column_pos;
::std::string text; //text in UTF-8 encoded
};
std::map<pat::detail::abstract_factory_base*, std::deque<std::unique_ptr<inline_pane>>> inline_table, inline_buffered_table;
essence()
@ -2868,8 +2907,8 @@ namespace nana
return *this;
}
iresolver::iresolver(const std::vector<cell>& cl)
: cells_(cl)
iresolver::iresolver(std::vector<cell> cl)
: cells_(std::move(cl))
{}
iresolver& iresolver::operator>>(cell& cl)
@ -2972,8 +3011,8 @@ namespace nana
: ess_{ ess }, column_pos_{column_pos}
{
}
void attach(index_type pos, essence::inline_pane* pane)
void attach(index_type pos, inline_pane* pane)
{
for (auto & pn : panes_)
{
@ -2997,6 +3036,11 @@ namespace nana
return *ess_->lister.wd_ptr();
}
std::size_t column() const override
{
return column_pos_;
}
void modify(index_type pos, const value_type& value) const override
{
ess_->lister.throw_if_immutable_model(pos);
@ -3009,15 +3053,6 @@ namespace nana
if (cells[column_pos_].text != value)
{
for (auto & pn : panes_)
{
if (pn.first == pos)
{
pn.second->text = value;
break;
}
}
cells[column_pos_].text = value;
if (model_cells.size())
@ -3049,7 +3084,7 @@ namespace nana
private:
essence * const ess_;
const std::size_t column_pos_;
std::vector<std::pair<index_type, essence::inline_pane*>> panes_;
std::vector<std::pair<index_type, inline_pane*>> panes_;
};
void es_lister::scroll(const index_pair& pos, bool to_bottom)
@ -3125,7 +3160,7 @@ namespace nana
void es_lister::move_select(bool upwards, bool unselect_previous, bool trace_selected)
{
auto next_selected_dpl = relative_pair ( last_selected_abs); // last_selected_dpl; // ??
auto next_selected_dpl = relative_pair ( last_selected_abs);
if (next_selected_dpl.empty()) // has no cat ? (cat == npos) => beging from first cat
{
bool good = false;
@ -3246,7 +3281,7 @@ namespace nana
if (it.selected() != sel)
it.select(sel);
}
last_selected_abs = last_selected_dpl = index_pair{cat, npos};
last_selected_abs = index_pair{cat, npos};
}
class drawer_header_impl
@ -3529,15 +3564,19 @@ namespace nana
public:
using item_state = essence::item_state;
using parts = essence::parts;
using status_type = inline_notifier_interface::status_type;
drawer_lister_impl(essence * es)
:essence_(es)
{}
void draw(const nana::rectangle& rect) const
void draw(const nana::rectangle& rect)
{
internal_scope_guard lock;
//clear active panes
essence_->lister.append_active_panes(nullptr);
//The count of items to be drawn
auto item_count = essence_->number_of_lister_items(true);
if (0 == item_count)
@ -3720,7 +3759,7 @@ namespace nana
nana::color bgcolor,
nana::color fgcolor,
item_state state
) const
)
{
auto & item = cat.items[item_pos.item];
@ -3834,35 +3873,31 @@ namespace nana
else
visible_state = false;
::nana::size sz{ wdg_w, essence_->scheme_ptr->item_height };
inline_wdg->pane_widget.size(sz);
inline_wdg->inline_ptr->resize(sz);
draw_column = inline_wdg->inline_ptr->whether_to_draw();
inline_wdg->item_pos = item_pos;
inline_wdg->column_pos = column_pos;
inline_wdg->inline_ptr->activate(*inline_wdg->indicator, item_pos);
::nana::size sz{ wdg_w, essence_->scheme_ptr->item_height };
inline_wdg->pane_widget.size(sz);
inline_wdg->inline_ptr->resize(sz);
inline_wdg->inline_ptr->notify_status(status_type::selected, item.flags.selected);
inline_wdg->inline_ptr->notify_status(status_type::checked, item.flags.checked);
inline_wdg->indicator->attach(item_pos, inline_wdg);
//To reduce the memory usage, the cells may not be allocated
if (cells.size() > column_pos)
{
auto & text = cells[column_pos].text;
if (text != inline_wdg->text)
{
inline_wdg->text = text;
inline_wdg->inline_ptr->set(text);
}
}
inline_wdg->inline_ptr->set(cells[column_pos].text);
else
{
inline_wdg->text.clear();
inline_wdg->inline_ptr->set({});
}
API::show_window(inline_wdg->pane_bottom, visible_state);
essence_->lister.append_active_panes(inline_wdg);
}
}
@ -3912,18 +3947,20 @@ namespace nana
_m_draw_border(content_r.x, y, show_w);
}
essence::inline_pane * _m_get_inline_pane(const category_t& cat, std::size_t column_pos) const
inline_pane * _m_get_inline_pane(const category_t& cat, std::size_t column_pos) const
{
if (column_pos < cat.factories.size())
{
auto & factory = cat.factories[column_pos];
if (factory)
{
return essence_->open_inline(factory.get(), cat.indicators[column_pos].get());
}
}
return nullptr;
}
essence::inline_pane* _m_find_inline_pane(const index_pair& pos, std::size_t column_pos) const
inline_pane* _m_find_inline_pane(const index_pair& pos, std::size_t column_pos) const
{
auto & cat = *essence_->lister.get(pos.cat);
@ -3949,18 +3986,14 @@ namespace nana
void _m_draw_border(int x, int y, unsigned width) const
{
//Draw selecting inner rectangle
auto graph = essence_->graph;
rectangle r{ x, y, width, essence_->scheme_ptr->item_height };
graph->rectangle({ x, y, width, essence_->scheme_ptr->item_height }, false, static_cast<color_rgb>(0x99defd));
graph->rectangle({ x + 1, y + 1, width - 2, essence_->scheme_ptr->item_height - 2 }, false, colors::white);
essence_->graph->rectangle(r, false, static_cast<color_rgb>(0x99defd));
const int right = x + width - 1;
const int bottom = y + essence_->scheme_ptr->item_height - 1;
essence_->graph->palette(false, colors::white);
paint::draw(*essence_->graph).corner(r, 1);
graph->set_pixel(x, y);
graph->set_pixel(x, bottom);
graph->set_pixel(right, y);
graph->set_pixel(right, bottom);
essence_->graph->rectangle(r.pare_off(1), false);
}
private:
essence * const essence_;
@ -4164,7 +4197,18 @@ namespace nana
if (!lister.single_selection())
{
if (arg.shift)
lister.select_display_range(lister.last_selected_abs , item_pos, sel);
{
//Set the first item as the begin of selected item if there
//is not a last selected item.(#154 reported by RenaudAlpes)
if (lister.last_selected_abs.empty() || lister.last_selected_abs.is_category())
lister.last_selected_abs.set_both(0);
auto before = lister.last_selected_abs;
lister.select_display_range(lister.last_selected_abs, item_pos, sel);
lister.last_selected_abs = before;
}
else if (arg.ctrl)
sel = !item_proxy(essence_, abs_item_pos).selected();
else
@ -4180,19 +4224,20 @@ namespace nana
if(item_ptr)
{
item_ptr->flags.selected = sel;
arg_listbox arg{ item_proxy{ essence_, abs_item_pos } };
lister.wd_ptr()->events().selected.emit(arg, lister.wd_ptr()->handle());
if (item_ptr->flags.selected)
if (item_ptr->flags.selected != sel)
{
lister.cancel_others_if_single_enabled(true, abs_item_pos);
essence_->lister.last_selected_abs = abs_item_pos;
item_ptr->flags.selected = sel;
lister.emit_selected(abs_item_pos);
if (item_ptr->flags.selected)
{
lister.cancel_others_if_single_enabled(true, abs_item_pos);
essence_->lister.last_selected_abs = abs_item_pos;
}
else if (essence_->lister.last_selected_abs == abs_item_pos)
essence_->lister.last_selected_abs.set_both(npos);
}
else if (essence_->lister.last_selected_abs == abs_item_pos)
essence_->lister.last_selected_abs.set_both(npos);
}
else if(!lister.single_selection())
lister.categ_selected(item_pos.cat, true);
@ -4203,8 +4248,7 @@ namespace nana
{
item_ptr->flags.checked = ! item_ptr->flags.checked;
arg_listbox arg{ item_proxy{ essence_, abs_item_pos } };
lister.wd_ptr()->events().checked.emit(arg, lister.wd_ptr()->handle());
lister.emit_checked(abs_item_pos);
if (item_ptr->flags.checked)
lister.cancel_others_if_single_enabled(false, abs_item_pos);
@ -4469,12 +4513,13 @@ namespace nana
item_proxy & item_proxy::check(bool ck)
{
internal_scope_guard lock;
auto & m = cat_->items.at(pos_.item);
if(m.flags.checked != ck)
{
m.flags.checked = ck;
arg_listbox arg{*this};
ess_->lister.wd_ptr()->events().checked.emit(arg, ess_->lister.wd_ptr()->handle());
ess_->lister.emit_checked(pos_);
ess_->update();
}
return *this;
@ -4488,13 +4533,14 @@ namespace nana
/// is ignored if no change (maybe set last_selected anyway??), but if change emit event, deselect others if need ans set/unset last_selected
item_proxy & item_proxy::select(bool s)
{
internal_scope_guard lock;
//pos_ never represents a category if this item_proxy is available.
auto & m = cat_->items.at(pos_.item); // a ref to the real item
if(m.flags.selected == s) return *this; // ignore if no change
m.flags.selected = s; // actually change selection
arg_listbox arg{*this};
ess_->lister.wd_ptr()->events().selected.emit(arg, ess_->lister.wd_ptr()->handle());
ess_->lister.emit_selected(this->pos_);
if (m.flags.selected)
{
@ -4565,14 +4611,6 @@ namespace nana
std::string item_proxy::text(size_type col) const
{
if (cat_->model_ptr)
{
auto cells = cat_->model_ptr->container()->to_cells(pos_.item);
if (col < cells.size())
return cells[col].text;
return{};
}
return ess_->lister.get_cells(cat_, pos_.item).at(col).text;
}
@ -4692,7 +4730,7 @@ namespace nana
return pos_;
}
auto item_proxy::_m_cells() const -> std::vector<cell>&
auto item_proxy::_m_cells() const -> std::vector<cell>
{
return ess_->lister.get_cells(cat_, pos_.item);
}
@ -4771,10 +4809,11 @@ namespace nana
for (item_proxy &it : *this )
it.select(sel);
ess_->lister.last_selected_abs = ess_->lister.last_selected_dpl = index_pair {this->pos_, npos};
ess_->lister.last_selected_abs = index_pair {this->pos_, npos};
return *this;
}
bool cat_proxy::selected() const
{
for (item_proxy &it : *this )
@ -5027,9 +5066,24 @@ namespace nana
internal_scope_guard lock;
cat_->sorted.push_back(cat_->items.size());
cells.resize(columns());
cat_->items.emplace_back(std::move(cells));
if (cat_->model_ptr)
{
es_lister::throw_if_immutable_model(cat_->model_ptr.get());
auto container = cat_->model_ptr->container();
auto item_index = container->size();
cat_->items.emplace_back();
container->emplace_back();
container->assign(item_index, cells);
}
else
{
cat_->sorted.push_back(cat_->items.size());
cells.resize(columns());
cat_->items.emplace_back(std::move(cells));
}
assign_colors_for_last(ess_, cat_);
}

91
source/gui/widgets/menu.cpp
View File

@ -18,6 +18,7 @@
#include <nana/gui/wvl.hpp>
#include <nana/paint/text_renderer.hpp>
#include <cctype> //introduces tolower
#include <map>
namespace nana
{
@ -113,19 +114,15 @@ namespace nana
void item(graph_reference graph, const nana::rectangle& r, const attr& at)
{
if (!at.enabled)
return;
if(at.item_state == state::active)
{
graph.rectangle(r, false, static_cast<color_rgb>(0xa8d8eb));
nana::point points[4] = {
nana::point(r.x, r.y),
nana::point(r.x + r.width - 1, r.y),
nana::point(r.x, r.y + r.height - 1),
nana::point(r.x + r.width - 1, r.y + r.height - 1)
};
graph.palette(false, static_cast<color_rgb>(0xc0ddfc));
for(int i = 0; i < 4; ++i)
graph.set_pixel(points[i].x, points[i].y);
paint::draw(graph).corner(r, 1);
if(at.enabled)
graph.gradual_rectangle(nana::rectangle(r).pare_off(1), static_cast<color_rgb>(0xE8F0F4), static_cast<color_rgb>(0xDBECF4), true);
@ -271,7 +268,7 @@ namespace nana
if(item.sub_menu == nullptr)
{
item.sub_menu = &sub;
sub.owner.push_back(&root_);
sub.owner.emplace_back(&root_);
return true;
}
}
@ -479,7 +476,7 @@ namespace nana
--pos;
}
if(! menu_->items.at(pos).flags.splitter)
if(! menu_->items.at(pos).flags.splitter && menu_->items.at(pos).flags.enabled)
break;
}
@ -785,9 +782,8 @@ namespace nana
{
if (event_code::mouse_down == arg.evt_code)
_m_open_sub(0); //Try to open submenu immediately
else if (event_code::mouse_up == arg.evt_code)
if (arg.button == ::nana::mouse::left_button)
pick();
else if ((event_code::mouse_up == arg.evt_code) && (mouse::left_button == arg.button))
pick();
};
events.mouse_down.connect_unignorable(fn);
@ -885,48 +881,45 @@ namespace nana
return;
menu_item_type & item = menu->items.at(active);
if (item.flags.splitter == false && item.sub_menu == nullptr)
if ((!item.flags.enabled) || item.flags.splitter || item.sub_menu)
return;
if (checks::highlight == item.style)
{
//There is a situation that menu will not call functor if the item style is check_option
//and it is checked before clicking.
bool call_functor = true;
if (checks::highlight == item.style)
item.flags.checked = !item.flags.checked;
}
else if (checks::option == item.style)
{
//Forward Looks for a splitter
auto pos = active;
while (pos)
{
item.flags.checked = !item.flags.checked;
}
else if (checks::option == item.style)
{
//Forward Looks for a splitter
auto pos = active;
while (pos)
{
if (menu->items.at(--pos).flags.splitter)
break;
}
for (; pos < menu->items.size(); ++pos)
{
menu_item_type & im = menu->items.at(pos);
if (im.flags.splitter) break;
if ((checks::option == im.style) && im.flags.checked)
im.flags.checked = false;
}
item.flags.checked = true;
if (menu->items.at(--pos).flags.splitter)
break;
}
this->_m_close_all(); //means deleting this;
//The deleting operation has moved here, because item.functor.operator()(ip)
//may create a window, which make a killing focus for menu window, if so the close_all
//operation preformences after item.functor.operator()(ip), that would be deleting this object twice!
if (call_functor && item.flags.enabled && item.functor)
for (; pos < menu->items.size(); ++pos)
{
item_type::item_proxy ip(active, item);
item.functor.operator()(ip);
menu_item_type & im = menu->items.at(pos);
if (im.flags.splitter) break;
if ((checks::option == im.style) && im.flags.checked)
im.flags.checked = false;
}
item.flags.checked = true;
}
this->_m_close_all(); //means deleting this;
//The deleting operation has moved here, because item.functor.operator()(ip)
//may create a window, which make a killing focus for menu window, if so the close_all
//operation preformences after item.functor.operator()(ip), that would be deleting this object twice!
if (item.functor)
{
item_type::item_proxy ip(active, item);
item.functor.operator()(ip);
}
}
private:

12
source/gui/widgets/menubar.cpp
View File

@ -55,7 +55,7 @@ namespace nana
void append(const native_string_type& text, unsigned long shortkey)
{
if(shortkey && shortkey < 0x61) shortkey += (0x61 - 0x41);
cont_.push_back(new item_type(text, shortkey));
cont_.emplace_back(new item_type(text, shortkey));
}
std::size_t find(unsigned long shortkey) const
@ -112,13 +112,9 @@ namespace nana
nana::rectangle r(pos, size);
graph_.rectangle(r, false, border);
int right = pos.x + static_cast<int>(size.width) - 1;
int bottom = pos.y + static_cast<int>(size.height) - 1;
graph_.palette(false, corner);
graph_.set_pixel(pos.x, pos.y);
graph_.set_pixel(right, pos.y);
graph_.set_pixel(pos.x, bottom);
graph_.set_pixel(right, bottom);
paint::draw{ graph_ }.corner(r, 1);
graph_.rectangle(r.pare_off(1), true, body);
}
@ -216,7 +212,7 @@ namespace nana
if (hotkey)
{
unsigned off_w = (hotkey_pos ? graph.text_extent_size(text.c_str(), static_cast<unsigned>(hotkey_pos)).width : 0);
unsigned off_w = (hotkey_pos ? graph.text_extent_size(text.c_str(), hotkey_pos).width : 0);
nana::size hotkey_size = graph.text_extent_size(text.c_str() + hotkey_pos, 1);
unsigned ascent, descent, inleading;

812
source/gui/widgets/skeletons/text_editor.cpp
View File

File diff suppressed because it is too large Load Diff

2
source/gui/widgets/slider.cpp
View File

@ -1,5 +1,6 @@
#include <nana/gui/widgets/slider.hpp>
#include <nana/paint/pixel_buffer.hpp>
#include <cstring> //memcpy
namespace nana
@ -645,7 +646,6 @@ namespace nana
{
adorn.bound.x = static_cast<int>(attr_.adorn_pos + attr_.slider.border_weight + bar.area.y);
adorn.bound.y = static_cast<int>(graph.height()) - static_cast<int>(attr_.slider.border_weight + bar.area.y);
//adorn.bound.x =
}
else
{

2
source/gui/widgets/spinbox.cpp
View File

@ -607,7 +607,7 @@ namespace nana
internal_scope_guard lock;
auto editor = get_drawer_trigger().impl()->editor();
if (editor)
editor->editable(accept);
editor->editable(accept, false);
}
bool spinbox::editable() const

9
source/gui/widgets/tabbar.cpp
View File

@ -748,14 +748,13 @@ namespace nana
bool _m_add_tab(std::size_t pos)
{
item_t m;
if((pos == npos) || (pos >= list_.size()))
{
this->list_.push_back(m);
pos = static_cast<unsigned>(list_.size() - 1);
this->list_.emplace_back();
pos = list_.size() - 1;
}
else
list_.insert(iterator_at(pos), m);
list_.emplace(iterator_at(pos));
basis_.active = pos;
if(evt_agent_)
@ -1505,7 +1504,7 @@ namespace nana
for (auto & m : items)
{
auto ts = graph.bidi_extent_size(m.text);
pxs.push_back(ts.width + 12);
pxs.emplace_back(ts.width + 12);
pixels += ts.width + 12;
}

38
source/gui/widgets/textbox.cpp
View File

@ -65,7 +65,6 @@ namespace drawerbase {
{
auto wd = wdg.handle();
widget_ = &wdg;
evt_agent_.reset(new event_agent(static_cast<::nana::textbox&>(wdg), editor_->text_position()));
auto scheme = API::dev::get_scheme(wdg);
@ -73,6 +72,8 @@ namespace drawerbase {
editor_->textbase().set_event_agent(evt_agent_.get());
editor_->set_event(evt_agent_.get());
evt_agent_.reset(new event_agent(static_cast<::nana::textbox&>(wdg), editor_->text_position()));
_m_text_area(graph.width(), graph.height());
API::tabstop(wd);
@ -344,8 +345,8 @@ namespace drawerbase {
{
auto editor = get_drawer_trigger().editor();
internal_scope_guard lock;
if (editor)
editor->move_caret(pos);
if (editor && editor->move_caret(pos, true))
API::refresh_window(handle());
return *this;
}
@ -414,7 +415,16 @@ namespace drawerbase {
internal_scope_guard lock;
auto editor = get_drawer_trigger().editor();
if(editor)
editor->editable(able);
editor->editable(able, false);
return *this;
}
textbox& textbox::enable_caret()
{
internal_scope_guard lock;
auto editor = get_drawer_trigger().editor();
if (editor)
editor->editable(editor->attr().editable, true);
return *this;
}
@ -459,6 +469,18 @@ namespace drawerbase {
API::update_window(*this);
}
std::pair<upoint, upoint> textbox::selection() const
{
std::pair<upoint, upoint> points;
internal_scope_guard lock;
auto editor = get_drawer_trigger().editor();
if (editor)
editor->get_select_points(points.first, points.second);
return points;
}
void textbox::copy() const
{
internal_scope_guard lock;
@ -606,6 +628,14 @@ namespace drawerbase {
editor->select_behavior(move_to_end);
}
void textbox::set_undo_queue_length(std::size_t len)
{
internal_scope_guard lock;
auto editor = get_drawer_trigger().editor();
if (editor)
editor->set_undo_queue_length(len);
}
//Override _m_caption for caption()
auto textbox::_m_caption() const throw() -> native_string_type
{

1
source/gui/widgets/treebox.cpp
View File

@ -15,6 +15,7 @@
#include <nana/gui/layout_utility.hpp>
#include <nana/system/platform.hpp>
#include <stdexcept>
#include <map>
namespace nana
{

6
source/gui/widgets/widget.cpp
View File

@ -382,12 +382,6 @@ namespace nana
}
//class widget_base
widget_base::~widget_base()
{
if (handle_)
API::close_window(handle_);
}
window widget_base::handle() const
{
return handle_;

20
source/internationalization.cpp
View File

@ -13,7 +13,7 @@
#include <nana/push_ignore_diagnostic>
#include <nana/internationalization.hpp>
#include <nana/gui/widgets/widget.hpp>
#include <nana/gui/programming_interface.hpp>
#include <unordered_map>
#include <fstream>
@ -486,32 +486,22 @@ namespace nana
void i18n_eval::_m_add_args(std::string& str)
{
args_.emplace_back(new arg_string(nana::charset(str)));
args_.emplace_back(new arg_string(str));
}
void i18n_eval::_m_add_args(const std::string& str)
{
args_.emplace_back(new arg_string(nana::charset(str)));
args_.emplace_back(new arg_string(str));
}
void i18n_eval::_m_add_args(std::string&& str)
{
args_.emplace_back(new arg_string(nana::charset(std::move(str))));
}
void i18n_eval::_m_add_args(std::wstring& str)
{
args_.emplace_back(new arg_string(nana::charset(str)));
args_.emplace_back(new arg_string(std::move(str)));
}
void i18n_eval::_m_add_args(const std::wstring& str)
{
args_.emplace_back(new arg_string(nana::charset(str)));
}
void i18n_eval::_m_add_args(std::wstring&& str)
{
args_.emplace_back(new arg_string(nana::charset(std::move(str))));
args_.emplace_back(new arg_string(to_utf8(str)));
}
//end class i18n_eval
}

431
source/paint/graphics.cpp
View File

@ -140,13 +140,13 @@ namespace paint
unsigned font::height() const
{
if(empty()) return false;
if(empty()) return 0;
return (impl_->font_ptr->height);
}
unsigned font::weight() const
{
if(empty()) return false;
if(empty()) return 0;
return (impl_->font_ptr->weight);
}
@ -194,76 +194,106 @@ namespace paint
//end class font
//class graphics
struct graphics::implementation
{
std::shared_ptr<::nana::detail::drawable_impl_type> platform_drawable;
font font_shadow;
drawable_type handle{ nullptr };
::nana::size size;
pixel_buffer pxbuf;
bool changed{ false };
};
graphics::graphics()
:handle_(nullptr), changed_(false)
: impl_(new implementation)
{}
graphics::graphics(const nana::size& sz)
:handle_(nullptr), changed_(true)
: impl_(new implementation)
{
make(sz);
}
graphics::graphics(const graphics& rhs)
:dwptr_(rhs.dwptr_), handle_(rhs.handle_), size_(rhs.size_), changed_(true)
: impl_(new implementation(*rhs.impl_))
{}
graphics& graphics::operator=(const graphics& rhs)
{
if(this != &rhs)
{
size_ = rhs.size_;
dwptr_ = rhs.dwptr_;
handle_ = rhs.handle_;
if(changed_ == false) changed_ = true;
*impl_ = *rhs.impl_;
impl_->changed = true;
}
return *this;
}
bool graphics::changed() const
graphics::graphics(graphics&& other)
: impl_(std::move(other.impl_))
{
return this->changed_;
}
bool graphics::empty() const { return (handle_ == nullptr); }
graphics& graphics::operator=(graphics&& other)
{
if (this != &other)
impl_ = std::move(other.impl_);
return *this;
}
graphics::~graphics()
{
//For instance of unique_ptr pimpl
}
bool graphics::changed() const
{
return impl_->changed;
}
bool graphics::empty() const
{
return (!impl_->handle);
}
graphics::operator const void *() const
{
return handle_;
return impl_->handle;
}
drawable_type graphics::handle() const
{
return handle_;
return impl_->handle;
}
const void* graphics::pixmap() const
{
//The reinterpret_cast is used for same platform. Under Windows, the type
//of pixmap can be conversed into void* directly, but under X11, the type is not a pointer.
return (handle_? reinterpret_cast<void*>(handle_->pixmap) : nullptr);
return (impl_->handle ? reinterpret_cast<void*>(impl_->handle->pixmap) : nullptr);
}
const void* graphics::context() const
{
return (handle_? handle_->context : nullptr);
return (impl_->handle ? impl_->handle->context : nullptr);
}
void graphics::make(const ::nana::size& sz)
{
if(handle_ == nullptr || size_ != sz)
if(impl_->handle == nullptr || impl_->size != sz)
{
//The object will be delete while dwptr_ is performing a release.
drawable_type dw = new nana::detail::drawable_impl_type;
//Reuse the old font
if(dwptr_)
if(impl_->platform_drawable)
{
drawable_type reuse = dwptr_.get();
drawable_type reuse = impl_->platform_drawable.get();
dw->font = reuse->font;
dw->string.tab_length = reuse->string.tab_length;
}
else
dw->font = font_shadow_.impl_->font_ptr;
dw->font = impl_->font_shadow.impl_->font_ptr;
#if defined(NANA_WINDOWS)
HDC hdc = ::GetDC(0);
@ -319,21 +349,22 @@ namespace paint
#else
dw->update_text_color();
#endif
dwptr_.reset(dw, detail::drawable_deleter{});
handle_ = dw;
size_ = sz;
impl_->platform_drawable.reset(dw, detail::drawable_deleter{});
impl_->handle = dw;
impl_->size = sz;
handle_->string.tab_pixels = detail::raw_text_extent_size(handle_, L"\t", 1).width;
handle_->string.whitespace_pixels = detail::raw_text_extent_size(handle_, L" ", 1).width;
impl_->handle->string.tab_pixels = detail::raw_text_extent_size(impl_->handle, L"\t", 1).width;
impl_->handle->string.whitespace_pixels = detail::raw_text_extent_size(impl_->handle, L" ", 1).width;
}
}
if(changed_ == false) changed_ = true;
if(impl_->changed == false)
impl_->changed = true;
}
void graphics::resize(const ::nana::size& sz)
{
graphics duplicate(*this);
graphics duplicate(std::move(*this));
make(sz);
bitblt(0, 0, duplicate);
}
@ -342,16 +373,18 @@ namespace paint
{
//Keep the font as a shadow, even if the graphics is empty. Setting the font is futile when the size
//of a widget is zero.
font_shadow_ = f;
if(handle_ && (false == f.empty()))
impl_->font_shadow = f;
if(impl_->handle && (false == f.empty()))
{
handle_->font = f.impl_->font_ptr;
impl_->handle->font = f.impl_->font_ptr;
#if defined(NANA_WINDOWS)
::SelectObject(handle_->context, reinterpret_cast<HFONT>(f.impl_->font_ptr->handle));
::SelectObject(impl_->handle->context, reinterpret_cast<HFONT>(f.impl_->font_ptr->handle));
#endif
handle_->string.tab_pixels = detail::raw_text_extent_size(handle_, L"\t", 1).width;
handle_->string.whitespace_pixels = detail::raw_text_extent_size(handle_, L" ", 1).width;
if(changed_ == false) changed_ = true;
impl_->handle->string.tab_pixels = detail::raw_text_extent_size(impl_->handle, L"\t", 1).width;
impl_->handle->string.whitespace_pixels = detail::raw_text_extent_size(impl_->handle, L" ", 1).width;
if (impl_->changed == false)
impl_->changed = true;
}
}
@ -359,7 +392,7 @@ namespace paint
{
//The font may be set when the graphics is still empty.
//it should return the shadow font when the graphics is empty.
return (handle_ ? font(handle_) : font_shadow_);
return (impl_->handle ? font(impl_->handle) : impl_->font_shadow);
}
::nana::size graphics::text_extent_size(const ::std::string& text) const
@ -385,26 +418,26 @@ namespace paint
nana::size graphics::text_extent_size(const wchar_t* str, std::size_t len) const
{
return detail::text_extent_size(handle_, str, len);
return detail::text_extent_size(impl_->handle, str, len);
}
nana::size graphics::text_extent_size(const std::wstring& str, std::size_t len) const
{
return detail::text_extent_size(handle_, str.c_str(), len);
return detail::text_extent_size(impl_->handle, str.c_str(), len);
}
nana::size graphics::glyph_extent_size(const wchar_t * str, std::size_t len, std::size_t begin, std::size_t end) const
{
if(len < end) end = len;
if (nullptr == handle_ || nullptr == str || 0 == len || begin >= end) return{};
if (nullptr == impl_->handle || nullptr == str || 0 == len || begin >= end) return{};
nana::size sz;
#if defined(NANA_WINDOWS)
int * dx = new int[len];
SIZE extents;
::GetTextExtentExPoint(handle_->context, str, static_cast<int>(len), 0, 0, dx, &extents);
::GetTextExtentExPoint(impl_->handle->context, str, static_cast<int>(len), 0, 0, dx, &extents);
sz.width = dx[end - 1] - (begin ? dx[begin - 1] : 0);
unsigned tab_pixels = handle_->string.tab_length * handle_->string.whitespace_pixels;
unsigned tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.whitespace_pixels;
const wchar_t * pend = str + end;
for(const wchar_t * p = str + begin; p != pend; ++p)
{
@ -426,14 +459,14 @@ namespace paint
bool graphics::glyph_pixels(const wchar_t * str, std::size_t len, unsigned* pxbuf) const
{
if(nullptr == handle_ || nullptr == handle_->context || nullptr == str || nullptr == pxbuf) return false;
if(nullptr == impl_->handle || nullptr == impl_->handle->context || nullptr == str || nullptr == pxbuf) return false;
if(len == 0) return true;
unsigned tab_pixels = handle_->string.tab_length * handle_->string.whitespace_pixels;
unsigned tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.whitespace_pixels;
#if defined(NANA_WINDOWS)
int * dx = new int[len];
SIZE extents;
::GetTextExtentExPoint(handle_->context, str, static_cast<int>(len), 0, 0, dx, &extents);
::GetTextExtentExPoint(impl_->handle->context, str, static_cast<int>(len), 0, 0, dx, &extents);
pxbuf[0] = (str[0] == '\t' ? tab_pixels : dx[0]);
@ -445,7 +478,7 @@ namespace paint
#elif defined(NANA_X11) && defined(NANA_USE_XFT)
Display * disp = nana::detail::platform_spec::instance().open_display();
XftFont * xft = handle_->font->handle;
XftFont * xft = impl_->handle->font->handle;
XGlyphInfo extents;
for(std::size_t i = 0; i < len; ++i)
@ -466,7 +499,7 @@ namespace paint
nana::size graphics::bidi_extent_size(const std::wstring& str) const
{
nana::size sz;
if(handle_ && handle_->context && str.size())
if(impl_->handle && impl_->handle->context && str.size())
{
std::vector<unicode_bidi::entity> reordered;
unicode_bidi bidi;
@ -489,25 +522,25 @@ namespace paint
bool graphics::text_metrics(unsigned & ascent, unsigned& descent, unsigned& internal_leading) const
{
if(handle_)
if(impl_->handle)
{
#if defined(NANA_WINDOWS)
::TEXTMETRIC tm;
::GetTextMetrics(handle_->context, &tm);
::GetTextMetrics(impl_->handle->context, &tm);
ascent = static_cast<unsigned>(tm.tmAscent);
descent = static_cast<unsigned>(tm.tmDescent);
internal_leading = static_cast<unsigned>(tm.tmInternalLeading);
return true;
#elif defined(NANA_X11)
if(handle_->font)
if(impl_->handle->font)
{
#if defined(NANA_USE_XFT)
XftFont * fs = reinterpret_cast<XftFont*>(handle_->font->handle);
XftFont * fs = reinterpret_cast<XftFont*>(impl_->handle->font->handle);
ascent = fs->ascent;
descent = fs->descent;
internal_leading = 0;
#else
XFontSet fs = reinterpret_cast<XFontSet>(handle_->font->handle);
XFontSet fs = reinterpret_cast<XFontSet>(impl_->handle->font->handle);
XFontSetExtents * ext = ::XExtentsOfFontSet(fs);
XFontStruct ** fontstructs;
char ** font_names;
@ -532,13 +565,13 @@ namespace paint
void graphics::line_begin(int x, int y)
{
if(!handle_) return;
if(!impl_->handle) return;
#if defined(NANA_WINDOWS)
::MoveToEx(handle_->context, x, y, 0);
::MoveToEx(impl_->handle->context, x, y, 0);
#elif defined(NANA_X11)
handle_->line_begin_pos.x = x;
handle_->line_begin_pos.y = y;
impl_->handle->line_begin_pos.x = x;
impl_->handle->line_begin_pos.y = y;
#endif
}
@ -552,94 +585,94 @@ namespace paint
void graphics::bitblt(const nana::rectangle& r_dst, native_window_type src)
{
if(handle_)
if(impl_->handle)
{
#if defined(NANA_WINDOWS)
HDC dc = ::GetDC(reinterpret_cast<HWND>(src));
::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, 0, 0, SRCCOPY);
::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, 0, 0, SRCCOPY);
::ReleaseDC(reinterpret_cast<HWND>(src), dc);
#elif defined(NANA_X11)
::XCopyArea(nana::detail::platform_spec::instance().open_display(),
reinterpret_cast<Window>(src), handle_->pixmap, handle_->context,
reinterpret_cast<Window>(src), impl_->handle->pixmap, impl_->handle->context,
0, 0, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
#endif
if(changed_ == false) changed_ = true;
if(impl_->changed == false) impl_->changed = true;
}
}
void graphics::bitblt(const nana::rectangle& r_dst, native_window_type src, const nana::point& p_src)
{
if(handle_)
if(impl_->handle)
{
#if defined(NANA_WINDOWS)
HDC dc = ::GetDC(reinterpret_cast<HWND>(src));
::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, p_src.x, p_src.y, SRCCOPY);
::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, p_src.x, p_src.y, SRCCOPY);
::ReleaseDC(reinterpret_cast<HWND>(src), dc);
#elif defined(NANA_X11)
::XCopyArea(nana::detail::platform_spec::instance().open_display(),
reinterpret_cast<Window>(src), handle_->pixmap, handle_->context,
reinterpret_cast<Window>(src), impl_->handle->pixmap, impl_->handle->context,
p_src.x, p_src.y, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
#endif
if(changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
}
void graphics::bitblt(const nana::rectangle& r_dst, const graphics& src)
{
if(handle_ && src.handle_)
if(impl_->handle && src.impl_->handle)
{
#if defined(NANA_WINDOWS)
::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.handle_->context, 0, 0, SRCCOPY);
::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.impl_->handle->context, 0, 0, SRCCOPY);
#elif defined(NANA_X11)
::XCopyArea(nana::detail::platform_spec::instance().open_display(),
src.handle_->pixmap, handle_->pixmap, handle_->context,
src.impl_->handle->pixmap, impl_->handle->pixmap, impl_->handle->context,
0, 0, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
#endif
if(changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
}
void graphics::bitblt(const nana::rectangle& r_dst, const graphics& src, const nana::point& p_src)
{
if(handle_ && src.handle_)
if(impl_->handle && src.impl_->handle)
{
#if defined(NANA_WINDOWS)
::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.handle_->context, p_src.x, p_src.y, SRCCOPY);
::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.impl_->handle->context, p_src.x, p_src.y, SRCCOPY);
#elif defined(NANA_X11)
::XCopyArea(nana::detail::platform_spec::instance().open_display(),
src.handle_->pixmap, handle_->pixmap, handle_->context,
src.impl_->handle->pixmap, impl_->handle->pixmap, impl_->handle->context,
p_src.x, p_src.y, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
#endif
if(changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
}
void graphics::blend(const nana::rectangle& s_r, graphics& dst, const nana::point& d_pos, double fade_rate) const
{
if(dst.handle_ && handle_ && (dst.handle_ != handle_))
if(dst.impl_->handle && impl_->handle && (dst.impl_->handle != impl_->handle))
{
pixel_buffer s_pixbuf;
s_pixbuf.attach(handle_, ::nana::rectangle{ size() });
s_pixbuf.attach(impl_->handle, ::nana::rectangle{ size() });
s_pixbuf.blend(s_r, dst.handle_, d_pos, fade_rate);
s_pixbuf.blend(s_r, dst.impl_->handle, d_pos, fade_rate);
if(dst.changed_ == false) dst.changed_ = true;
if(dst.impl_->changed == false) dst.impl_->changed = true;
}
}
void graphics::blur(const nana::rectangle& r, std::size_t radius)
{
if(handle_)
if(impl_->handle)
{
pixel_buffer pixbuf(handle_, 0, 0);
pixel_buffer pixbuf(impl_->handle, 0, 0);
pixbuf.blur(r, radius);
pixbuf.paste(handle_, point{});
pixbuf.paste(impl_->handle, point{});
}
}
void graphics::rgb_to_wb()
{
if(handle_)
if(impl_->handle)
{
//Create the color table for perfermance
float* tablebuf = new float[0x100 * 3];
@ -654,11 +687,11 @@ namespace paint
table_blue[i] = (i * 0.11f);
}
pixel_buffer pixbuf(handle_, 0, 0);
pixel_buffer pixbuf(impl_->handle, 0, 0);
auto pixels = pixbuf.raw_ptr(0);
const nana::size sz = paint::detail::drawable_size(handle_);
const nana::size sz = paint::detail::drawable_size(impl_->handle);
const int rest = sz.width % 4;
const int length_align4 = sz.width - rest;
@ -692,26 +725,26 @@ namespace paint
}
delete [] tablebuf;
pixbuf.paste(handle_, point{});
if(changed_ == false) changed_ = true;
pixbuf.paste(impl_->handle, point{});
if (impl_->changed == false) impl_->changed = true;
}
}
void graphics::paste(graphics& dst, int x, int y) const
{
if(handle_ && dst.handle_ && handle_ != dst.handle_)
if(impl_->handle && dst.impl_->handle && impl_->handle != dst.impl_->handle)
{
#if defined(NANA_WINDOWS)
::BitBlt(dst.handle_->context, x, y, size_.width, size_.height, handle_->context, 0, 0, SRCCOPY);
::BitBlt(dst.impl_->handle->context, x, y, impl_->size.width, impl_->size.height, impl_->handle->context, 0, 0, SRCCOPY);
#elif defined(NANA_X11)
Display* display = nana::detail::platform_spec::instance().open_display();
::XCopyArea(display,
handle_->pixmap, dst.handle_->pixmap, handle_->context,
0, 0, size_.width, size_.height, x, y);
impl_->handle->pixmap, dst.impl_->handle->pixmap, impl_->handle->context,
0, 0, impl_->size.width, impl_->size.height, x, y);
::XFlush(display);
#endif
dst.changed_ = true;
dst.impl_->changed = true;
}
}
@ -722,19 +755,19 @@ namespace paint
void graphics::paste(native_window_type dst, int dx, int dy, unsigned width, unsigned height, int sx, int sy) const
{
if(handle_)
if(impl_->handle)
{
#if defined(NANA_WINDOWS)
HDC dc = ::GetDC(reinterpret_cast<HWND>(dst));
if(dc)
{
::BitBlt(dc, dx, dy, width, height, handle_->context, sx, sy, SRCCOPY);
::BitBlt(dc, dx, dy, width, height, impl_->handle->context, sx, sy, SRCCOPY);
::ReleaseDC(reinterpret_cast<HWND>(dst), dc);
}
#elif defined(NANA_X11)
Display * display = nana::detail::platform_spec::instance().open_display();
::XCopyArea(display,
handle_->pixmap, reinterpret_cast<Window>(dst), handle_->context,
impl_->handle->pixmap, reinterpret_cast<Window>(dst), impl_->handle->context,
sx, sy, width, height, dx, dy);
::XMapWindow(display, reinterpret_cast<Window>(dst));
@ -745,15 +778,15 @@ namespace paint
void graphics::paste(drawable_type dst, int x, int y) const
{
if(handle_ && dst && handle_ != dst)
if(impl_->handle && dst && impl_->handle != dst)
{
#if defined (NANA_WINDOWS)
::BitBlt(dst->context, x, y, size_.width, size_.height, handle_->context, 0, 0, SRCCOPY);
::BitBlt(dst->context, x, y, impl_->size.width, impl_->size.height, impl_->handle->context, 0, 0, SRCCOPY);
#elif defined(NANA_X11)
Display * display = nana::detail::platform_spec::instance().open_display();
::XCopyArea(display,
handle_->pixmap, dst->pixmap, handle_->context,
0, 0, size_.width, size_.height, x, y);
impl_->handle->pixmap, dst->pixmap, impl_->handle->context,
0, 0, impl_->size.width, impl_->size.height, x, y);
::XFlush(display);
#endif
}
@ -762,14 +795,14 @@ namespace paint
void graphics::paste(const nana::rectangle& r_src, graphics& dst, int x, int y) const
{
if(handle_ && dst.handle_ && handle_ != dst.handle_)
if(impl_->handle && dst.impl_->handle && impl_->handle != dst.impl_->handle)
{
#if defined(NANA_WINDOWS)
::BitBlt(dst.handle_->context, x, y, r_src.width, r_src.height, handle_->context, r_src.x, r_src.y, SRCCOPY);
::BitBlt(dst.impl_->handle->context, x, y, r_src.width, r_src.height, impl_->handle->context, r_src.x, r_src.y, SRCCOPY);
#elif defined(NANA_X11)
Display* display = nana::detail::platform_spec::instance().open_display();
::XCopyArea(display,
handle_->pixmap, dst.handle_->pixmap, handle_->context,
impl_->handle->pixmap, dst.impl_->handle->pixmap, impl_->handle->context,
r_src.x, r_src.y, r_src.width, r_src.height, x, y);
::XFlush(display);
@ -779,10 +812,10 @@ namespace paint
void graphics::stretch(const nana::rectangle& src_r, graphics& dst, const nana::rectangle& r) const
{
if(handle_ && dst.handle_ && (handle_ != dst.handle_))
if(impl_->handle && dst.impl_->handle && (impl_->handle != dst.impl_->handle))
{
pixel_buffer pixbuf(handle_, 0, 0);
pixbuf.stretch(src_r, dst.handle_, r);
pixel_buffer pixbuf(impl_->handle, 0, 0);
pixbuf.stretch(src_r, dst.impl_->handle, r);
}
}
@ -799,58 +832,58 @@ namespace paint
}
unsigned graphics::width() const{
return size_.width;
return impl_->size.width;
}
unsigned graphics::height() const{
return size_.height;
return impl_->size.height;
}
nana::size graphics::size() const{
return this->size_;
return this->impl_->size;
}
void graphics::setsta()
{
changed_ = false;
impl_->changed = false;
}
void graphics::set_changed()
{
changed_ = true;
impl_->changed = true;
}
void graphics::release()
{
dwptr_.reset();
handle_ = nullptr;
size_.width = size_.height = 0;
impl_->platform_drawable.reset();
impl_->handle = nullptr;
impl_->size.width = impl_->size.height = 0;
}
void graphics::save_as_file(const char* file_utf8) const throw()
{
if(handle_)
if(impl_->handle)
{
#if defined(NANA_WINDOWS)
int iWidth = static_cast<int>(size_.width);
int iHeight = static_cast<int>(size_.height);
const int iWidth = static_cast<int>(impl_->size.width);
const int iHeight = static_cast<int>(impl_->size.height);
BITMAPINFO bmpInfo = {};
bmpInfo.bmiHeader.biSize = sizeof(bmpInfo.bmiHeader);
bmpInfo.bmiHeader.biWidth = static_cast<int>(size_.width);
bmpInfo.bmiHeader.biHeight = static_cast<int>(size_.height);
bmpInfo.bmiHeader.biWidth = iWidth;
bmpInfo.bmiHeader.biHeight = iHeight;
bmpInfo.bmiHeader.biPlanes = 1;
bmpInfo.bmiHeader.biBitCount = 24;
const size_t lineBytes = ((bmpInfo.bmiHeader.biWidth * 3) + 3) & (~3);
const size_t imageBytes = iHeight * lineBytes;
HDC hdcMem = ::CreateCompatibleDC(handle_->context);
HDC hdcMem = ::CreateCompatibleDC(impl_->handle->context);
BYTE *pData = nullptr;
HBITMAP hBmp = ::CreateDIBSection(hdcMem, &bmpInfo, DIB_RGB_COLORS, reinterpret_cast<void**>(&pData), 0, 0);
::SelectObject(hdcMem, hBmp);
BitBlt(hdcMem, 0, 0, iWidth, iHeight, handle_->context, 0, 0, SRCCOPY);
BitBlt(hdcMem, 0, 0, iWidth, iHeight, impl_->handle->context, 0, 0, SRCCOPY);
BITMAPFILEHEADER bmFileHeader = { 0 };
bmFileHeader.bfType = 0x4d42; //bmp
@ -874,20 +907,20 @@ namespace paint
::nana::color graphics::palette(bool for_text) const
{
if (handle_)
return static_cast<color_rgb>(for_text ? handle_->get_text_color() : handle_->get_color());
if (impl_->handle)
return static_cast<color_rgb>(for_text ? impl_->handle->get_text_color() : impl_->handle->get_color());
return{};
}
graphics& graphics::palette(bool for_text, const ::nana::color& clr)
{
if (handle_)
if (impl_->handle)
{
if (for_text)
handle_->set_text_color(clr);
impl_->handle->set_text_color(clr);
else
handle_->set_color(clr);
impl_->handle->set_color(clr);
}
return *this;
@ -915,34 +948,34 @@ namespace paint
void graphics::blend(const nana::rectangle& r, const ::nana::color& clr, double fade_rate)
{
if (handle_)
if (impl_->handle)
{
nana::paint::detail::blend(handle_, r, clr.px_color(), fade_rate);
if (changed_ == false) changed_ = true;
nana::paint::detail::blend(impl_->handle, r, clr.px_color(), fade_rate);
if (impl_->changed == false) impl_->changed = true;
}
}
void graphics::set_pixel(int x, int y, const ::nana::color& clr)
{
if (handle_)
if (impl_->handle)
{
handle_->set_color(clr);
impl_->handle->set_color(clr);
set_pixel(x, y);
}
}
void graphics::set_pixel(int x, int y)
{
if (handle_)
if (impl_->handle)
{
#if defined(NANA_WINDOWS)
::SetPixel(handle_->context, x, y, NANA_RGB(handle_->get_color()));
::SetPixel(impl_->handle->context, x, y, NANA_RGB(impl_->handle->get_color()));
#elif defined(NANA_X11)
Display* disp = nana::detail::platform_spec::instance().open_display();
handle_->update_color();
::XDrawPoint(disp, handle_->pixmap, handle_->context, x, y);
impl_->handle->update_color();
::XDrawPoint(disp, impl_->handle->pixmap, impl_->handle->context, x, y);
#endif
if (changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
}
@ -959,24 +992,24 @@ namespace paint
void graphics::string(nana::point pos, const wchar_t* str, std::size_t len)
{
if (handle_ && str && len)
if (impl_->handle && str && len)
{
auto const end = str + len;
auto i = std::find(str, end, '\t');
#if defined(NANA_LINUX) || defined(NANA_MACOS)
handle_->update_text_color();
impl_->handle->update_text_color();
#endif
if (i != end)
{
std::size_t tab_pixels = handle_->string.tab_length * handle_->string.tab_pixels;
std::size_t tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.tab_pixels;
while (true)
{
len = i - str;
if (len)
{
//Render a part that does not contains a tab
detail::draw_string(handle_, pos, str, len);
pos.x += detail::raw_text_extent_size(handle_, str, len).width;
detail::draw_string(impl_->handle, pos, str, len);
pos.x += detail::raw_text_extent_size(impl_->handle, str, len).width;
}
str = i;
@ -994,8 +1027,8 @@ namespace paint
}
}
else
detail::draw_string(handle_, pos, str, len);
if (changed_ == false) changed_ = true;
detail::draw_string(impl_->handle, pos, str, len);
if (impl_->changed == false) impl_->changed = true;
}
}
@ -1017,21 +1050,21 @@ namespace paint
void graphics::line(const nana::point& pos1, const nana::point& pos2)
{
if (!handle_) return;
if (!impl_->handle) return;
#if defined(NANA_WINDOWS)
handle_->update_pen();
impl_->handle->update_pen();
if (pos1 != pos2)
{
::MoveToEx(handle_->context, pos1.x, pos1.y, 0);
::LineTo(handle_->context, pos2.x, pos2.y);
::MoveToEx(impl_->handle->context, pos1.x, pos1.y, 0);
::LineTo(impl_->handle->context, pos2.x, pos2.y);
}
::SetPixel(handle_->context, pos2.x, pos2.y, NANA_RGB(handle_->pen.color));
::SetPixel(impl_->handle->context, pos2.x, pos2.y, NANA_RGB(impl_->handle->pen.color));
#elif defined(NANA_X11)
Display* disp = nana::detail::platform_spec::instance().open_display();
handle_->update_color();
::XDrawLine(disp, handle_->pixmap, handle_->context, pos1.x, pos1.y, pos2.x, pos2.y);
impl_->handle->update_color();
::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, pos1.x, pos1.y, pos2.x, pos2.y);
#endif
if (changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
void graphics::line(const point& pos_a, const point& pos_b, const color& clr)
@ -1042,26 +1075,26 @@ namespace paint
void graphics::line_to(const point& pos, const color& clr)
{
if (!handle_) return;
handle_->set_color(clr);
if (!impl_->handle) return;
impl_->handle->set_color(clr);
line_to(pos);
}
void graphics::line_to(const point& pos)
{
if (!handle_) return;
if (!impl_->handle) return;
#if defined(NANA_WINDOWS)
handle_->update_pen();
::LineTo(handle_->context, pos.x, pos.y);
impl_->handle->update_pen();
::LineTo(impl_->handle->context, pos.x, pos.y);
#elif defined(NANA_X11)
Display* disp = nana::detail::platform_spec::instance().open_display();
handle_->update_color();
::XDrawLine(disp, handle_->pixmap, handle_->context,
handle_->line_begin_pos.x, handle_->line_begin_pos.y,
impl_->handle->update_color();
::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context,
impl_->handle->line_begin_pos.x, impl_->handle->line_begin_pos.y,
pos.x, pos.y);
handle_->line_begin_pos = pos;
impl_->handle->line_begin_pos = pos;
#endif
if (changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
void graphics::rectangle(bool solid)
@ -1077,21 +1110,21 @@ namespace paint
void graphics::rectangle(const ::nana::rectangle& r, bool solid)
{
if (r.width && r.height && handle_ && r.right() > 0 && r.bottom() > 0)
if (r.width && r.height && impl_->handle && r.right() > 0 && r.bottom() > 0)
{
#if defined(NANA_WINDOWS)
::RECT native_r = { r.x, r.y, r.right(), r.bottom()};
handle_->update_brush();
(solid ? ::FillRect : ::FrameRect)(handle_->context, &native_r, handle_->brush.handle);
impl_->handle->update_brush();
(solid ? ::FillRect : ::FrameRect)(impl_->handle->context, &native_r, impl_->handle->brush.handle);
#elif defined(NANA_X11)
Display* disp = nana::detail::platform_spec::instance().open_display();
handle_->update_color();
impl_->handle->update_color();
if (solid)
::XFillRectangle(disp, handle_->pixmap, handle_->context, r.x, r.y, r.width, r.height);
::XFillRectangle(disp, impl_->handle->pixmap, impl_->handle->context, r.x, r.y, r.width, r.height);
else
::XDrawRectangle(disp, handle_->pixmap, handle_->context, r.x, r.y, r.width - 1, r.height - 1);
::XDrawRectangle(disp, impl_->handle->pixmap, impl_->handle->context, r.x, r.y, r.width - 1, r.height - 1);
#endif
if (changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
}
@ -1138,13 +1171,13 @@ namespace paint
void graphics::gradual_rectangle(const ::nana::rectangle& rct, const ::nana::color& from, const ::nana::color& to, bool vertical)
{
#if defined(NANA_WINDOWS)
if (pxbuf_.open(handle_))
if (impl_->pxbuf.open(impl_->handle))
{
pxbuf_.gradual_rectangle(rct, from, to, 0.0, vertical);
pxbuf_.paste(handle_, point{});
impl_->pxbuf.gradual_rectangle(rct, from, to, 0.0, vertical);
impl_->pxbuf.paste(impl_->handle, point{});
}
#elif defined(NANA_X11)
if (nullptr == handle_) return;
if (nullptr == impl_->handle) return;
double deltapx = double(vertical ? rct.height : rct.width);
double r, g, b;
@ -1155,7 +1188,7 @@ namespace paint
unsigned last_color = (int(r) << 16) | (int(g) << 8) | int(b);
Display * disp = nana::detail::platform_spec::instance().open_display();
handle_->fgcolor(static_cast<color_rgb>(last_color));
impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
const int endpos = deltapx + (vertical ? rct.y : rct.x);
if (endpos > 0)
{
@ -1165,12 +1198,12 @@ namespace paint
auto y = rct.y;
for (; y < endpos; ++y)
{
::XDrawLine(disp, handle_->pixmap, handle_->context, x1, y, x2, y);
::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, x1, y, x2, y);
unsigned new_color = (int(r += delta_r) << 16) | (int(g += delta_g) << 8) | int(b += delta_b);
if (new_color != last_color)
{
last_color = new_color;
handle_->fgcolor(static_cast<color_rgb>(last_color));
impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
}
}
}
@ -1180,39 +1213,40 @@ namespace paint
auto x = rct.x;
for (; x < endpos; ++x)
{
::XDrawLine(disp, handle_->pixmap, handle_->context, x, y1, x, y2);
::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, x, y1, x, y2);
unsigned new_color = (int(r += delta_r) << 16) | (int(g += delta_g) << 8) | int(b += delta_b);
if (new_color != last_color)
{
last_color = new_color;
handle_->fgcolor(static_cast<color_rgb>(last_color));
impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
}
}
}
}
#endif
if (changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
}
void graphics::round_rectangle(const ::nana::rectangle& r, unsigned radius_x, unsigned radius_y, const color& clr, bool solid, const color& solid_clr)
{
if (handle_)
if (impl_->handle)
{
#if defined(NANA_WINDOWS)
handle_->set_color(clr);
impl_->handle->set_color(clr);
if (solid)
{
handle_->update_pen();
handle_->brush.set(handle_->context, handle_->brush.Solid, solid_clr.px_color().value);
::RoundRect(handle_->context, r.x, r.y, r.right(), r.bottom(), static_cast<int>(radius_x * 2), static_cast<int>(radius_y * 2));
impl_->handle->update_pen();
impl_->handle->brush.set(impl_->handle->context, impl_->handle->brush.Solid, solid_clr.px_color().value);
::RoundRect(impl_->handle->context, r.x, r.y, r.right(), r.bottom(), static_cast<int>(radius_x * 2), static_cast<int>(radius_y * 2));
}
else
{
handle_->update_brush();
handle_->round_region.set(r, radius_x, radius_y);
::FrameRgn(handle_->context, handle_->round_region.handle, handle_->brush.handle, 1, 1);
impl_->handle->update_brush();
impl_->handle->round_region.set(r, radius_x, radius_y);
::FrameRgn(impl_->handle->context, impl_->handle->round_region.handle, impl_->handle->brush.handle, 1, 1);
}
if(changed_ == false) changed_ = true;
if (impl_->changed == false) impl_->changed = true;
#elif defined(NANA_X11)
if(solid && (clr == solid_clr))
{
@ -1233,5 +1267,40 @@ namespace paint
}
//end class graphics
//class draw
draw::draw(graphics& graph)
: graph_(graph)
{}
void draw::corner(const rectangle& r, unsigned pixels)
{
if (1 == pixels)
{
graph_.set_pixel(r.x, r.y);
graph_.set_pixel(r.right() - 1, r.y);
graph_.set_pixel(r.x, r.bottom() - 1);
graph_.set_pixel(r.right() - 1, r.bottom() - 1);
return;
}
else if (1 < pixels)
{
graph_.line(r.position(), point(r.x + pixels, r.y));
graph_.line(r.position(), point(r.x, r.y + pixels));
int right = r.right() - 1;
graph_.line(point(right, r.y), point(right - pixels, r.y));
graph_.line(point(right, r.y), point(right, r.y - pixels));
int bottom = r.bottom() - 1;
graph_.line(point(r.x, bottom), point(r.x + pixels, bottom));
graph_.line(point(r.x, bottom), point(r.x, bottom - pixels));
graph_.line(point(right, bottom), point(right - pixels, bottom));
graph_.line(point(right, bottom), point(right, bottom - pixels));
}
}
//end class draw
}//end namespace paint
}//end namespace nana

6
source/paint/text_renderer.cpp
View File

@ -70,7 +70,7 @@ namespace nana
auto ts = detail::text_extent_size(dw, ent.begin, ent.end - ent.begin);
if(ts.height > pixels) pixels = ts.height;
lenpx += ts.width;
widths.push_back(ts.width);
widths.emplace_back(ts.width);
}
pos.x += (endpos - pos.x - static_cast<int>(lenpx))/2;
@ -199,7 +199,7 @@ namespace nana
{
nana::size ts = detail::text_extent_size(dw, i.begin, i.end - i.begin);
if(ts.height > pixels) pixels = ts.height;
ts_keeper.push_back(ts);
ts_keeper.emplace_back(ts);
str_w += ts.width;
}
@ -417,7 +417,7 @@ namespace nana
for(auto & i : reordered)
{
nana::size ts = detail::text_extent_size(dw, i.begin, i.end - i.begin);
ts_keeper.push_back(ts);
ts_keeper.emplace_back(ts);
str_w += ts.width;
}

1
source/system/dataexch.cpp
View File

@ -13,6 +13,7 @@
#include <nana/system/dataexch.hpp>
#include <nana/traits.hpp>
#include <nana/paint/graphics.hpp>
#include <nana/paint/pixel_buffer.hpp>
#include <vector>
#include <cassert>
#include <cstring>

4
source/threads/pool.cpp
View File

@ -94,7 +94,7 @@ namespace threads
pto->suspended = false;
::pthread_create(&(pto->handle), 0, reinterpret_cast<void*(*)(void*)>(&impl::_m_thr_starter), pto);
#endif
container_.threads.push_back(pto);
container_.threads.emplace_back(pto);
}
}
@ -168,7 +168,7 @@ namespace threads
else
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
container_.tasks.push_back(taskptr);
container_.tasks.emplace_back(taskptr);
}
}

11
source/unicode_bidi.cpp
View File

@ -536,7 +536,8 @@ namespace nana
}
else if (LRE <= *c && *c <= RLO)
{
stack.push_back(cur);
stack.emplace_back(cur);
if (begin_character)
{
_m_push_entity(begin_character, c, cur.level, begin_char_type);
@ -607,19 +608,21 @@ namespace nana
void unicode_bidi::_m_push_entity(const char_type * begin, const char_type *end, unsigned level, bidi_char bidi_char_type)
{
entity e;
levels_.emplace_back();
auto & e = levels_.back();
e.begin = begin;
e.end = end;
e.level = level;
e.bidi_char_type = bidi_char_type;
levels_.push_back(e);
}
}
std::vector<unicode_bidi::entity>::iterator unicode_bidi::_m_search_first_character()
{
return levels_.begin();
}
auto unicode_bidi::_m_eor(std::vector<entity>::iterator i) ->bidi_char
{
const auto end = levels_.end();