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

add new platform_abstraction

Browse Source 
add support of loading ttf file
This commit is contained in:
Jinhao
2017-04-26 08:04:25 +08:00
parent 4aba8e8c7f
commit 2ff8a1c729
42 changed files with 876 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/nana/c++defines.hpp
View File

@@ -116,6 +116,8 @@
# define _enable_std_clamp
# endif
#elif defined(NANA_MINGW)
# define STD_THREAD_NOT_SUPPORTED
#elif defined(__clang__) //Clang
#include <iosfwd> //Introduces some implement-specific flags of ISO C++ Library

32
include/nana/detail/linux_X11/msg_packet.hpp
View File

@@ -1,32 +0,0 @@
#ifndef NANA_DETAIL_MSG_PACKET_HPP
#define NANA_DETAIL_MSG_PACKET_HPP
#include <X11/Xlib.h>
#include <vector>
#include <nana/deploy.hpp>
namespace nana
{
namespace detail
{
struct msg_packet_tag
{
enum kind_t{kind_xevent, kind_mouse_drop, kind_cleanup};
kind_t kind;
union
{
XEvent xevent;
Window packet_window; //Avaiable if the packet is not kind_xevent
struct mouse_drop_tag
{
Window window;
int x;
int y;
std::vector<std::string> * files;
}mouse_drop;
}u;
};
}//end namespace detail
}//end namespace nana
#endif

344
include/nana/detail/linux_X11/platform_spec.hpp
View File

@@ -1,344 +0,0 @@
/*
* Platform Specification Implementation
* Nana C++ Library(http://www.nanapro.org)
* 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/detail/platform_spec.hpp
*
* This file provides basis class and data structrue that required by nana
* This file should not be included by any header files.
*/
#if defined(NANA_LINUX) || defined(NANA_MACOS)
#ifndef NANA_DETAIL_PLATFORM_SPEC_HPP
#define NANA_DETAIL_PLATFORM_SPEC_HPP
#include <nana/push_ignore_diagnostic>
#include <thread>
#include <mutex>
#include <memory>
#include <condition_variable>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/Xos.h>
#include <nana/gui/basis.hpp>
#include <nana/paint/image.hpp>
#include <nana/paint/graphics.hpp>
#include <nana/gui/detail/event_code.hpp>
#include <vector>
#include <map>
#include "msg_packet.hpp"
#define NANA_USE_XFT
#if defined(NANA_USE_XFT)
#include <X11/Xft/Xft.h>
#include <iconv.h>
#include <fstream>
#endif
namespace nana
{
namespace detail
{
class msg_dispatcher;
#if defined(NANA_USE_XFT)
class conf
{
public:
conf(const char * file);
bool open(const char* file);
std::string value(const char* key);
private:
std::ifstream ifs_;
};
class charset_conv
{
charset_conv(const charset_conv&) = delete;
charset_conv& operator=(const charset_conv*) = delete;
public:
charset_conv(const char* tocode, const char* fromcode);
~charset_conv();
std::string charset(const std::string& str) const;
std::string charset(const char * buf, std::size_t len) const;
private:
iconv_t handle_;
};
#endif
struct font_tag
{
std::string name;
unsigned height;
unsigned weight;
bool italic;
bool underline;
bool strikeout;
#if defined(NANA_USE_XFT)
XftFont * handle;
#else
XFontSet handle;
#endif
};
struct drawable_impl_type
{
typedef std::shared_ptr<font_tag> font_ptr_t;
Pixmap pixmap;
GC context;
font_ptr_t font;
nana::point line_begin_pos;
struct string_spec
{
unsigned tab_length;
unsigned tab_pixels;
unsigned whitespace_pixels;
}string;
#if defined(NANA_USE_XFT)
XftDraw * xftdraw{nullptr};
XftColor xft_fgcolor;
const std::string charset(const std::wstring& str, const std::string& strcode);
#endif
drawable_impl_type();
~drawable_impl_type();
void fgcolor(const ::nana::color&); //deprecated
unsigned get_color() const;
unsigned get_text_color() const;
void set_color(const ::nana::color&);
void set_text_color(const ::nana::color&);
void update_color();
void update_text_color();
private:
drawable_impl_type(const drawable_impl_type&) = delete;
drawable_impl_type& operator=(const drawable_impl_type&) = delete;
unsigned current_color_{ 0xFFFFFF };
unsigned color_{ 0xFFFFFFFF };
unsigned text_color_{ 0xFFFFFFFF };
#if defined(NANA_USE_XFT)
struct conv_tag
{
iconv_t handle;
std::string code;
}conv_;
#endif
};
struct atombase_tag
{
Atom wm_protocols;
//window manager support
Atom wm_change_state;
Atom wm_delete_window;
//ext
Atom net_wm_state;
Atom net_wm_state_skip_taskbar;
Atom net_wm_state_fullscreen;
Atom net_wm_state_maximized_horz;
Atom net_wm_state_maximized_vert;
Atom net_wm_state_modal;
Atom net_wm_name;
Atom net_wm_window_type;
Atom net_wm_window_type_normal;
Atom net_wm_window_type_utility;
Atom net_wm_window_type_dialog;
Atom motif_wm_hints;
Atom clipboard;
Atom text;
Atom text_uri_list;
Atom utf8_string;
Atom targets;
Atom xdnd_aware;
Atom xdnd_enter;
Atom xdnd_position;
Atom xdnd_status;
Atom xdnd_action_copy;
Atom xdnd_drop;
Atom xdnd_selection;
Atom xdnd_typelist;
Atom xdnd_finished;
};
//A forward declaration of caret data
struct caret_rep;
class timer_runner;
class platform_scope_guard
{
public:
platform_scope_guard();
~platform_scope_guard();
};
class platform_spec
{
typedef platform_spec self_type;
struct window_context_t
{
native_window_type owner;
std::vector<native_window_type> * owned;
};
public:
int error_code;
public:
typedef drawable_impl_type::font_ptr_t font_ptr_t;
typedef void (*timer_proc_type)(unsigned tid);
typedef void (*event_proc_type)(Display*, msg_packet_tag&);
typedef ::nana::event_code event_code;
typedef ::nana::native_window_type native_window_type;
platform_spec(const platform_spec&) = delete;
platform_spec& operator=(const platform_spec&) = delete;
platform_spec();
~platform_spec();
const font_ptr_t& default_native_font() const;
void default_native_font(const font_ptr_t&);
unsigned font_size_to_height(unsigned) const;
unsigned font_height_to_size(unsigned) const;
font_ptr_t make_native_font(const char* name, unsigned height, unsigned weight, bool italic, bool underline, bool strick_out);
Display* open_display();
void close_display();
void lock_xlib();
void unlock_xlib();
Window root_window();
int screen_depth();
Visual* screen_visual();
Colormap& colormap();
static self_type& instance();
const atombase_tag & atombase() const;
void make_owner(native_window_type owner, native_window_type wd);
native_window_type get_owner(native_window_type) const;
void remove(native_window_type);
void write_keystate(const XKeyEvent&);
void read_keystate(XKeyEvent&);
XIC caret_input_context(native_window_type) const;
void caret_open(native_window_type, const ::nana::size&);
void caret_close(native_window_type);
void caret_pos(native_window_type, const ::nana::point&);
void caret_visible(native_window_type, bool);
bool caret_update(native_window_type, nana::paint::graphics& root_graph, bool is_erase_caret_from_root_graph);
void set_error_handler();
int rev_error_handler();
//grab
//register a grab window while capturing it if it is unviewable.
//when native_interface::show a window that is registered as a grab
//window, the native_interface grabs the window.
Window grab(Window);
void set_timer(std::size_t id, std::size_t interval, void (*timer_proc)(std::size_t id));
void kill_timer(std::size_t id);
void timer_proc(unsigned tid);
//Message dispatcher
void msg_insert(native_window_type);
void msg_set(timer_proc_type, event_proc_type);
void msg_dispatch(native_window_type modal);
//X Selections
void* request_selection(native_window_type requester, Atom type, size_t & bufsize);
void write_selection(native_window_type owner, Atom type, const void* buf, size_t bufsize);
//Icon storage
//@biref: The image object should be kept for a long time till the window is closed,
// the image object is release in remove() method.
const nana::paint::graphics& keep_window_icon(native_window_type, const nana::paint::image&);
private:
static int _m_msg_filter(XEvent&, msg_packet_tag&);
void _m_caret_routine();
private:
Display* display_;
Colormap colormap_;
atombase_tag atombase_;
font_ptr_t def_font_ptr_;
XKeyEvent key_state_;
int (*def_X11_error_handler_)(Display*, XErrorEvent*);
Window grab_;
std::recursive_mutex xlib_locker_;
struct caret_holder_tag
{
volatile bool exit_thread;
std::unique_ptr<std::thread> thr;
std::map<native_window_type, caret_rep*> carets;
}caret_holder_;
std::map<native_window_type, window_context_t> wincontext_;
std::map<native_window_type, nana::paint::graphics> iconbase_;
struct timer_runner_tag
{
timer_runner * runner;
std::recursive_mutex mutex;
bool delete_declared;
timer_runner_tag();
}timer_;
struct selection_tag
{
struct item_t
{
Atom type;
Window requestor;
void* buffer;
size_t bufsize;
std::mutex cond_mutex;
std::condition_variable cond;
};
std::vector<item_t*> items;
struct content_tag
{
std::string * utf8_string;
}content;
}selection_;
struct xdnd_tag
{
Atom good_type;
int timestamp;
Window wd_src;
nana::point pos;
}xdnd_;
msg_dispatcher * msg_dispatcher_;
};//end class platform_X11
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
// .h ward
#endif
//#if defined(NANA_LINUX) || defined(NANA_MACOS)
#endif

21
include/nana/detail/platform_spec_selector.hpp
View File

@@ -1,21 +0,0 @@
/**
* Selector of Platform Specification
* Nana C++ Library(http://www.nanapro.org)
* 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file nana/detail/platform_spec_selector.hpp
*
* @brief Selects the proper platform_spec header file for the current platform
*/
#include <nana/config.hpp>
#if defined(NANA_WINDOWS)
#include <nana/detail/win32/platform_spec.hpp>
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
#include <nana/detail/linux_X11/platform_spec.hpp>
#endif

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

@@ -1,225 +0,0 @@
/*
* Platform Specification Implementation
* Nana C++ Library(http://www.nanapro.org)
* 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/detail/platform_spec.hpp
*
* This file provides basis class and data structrue that required by nana
* This file should not be included by any header files.
*/
#if defined(NANA_WINDOWS)
#ifndef NANA_DETAIL_PLATFORM_SPEC_HPP
#define NANA_DETAIL_PLATFORM_SPEC_HPP
#include <nana/gui/basis.hpp>
#include <nana/paint/image.hpp>
#include <nana/gui/detail/event_code.hpp>
#include <windows.h>
#include <memory>
#include <functional>
namespace nana
{
namespace detail
{
//struct messages
//@brief: This defines some messages that are used for remote thread invocation.
// Some Windows APIs are window-thread-dependent, the operation in other thread
// must be posted to its own thread.
struct messages
{
struct caret
{
int x;
int y;
unsigned width;
unsigned height;
bool visible;
};
struct move_window
{
enum { Pos = 1, Size = 2};
int x;
int y;
unsigned width;
unsigned height;
unsigned ignore; //determinate that pos or size would be ignored.
};
struct map_thread
{
rectangle update_area;
bool ignore_update_area;
bool forced;
};
struct arg_affinity_execute
{
const std::function<void()> * function_ptr;
};
enum
{
tray = 0x501,
async_activate,
async_set_focus,
remote_flush_surface,
remote_thread_destroy_window,
remote_thread_move_window,
operate_caret, //wParam: 1=Destroy, 2=SetPos
remote_thread_set_window_pos,
remote_thread_set_window_text,
//Execute a function in a thread with is associated with a specified native window
affinity_execute,
user,
};
};
struct font_tag
{
native_string_type name;
unsigned height;
unsigned weight;
bool italic;
bool underline;
bool strikeout;
HFONT handle;
struct deleter
{
void operator()(const font_tag*) const;
};
};
struct drawable_impl_type
{
typedef std::shared_ptr<font_tag> font_ptr_t;
HDC context;
HBITMAP pixmap;
pixel_argb_t* pixbuf_ptr{nullptr};
std::size_t bytes_per_line{0};
font_ptr_t font;
struct pen_spec
{
HPEN handle;
unsigned color;
int style;
int width;
void set(HDC context, int style, int width,unsigned color);
}pen;
struct brush_spec
{
enum t{Solid, HatchBDiagonal};
HBRUSH handle;
t style;
unsigned color;
void set(HDC context, t style, unsigned color);
}brush;
struct round_region_spec
{
HRGN handle;
nana::rectangle r;
unsigned radius_x;
unsigned radius_y;
void set(const nana::rectangle& r, unsigned radius_x, unsigned radius_y);
}round_region;
struct string_spec
{
unsigned tab_length;
unsigned tab_pixels;
unsigned whitespace_pixels;
}string;
drawable_impl_type(const drawable_impl_type&) = delete;
drawable_impl_type& operator=(const drawable_impl_type&) = delete;
drawable_impl_type();
~drawable_impl_type();
void fgcolor(const ::nana::color&); //deprecated
unsigned get_color() const;
unsigned get_text_color() const;
void set_color(const ::nana::color&);
void set_text_color(const ::nana::color&);
void update_pen();
void update_brush();
private:
unsigned color_{ 0xffffffff };
unsigned text_color_{0xffffffff};
};
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;
typedef ::nana::native_window_type native_window_type;
class co_initializer
{
public:
co_initializer();
~co_initializer();
private:
HMODULE ole32_;
};
struct window_icons
{
::nana::paint::image sml_icon;
::nana::paint::image big_icon;
};
~platform_spec();
const font_ptr_t& default_native_font() const;
void default_native_font(const font_ptr_t&);
unsigned font_size_to_height(unsigned) const;
unsigned font_height_to_size(unsigned) const;
font_ptr_t make_native_font(const char* name, unsigned height, unsigned weight, bool italic, bool underline, bool strike_out);
static platform_spec& instance();
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:
struct implementation;
implementation * const impl_;
};
}//end namespace detail
}//end namespace nana
// .h ward
#endif
//#if defined(NANA_WINDOWS)
#endif

2
include/nana/gui/widgets/skeletons/text_token_stream.hpp
View File

@@ -435,7 +435,7 @@ namespace nana{ namespace widgets{ namespace skeletons
};
::std::string font;
std::size_t font_size;
double font_size;
bool bold;
bool bold_empty; //bold should be ignored if bold_empty is true
aligns::t text_align;

29
include/nana/paint/detail/ptdefs.hpp Normal file
View File

@@ -0,0 +1,29 @@
#ifndef NANA_PAINT_PTDEFS_INCLUDED
#define NANA_PAINT_PTDEFS_INCLUDED
namespace nana
{
namespace detail
{
struct native_font_signature;
struct font_style
{
unsigned weight{ 400 }; //normal
bool italic{ false };
bool underline{ false };
bool strike_out{ false };
font_style() = default;
font_style(unsigned weight, bool italic = false, bool underline = false, bool strike_out = false);
};
}//end namespace detail
namespace paint
{
using native_font_type = ::nana::detail::native_font_signature*;
}
}
#endif

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

@@ -1,7 +1,7 @@
/*
* Paint Graphics Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
* Copyright(C) 2003-2017 Jinhao(cnjinhao@hotmail.com)
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
@@ -17,36 +17,45 @@
#include "../basic_types.hpp"
#include "../gui/basis.hpp"
#include <nana/filesystem/filesystem.hpp>
#include "detail/ptdefs.hpp"
namespace nana
{
namespace paint
{
namespace detail
{
struct native_font_signature;
}// end namespace detail
typedef detail::native_font_signature* native_font_type;
class font
{
friend class graphics;
public:
using path_type = ::std::experimental::filesystem::path;
using font_style = ::nana::detail::font_style;
font();
font(drawable_type);
font(const font&);
font(const ::std::string& name, unsigned size, bool bold = false, bool italic = false, bool underline = false, bool strike_out = false);
font(const ::std::string& name, double size_pt, const font_style& fs = {});
font(double size_pt, const path_type& truetype, const font_style& ft = {});
~font();
bool empty() const;
/* //deprecated
void make(const ::std::string& name, unsigned size, bool bold = false, bool italic = false, bool underline = false, bool strike_out = false);
void make_raw(const ::std::string& name, unsigned height, unsigned weight, bool italic, bool underline, bool strike_out);
void make(const ::std::string& font_family, unsigned size, const font_style& fs = {});
void make_from_ttf(const path_type& truetype, unsigned size, const font_style& fs = {});
*/
void set_default() const;
::std::string name() const;
unsigned size() const;
double size() const;
bool bold() const;
unsigned height() const;
//unsigned height() const; //deprecated
unsigned weight() const;
bool italic() const;
native_font_type handle() const;