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
source/deploy.cpp
View File

@@ -21,7 +21,7 @@
#include <windows.h>
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
#include <string.h>
#include <nana/detail/platform_spec_selector.hpp>
#include "detail/platform_spec_selector.hpp"
#endif

205
source/detail/mswin/platform_spec.hpp Normal file
View File

@@ -0,0 +1,205 @@
/*
* 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>
#include "../platform_abstraction_types.hpp"
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 drawable_impl_type
{
using font_type = ::std::shared_ptr<font_interface>;
HDC context;
HBITMAP pixmap;
pixel_argb_t* pixbuf_ptr{nullptr};
std::size_t bytes_per_line{0};
font_type 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 ::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();
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

409
source/detail/platform_abstraction.cpp Normal file
View File

@@ -0,0 +1,409 @@
#include "platform_abstraction.hpp"
#include <nana/deploy.hpp>
#include "../paint/truetype.hpp"
#ifdef NANA_WINDOWS
# include <windows.h>
///////////////////////////////////////////////////////////////////////////////////////////////////////
/******************************************************************
* *
* VersionHelpers.h -- This module defines helper functions to *
* promote version check with proper *
* comparisons. *
* *
* Copyright (c) Microsoft Corp. All rights reserved. *
* *
******************************************************************/
#include <specstrings.h> // for _In_, etc.
#if !defined(__midl) && !defined(SORTPP_PASS)
#if (NTDDI_VERSION >= NTDDI_WINXP)
#ifdef __cplusplus
#define VERSIONHELPERAPI inline bool
#else // __cplusplus
#define VERSIONHELPERAPI FORCEINLINE BOOL
#endif // __cplusplus
VERSIONHELPERAPI
IsWindowsVersionOrGreater(WORD wMajorVersion, WORD wMinorVersion, WORD wServicePackMajor)
{
OSVERSIONINFOEXW osvi = { sizeof(osvi), 0, 0, 0, 0, { 0 }, 0, 0 };
DWORDLONG const dwlConditionMask = VerSetConditionMask(
VerSetConditionMask(
VerSetConditionMask(
0, VER_MAJORVERSION, VER_GREATER_EQUAL),
VER_MINORVERSION, VER_GREATER_EQUAL),
VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
osvi.dwMajorVersion = wMajorVersion;
osvi.dwMinorVersion = wMinorVersion;
osvi.wServicePackMajor = wServicePackMajor;
return VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, dwlConditionMask) != FALSE;
}
VERSIONHELPERAPI
IsWindowsXPOrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 0);
}
VERSIONHELPERAPI
IsWindowsXPSP1OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 1);
}
VERSIONHELPERAPI
IsWindowsXPSP2OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 2);
}
VERSIONHELPERAPI
IsWindowsXPSP3OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINXP), LOBYTE(_WIN32_WINNT_WINXP), 3);
}
VERSIONHELPERAPI
IsWindowsVistaOrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 0);
}
VERSIONHELPERAPI
IsWindowsVistaSP1OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 1);
}
VERSIONHELPERAPI
IsWindowsVistaSP2OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 2);
}
VERSIONHELPERAPI
IsWindows7OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7), 0);
}
VERSIONHELPERAPI
IsWindows7SP1OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7), 1);
}
#ifndef _WIN32_WINNT_WIN8 // (0x0602)
#define _WIN32_WINNT_WIN8 (0x0602)
#endif // _WIN32_WINNT_WIN8(0x0602)
VERSIONHELPERAPI
IsWindows8OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN8), LOBYTE(_WIN32_WINNT_WIN8), 0);
}
#ifndef _WIN32_WINNT_WINBLUE // (0x0602)
#define _WIN32_WINNT_WINBLUE (0x0602)
#endif // _WIN32_WINNT_WINBLUE (0x0602)
VERSIONHELPERAPI
IsWindows8Point1OrGreater()
{
return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINBLUE), LOBYTE(_WIN32_WINNT_WINBLUE), 0);
}
VERSIONHELPERAPI
IsWindowsServer()
{
OSVERSIONINFOEXW osvi = { sizeof(osvi), 0, 0, 0, 0, { 0 }, 0, 0, 0, VER_NT_WORKSTATION };
DWORDLONG const dwlConditionMask = VerSetConditionMask(0, VER_PRODUCT_TYPE, VER_EQUAL);
return !VerifyVersionInfoW(&osvi, VER_PRODUCT_TYPE, dwlConditionMask);
}
#endif // NTDDI_VERSION
#endif // defined(__midl)
#else
# include "posix/platform_spec.hpp"
# include <fontconfig/fontconfig.h>
# if defined(NANA_USE_XFT)
# include <X11/Xft/Xft.h>
# include <iconv.h>
# include <fstream>
# endif
#endif
namespace nana
{
class internal_font
: public font_interface
{
public:
using path_type = std::experimental::filesystem::path;
internal_font(const path_type& ttf, const std::string& font_family, double font_size, const font_style& fs, native_font_type native_font):
ttf_(ttf),
family_(font_family),
size_(font_size),
style_(fs),
native_handle_(native_font)
{}
~internal_font()
{
#ifdef NANA_WINDOWS
::DeleteObject(reinterpret_cast<HFONT>(native_handle_));
#elif defined(NANA_X11)
auto disp = ::nana::detail::platform_spec::instance().open_display();
# ifdef NANA_USE_XFT
::XftFontClose(disp, reinterpret_cast<XftFont*>(native_handle_));
# else
::XFreeFontSet(disp, reinterpret_cast<XFontSet>(native_handle_));
# endif
#endif
if (!ttf_.empty())
platform_abstraction::font_resource(false, ttf_);
}
public:
const std::string& family() const override
{
return family_;
}
double size() const override
{
return size_;
}
const font_style & style() const override
{
return style_;
}
native_font_type native_handle() const override
{
return native_handle_;
}
private:
path_type const ttf_;
std::string const family_;
double const size_;
font_style const style_;
native_font_type const native_handle_;
};
struct platform_runtime
{
std::shared_ptr<font_interface> font;
#ifdef NANA_X11
std::map<std::string, std::size_t> fontconfig_counts;
#endif
};
namespace
{
namespace data
{
static platform_runtime* storage;
}
}
static platform_runtime& platform_storage()
{
if (nullptr == data::storage)
throw std::runtime_error("platform_abstraction is empty");
return *data::storage;
}
void platform_abstraction::initialize()
{
if (nullptr == data::storage)
data::storage = new platform_runtime;
}
void platform_abstraction::shutdown()
{
auto & r = platform_storage();
if (r.font.use_count() > 1)
throw std::runtime_error("platform_abstraction is disallowed to shutdown");
r.font.reset();
delete data::storage;
data::storage = nullptr;
}
::std::shared_ptr<platform_abstraction::font> platform_abstraction::default_font(const ::std::shared_ptr<font>& new_font)
{
auto & r = platform_storage();
if (new_font)
{
auto f = r.font;
if (new_font != r.font)
r.font = new_font;
return f;
}
if (!r.font)
r.font = make_font({}, 0, {});
return r.font;
}
static std::shared_ptr<platform_abstraction::font> font_factory(::std::string font_family, double size_pt, const platform_abstraction::font::font_style& fs, internal_font::path_type ttf)
{
using native_font_type = platform_abstraction::font::native_font_type;
#ifdef NANA_WINDOWS
std::wstring wfont_family = to_nstring(font_family);
//Make sure the length of font family less than LF_FACESIZE which is defined by Windows
if (wfont_family.length() + 1 > LF_FACESIZE)
wfont_family.clear();
//Translate pt to px
auto hDC = ::GetDC(nullptr);
auto font_height = -static_cast<LONG>(size_pt * ::GetDeviceCaps(hDC, LOGPIXELSY) / 72);
::ReleaseDC(nullptr, hDC);
if (wfont_family.empty() || (0 == font_height))
{
//Create default font object.
NONCLIENTMETRICS metrics = {};
metrics.cbSize = sizeof metrics;
#if(WINVER >= 0x0600)
#if defined(NANA_MINGW)
OSVERSIONINFO osvi = {};
osvi.dwOSVersionInfoSize = sizeof(osvi);
::GetVersionEx(&osvi);
if (osvi.dwMajorVersion < 6)
metrics.cbSize -= sizeof(metrics.iPaddedBorderWidth);
#else
if (!IsWindowsVistaOrGreater())
metrics.cbSize -= sizeof(metrics.iPaddedBorderWidth);
#endif
#endif
::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof metrics, &metrics, 0);
if (wfont_family.empty())
{
wfont_family = metrics.lfMessageFont.lfFaceName;
font_family = to_utf8(wfont_family);
}
if (0 == font_height)
font_height = metrics.lfMessageFont.lfHeight;
}
::LOGFONT lf{};
std::wcscpy(lf.lfFaceName, wfont_family.c_str());
lf.lfHeight = font_height;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfWeight = fs.weight;
lf.lfQuality = PROOF_QUALITY;
lf.lfPitchAndFamily = FIXED_PITCH;
lf.lfItalic = fs.italic;
lf.lfUnderline = fs.underline;
lf.lfStrikeOut = fs.strike_out;
auto fd = ::CreateFontIndirect(&lf);
#elif defined(NANA_X11)
auto disp = ::nana::detail::platform_spec::instance().open_display();
# ifdef NANA_USE_XFT
if(font_family.empty())
font_family = '*';
std::string pat_str = font_family + '-' + std::to_string(size_pt ? size_pt : 10);
auto pat = ::XftNameParse(pat_str.c_str());
XftResult res;
auto match_pat = ::XftFontMatch(disp, ::XDefaultScreen(disp), pat, &res);
::XftFont* fd = nullptr;
if (match_pat)
fd = ::XftFontOpenPattern(disp, match_pat);
# else
std::string pat_str;
if (font_family.empty())
pat_str = "-misc-fixed-*";
else
pat_str = "-misc-fixed-" + font_family;
char ** missing_list;
int missing_count;
char * defstr;
XFontSet fd = ::XCreateFontSet(display_, const_cast<char*>(pat_str.c_str()), &missing_list, &missing_count, &defstr);
# endif
#endif
if (fd)
return std::make_shared<internal_font>(std::move(ttf), std::move(font_family), size_pt, fs, reinterpret_cast<native_font_type>(fd));
return{};
}
::std::shared_ptr<platform_abstraction::font> platform_abstraction::make_font(const std::string& font_family, double size_pt, const font::font_style& fs)
{
return font_factory(font_family, size_pt, fs, {});
}
::std::shared_ptr<platform_abstraction::font> platform_abstraction::make_font_from_ttf(const path_type& ttf, double size_pt, const font::font_style& fs)
{
::nana::spec::truetype truetype{ ttf };
if (truetype.font_family().empty())
return nullptr;
font_resource(true, ttf);
return font_factory(truetype.font_family(), size_pt, fs, ttf);
}
void platform_abstraction::font_resource(bool try_add, const path_type& ttf)
{
#ifdef NANA_WINDOWS
if (try_add)
::AddFontResourceEx(ttf.wstring().c_str(), FR_PRIVATE, nullptr);
else
::RemoveFontResourceEx(ttf.wstring().c_str(), FR_PRIVATE, nullptr);
#else
auto & fc = platform_storage().fontconfig_counts;
if(try_add)
{
if(1 == ++(fc[ttf.string()]))
{
auto state = ::FcConfigAppFontAddFile(nullptr, reinterpret_cast<const FcChar8*>(ttf.string().c_str()));
state = 0;
}
}
else
{
auto i = fc.find(ttf.string());
if(i != fc.end())
{
if(0 == --(i->second))
fc.erase(i);
if(0 == fc.size())
::FcConfigAppFontClear(nullptr);
}
}
#endif
}
}

43
source/detail/platform_abstraction.hpp Normal file
View File

@@ -0,0 +1,43 @@
/*
* Platform Abstraction
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2017 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
*
* The platform_abstraction provides some functions and types for the abstract
* system platform.
*/
#ifndef NANA_DETAIL_PLATFORM_ABSTRACTION_HEADER_INCLUDED
#define NANA_DETAIL_PLATFORM_ABSTRACTION_HEADER_INCLUDED
#include "platform_abstraction_types.hpp"
#include <memory>
#include <nana/filesystem/filesystem.hpp>
namespace nana
{
class platform_abstraction
{
public:
using font = font_interface;
using path_type = ::std::experimental::filesystem::path;
static void initialize();
/// Shutdown before destruction of platform_spec
static void shutdown();
static ::std::shared_ptr<font> default_font(const ::std::shared_ptr<font>&);
static ::std::shared_ptr<font> make_font(const ::std::string& font_family, double size_pt, const font::font_style& fs);
static ::std::shared_ptr<font> make_font_from_ttf(const path_type& ttf, double size_pt, const font::font_style& fs);
static void font_resource(bool try_add, const path_type& ttf);
};
}
#endif

29
source/detail/platform_abstraction_types.hpp Normal file
View File

@@ -0,0 +1,29 @@
#ifndef NANA_DETAIL_PLATFORM_ABSTRACTION_TYPES_HEADER_INCLUDED
#define NANA_DETAIL_PLATFORM_ABSTRACTION_TYPES_HEADER_INCLUDED
#include <nana/config.hpp>
#include <nana/paint/detail/ptdefs.hpp>
#include <string>
#ifdef NANA_X11
# define NANA_USE_XFT
#endif
namespace nana
{
class font_interface
{
public:
using font_style = detail::font_style;
using native_font_type = paint::native_font_type;
virtual ~font_interface() = default;
virtual const std::string& family() const = 0;
virtual double size() const = 0;
virtual const font_style & style() const = 0;
virtual native_font_type native_handle() const = 0;
};
}
#endif

93
source/detail/platform_spec_posix.cpp
View File

@@ -14,7 +14,8 @@
* http://standards.freedesktop.org/clipboards-spec/clipboards-0.1.txt
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "platform_spec_selector.hpp"
#include "platform_abstraction.hpp"
#if defined(NANA_POSIX) && defined(NANA_X11)
#include <nana/push_ignore_diagnostic>
@@ -33,7 +34,7 @@
#include <errno.h>
#include <sstream>
#include "x11/msg_dispatcher.hpp"
#include "posix/msg_dispatcher.hpp"
namespace nana
{
@@ -451,24 +452,6 @@ namespace detail
}
}
class font_deleter
{
public:
void operator()(const font_tag* fp) const
{
if(fp && fp->handle)
{
platform_scope_guard psg;
#if defined(NANA_USE_XFT)
::XftFontClose(nana::detail::platform_spec::instance().open_display(), fp->handle);
#else
::XFreeFontSet(nana::detail::platform_spec::instance().open_display(), fp->handle);
#endif
}
delete fp;
}
};//end class font_deleter
platform_scope_guard::platform_scope_guard()
{
platform_spec::instance().lock_xlib();
@@ -561,9 +544,9 @@ namespace detail
atombase_.xdnd_typelist = ::XInternAtom(display_, "XdndTypeList", False);
atombase_.xdnd_finished = ::XInternAtom(display_, "XdndFinished", False);
//Create default font object.
def_font_ptr_ = make_native_font(nullptr, font_size_to_height(10), 400, false, false, false);
msg_dispatcher_ = new msg_dispatcher(display_);
platform_abstraction::initialize();
}
platform_spec::~platform_spec()
@@ -572,75 +555,11 @@ namespace detail
//The font should be destroyed before closing display,
//otherwise it crashs
def_font_ptr_.reset();
platform_abstraction::shutdown();
close_display();
}
const platform_spec::font_ptr_t& platform_spec::default_native_font() const
{
return def_font_ptr_;
}
void platform_spec::default_native_font(const font_ptr_t& fp)
{
def_font_ptr_ = fp;
}
unsigned platform_spec::font_size_to_height(unsigned size) const
{
return size;
}
unsigned platform_spec::font_height_to_size(unsigned height) const
{
return height;
}
platform_spec::font_ptr_t platform_spec::make_native_font(const char* name, unsigned height, unsigned weight, bool italic, bool underline, bool strike_out)
{
font_ptr_t ref;
#if 1 //Xft
if(0 == name || *name == 0)
name = "*";
XftFont* handle = 0;
std::stringstream ss;
ss<<name<<"-"<<(height ? height : 10);
XftPattern * pat = ::XftNameParse(ss.str().c_str());
XftResult res;
XftPattern * match_pat = ::XftFontMatch(display_, ::XDefaultScreen(display_), pat, &res);
if(match_pat)
handle = ::XftFontOpenPattern(display_, match_pat);
#else
std::string basestr;
if(0 == name || *name == 0)
{
basestr = "-misc-fixed-*";
}
else
basestr = "-misc-fixed-*";
char ** missing_list;
int missing_count;
char * defstr;
XFontSet handle = ::XCreateFontSet(display_, const_cast<char*>(basestr.c_str()), &missing_list, &missing_count, &defstr);
#endif
if(handle)
{
font_tag * impl = new font_tag;
impl->name = name;
impl->height = height;
impl->weight = weight;
impl->italic = italic;
impl->underline = underline;
impl->strikeout = strike_out;
impl->handle = handle;
return font_ptr_t(impl, font_deleter());
}
return font_ptr_t();
}
Display* platform_spec::open_display()
{
return display_;

21
source/detail/platform_spec_selector.hpp Normal file
View File

@@ -0,0 +1,21 @@
/**
* 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 "mswin/platform_spec.hpp"
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
#include "posix/platform_spec.hpp"
#endif

101
source/detail/platform_spec_windows.cpp
View File

@@ -12,15 +12,18 @@
* @brief basis classes and data structures required by nana
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "platform_spec_selector.hpp"
#include "platform_abstraction.hpp"
#if defined(NANA_WINDOWS)
#include <stdexcept>
#include <map>
#include <windows.h>
#include <shellapi.h>
///////////////////////////////////////////////////////////////////////////////////////////////////////
/******************************************************************
@@ -310,15 +313,6 @@ namespace detail
}
}
//struct font_tag::deleter
void font_tag::deleter::operator()(const font_tag* tag) const
{
if(tag && tag->handle)
::DeleteObject(tag->handle);
delete tag;
}
//end struct font_tag::deleter
//class platform_spec
platform_spec::co_initializer::co_initializer()
: ole32_(::LoadLibrary(L"OLE32.DLL"))
@@ -354,104 +348,21 @@ 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 = {};
metrics.cbSize = sizeof metrics;
#if(WINVER >= 0x0600)
#if defined(NANA_MINGW)
OSVERSIONINFO osvi = {};
osvi.dwOSVersionInfoSize = sizeof(osvi);
::GetVersionEx(&osvi);
if (osvi.dwMajorVersion < 6)
metrics.cbSize -= sizeof(metrics.iPaddedBorderWidth);
#else
if(!IsWindowsVistaOrGreater())
metrics.cbSize -= sizeof(metrics.iPaddedBorderWidth);
#endif
#endif
::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof metrics, &metrics, 0);
impl_->def_font_ptr = make_native_font(to_utf8(metrics.lfMessageFont.lfFaceName).c_str(), font_size_to_height(9), 400, false, false, false);
platform_abstraction::initialize();
}
platform_spec::~platform_spec()
{
platform_abstraction::shutdown();
delete impl_;
}
const platform_spec::font_ptr_t& platform_spec::default_native_font() const
{
return impl_->def_font_ptr;
}
void platform_spec::default_native_font(const font_ptr_t& fp)
{
impl_->def_font_ptr = fp;
}
unsigned platform_spec::font_size_to_height(unsigned size) const
{
HDC hdc = ::GetDC(0);
size = ::MulDiv(int(size), ::GetDeviceCaps(hdc, LOGPIXELSY), 72);
::ReleaseDC(0, hdc);
return size;
}
unsigned platform_spec::font_height_to_size(unsigned height) const
{
HDC hdc = ::GetDC(0);
unsigned pixels = ::GetDeviceCaps(hdc, LOGPIXELSY);
::ReleaseDC(0, hdc);
height = static_cast<unsigned>(static_cast<long long>(72) * height / pixels);
return height;
}
platform_spec::font_ptr_t platform_spec::make_native_font(const char* name, unsigned height, unsigned weight, bool italic, bool underline, bool strike_out)
{
::LOGFONT logfont;
memset(&logfont, 0, sizeof logfont);
if (name && *name)
std::wcscpy(logfont.lfFaceName, to_wstring(name).c_str());
else
std::wcscpy(logfont.lfFaceName, impl_->def_font_ptr->name.c_str());
logfont.lfCharSet = DEFAULT_CHARSET;
HDC hdc = ::GetDC(0);
logfont.lfHeight = -static_cast<int>(height);
::ReleaseDC(0, hdc);
logfont.lfWidth = 0;
logfont.lfWeight = weight;
logfont.lfQuality = PROOF_QUALITY;
logfont.lfPitchAndFamily = FIXED_PITCH;
logfont.lfItalic = italic;
logfont.lfUnderline = underline;
logfont.lfStrikeOut = strike_out;
HFONT result = ::CreateFontIndirect(&logfont);
if(result)
{
font_tag * impl = new font_tag;
impl->name = logfont.lfFaceName;
impl->height = height;
impl->weight = weight;
impl->italic = italic;
impl->underline = underline;
impl->strikeout = strike_out;
impl->handle = result;
return std::shared_ptr<font_tag>(impl, font_tag::deleter());
}
return nullptr;
}
platform_spec& platform_spec::instance()
{
static platform_spec object;

2
source/detail/x11/msg_dispatcher.hpp → source/detail/posix/msg_dispatcher.hpp
View File

@@ -17,7 +17,7 @@
#ifndef NANA_DETAIL_MSG_DISPATCHER_HPP
#define NANA_DETAIL_MSG_DISPATCHER_HPP
#include <nana/detail/linux_X11/msg_packet.hpp>
#include "msg_packet.hpp"
#include <nana/system/platform.hpp>
#include <list>
#include <set>

32
source/detail/posix/msg_packet.hpp Normal file
View File

@@ -0,0 +1,32 @@
#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

325
source/detail/posix/platform_spec.hpp Normal file
View File

@@ -0,0 +1,325 @@
/*
* 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"
#include "../platform_abstraction_types.hpp"
#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 drawable_impl_type
{
using font_type = ::std::shared_ptr<font_interface>;
Pixmap pixmap;
GC context;
font_type 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 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();
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_;
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

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

@@ -10,7 +10,7 @@
* @file: nana/gui/detail/bedrock_pi.cpp
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../../detail/platform_spec_selector.hpp"
#include <nana/gui/detail/bedrock_pi_data.hpp>
#include <nana/gui/detail/event_code.hpp>
#include <nana/system/platform.hpp>

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

@@ -10,7 +10,7 @@
* @file: nana/gui/detail/linux_X11/bedrock.cpp
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../../detail/platform_spec_selector.hpp"
#if defined(NANA_POSIX) && defined(NANA_X11)
#include <nana/gui/detail/bedrock_pi_data.hpp>
#include <nana/gui/detail/event_code.hpp>

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

@@ -12,7 +12,7 @@
* @contributors: Ariel Vina-Rodriguez
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../../detail/platform_spec_selector.hpp"
#if defined(NANA_WINDOWS)
#include <nana/gui/detail/bedrock.hpp>
#include <nana/gui/detail/bedrock_pi_data.hpp>

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

@@ -18,7 +18,7 @@
#include "dynamic_drawing_object.hpp"
#if defined(NANA_X11)
#include <nana/detail/linux_X11/platform_spec.hpp>
#include "../../detail/posix/platform_spec.hpp"
#endif
namespace nana

2
source/gui/detail/native_window_interface.cpp
View File

@@ -10,7 +10,7 @@
* @file: nana/gui/detail/native_window_interface.cpp
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../../detail/platform_spec_selector.hpp"
#include <nana/gui/detail/native_window_interface.hpp>
#include <nana/gui/screen.hpp>
#include <nana/gui/detail/bedrock.hpp>

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

@@ -1397,13 +1397,13 @@ namespace detail
{
auto & tabs = wd->root_widget->other.attribute.root->tabstop;
auto end = tabs.cend();
if (forward)
{
if (detail::tab_type::none == wd->flags.tab)
return (tabs.front());
else if (detail::tab_type::tabstop & wd->flags.tab)
{
auto end = tabs.cend();
auto i = std::find(tabs.cbegin(), end, wd);
if (i != end)
{
@@ -1417,8 +1417,8 @@ namespace detail
}
else if (tabs.size() > 1) //at least 2 elments in tabs are required when moving backward.
{
auto i = std::find(tabs.cbegin(), tabs.cend(), wd);
if (i != tabs.cend())
auto i = std::find(tabs.cbegin(), end, wd);
if (i != end)
return (tabs.cbegin() == i ? tabs.back() : *(i - 1));
}
return nullptr;
@@ -1729,7 +1729,7 @@ namespace detail
if (established)
{
utl::erase(pa_children, wd);
utl::erase(wd->parent->children, wd);
if (for_new->children.empty())
wd->index = 0;
else
@@ -1892,15 +1892,20 @@ namespace detail
if(!wd->visible)
return nullptr;
for(auto i = wd->children.rbegin(); i != wd->children.rend(); ++i)
if (!wd->children.empty())
{
core_window_t* child = *i;
if((child->other.category != category::flags::root) && _m_effective(child, pos))
auto index = wd->children.size();
do
{
child = _m_find(child, pos);
if(child)
return child;
}
auto child = wd->children[--index];
if ((child->other.category != category::flags::root) && _m_effective(child, pos))
{
child = _m_find(child, pos);
if (child)
return child;
}
} while (0 != index);
}
return wd;
}

3
source/gui/detail/window_register.hpp
View File

@@ -133,9 +133,10 @@ namespace nana
if (base_.erase(wd))
{
wdcache_.insert(wd, false);
trash_.push_back(wd);
if (category::flags::root == wd->other.category)
{
trash_.push_back(wd);
auto i = std::find(queue_.begin(), queue_.end(), wd);
if (i != queue_.end())
queue_.erase(i);

2
source/gui/notifier.cpp
View File

@@ -26,7 +26,7 @@
#include <mutex>
#endif
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#if defined(NANA_LINUX) || defined(NANA_MACOS)
#include <nana/system/platform.hpp>

2
source/gui/timer.cpp
View File

@@ -28,7 +28,7 @@
#if defined(NANA_WINDOWS)
#include <windows.h>
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#include <nana/system/platform.hpp>
#endif

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

@@ -117,10 +117,10 @@ namespace nana
if((tv != align_v::top) && extent_v_pixels < graph.height())
{
rs.pos.y = static_cast<int>(graph.height() - extent_v_pixels);
if(align_v::center == tv)
rs.pos.y = static_cast<int>(graph.height() - extent_v_pixels) >> 1;
else if(align_v::bottom == tv)
rs.pos.y = static_cast<int>(graph.height() - extent_v_pixels);
rs.pos.y >>= 1;
}
else
rs.pos.y = 0;
@@ -203,7 +203,7 @@ namespace nana
}
private:
//Manage the fblock for a specified rectangle if it is a traceable fblock.
void _m_inser_if_traceable(int x, int y, const nana::size& sz, widgets::skeletons::fblock* fbp)
void _m_insert_if_traceable(int x, int y, const nana::size& sz, widgets::skeletons::fblock* fbp)
{
if(fbp->target.size() || fbp->url.size())
{
@@ -236,9 +236,9 @@ namespace nana
return fp->fgcolor;
}
std::size_t _m_font_size(nana::widgets::skeletons::fblock* fp) noexcept
double _m_font_size(nana::widgets::skeletons::fblock* fp) noexcept
{
while(fp->font_size == 0xFFFFFFFF)
while(fp->font_size == -1)
{
fp = fp->parent;
if(nullptr == fp)
@@ -274,12 +274,14 @@ namespace nana
if(fp != fblock_)
{
auto& name = _m_fontname(fp);
auto fontsize = static_cast<unsigned>(_m_font_size(fp));
auto fontsize = _m_font_size(fp);
bool bold = _m_bold(fp);
if((fontsize != font_.size()) || bold != font_.bold() || name != font_.name())
{
font_.make(name, fontsize, bold);
paint::font::font_style fs;
fs.weight = (bold ? 800 : 400);
font_ = paint::font{ name, fontsize, fs };
graph.typeface(font_);
}
fblock_ = fp;
@@ -345,7 +347,7 @@ namespace nana
std::vector<iterator> line_values;
for(auto i = line.begin(), end = line.end(); i != end; ++i)
for(auto i = line.begin(); i != line.end(); ++i)
{
data * data_ptr = i->data_ptr;
nana::size sz = data_ptr->size();
@@ -378,12 +380,11 @@ namespace nana
}
else
{
pixel_tag px;
_m_align_x_base(rs, px, (w ? w : sz.width));
if(w)
{
pixel_tag px;
_m_align_x_base(rs, px, w);
if(max_ascent + max_descent > max_px)
max_px = max_descent + max_ascent;
else
@@ -393,8 +394,6 @@ namespace nana
px.baseline = max_ascent;
px.values.swap(line_values);
rs.pixels.emplace_back(px);
w = sz.width;
max_px = sz.height;
max_ascent = as;
@@ -403,18 +402,16 @@ namespace nana
}
else
{
pixel_tag px;
_m_align_x_base(rs, px, sz.width);
px.pixels = sz.height;
px.baseline = as;
px.values.emplace_back(i);
rs.pixels.emplace_back(px);
max_px = 0;
max_ascent = max_descent = 0;
}
rs.pixels.emplace_back(px);
}
}
@@ -444,49 +441,48 @@ namespace nana
const int lastpos = static_cast<int>(graph.height()) - 1;
for(auto i = rs.pixels.begin(), end = rs.pixels.end(); i != end; ++i)
for(auto & px : rs.pixels)
{
for (auto & render_iterator : i->values)
for(auto & render_iterator: px.values)
{
auto & value = *render_iterator;
if(false == value.data_ptr->is_text())
{
if(text.size())
{
_m_draw_block(graph, text, block_start, rs);
if(lastpos <= rs.pos.y)
return false;
text.clear();
}
nana::size sz = value.data_ptr->size();
pixel_tag px = rs.pixels[rs.index];
if ((rs.allowed_width < rs.pos.x + sz.width) && (rs.pos.x != px.x_base))
{
//Change a line.
rs.pos.y += static_cast<int>(px.pixels);
px = rs.pixels[++rs.index];
rs.pos.x = px.x_base;
}
int y = rs.pos.y + _m_text_top(px, value.fblock_ptr, value.data_ptr);
value.data_ptr->nontext_render(graph, rs.pos.x, y);
_m_inser_if_traceable(rs.pos.x, y, sz, value.fblock_ptr);
rs.pos.x += static_cast<int>(sz.width);
if(lastpos < y)
return false;
}
else
if (value.data_ptr->is_text())
{
//hold the block while the text is empty,
//it stands for the first block
if(text.empty())
if (text.empty())
block_start = render_iterator;
text += value.data_ptr->text();
continue;
}
if(text.size())
{
_m_draw_block(graph, text, block_start, rs);
if(lastpos <= rs.pos.y)
return false;
text.clear();
}
nana::size sz = value.data_ptr->size();
pixel_tag px = rs.pixels[rs.index];
if ((rs.allowed_width < rs.pos.x + sz.width) && (rs.pos.x != px.x_base))
{
//Change a line.
rs.pos.y += static_cast<int>(px.pixels);
px = rs.pixels[++rs.index];
rs.pos.x = px.x_base;
}
int y = rs.pos.y + _m_text_top(px, value.fblock_ptr, value.data_ptr);
value.data_ptr->nontext_render(graph, rs.pos.x, y);
_m_insert_if_traceable(rs.pos.x, y, sz, value.fblock_ptr);
rs.pos.x += static_cast<int>(sz.width);
if(lastpos < y)
return false;
}
if(text.size())
@@ -575,7 +571,7 @@ namespace nana
}
_m_inser_if_traceable(rs.pos.x, y, sz, fblock_ptr);
_m_insert_if_traceable(rs.pos.x, y, sz, fblock_ptr);
rs.pos.x += static_cast<int>(sz.width);
if(text_range.second < len)
@@ -604,13 +600,13 @@ namespace nana
dstream dstream_;
bool format_enabled_ = false;
::nana::widgets::skeletons::fblock * fblock_ = nullptr;
std::deque<traceable> traceable_;
::std::deque<traceable> traceable_;
::nana::paint::font font_;
struct def_font_tag
{
::std::string font_name;
std::size_t font_size;
double font_size;
bool font_bold;
::nana::color fgcolor;
}def_;

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

@@ -1953,7 +1953,6 @@ namespace nana
index_pairs already_selected;
index_pairs selections;
//nana::timer timer;
bool scroll_direction;
unsigned scroll_step{ 1 };
unsigned mouse_move_timestamp{ 0 };
@@ -4134,6 +4133,7 @@ namespace nana
}
else if (ptr_where.first == parts::list_blank) //not selected
{
//Start box selection if mulit-selection is enabled
if (arg.is_left_button() && (!lister.single_status(true)))
essence_->start_mouse_selection(arg.pos);

10
source/paint/detail/native_paint_interface.cpp
View File

@@ -11,7 +11,7 @@
* @contributors: dareg
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../../detail/platform_spec_selector.hpp"
#include <nana/paint/detail/native_paint_interface.hpp>
#include <nana/paint/pixel_buffer.hpp>
#include <nana/gui/layout_utility.hpp>
@@ -145,14 +145,14 @@ namespace detail
#if defined(NANA_USE_XFT)
std::string utf8str = to_utf8(std::wstring(text, len));
XGlyphInfo ext;
XftFont * fs = reinterpret_cast<XftFont*>(dw->font->handle);
XftFont * fs = reinterpret_cast<XftFont*>(dw->font->native_handle());
::XftTextExtentsUtf8(nana::detail::platform_spec::instance().open_display(), fs,
reinterpret_cast<XftChar8*>(const_cast<char*>(utf8str.c_str())), utf8str.size(), &ext);
return nana::size(ext.xOff, fs->ascent + fs->descent);
#else
XRectangle ink;
XRectangle logic;
::XmbTextExtents(reinterpret_cast<XFontSet>(dw->font->handle), text, len, &ink, &logic);
::XmbTextExtents(reinterpret_cast<XFontSet>(dw->font->native_handle()), text, len, &ink, &logic);
return nana::size(logic.width, logic.height);
#endif
#endif
@@ -185,7 +185,7 @@ namespace detail
#elif defined(NANA_X11)
auto disp = ::nana::detail::platform_spec::instance().open_display();
#if defined(NANA_USE_XFT)
auto fs = reinterpret_cast<XftFont*>(dw->font->handle);
auto fs = reinterpret_cast<XftFont*>(dw->font->native_handle());
//Fixed missing array declaration by dareg
std::unique_ptr<FT_UInt[]> glyphs_ptr(new FT_UInt[len]);
@@ -197,7 +197,7 @@ namespace detail
}
XftDrawGlyphs(dw->xftdraw, &(dw->xft_fgcolor), fs, pos.x, pos.y + fs->ascent, glyphs_ptr.get(), len);
#else
XFontSet fs = reinterpret_cast<XFontSet>(dw->font->handle);
XFontSet fs = reinterpret_cast<XFontSet>(dw->font->native_handle());
XFontSetExtents * ext = ::XExtentsOfFontSet(fs);
XFontStruct ** fontstructs;
char ** font_names;

106
source/paint/graphics.cpp
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
@@ -10,7 +10,7 @@
* @file: nana/paint/graphics.cpp
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#include <nana/gui/detail/bedrock.hpp>
#include <nana/paint/graphics.hpp>
#include <nana/paint/detail/native_paint_interface.hpp>
@@ -24,8 +24,19 @@
#include <X11/Xlib.h>
#endif
#include "../detail/platform_abstraction.hpp"
namespace nana
{
namespace detail
{
font_style::font_style(unsigned weight, bool italic, bool underline, bool strike_out) :
weight(weight),
italic(italic),
underline(underline),
strike_out(strike_out)
{}
}
namespace paint
{
namespace detail
@@ -56,33 +67,39 @@ namespace paint
//class font
struct font::impl_type
{
typedef nana::detail::platform_spec::font_ptr_t ptr_t;
ptr_t font_ptr;
std::shared_ptr<font_interface> real_font;
};
font::font()
: impl_(new impl_type)
{
impl_->font_ptr = nana::detail::platform_spec::instance().default_native_font();
impl_->real_font = platform_abstraction::default_font(nullptr);
}
font::font(drawable_type dw)
: impl_(new impl_type)
{
impl_->font_ptr = dw->font;
impl_->real_font = dw->font;
}
font::font(const font& rhs)
: impl_(new impl_type)
{
if(rhs.impl_)
impl_->font_ptr = rhs.impl_->font_ptr;
impl_->real_font = rhs.impl_->real_font;
}
font::font(const std::string& name, unsigned size, bool bold, bool italic, bool underline, bool strike_out)
: impl_(new impl_type)
font::font(const std::string& font_family, double size_pt, const font_style& fs):
impl_(new impl_type)
{
make(name, size, bold, italic, underline, strike_out);
impl_->real_font = platform_abstraction::make_font(font_family, size_pt, fs);
}
font::font(double size_pt, const path_type& truetype, const font_style& fs) :
impl_(new impl_type)
{
impl_->real_font = platform_abstraction::make_font_from_ttf(truetype, size_pt, fs);
}
font::~font()
@@ -92,23 +109,7 @@ namespace paint
bool font::empty() const
{
return ((nullptr == impl_) || (nullptr == impl_->font_ptr));
}
void font::make(const std::string& name, unsigned size, bool bold, bool italic, bool underline, bool strike_out)
{
size = nana::detail::platform_spec::instance().font_size_to_height(size);
make_raw(name, size, bold ? 700 : 400, italic, underline, strike_out);
}
void font::make_raw(const std::string& name, unsigned height, unsigned weight, bool italic, bool underline, bool strike_out)
{
if(impl_)
{
auto t = nana::detail::platform_spec::instance().make_native_font(name.c_str(), height, weight, italic, underline, strike_out);
if(t)
impl_->font_ptr = t;
}
return ((nullptr == impl_) || (nullptr == impl_->real_font));
}
void font::set_default() const
@@ -116,74 +117,69 @@ namespace paint
if(empty())
return;
nana::detail::platform_spec::instance().default_native_font(impl_->font_ptr);
platform_abstraction::default_font(impl_->real_font);
}
std::string font::name() const
{
if(empty()) return std::string();
return to_utf8(impl_->font_ptr->name);
return impl_->real_font->family();
}
unsigned font::size() const
double font::size() const
{
if(empty()) return 0;
return nana::detail::platform_spec::instance().font_height_to_size(impl_->font_ptr->height);
return impl_->real_font->size();
}
bool font::bold() const
{
if(empty()) return false;
return (impl_->font_ptr->weight >= 700);
}
unsigned font::height() const
{
if(empty()) return 0;
return (impl_->font_ptr->height);
return (impl_->real_font->style().weight >= 700);
}
unsigned font::weight() const
{
if(empty()) return 0;
return (impl_->font_ptr->weight);
return impl_->real_font->style().weight;
}
bool font::italic() const
{
if(empty()) return false;
return (impl_->font_ptr->italic);
return impl_->real_font->style().italic;
}
bool font::underline() const
{
if(empty()) return false;
return (impl_->font_ptr->underline);
return impl_->real_font->style().underline;
}
bool font::strikeout() const
{
if(empty()) return false;
return (impl_->font_ptr->strikeout);
return impl_->real_font->style().strike_out;
}
native_font_type font::handle() const
{
if(empty()) return nullptr;
return reinterpret_cast<native_font_type>(impl_->font_ptr->handle);
return impl_->real_font->native_handle();
}
void font::release()
{
if(impl_)
impl_->font_ptr.reset();
impl_->real_font.reset();
}
font & font::operator=(const font& rhs)
{
if(impl_ && rhs.impl_ && (this != &rhs))
impl_->font_ptr = rhs.impl_->font_ptr;
impl_->real_font = rhs.impl_->real_font;
return *this;
}
@@ -191,7 +187,7 @@ namespace paint
bool font::operator==(const font& rhs) const
{
if(empty() == rhs.empty())
return (empty() || (impl_->font_ptr->handle == rhs.impl_->font_ptr->handle));
return (empty() || (impl_->real_font == rhs.impl_->real_font));
return false;
}
@@ -199,7 +195,7 @@ namespace paint
bool font::operator!=(const font& rhs) const
{
if(empty() == rhs.empty())
return ((empty() == false) && (impl_->font_ptr->handle != rhs.impl_->font_ptr->handle));
return ((empty() == false) && (impl_->real_font != rhs.impl_->real_font));
return true;
}
@@ -305,7 +301,7 @@ namespace paint
dw->string.tab_length = reuse->string.tab_length;
}
else
dw->font = impl_->font_shadow.impl_->font_ptr;
dw->font = impl_->font_shadow.impl_->real_font;
#if defined(NANA_WINDOWS)
HDC hdc = ::GetDC(0);
@@ -325,7 +321,7 @@ namespace paint
if(bmp)
{
::DeleteObject((HBITMAP)::SelectObject(cdc, bmp));
::DeleteObject(::SelectObject(cdc, dw->font->handle));
::DeleteObject(::SelectObject(cdc, dw->font->native_handle()));
dw->context = cdc;
dw->pixmap = bmp;
@@ -388,9 +384,9 @@ namespace paint
impl_->font_shadow = f;
if(impl_->handle && (false == f.empty()))
{
impl_->handle->font = f.impl_->font_ptr;
impl_->handle->font = f.impl_->real_font;
#if defined(NANA_WINDOWS)
::SelectObject(impl_->handle->context, reinterpret_cast<HFONT>(f.impl_->font_ptr->handle));
::SelectObject(impl_->handle->context, reinterpret_cast<HFONT>(f.impl_->real_font->native_handle()));
#endif
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;
@@ -489,8 +485,8 @@ namespace paint
delete [] dx;
#elif defined(NANA_X11) && defined(NANA_USE_XFT)
Display * disp = nana::detail::platform_spec::instance().open_display();
XftFont * xft = impl_->handle->font->handle;
auto disp = nana::detail::platform_spec::instance().open_display();
auto xft = reinterpret_cast<XftFont*>(impl_->handle->font->native_handle());
XGlyphInfo extents;
for(std::size_t i = 0; i < len; ++i)
@@ -547,12 +543,12 @@ namespace paint
if(impl_->handle->font)
{
#if defined(NANA_USE_XFT)
XftFont * fs = reinterpret_cast<XftFont*>(impl_->handle->font->handle);
auto fs = reinterpret_cast<XftFont*>(impl_->handle->font->native_handle());
ascent = fs->ascent;
descent = fs->descent;
internal_leading = 0;
#else
XFontSet fs = reinterpret_cast<XFontSet>(impl_->handle->font->handle);
auto fs = reinterpret_cast<XFontSet>(impl_->handle->font->native_handle());
XFontSetExtents * ext = ::XExtentsOfFontSet(fs);
XFontStruct ** fontstructs;
char ** font_names;

2
source/paint/image.cpp
View File

@@ -13,7 +13,7 @@
*/
#include <nana/push_ignore_diagnostic>
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#include <nana/paint/image.hpp>
#include <algorithm>
#include <fstream>

2
source/paint/pixel_buffer.cpp
View File

@@ -11,7 +11,7 @@
* @note: The format of Xorg 16bits depth is 565
*/
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#include <nana/paint/pixel_buffer.hpp>
#include <nana/gui/layout_utility.hpp>
#include <nana/paint/detail/native_paint_interface.hpp>

2
source/paint/text_renderer.cpp
View File

@@ -1,5 +1,5 @@
#include <nana/detail/platform_spec_selector.hpp>
#include "../detail/platform_spec_selector.hpp"
#include <nana/paint/text_renderer.hpp>
#include <nana/unicode_bidi.hpp>
#include <nana/paint/detail/native_paint_interface.hpp>

161
source/paint/truetype.hpp Normal file
View File

@@ -0,0 +1,161 @@
#ifndef TTF_HEADER_INCLUDED
#define TTF_HEADER_INCLUDED
#include <cstdint>
#include <fstream>
#include <nana/charset.hpp>
#include <nana/filesystem/filesystem.hpp>
namespace nana
{
namespace spec
{
class truetype
{
struct tt_offset_table
{
std::uint16_t major_version;
std::uint16_t minor_version;
std::uint16_t num_of_tables;
std::uint16_t search_range;
std::uint16_t entry_selector;
std::uint16_t range_shift;
};
struct tt_table_directory
{
char name[4]; //table name
std::uint32_t checksum; //Check sum
std::uint32_t offset; //Offset from beginning of file
std::uint32_t length; //length of the table in bytes
};
struct tt_name_table_header
{
std::uint16_t format_selector; //format selector. Always 0
std::uint16_t name_records_count; //Name Records count
std::uint16_t storage_offset; //Offset for strings storage, from start of the table
};
struct tt_name_record
{
std::uint16_t platform_id;
std::uint16_t encoding_id;
std::uint16_t language_id;
std::uint16_t name_id;
std::uint16_t string_length;
std::uint16_t string_offset; //from start of storage area
};
public:
using path_type = ::std::experimental::filesystem::path;
truetype(const path_type& filename)
{
std::ifstream ifs{ filename, std::ios::binary };
if (!ifs.is_open())
return;
tt_offset_table offset_table;
if (ifs.read(reinterpret_cast<char*>(&offset_table), sizeof offset_table).gcount() != sizeof offset_table)
return;
const std::size_t num_of_tables = _m_swap(offset_table.num_of_tables);
for (std::size_t i = 0; i < num_of_tables; ++i)
{
tt_table_directory table_directory;
if (ifs.read(reinterpret_cast<char*>(&table_directory), sizeof table_directory).gcount() != sizeof table_directory)
return;
if (reinterpret_cast<const std::uint32_t&>("name") == reinterpret_cast<std::uint32_t&>(table_directory.name))
{
//const std::size_t length = _m_swap(table_directory.length);
const std::size_t directory_offset = _m_swap(table_directory.offset);
ifs.seekg(directory_offset, std::ios::beg);
tt_name_table_header name_table;
if (ifs.read(reinterpret_cast<char*>(&name_table), sizeof name_table).gcount() != sizeof name_table)
return;
const std::size_t name_records_count = _m_swap(name_table.name_records_count);
const std::size_t storage_offset = _m_swap(name_table.storage_offset);
for (std::size_t u = 0; u < name_records_count; ++u)
{
tt_name_record record;
if (ifs.read(reinterpret_cast<char*>(&record), sizeof record).gcount() != sizeof record)
return;
if ((0 == record.string_length) || (0x100 != record.name_id))
continue;
std::size_t string_length = _m_swap(record.string_length);
auto const filepos = ifs.tellg();
ifs.seekg(directory_offset + _m_swap(record.string_offset) + storage_offset, std::ios::beg);
std::string text;
//Check if it is unicode
if ((0 == record.platform_id) || (record.platform_id == 0x300 && record.encoding_id == 0x100))
{
if (0 == (string_length & 1)) //the string_length must be
{
//This is unicode
text.resize(string_length);
ifs.read(&text.front(), string_length);
for (auto i = 0; i < string_length; i += 2)
{
std::swap(text[i], text[i + 1]);
}
text = nana::charset(text, nana::unicode::utf16).to_bytes(nana::unicode::utf8);
}
}
else
{
text.resize(string_length);
ifs.read(&text.front(), string_length);
}
if (!text.empty())
{
switch (record.name_id)
{
case 0x100:
font_family_.swap(text);
break;
case 0x400:
text.clear();
}
}
ifs.seekg(filepos, std::ios::beg);
}
}
}
}
const std::string& font_family() const
{
return font_family_;
}
private:
static std::uint16_t _m_swap(std::uint16_t val)
{
return (val << 8) | (val >> 8);
}
static std::uint32_t _m_swap(std::uint32_t val)
{
return (static_cast<std::uint32_t>(_m_swap(std::uint16_t(val & 0xFFFF))) << 16) | _m_swap(std::uint16_t(val >> 16));
}
private:
std::string font_family_;
};
}
}
#endif

8
source/system/dataexch.cpp
View File

@@ -19,11 +19,11 @@
#include <cstring>
#if defined(NANA_WINDOWS)
#include <windows.h>
# include <windows.h>
#elif defined(NANA_X11)
#include <nana/detail/platform_spec_selector.hpp>
#include <nana/gui/detail/bedrock.hpp>
#include <nana/gui/detail/basic_window.hpp>
# include "../detail/platform_spec_selector.hpp"
# include <nana/gui/detail/bedrock.hpp>
# include <nana/gui/detail/basic_window.hpp>
#endif
namespace nana{ namespace system{

2
source/system/platform.cpp
View File

@@ -16,7 +16,7 @@
#if defined(NANA_WINDOWS)
#include <windows.h>
#include <nana/detail/win32/platform_spec.hpp>
#include "../detail/mswin/platform_spec.hpp"
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
#include <time.h>
#include <errno.h>