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-07-19 23:47:41 +08:00
commit 8ddb4926fb
159 changed files with 9850 additions and 5998 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -24,6 +24,7 @@ build/makefile-bkl/*
*.ilk
*.log
[Bb]in
[Bb]in/
[Dd]ebug*/
*.lib
*.a

95
.travis.yml
View File

@ -34,6 +34,7 @@ matrix:
- alsa-oss
- libx11-dev
- libxft-dev
- libboost-filesystem-dev
sources:
- ubuntu-toolchain-r-test
@ -55,7 +56,7 @@ matrix:
- llvm-toolchain-precise
before_install:
- git clone --depth=50 --branch=master https://github.com/qPCR4vir/nana-demo.git nana-demo
- git clone --depth=1 --branch=develop https://github.com/qPCR4vir/nana-demo.git ../nana-demo
- export PATH="$HOME/bin:$PATH"
- mkdir ~/bin
- wget --no-check-certificate --no-clobber -O /tmp/tools/cmake https://cmake.org/files/v3.4/cmake-3.4.0-rc3-Linux-x86_64.sh || true
@ -65,10 +66,92 @@ install:
- /tmp/tools/cmake --prefix="$HOME" --exclude-subdir
before_script :
- mkdir bld
- cd bld
# travis don't have a physical monitor. We need to install an emulator: https://docs.travis-ci.com/user/gui-and-headless-browsers/
- "export DISPLAY=:99.0"
- "sh -e /etc/init.d/xvfb start"
- sleep 3 # give xvfb some time to start
# we have: qPCR4vir/nana/../nana-demo and now we are in: qPCR4vir/nana/ our executable tests will access: ../nana-demo/Examples/*.bmp etc.(need to be in parallel with nana-demo/Examples)
#- cd ../nana-demo
- mkdir ../nana_lib
- mkdir ../nana_demo_bin
- cd ../nana_lib
- mkdir bin
- cd bin
script:
- cmake -G"Unix Makefiles" .. -DENABLE_JPEG=ON -DENABLE_PNG=OFF -DBUILD_NANA_DEMOS=ON -DENABLE_AUDIO=OFF
- make
# Installing: the static "nana lib" will be in DESTDIR/CMAKE_INSTALL_PREFIX/lib/
# and the includes files "nana" in DESTDIR/CMAKE_INSTALL_PREFIX/include/
# we are in "... nana/../nana_lib/bin/" we need "../../nana" to get the CMakeList.txt of nana.
# Thus, make install will put the nana.lib in "... nana/../nana_lib/lib/"
# and the includes in "... nana/../nana_lib/include/"
- cmake -G"Unix Makefiles" ../../nana -DCMAKE_INSTALL_PREFIX=.. -DNANA_CMAKE_ENABLE_JPEG=ON -DNANA_CMAKE_ENABLE_PNG=OFF -DNANA_CMAKE_BUILD_DEMOS=ON -DNANA_CMAKE_ENABLE_AUDIO=OFF -DNANA_CMAKE_FIND_BOOST_FILESYSTEM=ON -DNANA_CMAKE_BOOST_FILESYSTEM_FORCE=OFF -DNANA_CMAKE_AUTOMATIC_GUI_TESTING=ON
- make install
- ls
- cd ..
- ls
- cd ..
- ls
- cd nana_demo_bin
- cmake -G"Unix Makefiles" ../nana-demo -DCMAKE_INSTALL_PREFIX=.. -DNANA_CMAKE_ENABLE_JPEG=ON -DNANA_CMAKE_ENABLE_PNG=OFF -DNANA_CMAKE_BUILD_DEMOS=ON -DNANA_CMAKE_ENABLE_AUDIO=OFF -DNANA_CMAKE_FIND_BOOST_FILESYSTEM=ON -DNANA_CMAKE_BOOST_FILESYSTEM_FORCE=OFF -DNANA_CMAKE_INCLUDE_EXPERIMENTAL_DEMOS=OFF -DNANA_CMAKE_AUTOMATIC_GUI_TESTING=ON
- make install
# todo: separate resources from sources (a directory for images)
- ls
- cd ../bin
- ls
- ./a_group_impl
- ./animate-bmp
- ./audio_player
- ./background-effects
#- ./calculator # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1159
- ./categ
- ./clicked
- ./decore
- ./dock
- ./drag-button
- ./draw
- ./file_explorer
#- ./example_menu # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1348
- ./example_listbox
#- ./example_combox # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1378
- ./example.button
#- ./filebox-txt # https://travis-ci.org/qPCR4vir/nana/jobs/140250744#L1393
- ./folder_tree
#- ./folder_tree_nana # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1408
#- ./folder_tree_std # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1421
- ./framework_design_1
- ./framework_design_2
- ./framework_design_3
- ./group
- ./HelloWord
#- ./helloword_quit # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1572
#- ./inputbox # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1585
- ./label_listener
- ./lambda_event.Cpp11
- ./listbox_inline_widget
- ./listbox_Resolver
- ./loader_1
#- ./loader_2 # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1732
- ./mbox
- ./main
- ./menu_debug
#- ./modal_form # https://travis-ci.org/qPCR4vir/nana/jobs/140250744#L1736
#- ./MontiHall # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1775
#- ./helloworld_demo # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1786
#- ./notepad # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1799
- ./menu_debug
- ./menu_popuper
#- ./modal_form # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1846
#- ./widget_show2 # https://travis-ci.org/qPCR4vir/nana/jobs/140245437#L1730
#- ./widget_show # https://travis-ci.org/qPCR4vir/nana/jobs/140245437#L1740
- ./place_login
- ./png
#- ./screen # https://travis-ci.org/qPCR4vir/nana/jobs/140238537#L1909
- ./stretch_image
#- ./threading # https://travis-ci.org/qPCR4vir/nana/jobs/140245437#L1826 ?
#- ./thread-pool # https://travis-ci.org/qPCR4vir/nana/jobs/140247564#L1782
- ./various_events
#- ./window-dragger # https://travis-ci.org/qPCR4vir/nana/jobs/140245438#L1820
- ./windows-subclassing
- ./textbox_line_number

505
CMakeLists.txt
View File

@ -1,68 +1,71 @@
# CMake configuration for Nana
# Author: Andrew Kornilov(https://github.com/ierofant)
# Contributor:
# Robert Hauck - Enable support for PNG/Freetype
# Contributors:
# Jinhao
# Robert Hauck - Enable support for PNG/Freetype
# Qiangqiang Wu - Add biicode support
# Ariel Vina-Rodriguez (qPCR4vir)
#
# Nana uses some build systems: MS-VS solution, MAKE, bakefile, codeblock, etc. manually optimized.
# In the future CMake could be the prefered, and maybe will be used to generate the others and the central nana repo
# will distribute all of them. But by now CMake is just one of them and all the other distributed build system
# files/projects are manually write. This current CMakeList.txt reflect this fact and that is why we don't
# generate here configurated *.h files or explicitly enumerate the sources files: anyway this CM-list
# will be "touched" to force a re-run of cmake.
#https://cmake.org/cmake-tutorial/
#https://cmake.org/cmake/help/v3.3/module/CMakeDependentOption.html?highlight=cmakedependentoption
# use CACHE FORCE or set(ENABLE_MINGW_STD_THREADS_WITH_MEGANZ ON) or delete CMakecache.txt or the entirely build dir
# use CACHE FORCE or set(ENABLE_MINGW_STD_THREADS_WITH_MEGANZ ON) or delete CMakecache.txt or the entirely build dir
# if your changes don't execute
option(ENABLE_MINGW_STD_THREADS_WITH_MEGANZ "replaced boost.thread with meganz's mingw-std-threads." OFF)
option(ENABLE_PNG "Enable the use of PNG" OFF)
option(LIBPNG_FROM_OS "Use libpng from operating system." ON)
option(ENABLE_JPEG "Enable the use of JPEG" OFF)
option(LIBJPEG_FROM_OS "Use libjpeg from operating system." ON)
option(ENABLE_AUDIO "Enable class audio::play for PCM playback." OFF)
option(CMAKE_VERBOSE_PREPROCESSOR "Show annoying debug messages during compilation." OFF)
option(CMAKE_STOP_VERBOSE_PREPROCESSOR "Stop compilation after showing the annoying debug messages." ON)
option(BUILD_NANA_DEMOS "Build all the demos form the nana_demo repository." OFF)
# The ISO C++ File System Technical Specification is optional.
# It seems that project() defines essential system variables like CMAKE_FIND_LIBRARY_PREFIXES.
# https://bbs.archlinux.org/viewtopic.php?id=84967
project(nana)
cmake_minimum_required(VERSION 2.8)
option(NANA_CMAKE_INSTALL_INCLUDES "Install nana includes when compile the library" ON)
option(NANA_CMAKE_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ "replaced boost.thread with meganz's mingw-std-threads." OFF)
option(NANA_CMAKE_ENABLE_PNG "Enable the use of PNG" OFF)
option(NANA_CMAKE_LIBPNG_FROM_OS "Use libpng from operating system." ON)
option(NANA_CMAKE_ENABLE_JPEG "Enable the use of JPEG" OFF)
option(NANA_CMAKE_LIBJPEG_FROM_OS "Use libjpeg from operating system." ON)
option(NANA_CMAKE_ENABLE_AUDIO "Enable class audio::play for PCM playback." OFF)
option(NANA_CMAKE_VERBOSE_PREPROCESSOR "Show annoying debug messages during compilation." ON)
option(NANA_CMAKE_STOP_VERBOSE_PREPROCESSOR "Stop compilation after showing the annoying debug messages." OFF)
option(NANA_CMAKE_AUTOMATIC_GUI_TESTING "Activate automatic GUI testing?" OFF)
# The ISO C++ File System Technical Specification (ISO-TS, or STD) is optional.
# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf
# This is not a workaround, but an user option.
# The library maybe available in the std library in use or from Boost (almost compatible)
# http://www.boost.org/doc/libs/1_60_0/libs/filesystem/doc/index.htm
# or you can choose to use the (partial, but functional) implementation provided by nana.
# If you include the file <nana/filesystem/filesystem_selector.hpp>
# The selected option will be set by nana into std::experimental::filesystem
# By default Nana will use the ISO TS if available, or nana if not.
# Boost will be use only if you change one of the following:
option(CMAKE_BOOST_FILESYSTEM_AVAILABLE "Is Boost filesystem available?" OFF)
option(NANA_BOOST_FILESYSTEM_PREFERRED "Is Boost filesystem preferred over nana?" OFF)
option(CMAKE_BOOST_FILESYSTEM_FORCE "Force use of Boost filesystem if available (over ISO)?" OFF)
option(CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT "Where to find <boost/filesystem.hpp>?" "../")
option(CMAKE_BOOST_FILESYSTEM_LIB "Flag for the compiler to link: " "-lboost/fs")
# If you include the file <nana/filesystem/filesystem.hpp> or <nana/filesystem/filesystem_ext.hpp>
# the selected option will be set by nana into std::experimental::filesystem
# By default Nana will try to use the STD. If STD is not available and NANA_CMAKE_FIND_BOOST_FILESYSTEM
# is set to ON nana will try to use boost if available. Nana own implementation will be use if none of
# the previus were selected or available.
# You can change that default if you change one of the following
# (please don't define more than one of the _XX_FORCE options):
option(NANA_CMAKE_FIND_BOOST_FILESYSTEM "Search: Is Boost filesystem available?" OFF)
option(NANA_CMAKE_NANA_FILESYSTEM_FORCE "Force nana filesystem over ISO and boost?" OFF)
option(NANA_CMAKE_STD_FILESYSTEM_FORCE "Use of STD filesystem?(a compilation error will ocurre if not available)" OFF)
option(NANA_CMAKE_BOOST_FILESYSTEM_FORCE "Force use of Boost filesystem if available (over STD)?" OFF)
set(NANA_LINKS)
if (CMAKE_BOOST_FILESYSTEM_AVAILABLE)
if (CMAKE_BOOST_FILESYSTEM_PREFERED OR CMAKE_BOOST_FILESYSTEM_FORCE)
add_definitions(-DNANA_BOOST_FILESYSTEM_AVAILABLE)
if (CMAKE_BOOST_FILESYSTEM_FORCE)
add_definitions(-DNANA_BOOST_FILESYSTEM_FORCE)
else()
add_definitions(-DNANA_BOOST_FILESYSTEM_PREFERED)
endif()
include_directories("${CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT}")
list(APPEND NANA_LINKS "${CMAKE_BOOST_FILESYSTEM_LIB}")
endif (CMAKE_BOOST_FILESYSTEM_PREFERED OR CMAKE_BOOST_FILESYSTEM_FORCE)
endif (CMAKE_BOOST_FILESYSTEM_AVAILABLE)
project(nana)
cmake_minimum_required(VERSION 2.8)
# Compatibility with CMake 3.1
########### Compatibility with CMake 3.1
if(POLICY CMP0054)
# http://www.cmake.org/cmake/help/v3.1/policy/CMP0054.html
cmake_policy(SET CMP0054 OLD)
endif()
if(POLICY CMP0004) # ignore leading space
# http://www.cmake.org/cmake/help/v3.0/policy/CMP0004.html
cmake_policy(SET CMP0004 OLD)
endif()
add_definitions(-DNANA_IGNORE_CONF)
########### OS
if(WIN32)
add_definitions(-DWIN32)
set(BUILD_FreeMe ON) #"Build FreeMe only on Windows."
#Global MSVC definitions. You may prefer the hand-tuned sln and projects from the nana repository.
if(MSVC)
option(WIN32_USE_MP "Set to ON to build nana with the /MP option (Visual Studio 2005 and above)." ON)
@ -73,325 +76,219 @@ if(WIN32)
endif(MSVC)
if(MINGW)
if(ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
if(NANA_CMAKE_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
add_definitions(-DSTD_THREAD_NOT_SUPPORTED)
add_definitions(-DNANA_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
endif(ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
endif(NANA_CMAKE_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
endif(MINGW)
elseif(WIN32)
set(BUILD_FreeMe OFF)
endif(WIN32)
if(APPLE)
add_definitions(-DAPPLE)
include_directories(/opt/X11/include/)
list(APPEND NANA_LINKS -L/opt/X11/lib/ -liconv)
set(NANA_LINKS "${NANA_LINKS} -L/opt/X11/lib/ -liconv")
set(ENABLE_AUDIO OFF)
elseif(UNIX)
add_definitions(-Dlinux)
message("added -D linux")
endif(APPLE)
if(UNIX)
list(APPEND NANA_LINKS -lX11 )
set(NANA_LINKS "${NANA_LINKS} -lX11")
find_package(Freetype)
if (FREETYPE_FOUND)
include_directories( ${FREETYPE_INCLUDE_DIRS})
list(APPEND NANA_LINKS -lXft )
set(NANA_LINKS "${NANA_LINKS} -lXft")
endif(FREETYPE_FOUND)
endif(UNIX)
#Find PNG
if(ENABLE_PNG)
########### Compilers
#
# Using gcc: gcc 4.8 don't support C++14 and make_unique. You may want to update at least to 4.9.
# In Windows, the gcc which come with CLion was 4.8 from MinGW. You may want to install MinGW-w64 from the
# TDM-GCC Compiler Suite for Windows which will update you to gcc 5.1.
# gcc 5.3 and 5.4 include filesytem, but you need to add the link flag: -lstdc++fs
#
# see at end of: https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dynamic_or_shared.html
if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") # Clang || GNU
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++14 -Wall -g") # Clang
else ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -g") # GNU
endif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
endif(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
# enable static linkage # GNU || CLang not MinGW
if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") # AND NOT MINGW
# set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++ -pthread")
set(NANA_LINKS "${NANA_LINKS} -static-libgcc -static-libstdc++ -pthread")
# message("Setting NANA_LINKS to -static-libgcc -static-libstdc++ -pthread or ${NANA_LINKS}")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.3)
# IS_GNUCXX < 5.3
else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.3)
# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++fs") # IS_GNUCXX 5.3 or more
set(NANA_LINKS "${NANA_LINKS} -lstdc++fs")
endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.3)
endif(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") # AND NOT MINGW
if (APPLE AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") # APPLE Clang
# set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libstdc++")
set(NANA_LINKS "${NANA_LINKS} -stdlib=libstdc++")
endif ()
############# Optional libraries
# Find PNG
if(NANA_CMAKE_ENABLE_PNG)
add_definitions(-DNANA_ENABLE_PNG)
#set(NANA_PNG_LIB "png")
list(APPEND NANA_LINKS -lpng )
if(LIBPNG_FROM_OS)
set(NANA_LINKS "${NANA_LINKS} -lpng")
if(NANA_CMAKE_LIBPNG_FROM_OS)
find_package(PNG)
if (PNG_FOUND)
include_directories( ${PNG_INCLUDE_DIRS})
add_definitions(-DUSE_LIBPNG_FROM_OS)
endif(PNG_FOUND)
endif(LIBPNG_FROM_OS)
endif(ENABLE_PNG)
endif(NANA_CMAKE_LIBPNG_FROM_OS)
endif(NANA_CMAKE_ENABLE_PNG)
#Find JPEG
if(ENABLE_JPEG)
# Find JPEG
if(NANA_CMAKE_ENABLE_JPEG)
add_definitions(-DNANA_ENABLE_JPEG)
#set(NANA_JPEG_LIB "jpeg")
list(APPEND NANA_LINKS -ljpeg )
if(LIBJPEG_FROM_OS)
set(NANA_LINKS "${NANA_LINKS} -ljpeg")
if(NANA_CMAKE_LIBJPEG_FROM_OS)
find_package(JPEG)
if (JPEG_FOUND)
include_directories( ${JPEG_INCLUDE_DIRS})
add_definitions(-DUSE_LIBJPEG_FROM_OS)
endif(JPEG_FOUND)
endif(LIBJPEG_FROM_OS)
endif(ENABLE_JPEG)
endif(NANA_CMAKE_LIBJPEG_FROM_OS)
endif(NANA_CMAKE_ENABLE_JPEG)
if(ENABLE_AUDIO)
# Find ASOUND
if(NANA_CMAKE_ENABLE_AUDIO)
add_definitions(-DNANA_ENABLE_AUDIO)
if(UNIX)
find_package(ASOUND)
if (ASOUND_FOUND)
include_directories( ${ASOUND_INCLUDE_DIRS})
list(APPEND NANA_LINKS -lasound )
set(NANA_LINKS "${NANA_LINKS} -lasound")
else(ASOUND_FOUND)
message(FATAL_ERROR "libasound is not found")
endif(ASOUND_FOUND)
endif(UNIX)
endif(ENABLE_AUDIO)
endif(NANA_CMAKE_ENABLE_AUDIO)
#Unicode
if(CMAKE_VERBOSE_PREPROCESSOR)
# Find/Select filesystem
if (NANA_CMAKE_NANA_FILESYSTEM_FORCE)
add_definitions(-DNANA_FILESYSTEM_FORCE)
elseif (NANA_CMAKE_STD_FILESYSTEM_FORCE)
add_definitions(-DSTD_FILESYSTEM_FORCE)
elseif (NANA_CMAKE_FIND_BOOST_FILESYSTEM OR NANA_CMAKE_BOOST_FILESYSTEM_FORCE)
if (NANA_CMAKE_BOOST_FILESYSTEM_FORCE)
add_definitions(-DNANA_BOOST_FILESYSTEM_FORCE)
endif(NANA_CMAKE_BOOST_FILESYSTEM_FORCE)
# https://cmake.org/cmake/help/git-master/module/FindBoost.html
# Implicit dependencies such as Boost::filesystem requiring Boost::system will be automatically detected and satisfied,
# even if system is not specified when using find_package and if Boost::system is not added to target_link_libraries.
# If using Boost::thread, then Thread::Thread will also be added automatically.
find_package(Boost COMPONENTS filesystem)
if (Boost_FOUND)
add_definitions(-DNANA_BOOST_FILESYSTEM_AVAILABLE)
include_directories(SYSTEM "${Boost_INCLUDE_DIR}")
set(NANA_LINKS "${NANA_LINKS} ${Boost_LIBRARIES}") ###### FIRST !!!!!!!!!!!!!!!!! add is not first
endif (Boost_FOUND)
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON) # ??
endif (NANA_CMAKE_NANA_FILESYSTEM_FORCE)
######## Nana options
add_definitions(-DNANA_IGNORE_CONF)
if(NANA_CMAKE_VERBOSE_PREPROCESSOR)
add_definitions(-DVERBOSE_PREPROCESSOR)
endif(CMAKE_VERBOSE_PREPROCESSOR)
endif(NANA_CMAKE_VERBOSE_PREPROCESSOR)
if(NANA_CMAKE_AUTOMATIC_GUI_TESTING)
add_definitions(-DNANA_AUTOMATIC_GUI_TESTING)
enable_testing ()
endif(NANA_CMAKE_AUTOMATIC_GUI_TESTING)
####################### Main setting of Nana sources, targets and install
set(NANA_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/source)
set(NANA_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
# collect all source sub-directories in a list to avoid duplication here
set(NANA_SOURCE_SUBDIRS /.
/detail
/filesystem
/gui
/gui/detail
/gui/widgets
/gui/widgets/skeletons
/paint
/paint/detail
/system
/threads )
if(NANA_CMAKE_ENABLE_AUDIO)
list(APPEND NANA_SOURCE_SUBDIRS
/audio
/audio/detail )
endif(NANA_CMAKE_ENABLE_AUDIO)
# collect all source files in the source-sub-dir
# To show .h files in Visual Studio, add them to the list of sources in add_executable / add_library
# and Use SOURCE_GROUP if all your sources are in the same directory
foreach(subdir ${NANA_SOURCE_SUBDIRS})
aux_source_directory(${NANA_SOURCE_DIR}${subdir} sources)
# message("Subir: ${subdir}") # message("Files: ${sources}")
endforeach(subdir ${NANA_SOURCE_SUBDIRS})
include_directories(${NANA_INCLUDE_DIR})
aux_source_directory(${NANA_SOURCE_DIR} NANA_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/detail NANA_DETAIL_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/filesystem NANA_FILESYSTEM_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/gui NANA_GUI_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/gui/detail NANA_GUI_DETAIL_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/gui/widgets NANA_GUI_WIDGETS_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/gui/widgets/skeletons NANA_GUI_WIDGETS_SKELETONS_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/paint NANA_PAINT_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/paint/detail NANA_PAINT_DETAIL_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/system NANA_SYSTEM_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/threads NANA_THREADS_SOURCE)
if(ENABLE_AUDIO)
aux_source_directory(${NANA_SOURCE_DIR}/audio NANA_AUDIO_SOURCE)
aux_source_directory(${NANA_SOURCE_DIR}/audio/detail NANA_AUDIO_DETAIL_SOURCE)
endif()
add_library(${PROJECT_NAME} ${sources} )
target_link_libraries(${PROJECT_NAME} ${NANA_LINKS})
#To show .h files in Visual Studio, add them to the list of sources in add_executable / add_library
#and Use SOURCE_GROUP if all your sources are in the same directory
# Headers: use INCLUDE_DIRECTORIES
# Libraries: use FIND_LIBRARY and link with the result of it (try to avoid LINK_DIRECTORIES)
add_library(${PROJECT_NAME} ${NANA_SOURCE}
${NANA_DETAIL_SOURCE}
${NANA_FILESYSTEM_SOURCE}
${NANA_AUDIO_SOURCE}
${NANA_AUDIO_DETAIL_SOURCE}
${NANA_GUI_SOURCE}
${NANA_GUI_DETAIL_SOURCE}
${NANA_GUI_WIDGETS_SOURCE}
${NANA_GUI_WIDGETS_SKELETONS_SOURCE}
${NANA_PAINT_SOURCE}
${NANA_PAINT_DETAIL_SOURCE}
${NANA_SYSTEM_SOURCE}
${NANA_THREADS_SOURCE})
#Headers: use INCLUDE_DIRECTORIES
# Libraries: use FIND_LIBRARY and link with the result of it (try to avoid LINK_DIRECTORIES
target_link_libraries(${PROJECT_NAME} ${NANA_LINKS})
install(TARGETS ${PROJECT_NAME}
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
# ??
install(DIRECTORY ${NANA_INCLUDE_DIR}/nana DESTINATION include)
# Installing: the static "nana lib" will be in DESTDIR/CMAKE_INSTALL_PREFIX/lib/
# and the includes files "include/nana/" in DESTDIR/CMAKE_INSTALL_PREFIX/include/nana/
install(TARGETS ${PROJECT_NAME} ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
message("The compiled Nana library will be installed in ${CMAKE_INSTALL_PREFIX}/lib")
# Install the include directories too.
if(NANA_CMAKE_INSTALL_INCLUDES)
install(DIRECTORY ${NANA_INCLUDE_DIR}/nana DESTINATION include )
message("The Nana include files will be installed in ${CMAKE_INSTALL_PREFIX}/include")
endif(NANA_CMAKE_INSTALL_INCLUDES)
set_property( TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 14 )
# TODO: move this nana-demo section to the nana demo repository, and here only include that cmake file
if (BUILD_NANA_DEMOS)
set (CMAKE_INSTALL_PREFIX ${DEMO_BIN})
set(DEMO_BIN ${NANA_SOURCE_DIR}../nana-demo/bin)
set(CMAKE_INSTALL_PREFIX )
add_executable(calculator ../nana-demo/calculator.cpp)
set_property( TARGET calculator PROPERTY CXX_STANDARD 14 )
target_link_libraries(calculator ${PROJECT_NAME} )
install(TARGETS calculator RUNTIME DESTINATION &{DEMO_BIN})
if (BUILD_FreeMe)
add_executable(FreeMe ../nana-demo/FreeMe.cpp)
set_property( TARGET FreeMe PROPERTY CXX_STANDARD 14 )
target_link_libraries(FreeMe ${PROJECT_NAME} )
install(TARGETS FreeMe RUNTIME DESTINATION &{DEMO_BIN})
endif (BUILD_FreeMe)
add_executable(notepad ../nana-demo/notepad.cpp)
set_property( TARGET notepad PROPERTY CXX_STANDARD 14 )
target_link_libraries(notepad ${PROJECT_NAME} )
install(TARGETS notepad RUNTIME DESTINATION &{DEMO_BIN})
add_executable(widget_show ../nana-demo/widget_show.cpp)
set_property( TARGET widget_show PROPERTY CXX_STANDARD 14 )
target_link_libraries(widget_show ${PROJECT_NAME})
install(TARGETS widget_show RUNTIME DESTINATION &{DEMO_BIN})
add_executable(widget_show2 ../nana-demo/widget_show2.cpp)
set_property( TARGET widget_show2 PROPERTY CXX_STANDARD 14 )
target_link_libraries(widget_show2 ${PROJECT_NAME})
install(TARGETS widget_show2 RUNTIME DESTINATION &{DEMO_BIN})
if (OFF) # temporal: we need to adapt the use of filesystem to nana v1.03 (no file iterator)
add_executable(file_explorer ../nana-demo/file_explorer.cpp)
set_property( TARGET file_explorer PROPERTY CXX_STANDARD 14 )
target_link_libraries(file_explorer ${PROJECT_NAME} )
install(TARGETS file_explorer RUNTIME DESTINATION &{DEMO_BIN})
endif(OFF)
add_executable(a_group_impl ../nana-demo/Examples/a_group_impl.cpp)
set_property( TARGET a_group_impl PROPERTY CXX_STANDARD 14 )
target_link_libraries(a_group_impl ${PROJECT_NAME})
add_executable(animate-bmp ../nana-demo/Examples/animate-bmp.cpp)
set_property( TARGET animate-bmp PROPERTY CXX_STANDARD 14 )
target_link_libraries(animate-bmp ${PROJECT_NAME})
add_executable(background-effects ../nana-demo/Examples/background-effects.cpp)
set_property( TARGET background-effects PROPERTY CXX_STANDARD 14 )
target_link_libraries(background-effects ${PROJECT_NAME})
add_executable(categ ../nana-demo/Examples/categ.cpp)
set_property( TARGET categ PROPERTY CXX_STANDARD 14 )
target_link_libraries(categ ${PROJECT_NAME})
add_executable(clicked ../nana-demo/Examples/clicked.cpp)
set_property( TARGET clicked PROPERTY CXX_STANDARD 14 )
target_link_libraries(clicked ${PROJECT_NAME})
add_executable(decore ../nana-demo/Examples/decore.cpp)
set_property( TARGET decore PROPERTY CXX_STANDARD 14 )
target_link_libraries(decore ${PROJECT_NAME})
add_executable(dock ../nana-demo/Examples/dock.cpp)
set_property( TARGET dock PROPERTY CXX_STANDARD 14 )
target_link_libraries(dock ${PROJECT_NAME})
add_executable(drag-button ../nana-demo/Examples/drag-button.cpp)
set_property( TARGET drag-button PROPERTY CXX_STANDARD 14 )
target_link_libraries(drag-button ${PROJECT_NAME})
add_executable(draw ../nana-demo/Examples/draw.cpp)
set_property( TARGET draw PROPERTY CXX_STANDARD 14 )
target_link_libraries(draw ${PROJECT_NAME})
add_executable(example_combox ../nana-demo/Examples/example_combox.cpp)
set_property( TARGET example_combox PROPERTY CXX_STANDARD 14 )
target_link_libraries(example_combox ${PROJECT_NAME})
add_executable(example_listbox ../nana-demo/Examples/example_listbox.cpp)
set_property( TARGET example_listbox PROPERTY CXX_STANDARD 14 )
target_link_libraries(example_listbox ${PROJECT_NAME})
add_executable(example_menu ../nana-demo/Examples/example_menu.cpp)
set_property( TARGET example_menu PROPERTY CXX_STANDARD 14 )
target_link_libraries(example_menu ${PROJECT_NAME})
add_executable(filebox-txt ../nana-demo/Examples/filebox-txt.cpp)
set_property( TARGET filebox-txt PROPERTY CXX_STANDARD 14 )
target_link_libraries(filebox-txt ${PROJECT_NAME})
add_executable(folder_tree ../nana-demo/Examples/folder_tree.cpp)
set_property( TARGET folder_tree PROPERTY CXX_STANDARD 14 )
target_link_libraries(folder_tree ${PROJECT_NAME})
add_executable(folder_tree_nana ../nana-demo/Examples/folder_tree_nana.cpp)
set_property( TARGET folder_tree_nana PROPERTY CXX_STANDARD 14 )
target_link_libraries(folder_tree_nana ${PROJECT_NAME})
add_executable(folder_tree_std ../nana-demo/Examples/folder_tree_std.cpp)
set_property( TARGET folder_tree_std PROPERTY CXX_STANDARD 14 )
target_link_libraries(folder_tree_std ${PROJECT_NAME})
add_executable(listbox_Resolver ../nana-demo/Examples/listbox_Resolver.cpp)
set_property( TARGET listbox_Resolver PROPERTY CXX_STANDARD 14 )
target_link_libraries(listbox_Resolver ${PROJECT_NAME})
add_executable(framework_design_2 ../nana-demo/Examples/framework_design_2.cpp)
set_property( TARGET framework_design_2 PROPERTY CXX_STANDARD 14 )
target_link_libraries(framework_design_2 ${PROJECT_NAME})
add_executable(framework_design_3 ../nana-demo/Examples/framework_design_3.cpp)
set_property( TARGET framework_design_3 PROPERTY CXX_STANDARD 14 )
target_link_libraries(framework_design_3 ${PROJECT_NAME})
add_executable(group ../nana-demo/Examples/group.cpp)
set_property( TARGET group PROPERTY CXX_STANDARD 14 )
target_link_libraries(group ${PROJECT_NAME})
add_executable(HelloWord ../nana-demo/Examples/HelloWord.cpp)
set_property( TARGET HelloWord PROPERTY CXX_STANDARD 14 )
target_link_libraries(HelloWord ${PROJECT_NAME})
add_executable(listbox_inline_widget ../nana-demo/Examples/listbox_inline_widget.cpp)
set_property( TARGET listbox_inline_widget PROPERTY CXX_STANDARD 14 )
target_link_libraries(listbox_inline_widget ${PROJECT_NAME})
add_executable(inputbox ../nana-demo/Examples/inputbox.cpp)
set_property( TARGET inputbox PROPERTY CXX_STANDARD 14 )
target_link_libraries(inputbox ${PROJECT_NAME})
add_executable(label_listener ../nana-demo/Examples/label_listener.cpp)
set_property( TARGET label_listener PROPERTY CXX_STANDARD 14 )
target_link_libraries(label_listener ${PROJECT_NAME})
add_executable(lambda_event.Cpp11 ../nana-demo/Examples/lambda_event.Cpp11.cpp)
set_property( TARGET lambda_event.Cpp11 PROPERTY CXX_STANDARD 14 )
target_link_libraries(lambda_event.Cpp11 ${PROJECT_NAME})
if (ENABLE_AUDIO)
add_executable(audio_player ../nana-demo/Examples/audio_player.cpp)
set_property( TARGET audio_player PROPERTY CXX_STANDARD 14 )
target_link_libraries(audio_player ${PROJECT_NAME} )
endif(ENABLE_AUDIO)
# TODO: make it automatic to select each demo and example and build each.
#set(NANA_DEMOS_DIR ${CMAKE_SOURCE_DIR}/../nana-demo)
#set(NANA_EXAMPLES_DIR ${CMAKE_SOURCE_DIR}/../Examples/nana-demo/)
# https://cmake.org/cmake/help/v3.3/command/file.html?highlight=glob#file
#file( GLOB_RECURSE DEMO_SOURCES RELATIVE ../nana-demo *.cpp )
#foreach( demofile ${DEMO_SOURCES} )
# string( REPLACE ".cpp" "" demoname ${demofile} )
# add_executable( ${demoname} ${demofile} )
# set_property( TARGET ${demoname} PROPERTY CXX_STANDARD 14 )
# target_link_libraries(${demoname} ${PROJECT_NAME} )# X11 Xft ${NANA_JPEG_LIB} ${NANA_PNG_LIB})
#endforeach( demofile ${DEMO_SOURCES} )
endif(BUILD_NANA_DEMOS)
# set compile flags
if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11 -Wall")
else("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall")
endif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
endif(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
# enable static linkage
if (CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND NOT MINGW)
#set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++ -pthread")
endif ()
if (APPLE AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libstdc++")
endif ()
# Just for information:
message ( "CMAKE_CXX_COMPILER_ID = " ${CMAKE_CXX_COMPILER_ID})
message ( "COMPILER_IS_CLANG = " ${COMPILER_IS_CLANG})
message ( "CMAKE_CXX_FLAGS = " ${CMAKE_CXX_FLAGS})
message ( "CMAKE_COMPILER_IS_GNUCXX= " ${CMAKE_COMPILER_IS_GNUCXX})
message ( "CMAKE_CXX_FLAGS = " ${CMAKE_CXX_FLAGS})
message ( "CMAKE_EXE_LINKER_FLAGS = " ${CMAKE_EXE_LINKER_FLAGS})
message ( "CMAKE_STATIC_LINKER_FLAGS=" ${CMAKE_STATIC_LINKER_FLAGS})
message ( "NANA_LINKS = " ${NANA_LINKS})
message ( "ENABLE_AUDIO = " ${ENABLE_AUDIO})
message ( "DESTDIR = " ${DESTDIR})
message ( "CMAKE_INSTALL_PREFIX = " ${CMAKE_INSTALL_PREFIX})
message ( "NANA_INCLUDE_DIR = " ${NANA_INCLUDE_DIR})
message ( "CMAKE_CURRENT_SOURCE_DIR= " ${CMAKE_CURRENT_SOURCE_DIR})
message ( "NANA_CMAKE_ENABLE_AUDIO = " ${NANA_CMAKE_ENABLE_AUDIO})
message ( "NANA_CMAKE_FIND_BOOST_FILESYSTEM = " ${NANA_CMAKE_FIND_BOOST_FILESYSTEM})
message ( "NANA_CMAKE_BOOST_FILESYSTEM_FORCE = " ${NANA_CMAKE_BOOST_FILESYSTEM_FORCE})
message ( "NANA_CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT = " ${NANA_CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT})
message ( "NANA_CMAKE_BOOST_FILESYSTEM_LIB = " ${NANA_CMAKE_BOOST_FILESYSTEM_LIB})
message ( "NANA_CMAKE_AUTOMATIC_GUI_TESTING = " ${NANA_CMAKE_AUTOMATIC_GUI_TESTING})
message ( "NANA_CMAKE_ADD_DEF_AUTOMATIC_GUI_TESTING = " ${NANA_CMAKE_ADD_DEF_AUTOMATIC_GUI_TESTING})

8
README.md
View File

@ -1,12 +1,12 @@
# Nana C++ Library
[Linux (gcc 5, including demos) ![TravisCI build status](https://travis-ci.org/cnjinhao/nana.svg)](https://travis-ci.org/cnjinhao/nana)
[Linux (gcc 5.4.0 and 4.9.2)![TravisCI build status](https://travis-ci.org/cnjinhao/nana.svg)](https://travis-ci.org/cnjinhao/nana) including [(nana-demos)](https://github.com/qPCR4vir/nana-demo)
[Windows (VC2015) ![AppVeyor uild status](https://ci.appveyor.com/api/projects/status/5j79p9fi887usv7h?svg=true)](https://ci.appveyor.com/project/qPCR4vir/nana)
[Windows (Microsoft (R) Build Engine version 14.0.24720.0) ![AppVeyor build status](https://ci.appveyor.com/api/projects/status/5j79p9fi887usv7h?svg=true)](https://ci.appveyor.com/project/qPCR4vir/nana)
[![Licence](https://img.shields.io/badge/license-BSL-blue.svg?style=flat)](LICENSE_1_0.txt)
Nana is a C++ library designed to allow developers to easily create cross-platform GUI applications with modern C++11 style, currently it can work on Linux(X11) and Windows. The nana repository contains the entire source of library, you can browse the source code and submit your pull request for contributing.
Nana is a C++ library designed to allow developers to easily create cross-platform GUI applications with modern C++11 style. Currently it can work on Linux(X11) and Windows. The [nana repository](https://github.com/cnjinhao/nana) contains the entire source of the library. You can browse the source code and submit your pull request for contributing.
## License
@ -24,7 +24,7 @@ The best way to get help with Nana library is by visiting http://nanapro.org/hel
## Sending a Pull Request ?
This project is encourage you to contribute it through sending a pull request! There is a simple rule, please **don't** directly commit your contributions to the **master** branch. According to your commits, please choose the **hotfixes** branch or the **develop** branch. Thank you!
This project encourage you to contribute through sending a pull request! There is a simple rule: please **don't** directly commit your contributions to the **master** branch. According to your commits, please choose the **hotfixes** branch or the **develop** branch. Thank you!
## Introduction to the Repository

54
build/makefile/makefile
View File

@ -1,43 +1,53 @@
#Nana C++ Library
#
#Makefile created by Jinhao(cnjinhao@hotmail.com)
#Makefile created by sarrow104(sarrow104@gmail.com)
GCC = g++
INCROOT = ../../include
SRCROOT = ../../source
EXTRLIB = ../../extrlib
NANA_INC= $(INCROOT)/nana
OUTROOT = out
#CXXFLAGS= -g -std=c++11 -Wall
CXXFLAGS= -g -fexceptions -std=c++11 -Wall -Wextra -Wunused-variable -Wfatal-errors
INCS = -I$(INCROOT) -I/usr/include/freetype2 -I$(EXTRLIB)
BIN = libnana.a
SRC_NANA = $(wildcard $(SRCROOT)/*.cpp)
SRC_DETAIL = $(wildcard $(SRCROOT)/detail/*.cpp)
SRC_FILESYSTEM = $(wildcard $(SRCROOT)/filesystem/*.cpp)
SRC_AUDIO = $(wildcard $(SRCROOT)/audio/*.cpp)
SRC_AUDIO_DETAIL = $(wildcard $(SRCROOT)/audio/detail/*.cpp)
SRC_GUI = $(wildcard $(SRCROOT)/gui/*.cpp)
SRC_GUI_DETAIL = $(wildcard $(SRCROOT)/gui/detail/*.cpp)
SRC_GUI_WIDGETS = $(wildcard $(SRCROOT)/gui/widgets/*.cpp)
SRC_GUI_WIDGETS_SKELETONS = $(wildcard $(SRCROOT)/gui/widgets/skeletons/*.cpp)
SRC_PAINT = $(wildcard $(SRCROOT)/paint/*.cpp)
SRC_PAINT_DETAIL = $(wildcard $(SRCROOT)/paint/detail/*.cpp)
SRC_SYSTEM = $(wildcard $(SRCROOT)/system/*.cpp)
SRC_THREADS= $(wildcard $(SRCROOT)/threads/*.cpp)
TARGET = ../bin/$(BIN)
SOURCES = $(SRC_NANA) $(SRC_DETAIL) $(SRC_FILESYSTEM) $(SRC_AUDIO) $(SRC_AUDIO_DETAIL) $(SRC_GUI) $(SRC_GUI_DETAIL) $(SRC_GUI_WIDGETS) $(SRC_GUI_WIDGETS_SKELETONS) $(SRC_PAINT) $(SRC_PAINT_DETAIL) $(SRC_SYSTEM) $(SRC_THREADS)
.PHONY: all clean install print
LINKOBJ = $(SOURCES:.cpp=.o)
all: $(TARGET)
$(BIN): $(LINKOBJ)
ar r ../bin/$(BIN) $(LINKOBJ)
ranlib ../bin/$(BIN)
define walk
$(wildcard $(1)) $(foreach e, $(wildcard $(1)/*), $(call walk, $(e)))
endef
.cpp.o:
$(GCC) -g -c $< -o $@ $(INCS) -std=c++11 -Wall
SRCFILES := $(filter %.cpp,$(patsubst ./%,%,$(filter-out .,$(call walk, $(SRCROOT)))))
LINKOBJ = $(patsubst $(SRCROOT)/%.cpp,$(OUTROOT)/objs/%.o,$(SRCFILES))
print:
@echo $(LINKOBJ)
$(TARGET): $(LINKOBJ)
mkdir -p $(dir $@)
ar rus $@ $?
ranlib $@
$(OUTROOT)/objs/%.o: $(SRCROOT)/%.cpp
@mkdir -p $(dir $@)
$(GCC) -o $@ -c $< $(INCS) $(CXXFLAGS)
clean:
rm -f $(LINKOBJ)
rm -f ../bin/$(BIN)
rm -f $(TARGET)
install:
@mkdir -p $(INSTALL_PREFIX)/include
@mkdir -p $(INSTALL_PREFIX)/bin
@mkdir -p $(INSTALL_PREFIX)/lib
cp -rfl $(INCROOT)/* $(INSTALL_PREFIX)/include
cp -rfl $(TARGET) $(INSTALL_PREFIX)/lib/

6
build/makefile/readme.md
View File

@ -1,8 +1,8 @@
Building Nana C++ Library
requires:
# Building Nana C++ Library directly with make
If you are using make directly, it require:
X11, pthread, Xpm, rt, dl, freetype2, Xft, fontconfig, ALSA
Writing a makefile for creating applications with Nana C++ Library
Example of writing a makefile for creating applications with Nana C++ Library
-------------------
```
GCC = g++

3
build/vc2015/nana.vcxproj.filters
View File

@ -49,6 +49,9 @@
<Filter Include="Source Files\paint\detail">
<UniqueIdentifier>{53feb93f-2b86-4bf5-b2f3-f60ef1bbbf76}</UniqueIdentifier>
</Filter>
<Filter Include="Header Files\filesystem">
<UniqueIdentifier>{6caffbf6-c023-4dbf-ba69-cdb49feddb5d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\source\any.cpp">

9
extrlib/readme.txt
View File

@ -1,5 +1,12 @@
You can download the precompiled external libraries at http://sourceforge.net/projects/nanapro/files/extrlib/
Extract the ZIP file to the directory nana/extrlib. Then modify the marco switch defined in nana/include/config.hpp header file and rebuild the nana library.
A method to configure the 3rd party libraries
https://github.com/cnjinhao/nana/wiki/Configuration-of-Third-Party-Libraries-for-Nana
您可以下载预先编译的外部程序库，下载地址http://sourceforge.net/projects/nanapro/files/extrlib/
将ZIP文件释放到nana/extrlib目录。然后修改nana/include/config.hpp文件中对应的标志，重新编译Nana库即可。
将ZIP文件释放到nana/extrlib目录。然后修改nana/include/config.hpp文件中对应的标志，重新编译Nana库即可。
配置第三方库的方法
https://github.com/cnjinhao/nana/wiki/Configuration-of-Third-Party-Libraries-for-Nana

2
include/nana/any.hpp
View File

@ -150,7 +150,7 @@ namespace nana
if (!operand)
return nullptr;
auto holder = dynamic_cast<any::holder<Value>*>(operand->content_);
auto holder = dynamic_cast<any::holder<typename std::decay<Value>::type>*>(operand->content_);
return (holder ? &holder->value : nullptr);
}

7
include/nana/audio/player.hpp
View File

@ -1,6 +1,6 @@
#ifndef NANA_AUDIO_PLAYER_HPP
#define NANA_AUDIO_PLAYER_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/deploy.hpp>
#ifdef NANA_ENABLE_AUDIO
@ -31,4 +31,7 @@ namespace nana{ namespace audio
}//end namespace nana
#endif //NANA_ENABLE_AUDIO
#endif
#include <nana/pop_ignore_diagnostic>
#endif

133
include/nana/basic_types.hpp
View File

@ -15,6 +15,7 @@
#include <nana/deploy.hpp>
#include <cctype>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -83,7 +84,7 @@ namespace nana
enum class mouse_action
{
begin, normal = begin, over, pressed, end
begin, normal = begin, hovered, pressed, end
};
enum class element_state
@ -336,67 +337,100 @@ namespace nana
bool operator==(const color& other) const;
bool operator!=(const color& other) const;
friend color operator+(const color&, const color&);
private:
double r_;
double g_;
double b_;
double r_{ 0.0 };
double g_{ 0.0 };
double b_{ 0.0 };
double a_{ 0.0 }; //invisible
};
struct rectangle;
struct point
template<typename T>
struct basic_point
{
point();
point(int x, int y);
point(const rectangle&);
//typedef-names
using value_type = T;
point& operator=(const rectangle&);
bool operator==(const point&) const;
bool operator!=(const point&) const;
bool operator<(const point&) const;
bool operator<=(const point&) const;
bool operator>(const point&) const;
bool operator>=(const point&) const;
//data member
value_type x{};
value_type y{};
point operator-(const point&) const;
point operator+(const point&) const;
point& operator-=(const point&);
point& operator+=(const point&);
//member functions
basic_point() = default;
int x;
int y;
basic_point(value_type x, value_type y)
: x{ x }, y{y}
{}
bool operator==(const basic_point& other) const noexcept
{
return (x == other.x && y == other.y);
}
bool operator!=(const basic_point& other) const noexcept
{
return (x != other.x || y != other.y);
}
bool operator<(const basic_point& other) const noexcept
{
return ((y < other.y) || (y == other.y && x < other.x));
}
bool operator<=(const basic_point& other) const noexcept
{
return ((y < other.y) || (y == other.y && x <= other.x));
}
bool operator>(const basic_point& other) const noexcept
{
return ((y > other.y) || (y == other.y && x > other.x));
}
bool operator>=(const basic_point& other) const noexcept
{
return ((y > other.y) || (y == other.y && x >= other.x));
}
basic_point operator-(const basic_point& other) const noexcept
{
return{ x - other.x, y - other.y };
}
basic_point operator+(const basic_point& other) const noexcept
{
return{ x + other.x, y + other.y };
}
basic_point& operator-=(const basic_point& other) noexcept
{
x -= other.x;
y -= other.y;
return *this;
}
basic_point& operator+=(const basic_point& other) noexcept
{
x += other.x;
y += other.y;
return *this;
}
};
struct upoint
{
typedef unsigned value_type;
upoint();
upoint(value_type x, value_type y);
bool operator==(const upoint&) const;
bool operator!=(const upoint&) const;
bool operator<(const upoint&) const;
bool operator<=(const upoint&) const;
bool operator>(const upoint&) const;
bool operator>=(const upoint&) const;
value_type x;
value_type y;
};
using point = basic_point<int>;
using upoint = basic_point<unsigned>;
struct size
{
using value_type = unsigned;
size();
size(value_type width, value_type height);
size(const rectangle&);
size& operator=(const rectangle&);
bool empty() const; ///< true if width * height == 0
bool is_hit(const point&) const; ///< Assume it is a rectangle at (0,0), and check whether a specified position is in the rectange.
size& shift();
bool operator==(const size& rhs) const;
bool operator!=(const size& rhs) const;
size operator+(const size&) const;
@ -415,11 +449,11 @@ namespace nana
bool operator==(const rectangle& rhs) const;
bool operator!=(const rectangle& rhs) const;
rectangle& operator=(const point&);
rectangle& operator=(const size&);
point position() const noexcept;
rectangle& position(const point&) noexcept;
rectangle& set_pos(const point&);
rectangle& set_size(const size&);
size dimension() const noexcept;
rectangle& dimension(const size&) noexcept;
rectangle& pare_off(int pixels); ///<Pares the specified pixels off the rectangle. It's equal to x += pixels; y + pixels; width -= (pixels << 1); height -= (pixels << 1);
@ -427,7 +461,8 @@ namespace nana
int bottom() const;
bool is_hit(int x, int y) const;
bool is_hit(const point& pos) const;
bool empty() const; ///< true if width * height == 0
bool empty() const; ///< true if width * height == 0.
rectangle& shift(); ///< Swap position x and y, size width and height.
int x;
int y;
@ -484,7 +519,7 @@ namespace nana
southeast
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -31,10 +31,14 @@
* - _SCL_SECURE_NO_WARNNGS, _CRT_SECURE_NO_DEPRECATE (VC)
* - STD_CODECVT_NOT_SUPPORTED (VC RC, <codecvt> is a known issue on libstdc++, it works on libc++)
* - STD_THREAD_NOT_SUPPORTED (GCC < 4.8.1)
* - STD_put_time_NOT_SUPPORTED (GCC < 5)
* - STD_NUMERIC_CONVERSIONS_NOT_SUPPORTED (MinGW with GCC < 4.8.1)
* - STD_NUMERIC_CONVERSIONS_NOT_SUPPORTED (MinGW with GCC < 4.8.1)
* - STD_TO_STRING_NOT_SUPPORTED (MinGW with GCC < 4.8)
*/
* - STD_FILESYSTEM_NOT_SUPPORTED (GCC < 5.3) ....
* - CXX_NO_INLINE_NAMESPACE (Visual C++ < 2015)
* - STD_MAKE_UNIQUE_NOT_SUPPORTED (GCC < 4.9)
*/
#ifndef NANA_CXX_DEFINES_INCLUDED
#define NANA_CXX_DEFINES_INCLUDED
@ -42,14 +46,20 @@
//C++ language
#if defined(_MSC_VER)
# undef STD_FILESYSTEM_NOT_SUPPORTED
# if (_MSC_VER < 1900)
# //About std.experimental.filesystem.
# //Through VC2013 has provided <filesystem>, but all the names are given in namespace std. It's hard to alias these names into std::experimental,
# //So Nana use nana.filesystem implement instead for VC2013
#
# //Nana defines some macros for lack of support of keywords
# define _ALLOW_KEYWORD_MACROS
#
# define CXX_NO_INLINE_NAMESPACE //no support of C++11 inline namespace until Visual C++ 2015
# define noexcept //no support of noexcept until Visual C++ 2015
# define constexpr //no support of constexpr until Visual C++ 2015
# define constexpr const //no support of constexpr until Visual C++ 2015 ? const ??
# else
# undef STD_FILESYSTEM_NOT_SUPPORTED
# endif
#elif defined(__GNUC__)
# if (__GNUC__ == 4 && __GNUC_MINOR__ < 6)
@ -76,7 +86,7 @@
#define NANA_LINUX
#define NANA_X11
#else
# static_assert(false, "Only Windows and Unix are supported now (Mac OS is experimental)");
static_assert(false, "Only Windows and Unix are supported now (Mac OS is experimental)");
#endif
//Define a symbol for POSIX operating system.
@ -108,9 +118,10 @@
//<codecvt> is a known issue on libstdc++, it works on libc++
#define STD_CODECVT_NOT_SUPPORTED
#ifndef STD_MAKE_UNIQUE_NOT_SUPPORTED
#define STD_MAKE_UNIQUE_NOT_SUPPORTED
#if !defined(__cpp_lib_make_unique) || (__cpp_lib_make_unique != 201304)
#ifndef STD_MAKE_UNIQUE_NOT_SUPPORTED
#define STD_MAKE_UNIQUE_NOT_SUPPORTED
#endif
#endif
#endif
@ -133,9 +144,15 @@
#endif
#endif
#if ((__GNUC__ > 5) || ((__GNUC__ == 5) && (__GNUC_MINOR__ >= 3 ) ) )
#undef STD_FILESYSTEM_NOT_SUPPORTED
#endif
#if ((__GNUC__ < 5) )
# define STD_put_time_NOT_SUPPORTED
#endif
#if ((__GNUC__ > 5) || ((__GNUC__ == 5) && (__GNUC_MINOR__ >= 3 ) ) )
# undef STD_FILESYSTEM_NOT_SUPPORTED
/// \todo define the namespace ????
#endif
#if (__GNUC__ == 4)
#if ((__GNUC_MINOR__ < 8) || (__GNUC_MINOR__ == 8 && __GNUC_PATCHLEVEL__ < 1))
@ -147,8 +164,10 @@
#endif
#if defined(NANA_MINGW)
//It's a knonwn issue under MinGW
#define STD_NUMERIC_CONVERSIONS_NOT_SUPPORTED
#ifndef __MINGW64_VERSION_MAJOR
//It's a knonwn issue under MinGW(except MinGW-W64)
#define STD_NUMERIC_CONVERSIONS_NOT_SUPPORTED
#endif
#endif
#if (__GNUC_MINOR__ < 8)
@ -177,9 +196,9 @@
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0061r0.html
# if __cpp_lib_experimental_filesystem
# undef STD_FILESYSTEM_NOT_SUPPORTED
# endif
#if defined(__cpp_lib_experimental_filesystem) && (__cpp_lib_experimental_filesystem == 201406)
# undef STD_FILESYSTEM_NOT_SUPPORTED
#endif
#ifdef __has_include

50
include/nana/charset.hpp
View File

@ -46,7 +46,31 @@ namespace nana
class charset_encoding_interface;
}
/// An intelligent charset class for character code conversion.
/*!\class charset
\brief An intelligent charset class for character code conversion.
Example:
1. A UTF-8 string from the socket.
int len = ::recv(sd, buf, buflen, 0);
textbox.caption(nana::charset(std::string(buf, len), nana::unicode::utf8));
2. Send the string in text to the socket as UTF-8.
std::string utf8str = nana::charset(textbox.caption()).to_bytes(nana::unicode::utf8);
::send(sd, utf8str.c_str(), utf8str.size(), 0);
3, Convert a string to the specified multi-byte character code.
// Convert to a multibytes string through default system language.
std::string mbstr = nana::charset(a_wstring);
// If the default system language is English and convert
// a Chinese unicode string to multibytes string through GB2312
std::setlocale(LC_CTYPE, "zh_CN.GB2312");
//set::setlocale(LC_CTYPE, ".936"); call it in Windows
std::string mbstr = nana::charset(a_wstring_with_chinese);
*/
class charset
{
public:
@ -74,27 +98,3 @@ namespace nana
}//end namespace nana
#endif
/*!\class charset
Example
1. A UTF-8 string from the socket.
int len = ::recv(sd, buf, buflen, 0);
textbox.caption(nana::charset(std::string(buf, len), nana::unicode::utf8));
2. Send the string in text to the socket as UTF-8.
std::string utf8str = nana::charset(textbox.caption()).to_bytes(nana::unicode::utf8);
::send(sd, utf8str.c_str(), utf8str.size(), 0);
3, Convert a string to the specified multi-byte character code.
//Convert to a multibytes string through default system language.
std::string mbstr = nana::charset(a_wstring);
//If the default system language is English and convert
//a Chinese unicode string to multibytes string through GB2312
std::setlocale(LC_CTYPE, "zh_CN.GB2312");
//set::setlocale(LC_CTYPE, ".936"); call it in Windows
std::string mbstr = nana::charset(a_wstring_with_chinese);
*/

56
include/nana/config.hpp
View File

@ -25,7 +25,11 @@
#include "c++defines.hpp"
//The basic configurations are ignored when NANA_IGNORE_CONF is defined.
//This marco is defined since 1.4 and until 1.5 for deprecating frame widget.
//This marco and class frame will be removed in version 1.5
#define WIDGET_FRAME_DEPRECATED
//The following basic configurations are ignored when NANA_IGNORE_CONF is defined.
//The NANA_IGNORE_CONF may be specified by CMake generated makefile.
#ifndef NANA_IGNORE_CONF
@ -39,20 +43,30 @@
// https://github.com/meganz/mingw-std-threads
//#define NANA_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ
////////////////////////////
// The ISO C++ File System Technical Specification is optional.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf
// This is not a workaround, but an user option.
// The library maybe available in the std library in use or from Boost (almost compatible)
// http://www.boost.org/doc/libs/1_60_0/libs/filesystem/doc/index.htm
// or you can choose to use the (partial, but functional) implementation provided by nana.
// If you include the file <nana/filesystem/filesystem_selector.hpp>
// The selected option will be set by nana into std::experimental::filesystem
// By default Nana will use the ISO TS if available, or nana if not.
// Boost will be use only if you change one of the following (set the includes and link correspondly):
//#define NANA_BOOST_FILESYSTEM_AVAILABLE // "Is Boost filesystem available?"
//#define NANA_BOOST_FILESYSTEM_PREFERRED // "Is Boost filesystem preferred over nana?"
//#define NANA_BOOST_FILESYSTEM_FORCE // "Force use of Boost filesystem if available (over ISO)?
//# The ISO C++ File System Technical Specification(ISO - TS, or STD) is optional.
//# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf
//# This is not a workaround, but an user option.
//# The library maybe available in the std library in use or from Boost(almost compatible)
//# http://www.boost.org/doc/libs/1_60_0/libs/filesystem/doc/index.htm
//# or you can choose to use the(partial, but functional) implementation provided by nana.
//# If you include the file <nana/filesystem/filesystem.hpp>
//# the selected option will be set by nana into std::experimental::filesystem
//# By default Nana will try to use the STD.If not available will try
//# to use boost if available.Nana own implementation will be use only none of them are available.
//# You can change that default if you change one of the following
//# (please don't define more than one of the _XX_FORCE options):
//
//#define BOOST_FILESYSTEM_AVAILABLE // "Is Boost filesystem available?"
//#define BOOST_FILESYSTEM_FORCE // "Force use of Boost filesystem if available (over ISO and nana)
//#define STD_FILESYSTEM_FORCE // "Use of STD filesystem?(a compilation error will ocurre if not available)" OFF)
//#define NANA_FILESYSTEM_FORCE // "Force nana filesystem over ISO and boost?" OFF)
//
// Make sure you (cmake?) provide the following where correspond (please find the correct values):
// set CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT "Where to find <boost/filesystem.hpp>?" "../")
// set CMAKE_BOOST_FILESYSTEM_LIB "Flag for the compiler to link: " "-lboost/fs")
// include_directories CMAKE_BOOST_FILESYSTEM_INCLUDE_ROOT
// APPEND flag LINKS CMAKE_BOOST_FILESYSTEM_LIB
///////////////////
// Support of PCM playback
@ -83,12 +97,22 @@
#endif
#endif
///////////////////
// Support for NANA_AUTOMATIC_GUI_TESTING
// Will cause the program to self-test the GUI. A default automatic GUI test
// will be added to all programs which don't have yet one defined. This default test will simple
// wait 10 sec. (time to construct, show and execute the GUI) and then exit normally.
//
//#define NANA_AUTOMATIC_GUI_TESTING
#if !defined(VERBOSE_PREPROCESSOR)
//#define VERBOSE_PREPROCESSOR
#endif
#if !defined(STOP_VERBOSE_PREPROCESSOR)
#define STOP_VERBOSE_PREPROCESSOR
//#define STOP_VERBOSE_PREPROCESSOR
#endif
#endif // NANA_IGNORE_CONFIG

56
include/nana/deploy.hpp
View File

@ -14,11 +14,10 @@
#ifndef NANA_DEPLOY_HPP
#define NANA_DEPLOY_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/config.hpp>
#if defined(VERBOSE_PREPROCESSOR)
#include <nana/verbose_preprocessor.hpp>
#endif
#include <stdexcept>
#include <nana/charset.hpp>
@ -92,14 +91,57 @@ namespace std
}
#endif
#ifdef STD_put_time_NOT_SUPPORTED
#include <ctime>
namespace std
{
//Workaround for no implemenation of std::put_time in gcc < 5.
/* std unspecified return type */
//template< class CharT, class RTSTR >// let fail for CharT != char / wchar_t
//RTSTR put_time(const std::tm* tmb, const CharT* fmt);
//template< >
std::string put_time/*<char, std::string>*/(const std::tm* tmb, const char* fmt);
//Defined in header <ctime>
// std::size_t strftime(char* str, std::size_t count, const char* format, const std::tm* time);
//template<>
//std::wstring put_time<wchar_t, std::wstring>(const std::tm* tmb, const wchar_t* fmt);
}
#endif // STD_put_time_NOT_SUPPORTED
namespace nana
{
/// move to *.h ??
struct utf8_Error : std::runtime_error
{
static bool use_throw; ///< def { true }; use carefully - it is a global variable !! \todo initialize from a #define ?
using std::runtime_error::runtime_error;
#if defined(_MSC_VER)
# if (_MSC_VER < 1900)
//A workaround for lack support of C++11 inheriting constructors for VC2013
explicit utf8_Error(const std::string& msg);
# endif
#endif
void emit();
};
/// Checks whether a specified text is utf8 encoding
bool is_utf8(const char* str, unsigned len);
bool is_utf8(const char* str, std::size_t len);
void throw_not_utf8(const std::string& text);
void throw_not_utf8(const char*, unsigned len);
void throw_not_utf8(const char*, std::size_t len);
void throw_not_utf8(const char*);
/// this text needed change, it needed review ??
bool review_utf8(const std::string& text);
/// this text needed change, it needed review ??
bool review_utf8(std::string& text);
const std::string& to_utf8(const std::string&);
std::string to_utf8(const std::wstring&);
@ -190,5 +232,5 @@ namespace std {
make_unique(Args&&...) = delete;
}
#endif //STD_make_unique_NOT_SUPPORTED
#endif //NANA_MACROS_HPP
#include <nana/pop_ignore_diagnostic>
#endif //NANA_DEPLOY_HPP

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

@ -18,6 +18,8 @@
#ifndef NANA_DETAIL_PLATFORM_SPEC_HPP
#define NANA_DETAIL_PLATFORM_SPEC_HPP
#include <nana/push_ignore_diagnostic>
#include <thread>
#include <mutex>
#include <memory>
@ -60,6 +62,8 @@ namespace detail
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();
@ -118,6 +122,9 @@ namespace detail
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 };
@ -188,8 +195,8 @@ namespace detail
native_window_type owner;
std::vector<native_window_type> * owned;
};
public:
int error_code;
public:
int error_code;
public:
typedef drawable_impl_type::font_ptr_t font_ptr_t;
typedef void (*timer_proc_type)(unsigned tid);
@ -197,6 +204,8 @@ namespace detail
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();
@ -327,6 +336,7 @@ namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
// .h ward
#endif

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

@ -1,15 +1,15 @@
/*
/**
* Selector of Platform Specification
* 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/detail/platform_spec_selector.hpp
* @file nana/detail/platform_spec_selector.hpp
*
* Selects the proper platform_spec header file for the current platform
* @brief Selects the proper platform_spec header file for the current platform
*/
#include <nana/config.hpp>

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

@ -1,7 +1,7 @@
/*
* Platform Specification 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
@ -25,6 +25,7 @@
#include <windows.h>
#include <map>
#include <memory>
#include <functional>
namespace nana
{
@ -63,17 +64,27 @@ namespace detail
bool forced;
};
struct arg_affinity_execute
{
const std::function<void()> * function_ptr;
};
enum
{
tray = 0x501,
async_activate,
async_set_focus,
map_thread_root_buffer,
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,
};
};
@ -142,6 +153,9 @@ namespace detail
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();

219
include/nana/filesystem/filesystem.hpp
View File

@ -1,4 +1,4 @@
/*
/**
* A ISO C++ filesystem Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
@ -7,17 +7,17 @@
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/filesystem/filesystem.hpp
* Modiffied by Ariel Vina-Rodriguez:
* Now mimic std::experimental::filesystem::v1 (boost v3)
* and need VC2015 or a C++11 compiler. With a few correction will be compiler by VC2013
* @file nana/filesystem/filesystem.hpp
* @author Ariel Vina-Rodriguez, Jinhao
* @brief Mimic std::experimental::filesystem::v1 (boost v3)
* and need VC2015 or a C++11 compiler. With a few correction can be compiler by VC2013
*/
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf --- last pdf of std draft N4100 <filesystem> 2014-07-04
// http://en.cppreference.com/w/cpp/experimental/fs
// http://cpprocks.com/introduction-to-tr2-filesystem-library-in-vs2012/ --- TR2 filesystem in VS2012
// https://msdn.microsoft.com/en-us/library/hh874694%28v=vs.140%29.aspx --- C++ 14, the <filesystem> header VS2015
// https://msdn.microsoft.com/en-us/library/hh874694%28v=vs.120%29.aspx --- <filesystem> header VS2013
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf --- last pdf of std draft N4100 2014-07-04
// http://cplusplus.github.io/filesystem-ts/working-draft.html --- in html format
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4099.html --- in html format
// http://article.gmane.org/gmane.comp.lib.boost.devel/256220 --- The filesystem TS unanimously approved by ISO.
@ -29,6 +29,54 @@
#ifndef NANA_FILESYSTEM_HPP
#define NANA_FILESYSTEM_HPP
#include <nana/push_ignore_diagnostic>
//Filesystem Selection
#include <nana/config.hpp>
#if defined(NANA_USING_NANA_FILESYSTEM) || defined(NANA_USING_STD_FILESYSTEM) || defined(NANA_USING_BOOST_FILESYSTEM)
#undef NANA_USING_NANA_FILESYSTEM
#undef NANA_USING_STD_FILESYSTEM
#undef NANA_USING_BOOST_FILESYSTEM
#endif
#define NANA_USING_NANA_FILESYSTEM 0
#define NANA_USING_STD_FILESYSTEM 0
#define NANA_USING_BOOST_FILESYSTEM 0
#if (defined(NANA_FILESYSTEM_FORCE) || ( (defined(STD_FILESYSTEM_NOT_SUPPORTED) && !defined(BOOST_FILESYSTEM_AVAILABLE)) && !(defined(BOOST_FILESYSTEM_FORCE) || defined(STD_FILESYSTEM_FORCE)) ) )
#undef NANA_USING_NANA_FILESYSTEM
#define NANA_USING_NANA_FILESYSTEM 1
#elif (defined(BOOST_FILESYSTEM_AVAILABLE) && ( defined(BOOST_FILESYSTEM_FORCE) || ( defined(STD_FILESYSTEM_NOT_SUPPORTED) && !defined(STD_FILESYSTEM_FORCE) ) ))
#undef NANA_USING_BOOST_FILESYSTEM
#define NANA_USING_BOOST_FILESYSTEM 1
# include <boost/filesystem.hpp>
// add boost::filesystem into std::experimental::filesystem
namespace std {
namespace experimental {
namespace filesystem {
using namespace boost::filesystem;
} // filesystem
} // experimental
} // std
#else
#undef NANA_USING_STD_FILESYSTEM
#define NANA_USING_STD_FILESYSTEM 1
# include <experimental/filesystem>
#endif
#ifndef __cpp_lib_experimental_filesystem
# define __cpp_lib_experimental_filesystem 1
#endif
#if NANA_USING_NANA_FILESYSTEM
#include <string>
#include <system_error>
#include <iterator>
@ -40,18 +88,14 @@
#include <nana/deploy.hpp>
// namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
namespace nana { namespace experimental {
#ifndef CXX_NO_INLINE_NAMESPACE
inline namespace v1
namespace nana { namespace experimental { namespace filesystem
{
#ifndef CXX_NO_INLINE_NAMESPACE
inline namespace v1
{
#endif
namespace filesystem
{
enum class file_type
enum class file_type
{
none = 0, ///< has not been determined or an error occurred while trying to determine
not_found = -1, ///< Pseudo-type: file was not found. Is not considered an error
@ -82,7 +126,7 @@ namespace filesystem
uintmax_t available;
};
using file_time_type = std::chrono::time_point<std::chrono::system_clock>;// trivial-clock> ;
using file_time_type = std::chrono::time_point<std::chrono::system_clock>; ///< trivial-clock> ;
class file_status
{
@ -116,7 +160,7 @@ namespace filesystem
public:
#if defined(NANA_WINDOWS)
using value_type = wchar_t;
const static value_type preferred_separator = '\\';
const static value_type preferred_separator = L'\\';
#else
using value_type = char;
const static value_type preferred_separator = '/';
@ -131,23 +175,41 @@ namespace filesystem
_m_assign(source);
}
// modifiers
//void clear() noexcept;
path& make_preferred();
path& remove_filename();
//path& replace_filename(const path& replacement);
//path& replace_extension(const path& replacement = path());
//void swap(path& rhs) noexcept;
// decomposition
//path root_name() const;
//path root_directory() const;
//path root_path() const;
//path relative_path() const;
path parent_path() const;
path filename() const;
//path stem() const;
path extension() const;
// query
bool empty() const noexcept;
//bool has_root_name() const;
//bool has_root_directory() const;
//bool has_root_path() const;
//bool has_relative_path() const;
bool has_parent_path() const { return !parent_path().string().empty(); }; // temp;;
bool has_filename() const { return !filename().string().empty(); }; // temp;
//bool has_stem() const;
bool has_extension() const { return !extension().string().empty(); }; // temp
//bool is_absolute() const;
//bool is_relative() const;
int compare(const path& other) const;
bool empty() const;
path extension() const;
path parent_path() const;
file_type what() const;
//decomposition
path filename() const;
//modifiers
path& remove_filename();
const value_type*c_str() const;
const string_type& native() const;
operator string_type() const;
@ -203,8 +265,9 @@ namespace filesystem
filesystem_error(const std::string& msg, const path& path1, std::error_code err);
filesystem_error(const std::string& msg, const path& path1, const path& path2, std::error_code err);
const path& path1() const; //noexcept
const path& path2() const; //noexcept
const path& path1() const noexcept;
const path& path2() const noexcept;
// const char* what() const noexcept;
private:
path path1_;
path path2_;
@ -215,47 +278,37 @@ namespace filesystem
{
public:
directory_entry() = default;
explicit directory_entry(const path&);
explicit directory_entry(const ::nana::experimental::filesystem::path&);
//modifiers
void assign(const path&);
void replace_filename(const path&);
void assign(const ::nana::experimental::filesystem::path&);
void replace_filename(const ::nana::experimental::filesystem::path&);
//observers
file_status status() const;
operator const filesystem::path&() const;
operator const filesystem::path&() const { return path_; };
const filesystem::path& path() const;
private:
filesystem::path path_;
::nana::experimental::filesystem::path path_;
};
/// an iterator for a sequence of directory_entry elements representing the files in a directory, not an recursive_directory_iterator
//template<typename FileInfo>
/// InputIterator that iterate over the sequence of directory_entry elements representing the files in a directory, not an recursive_directory_iterator
class directory_iterator :public std::iterator<std::input_iterator_tag, directory_entry>
{
using find_handle = void*;
public:
using value_type = directory_entry ;
typedef ptrdiff_t difference_type;
typedef const directory_entry* pointer;
typedef const directory_entry& reference;
typedef std::input_iterator_tag iterator_category;
directory_iterator();
directory_iterator(const path& file_path);
directory_iterator() noexcept;
explicit directory_iterator(const path& dir);
const value_type& operator*() const;
const value_type* operator->() const;
directory_iterator& operator++();
directory_iterator operator++(int);
directory_iterator operator++(int); ///< extention
bool equal(const directory_iterator& x) const;
bool equal(const directory_iterator& x) const;
// enable directory_iterator range-based for statements
directory_iterator begin();
directory_iterator end();
private:
template<typename Char>
static bool _m_ignore(const Char * p)
@ -275,6 +328,16 @@ namespace filesystem
find_handle handle_{nullptr};
value_type value_;
};
/// enable directory_iterator range-based for statements
inline directory_iterator begin( directory_iterator iter) noexcept
{
return iter;
}
inline directory_iterator end( const directory_iterator&) noexcept
{
return {};
}
//class recursive_directory_iterator;
@ -301,15 +364,23 @@ namespace filesystem
std::uintmax_t file_size(const path& p);
//uintmax_t file_size(const path& p, error_code& ec) noexcept;
inline bool is_directory(file_status s) { return s.type() == file_type::directory ;}
inline bool is_directory(file_status s) noexcept
{ return s.type() == file_type::directory ;}
bool is_directory(const path& p);
inline bool is_directory(const directory_entry& d)
{
return is_directory(d.status());
}
//bool is_directory(const path& p, error_code& ec) noexcept;
//bool is_regular_file(file_status s) noexcept;
inline bool is_regular_file(file_status s) noexcept
{
return s.type() == file_type::regular;
}
inline bool is_regular_file(const path& p)
{
return is_regular_file(status(p));
}
// bool is_regular_file(const path& p, error_code& ec) noexcept;
// Returns: is_regular_file(status(p, ec)).Returns false if an error occurs.
inline bool is_empty(const path& p)
{
@ -320,7 +391,7 @@ namespace filesystem
return (file_size(p) == 0);
}
//bool is_empty(const path& p, error_code& ec) noexcept;
// bool is_empty(const path& p, error_code& ec) noexcept;
bool create_directories(const path& p);
@ -330,16 +401,19 @@ namespace filesystem
bool create_directory(const path& p, const path& attributes);
//bool create_directory(const path& p, const path& attributes, error_code& ec) noexcept;
bool modified_file_time(const path& p, struct tm&);
path path_user();
/// The time of last data modification of p, determined as if by the value of the POSIX
/// stat structure member st_mtime obtained as if by POSIX stat().
file_time_type last_write_time(const path& p);
/// returns file_time_type::min() if an error occurs
//file_time_type last_write_time(const path& p, error_code& ec) noexcept;
path current_path();
//path current_path(error_code& ec);
void current_path(const path& p);
void current_path(const path& p); ///< chdir
//void current_path(const path& p, error_code& ec) noexcept;
bool remove(const path& p);
bool remove(const path& p, std::error_code& ec); // noexcept;
@ -381,4 +455,21 @@ namespace filesystem
//namespace filesystem = experimental::filesystem;
} //end namespace nana
#endif
namespace std {
namespace experimental {
namespace filesystem {
# ifdef CXX_NO_INLINE_NAMESPACE
using namespace nana::experimental::filesystem;
# else
using namespace nana::experimental::filesystem::v1;
# endif
} // filesystem
} // experimental
} // std
#endif //NANA_USING_NANA_FILESYSTEM
#include <nana/pop_ignore_diagnostic>
#endif //NANA_FILESYSTEM_HPP

129
include/nana/filesystem/filesystem_ext.hpp Normal file
View File

@ -0,0 +1,129 @@
/**
* 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\filesystem\filesystem_ext.hpp
* @autor by Ariel Vina-Rodriguez:
* @brief Some convenient extensions to the filesystem library.
*
*/
#ifndef NANA_FILESYSTEM_EXT_HPP
#define NANA_FILESYSTEM_EXT_HPP
#include <nana/filesystem/filesystem.hpp>
namespace nana
{
namespace filesystem_ext
{
#if defined(NANA_WINDOWS)
constexpr auto def_root = "C:";
constexpr auto def_rootstr = "C:\\";
constexpr auto def_rootname = "Local Drive(C:)";
#elif defined(NANA_LINUX)
constexpr auto def_root = "/";
constexpr auto def_rootstr = "/";
constexpr auto def_rootname = "Root/";
#endif
std::experimental::filesystem::path path_user(); ///< extention ?
inline bool is_directory(const std::experimental::filesystem::directory_entry& dir) noexcept
{
return is_directory(dir.status());
}
//template<class DI> // DI = directory_iterator from std, boost, or nana : return directory_entry
class directory_only_iterator : public std::experimental::filesystem::directory_iterator
{
using directory_iterator = std::experimental::filesystem::directory_iterator;
directory_only_iterator& find_first()
{
auto end = directory_only_iterator{};
while (*this != end)
{
if (is_directory((**this).status()))
return *this;
this->directory_iterator::operator++();
}
return *this;
}
public:
directory_only_iterator() = default;
template <typename Arg, typename... Args>
directory_only_iterator(Arg&& arg, Args&&... args) : directory_iterator(arg, std::forward<Args>(args)...)
{
find_first();
}
directory_only_iterator& operator++()
{
this->directory_iterator::operator++();
return find_first();
}
};
inline directory_only_iterator begin(directory_only_iterator iter) noexcept
{
return iter;
}
inline directory_only_iterator end(const directory_only_iterator&) noexcept
{
return{};
}
//template<class DI> // DI = directory_iterator from std, boost, or nana : value_type directory_entry
class regular_file_only_iterator : public std::experimental::filesystem::directory_iterator
{
using directory_iterator = std::experimental::filesystem::directory_iterator;
regular_file_only_iterator& find_first()
{
while (((*this) != directory_iterator{}) && !is_regular_file((**this).status()))
this->directory_iterator::operator++();
return (*this);
}
public:
regular_file_only_iterator() = default;
template <typename Arg, typename... Args>
regular_file_only_iterator(Arg&& arg, Args&&... args) : directory_iterator(std::forward<Arg>(arg), std::forward<Args>(args)...)
{
find_first();
}
regular_file_only_iterator& operator++()
{
this->directory_iterator::operator++();
return find_first();
}
};
inline regular_file_only_iterator begin(regular_file_only_iterator iter) noexcept
{
return iter;
}
inline regular_file_only_iterator end(const regular_file_only_iterator&) noexcept
{
return{};
}
std::string pretty_file_size(const std::experimental::filesystem::path& path);
std::string pretty_file_date(const std::experimental::filesystem::path& path);
bool modified_file_time(const std::experimental::filesystem::path& p, struct tm&); ///< extention ?
} // filesystem_ext
} // nana
#endif //NANA_FILESYSTEM_EXT_HPP

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

@ -12,7 +12,7 @@
#ifndef NANA_GUI_ANIMATION_HPP
#define NANA_GUI_ANIMATION_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/paint/image.hpp>
#include <functional>
@ -82,4 +82,5 @@ namespace nana
impl * impl_;
};
} //end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_ANIMATION_HPP

99
include/nana/gui/basis.hpp
View File

@ -1,20 +1,22 @@
/*
/**
* \file basis.hpp
* \brief This file provides basis class and data structures required by the GUI
*
* Basis 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/basis.hpp
*
* This file provides basis class and data structrue that required by gui
*/
#ifndef NANA_GUI_BASIS_HPP
#define NANA_GUI_BASIS_HPP
#include <nana/push_ignore_diagnostic>
#include "../basic_types.hpp"
#include "../traits.hpp" //metacomp::fixed_type_set
@ -54,14 +56,18 @@ namespace nana
super,
widget = 0x1,
lite_widget = 0x3,
root = 0x5,
frame = 0x9
root = 0x5
#ifndef WIDGET_FRAME_DEPRECATED
,frame = 0x9
#endif
};
//wait for constexpr
struct widget_tag{ static const flags value = flags::widget; };
struct lite_widget_tag : widget_tag{ static const flags value = flags::lite_widget;};
struct root_tag : widget_tag{ static const flags value = flags::root; };
struct frame_tag: widget_tag{ static const flags value = flags::frame; };
struct lite_widget_tag : public widget_tag{ static const flags value = flags::lite_widget; };
struct root_tag : public widget_tag{ static const flags value = flags::root; };
#ifndef WIDGET_FRAME_DEPRECATED
struct frame_tag : public widget_tag{ static const flags value = flags::frame; };
#endif
}// end namespace category
using native_window_type = detail::native_window_handle_impl*;
@ -95,6 +101,7 @@ namespace nana
undo = substitute,
//System Code for OS
os_tab = 0x09,
os_shift = 0x10,
os_ctrl = 0x11,
os_pageup = 0x21, os_pagedown,
@ -151,7 +158,25 @@ namespace nana
appearance();
appearance(bool has_decoration, bool taskbar, bool floating, bool no_activate, bool min, bool max, bool sizable);
};
/// Provided to generate an appearance object with better readability and understandability
/** @brief Provided to generate an appearance object with better readability and understandability
A window has an appearance. This appearance can be specified when a window is being created.
To determine the appearance of a window there is a structure named nana::appearance with
a bool member for each feature with can be included or excluded in the "apereance" of the windows form.
But in practical development is hard to describe the style of the appearance using the struct nana::appearance.
If a form would to be defined without min/max button and sizable border, then
\code{.CPP}
nana::form form(x, y, width, height, nana::appearance(false, false, false, true, false));
\endcode
This piece of code may be confusing because of the 5 parameters of the constructor of `nana::form`. So the library provides a helper class for making it easy.
For better readability and understandability Nana provides three templates classes to generate an appearance object:
nana::appear::decorate, nana::appear::bald and nana::appear::optional. Each provide an operator
that return a corresponding nana::appearance with predefined values.
*/
struct appear
{
struct minimize{};
@ -160,7 +185,20 @@ namespace nana
struct taskbar{};
struct floating{};
struct no_activate{};
/// Create an appearance of a window with "decoration"
/** @brief Create an appearance of a window with "decoration" in non-client area, such as title bar
*
* We can create a form without min/max button and sizable border like this:
* \code{.CPP}
* using nana::appear;
* nana::form form(x, y, width, height, appear::decorate<appear::taskbar>());
* \endcode
* The appearance created by appear::decorate<>() has a titlebar and borders that are draw by the
* platform- window manager. If a window needs a minimize button, it should be:
* \code{.CPP}
* appear::decorate<appear::minimize, appear::taskbar>()
* \endcode
*/
template< typename Minimize = null_type,
typename Maximize = null_type,
typename Sizable = null_type,
@ -181,7 +219,8 @@ namespace nana
);
}
};
/// Create an appearance of a window without "decoration"
/// Create an appearance of a window without "decoration" with no titlebar and no 3D-look borders.
template < typename Taskbar = null_type,
typename Floating = null_type,
typename NoActive = null_type,
@ -225,5 +264,39 @@ namespace nana
}
};
};//end namespace apper
/// Interface for caret operations
class caret_interface
{
public:
virtual ~caret_interface() = default;
virtual void disable_throw() noexcept = 0;
virtual void effective_range(const rectangle& range) = 0;
virtual void position(const point& pos) = 0;
virtual point position() const = 0;
virtual void dimension(const size& size) = 0;
virtual size dimension() const = 0;
virtual void visible(bool visibility) = 0;
virtual bool visible() const = 0;
};//end class caret_interface
namespace parameters
{
/// The system-wide parameters for mouse wheel
struct mouse_wheel
{
unsigned lines; ///< The number of lines to scroll when the vertical mouse wheel is moved.
unsigned characters; ///< The number of characters to scroll when the horizontal mouse wheel is moved.
mouse_wheel();
};
}
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

145
include/nana/gui/detail/basic_window.hpp
View File

@ -1,4 +1,4 @@
/*
/**
* A Basic Window Widget Definition
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
@ -7,14 +7,16 @@
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/detail/basic_window.hpp
* @file nana/gui/detail/basic_window.hpp
* @brief A Basic Window Widget Definition
*/
#ifndef NANA_GUI_DETAIL_BASIC_WINDOW_HPP
#define NANA_GUI_DETAIL_BASIC_WINDOW_HPP
#include <nana/push_ignore_diagnostic>
#include "drawer.hpp"
#include "events_holder.hpp"
#include "widget_colors.hpp"
#include "widget_geometrics.hpp"
#include "widget_notifier_interface.hpp"
#include <nana/basic_types.hpp>
#include <nana/system/platform.hpp>
@ -30,47 +32,52 @@ namespace detail
invisible, visible, displayed
};
class caret_descriptor
class caret
: public caret_interface
{
public:
typedef basic_window core_window_t;
caret(basic_window* owner, const size& size);
~caret();
caret_descriptor(core_window_t*, unsigned width, unsigned height);
~caret_descriptor();
void set_active(bool);
core_window_t* window() const;
void position(int x, int y);
void effective_range(::nana::rectangle);
::nana::point position() const;
void visible(bool isshow);
bool visible() const;
::nana::size size() const;
void size(const ::nana::size&);
void activate(bool activity);
basic_window* owner() const noexcept;
void update();
private:
core_window_t* wd_;
::nana::point point_;
::nana::size size_;
::nana::size paint_size_;
visible_state visible_state_;
bool out_of_range_;
::nana::rectangle effective_range_;
};//end class caret_descriptor
public:
//Implement caret_interface functions
//tab_type
//@brief: Define some constant about tab category, these flags can be combine with operator |
//This function is useless for class caret, see caret_proxy.
void disable_throw() noexcept override;
void effective_range(const rectangle& r) override;
void position(const point& pos) override;
nana::point position() const override;
size dimension() const override;
void dimension(const size& s);
void visible(bool visibility) override;
bool visible() const override;
private:
basic_window * owner_;
point position_;
size size_;
size visual_size_;
visible_state visibility_{ visible_state::invisible };
bool out_of_range_{ false };
rectangle effect_range_;
};//end class caret
/// Define some constant about tab category, these flags can be combine with operator |
struct tab_type
{
enum t
{
none, //process by nana
tabstop, //move to the next tabstop window
eating, //process by current window
none, ///< process by nana
tabstop, ///< move to the next tabstop window
eating, ///< process by current window
};
};
//struct basic_window
//@brief: a window data structure descriptor
/// a window data structure descriptor
struct basic_window
: public events_holder
{
@ -87,8 +94,7 @@ namespace detail
bool rendered;
};
//basic_window
//@brief: constructor for the root window
/// constructor for the root window
basic_window(basic_window* owner, std::unique_ptr<widget_notifier_interface>&&, category::root_tag**);
template<typename Category>
@ -105,23 +111,26 @@ namespace detail
~basic_window();
//bind_native_window
//@brief: bind a native window and baisc_window
/// bind a native window and baisc_window
void bind_native_window(native_window_type, unsigned width, unsigned height, unsigned extra_width, unsigned extra_height, paint::graphics&);
#ifndef WIDGET_FRAME_DEPRECATED
void frame_window(native_window_type);
#endif
bool is_ancestor_of(const basic_window* wd) const;
bool visible_parents() const;
bool displayed() const;
bool belong_to_lazy() const;
const basic_window * child_caret() const; //Returns a child which owns a caret
const basic_window * child_caret() const; ///< Returns the child which owns the caret
bool is_draw_through() const; ///< Determines whether it is a draw-through window.
basic_window * seek_non_lite_widget_ancestor() const;
void set_action(mouse_action);
public:
//Override event_holder
/// Override event_holder
bool set_events(const std::shared_ptr<general_events>&) override;
general_events * get_events() const override;
private:
@ -131,7 +140,7 @@ namespace detail
#if defined(NANA_LINUX) || defined(NANA_MACOS)
point pos_native;
#endif
point pos_root; //coordinate for root window
point pos_root; ///< coordinates of the root window
point pos_owner;
size dimension;
::nana::size min_track_size;
@ -146,9 +155,9 @@ namespace detail
basic_window *owner;
native_string_type title;
::nana::detail::drawer drawer; //Self Drawer with owen graphics
basic_window* root_widget; //A pointer refers to the root basic window, if the window is a root, the pointer refers to itself.
paint::graphics* root_graph; //Refer to the root buffer graphics
::nana::detail::drawer drawer; ///< Self Drawer with owen graphics
basic_window* root_widget; ///< A pointer refers to the root basic window, if the window is a root, the pointer refers to itself.
paint::graphics* root_graph; ///< Refer to the root buffer graphics
cursor predef_cursor;
std::unique_ptr<widget_notifier_interface> widget_notifier;
@ -156,30 +165,33 @@ namespace detail
{
bool enabled :1;
bool dbl_click :1;
bool captured :1; //if mouse button is down, it always receive mouse move even the mouse is out of its rectangle
bool captured :1; ///< if mouse button is down, it always receive mouse move even the mouse is out of its rectangle
bool modal :1;
bool take_active:1; //If take_active is false, other.active_window still keeps the focus.
bool take_active:1; ///< If take_active is false, other.active_window still keeps the focus.
bool refreshing :1;
bool destroying :1;
bool dropable :1; //Whether the window has make mouse_drop event.
bool fullscreen :1; //When the window is maximizing whether it fit for fullscreen.
bool dropable :1; ///< Whether the window has make mouse_drop event.
bool fullscreen :1; ///< When the window is maximizing whether it fit for fullscreen.
bool borderless :1;
bool make_bground_declared : 1; //explicitly make bground for bground effects
bool ignore_menubar_focus : 1; //A flag indicates whether the menubar sets the focus.
bool ignore_mouse_focus : 1; //A flag indicates whether the widget accepts focus when clicking on it
bool space_click_enabled : 1; //A flag indicates whether enable mouse_down/click/mouse_up when pressing and releasing whitespace key.
bool make_bground_declared : 1; ///< explicitly make bground for bground effects
bool ignore_menubar_focus : 1; ///< A flag indicates whether the menubar sets the focus.
bool ignore_mouse_focus : 1; ///< A flag indicates whether the widget accepts focus when clicking on it
bool space_click_enabled : 1; ///< A flag indicates whether enable mouse_down/click/mouse_up when pressing and releasing whitespace key.
unsigned Reserved :18;
unsigned char tab; //indicate a window that can receive the keyboard TAB
unsigned char tab; ///< indicate a window that can receive the keyboard TAB
mouse_action action;
mouse_action action_before;
}flags;
struct
struct annex_components
{
caret_descriptor* caret;
caret* caret_ptr{ nullptr };
//The following pointers refer to the widget's object.
std::shared_ptr<general_events> events_ptr;
}together;
widget_colors* scheme{ nullptr };
widget_geometrics* scheme{ nullptr };
}annex;
struct
{
@ -190,15 +202,19 @@ namespace detail
struct other_tag
{
#ifndef WIDGET_FRAME_DEPRECATED
struct attr_frame_tag
{
native_window_type container{nullptr};
std::vector<native_window_type> attach;
};
#endif
struct attr_root_tag
{
container frames; //initialization is null, it will be created while creating a frame widget. Refer to WindowManager::create_frame
#ifndef WIDGET_FRAME_DEPRECATED
container frames; ///< initialization is null, it will be created while creating a frame widget. Refer to WindowManager::create_frame
#endif
container tabstop;
std::vector<edge_nimbus_action> effects_edge_nimbus;
basic_window* focus{nullptr};
@ -210,32 +226,35 @@ namespace detail
cursor state_cursor{nana::cursor::arrow};
basic_window* state_cursor_window{ nullptr };
std::function<void()> draw_through; // A draw through renderer for root widgets.
std::function<void()> draw_through; ///< A draw through renderer for root widgets.
};
const category::flags category;
basic_window *active_window; //if flags.take_active is false, the active_window still keeps the focus,
//if the active_window is null, the parent of this window keeps focus.
paint::graphics glass_buffer; //if effect.bground is avaiable. Refer to window_layout::make_bground.
basic_window *active_window; ///< if flags.take_active is false, the active_window still keeps the focus,
///< if the active_window is null, the parent of this window keeps focus.
paint::graphics glass_buffer; ///< if effect.bground is avaiable. Refer to window_layout::make_bground.
update_state upd_state;
union
{
attr_root_tag * root;
#ifndef WIDGET_FRAME_DEPRECATED
attr_frame_tag * frame;
#endif
}attribute;
other_tag(category::flags);
~other_tag();
}other;
native_window_type root; //root Window handle
unsigned thread_id; //the identifier of the thread that created the window.
native_window_type root; ///< root Window handle
unsigned thread_id; ///< the identifier of the thread that created the window.
unsigned index;
container children;
};
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

31
include/nana/gui/detail/bedrock.hpp
View File

@ -1,20 +1,21 @@
/*
/**
* A Bedrock 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/detail/bedrock.hpp
* @file nana/gui/detail/bedrock.hpp
*
* @brief A Bedrock Implementation
*/
#ifndef NANA_GUI_DETAIL_BEDROCK_HPP
#define NANA_GUI_DETAIL_BEDROCK_HPP
#include "general_events.hpp"
#include "color_schemes.hpp"
#include "internal_scope_guard.hpp"
namespace nana
{
@ -26,12 +27,14 @@ namespace detail
struct basic_window;
class window_manager;
//class bedrock
//@brief: bedrock is a fundamental core component, it provides a abstract to the OS platform
// and some basic functions.
/// @brief fundamental core component, it provides an abstraction to the OS platform and some basic functions.
class bedrock
{
bedrock();
bedrock(const bedrock&) = delete;
bedrock& operator=(const bedrock&) = delete;
public:
using core_window_t = basic_window;
@ -41,14 +44,13 @@ namespace detail
~bedrock();
void pump_event(window, bool is_modal);
void map_thread_root_buffer(core_window_t*, bool forced, const rectangle* update_area = nullptr);
void flush_surface(core_window_t*, bool forced, const rectangle* update_area = nullptr);
static int inc_window(unsigned tid = 0);
thread_context* open_thread_context(unsigned tid = 0);
thread_context* get_thread_context(unsigned tid = 0);
void remove_thread_context(unsigned tid = 0);
static bedrock& instance();
::nana::category::flags category(core_window_t*);
core_window_t* focus();
void set_menubar_taken(core_window_t*);
@ -62,8 +64,9 @@ namespace detail
void erase_menu(bool try_destroy);
void get_key_state(arg_keyboard&);
bool set_keyboard_shortkey(bool yes);
bool whether_keyboard_shortkey() const;
bool shortkey_occurred(bool status);
bool shortkey_occurred() const;
element_store& get_element_store() const;
void map_through_widgets(core_window_t*, native_drawable_type);
@ -71,6 +74,7 @@ namespace detail
void event_expose(core_window_t *, bool exposed);
void event_move(core_window_t*, int x, int y);
bool event_msleave(core_window_t*);
void event_focus_changed(core_window_t* root_wd, native_window_type receiver, bool getting);
void thread_context_destroy(core_window_t*);
void thread_context_lazy_refresh();
void update_cursor(core_window_t*);
@ -78,16 +82,13 @@ namespace detail
void define_state_cursor(core_window_t*, nana::cursor, thread_context*);
void undefine_state_cursor(core_window_t*, thread_context*);
widget_colors& get_scheme_template(scheme_factory_base&&);
widget_colors* make_scheme(scheme_factory_base&&);
color_schemes& scheme();
events_operation& evt_operation();
window_manager& wd_manager();
void manage_form_loader(core_window_t*, bool insert_or_remove);
public:
bool emit(event_code, core_window_t*, const event_arg&, bool ask_update, thread_context*);
bool emit_drawer(event_code, core_window_t*, const event_arg&, thread_context*);
private:
void _m_emit_core(event_code, core_window_t*, bool draw_only, const event_arg&);
void _m_event_filter(event_code, core_window_t*, thread_context*);

15
include/nana/gui/detail/bedrock_pi_data.hpp
View File

@ -1,6 +1,8 @@
#ifndef NANA_DETAIL_BEDROCK_PI_DATA_HPP
#define NANA_DETAIL_BEDROCK_PI_DATA_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/detail/bedrock.hpp>
#include "color_schemes.hpp"
#include "events_operation.hpp"
@ -17,7 +19,20 @@ namespace nana
events_operation evt_operation;
window_manager wd_manager;
std::set<core_window_t*> auto_form_set;
bool shortkey_occurred{ false };
struct menu_rep
{
core_window_t* taken_window{ nullptr };
bool delay_restore{ false };
native_window_type window{ nullptr };
native_window_type owner{ nullptr };
bool has_keyboard{ false };
}menu;
};
}
}
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -1,7 +1,7 @@
/*
* Color Schemes
* 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
@ -13,26 +13,27 @@
#ifndef NANA_DETAIL_COLOR_SCHEMES_HPP
#define NANA_DETAIL_COLOR_SCHEMES_HPP
#include "widget_colors.hpp"
#include "widget_geometrics.hpp"
namespace nana
{
namespace detail
{
class scheme_factory_base
class scheme_factory_interface
{
public:
struct factory_identifier{};
virtual ~scheme_factory_base() = default;
virtual ~scheme_factory_interface() = default;
virtual factory_identifier* get_id() const = 0;
virtual widget_colors* create() = 0;
virtual widget_colors* create(widget_colors&) = 0;
virtual widget_geometrics* create() = 0;
virtual widget_geometrics* create(widget_geometrics&) = 0;
};
template<typename Scheme>
class scheme_factory
: public scheme_factory_base
: public scheme_factory_interface
{
private:
factory_identifier* get_id() const override
@ -40,12 +41,12 @@ namespace nana
return &fid_;
}
widget_colors* create() override
widget_geometrics* create() override
{
return (new Scheme);
}
widget_colors* create(widget_colors& other) override
widget_geometrics* create(widget_geometrics& other) override
{
return (new Scheme(static_cast<Scheme&>(other)));
}
@ -54,7 +55,7 @@ namespace nana
};
template<typename Scheme>
scheme_factory_base::factory_identifier scheme_factory<Scheme>::fid_;
scheme_factory_interface::factory_identifier scheme_factory<Scheme>::fid_;
class color_schemes
{
@ -64,13 +65,13 @@ namespace nana
color_schemes& operator=(const color_schemes&) = delete;
color_schemes& operator=(color_schemes&&) = delete;
public:
using scheme = widget_colors;
using scheme = widget_geometrics;
color_schemes();
~color_schemes();
scheme& scheme_template(scheme_factory_base&&);
scheme* create(scheme_factory_base&&);
scheme& scheme_template(scheme_factory_interface&&);
scheme* create(scheme_factory_interface&&);
private:
implement * impl_;
};

66
include/nana/gui/detail/drawer.hpp
View File

@ -13,7 +13,7 @@
#ifndef NANA_GUI_DETAIL_DRAWER_HPP
#define NANA_GUI_DETAIL_DRAWER_HPP
#include <vector>
#include <nana/push_ignore_diagnostic>
#include "general_events.hpp"
#include <nana/paint/graphics.hpp>
#include <functional>
@ -28,14 +28,23 @@ namespace nana
}
class drawer_trigger
: ::nana::noncopyable, ::nana::nonmovable
{
friend class detail::drawer;
//Noncopyable
drawer_trigger(const drawer_trigger&) = delete;
drawer_trigger& operator=(const drawer_trigger&) = delete;
//Nonmovable
drawer_trigger(drawer_trigger&&) = delete;
drawer_trigger& operator=(drawer_trigger&&) = delete;
public:
using widget_reference = widget&;
using graph_reference = paint::graphics&;
virtual ~drawer_trigger();
drawer_trigger() = default;
virtual ~drawer_trigger() = default;
virtual void attached(widget_reference, graph_reference); //none-const
virtual void detached(); //none-const
@ -72,21 +81,11 @@ namespace nana
{
struct basic_window;
namespace dynamic_drawing
{
//declaration
class object;
}
//@brief: Every window has a drawer, the drawer holds a drawer_trigger for
// a widget.
class drawer
: nana::noncopyable, nana::nonmovable
{
enum{
event_size = static_cast<int>(event_code::end)
};
enum class method_state
{
pending,
@ -94,6 +93,7 @@ namespace nana
not_overrided
};
public:
drawer();
~drawer();
void bind(basic_window*);
@ -126,48 +126,48 @@ namespace nana
void* draw(std::function<void(paint::graphics&)> &&, bool diehard);
void erase(void* diehard);
private:
void _m_bground_pre();
void _m_bground_end();
void _m_draw_dynamic_drawing_object();
void _m_effect_bground(bool before);
bool _m_lazy_decleared() const;
method_state& _m_mth_state(int pos);
template<typename Arg, typename Mfptr>
void _m_emit(event_code evt_code, const Arg& arg, Mfptr mfptr)
{
const int pos = static_cast<int>(evt_code);
if (realizer_ && (method_state::not_overrided != mth_state_[pos]))
{
_m_bground_pre();
if (method_state::pending == mth_state_[pos])
auto realizer = this->realizer();
auto & mth_state = _m_mth_state(pos);
if (realizer && (method_state::not_overrided != mth_state))
{
_m_effect_bground(true);
if (method_state::pending == mth_state)
{
(realizer_->*mfptr)(graphics, arg);
(realizer->*mfptr)(graphics, arg);
//Check realizer, when the window is closed in that event handler, the drawer will be
//detached and realizer will be a nullptr
if(realizer_)
mth_state_[pos] = (realizer_->_m_overrided(evt_code) ? method_state::overrided : method_state::not_overrided);
if (realizer)
mth_state = (realizer->_m_overrided(evt_code) ? method_state::overrided : method_state::not_overrided);
}
else
(realizer_->*mfptr)(graphics, arg);
(realizer->*mfptr)(graphics, arg);
if (_m_lazy_decleared())
{
_m_draw_dynamic_drawing_object();
_m_bground_end();
}
_m_effect_bground(false);
}
}
public:
nana::paint::graphics graphics;
private:
basic_window* core_window_{nullptr};
drawer_trigger* realizer_{nullptr};
std::vector<dynamic_drawing::object*> dynamic_drawing_objects_;
bool refreshing_{false};
method_state mth_state_[event_size];
struct data_implement;
data_implement * const data_impl_;
};
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -24,7 +24,7 @@ namespace nana{
return object;
}
unsigned weight() const
constexpr unsigned weight() const
{
return 2;
}
@ -122,22 +122,37 @@ namespace nana{
}
}
rectangle wd_r{ wd->pos_root, wd->dimension };
wd_r.pare_off(-static_cast<int>(this->weight()));
//Render
for (auto & rd : rd_set)
_m_render_edge_nimbus(rd.second, rd.first);
{
auto other_wd = rd.second;
if (other_wd != wd)
{
rectangle other_r{ other_wd->pos_root, other_wd->dimension };
other_r.pare_off(-static_cast<int>(this->weight()));
if (!overlapped(wd_r, other_r))
continue;
}
_m_render_edge_nimbus(other_wd, rd.first);
}
}
private:
static bool _m_edge_nimbus(core_window_t * focused_wd, core_window_t * wd)
{
if((focused_wd == wd) && (static_cast<unsigned>(wd->effect.edge_nimbus) & static_cast<unsigned>(effects::edge_nimbus::active)))
return true;
else if((static_cast<unsigned>(wd->effect.edge_nimbus) & static_cast<unsigned>(effects::edge_nimbus::over)) && (wd->flags.action == mouse_action::over))
else if((static_cast<unsigned>(wd->effect.edge_nimbus) & static_cast<unsigned>(effects::edge_nimbus::over)) && (wd->flags.action == mouse_action::hovered))
return true;
return false;
}
void _m_render_edge_nimbus(core_window_t* wd, const nana::rectangle & visual)
{
wd->flags.action_before = wd->flags.action;
auto r = visual;
r.pare_off(-static_cast<int>(weight()));
rectangle good_r;
@ -159,12 +174,12 @@ namespace nana{
good_r.x = good_r.y = 1;
good_r.width = r.width - 2;
good_r.height = r.height - 2;
pixbuf.rectangle(good_r, wd->scheme->activated.get_color(), 0.95, false);
pixbuf.rectangle(good_r, wd->annex.scheme->activated.get_color(), 0.95, false);
good_r.x = good_r.y = 0;
good_r.width = r.width;
good_r.height = r.height;
pixbuf.rectangle(good_r, wd->scheme->activated.get_color(), 0.4, false);
pixbuf.rectangle(good_r, wd->annex.scheme->activated.get_color(), 0.4, false);
pixbuf.pixel(0, 0, px0);
pixbuf.pixel(r.width - 1, 0, px1);

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

@ -15,9 +15,13 @@
#include <nana/gui/element.hpp>
#include <nana/pat/cloneable.hpp>
#include <map>
#include <string>
#include <nana/push_ignore_diagnostic>
namespace nana
{
namespace detail
@ -48,5 +52,6 @@ namespace detail
};
}//end namespace detail
}
#include <nana/pop_ignore_diagnostic>
#endif

4
include/nana/gui/detail/events_operation.hpp
View File

@ -3,7 +3,6 @@
#include <nana/gui/detail/general_events.hpp>
#include <unordered_set>
#include <unordered_map>
#if defined(STD_THREAD_NOT_SUPPORTED)
#include <nana/std_mutex.hpp>
@ -18,15 +17,12 @@ namespace nana
class events_operation
{
public:
void make(window, const std::shared_ptr<general_events> &);
void umake(window);
void register_evt(event_handle);
void cancel(event_handle);
void erase(event_handle);
private:
std::recursive_mutex mutex_;
std::unordered_set<event_handle> handles_;
std::unordered_map<window, std::shared_ptr<general_events>> evt_table_;
};
}//end namespace detail
}//end namespace nana

308
include/nana/gui/detail/general_events.hpp
View File

@ -12,18 +12,22 @@
#ifndef NANA_DETAIL_GENERAL_EVENTS_HPP
#define NANA_DETAIL_GENERAL_EVENTS_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/basis.hpp>
#include "event_code.hpp"
#include "internal_scope_guard.hpp"
#include <type_traits>
#include <functional>
#include <memory>
#include <vector>
namespace nana
{
namespace detail
{
bool check_window(window);
void events_operation_register(event_handle);
class event_interface
{
public:
@ -38,11 +42,51 @@ namespace nana
virtual event_interface* get_event() const = 0;
};
void events_operation_register(event_handle);
void events_operation_cancel(event_handle);
struct docker_base
: public docker_interface
{
event_interface * event_ptr;
bool flag_deleted{ false };
const bool unignorable;
docker_base(event_interface*, bool unignorable_flag);
detail::event_interface * get_event() const override;
};
class event_base
: public detail::event_interface
{
public:
~event_base();
std::size_t length() const;
void clear() noexcept;
void remove(event_handle evt) override;
protected:
//class emit_counter is a RAII helper for emitting count
//It is used for avoiding a try{}catch block which is required for some finial works when
//event handlers throw exceptions. Precondition event_base.dockers_ != nullptr.
class emit_counter
{
public:
emit_counter(event_base*);
~emit_counter();
private:
event_base * const evt_;
};
event_handle _m_emplace(detail::docker_interface*, bool in_front);
protected:
unsigned emitting_count_{ 0 };
bool deleted_flags_{ false };
std::vector<detail::docker_interface*> * dockers_{ nullptr };
};
}//end namespace detail
/// base clase for all event argument types
/// base class for all event argument types
class event_arg
{
public:
@ -57,87 +101,44 @@ namespace nana
struct general_events;
/// the type of the members of general_events
/** @brief the type of the members of general_events.
*
* It connect the functions to be called as response to the event and manages that chain of responses
* It is a functor, that get called to connect a "normal" response function, with normal "priority".
* If a response function need another priority (unignorable or called first) it will need to be connected with
* the specific connect function not with the operator()
* It also permit to "emit" that event, calling all the active responders.
*/
template<typename Arg>
class basic_event : public detail::event_interface
class basic_event : public detail::event_base
{
public:
using arg_reference = const typename std::remove_reference<Arg>::type &;
private:
struct docker
: public detail::docker_interface
{
basic_event * const event_ptr;
: public detail::docker_base
{
/// the callback/response function taking the typed argument
std::function<void(arg_reference)> invoke;
bool flag_deleted{ false };
bool unignorable{false};
docker(basic_event * s, std::function<void(arg_reference)> && ivk, bool unignorable_flag)
: event_ptr(s), invoke(std::move(ivk)), unignorable(unignorable_flag)
docker(basic_event * evt, std::function<void(arg_reference)> && ivk, bool unignorable_flag)
: docker_base(evt, unignorable_flag), invoke(std::move(ivk))
{}
docker(basic_event * s, const std::function<void(arg_reference)> & ivk, bool unignorable_flag)
: event_ptr(s), invoke(ivk), unignorable(unignorable_flag)
docker(basic_event * evt, const std::function<void(arg_reference)> & ivk, bool unignorable_flag)
: docker_base(evt, unignorable_flag), invoke(ivk)
{}
~docker()
{
detail::events_operation_cancel(reinterpret_cast<event_handle>(this));
}
detail::event_interface * get_event() const override
{
return event_ptr;
}
};
//class emit_counter is a RAII helper for emitting count
//It is used for avoiding a try{}catch block which is required for some finial works when
//event handlers throw exceptions.
class emit_counter
{
public:
emit_counter(basic_event* evt)
: evt_{evt}
{
++evt->emitting_count_;
}
~emit_counter()
{
if ((0 == --evt_->emitting_count_) && evt_->deleted_flags_)
{
evt_->deleted_flags_ = false;
for (auto i = evt_->dockers_->begin(); i != evt_->dockers_->end();)
{
if (static_cast<docker*>(i->get())->flag_deleted)
i = evt_->dockers_->erase(i);
else
++i;
}
}
}
private:
basic_event * const evt_;
};
public:
/// It will get called firstly, because it is set at the beginning of the chain.
/// Creates an event handler at the beginning of event chain
template<typename Function>
event_handle connect_front(Function && fn)
{
internal_scope_guard lock;
if (nullptr == dockers_)
dockers_.reset(new std::vector<std::unique_ptr<detail::docker_interface>>);
{
using prototype = typename std::remove_reference<Function>::type;
std::unique_ptr<detail::docker_interface> dck(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), false));
auto evt = reinterpret_cast<event_handle>(dck.get());
dockers_->emplace(dockers_->begin(), std::move(dck));
detail::events_operation_register(evt);
return evt;
return _m_emplace(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), false), true);
}
/// It will not get called if stop_propagation() was called.
event_handle connect(void (*fn)(arg_reference))
{
return connect([fn](arg_reference arg){
@ -145,20 +146,12 @@ namespace nana
});
}
/// It will not get called if stop_propagation() was called.
/// It will not get called if stop_propagation() was called, because it is set at the end of the chain..
template<typename Function>
event_handle connect(Function && fn)
{
internal_scope_guard lock;
if (nullptr == dockers_)
dockers_.reset(new std::vector<std::unique_ptr<detail::docker_interface>>);
using prototype = typename std::remove_reference<Function>::type;
std::unique_ptr<detail::docker_interface> dck(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), false));
auto evt = reinterpret_cast<event_handle>(dck.get());
dockers_->emplace_back(std::move(dck));
detail::events_operation_register(evt);
return evt;
return _m_emplace(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), false), false);
}
/// It will not get called if stop_propagation() was called.
@ -171,29 +164,13 @@ namespace nana
/// It will get called because it is unignorable.
template<typename Function>
event_handle connect_unignorable(Function && fn, bool in_front = false)
{
internal_scope_guard lock;
if (nullptr == dockers_)
dockers_.reset(new std::vector<std::unique_ptr<detail::docker_interface>>);
{
using prototype = typename std::remove_reference<Function>::type;
std::unique_ptr<detail::docker_interface> dck(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), true));
auto evt = reinterpret_cast<event_handle>(dck.get());
if (in_front)
dockers_->emplace(dockers_->begin(), std::move(dck));
else
dockers_->emplace_back(std::move(dck));
detail::events_operation_register(evt);
return evt;
return _m_emplace(new docker(this, factory<prototype, std::is_bind_expression<prototype>::value>::build(std::forward<Function>(fn)), true), in_front);
}
std::size_t length() const
{
internal_scope_guard lock;
return (nullptr == dockers_ ? 0 : dockers_->size());
}
void emit(arg_reference& arg)
void emit(arg_reference& arg, window window_handle)
{
internal_scope_guard lock;
if (nullptr == dockers_)
@ -201,62 +178,37 @@ namespace nana
emit_counter ec(this);
auto& dockers = *dockers_;
const auto dockers_len = dockers.size();
//The dockers may resize when a new event handler is created by a calling handler.
//Traverses with position can avaid crash error which caused by a iterator which becomes invalid.
for (std::size_t pos = 0; pos < dockers_len; ++pos)
auto i = dockers_->data();
auto const end = i + dockers_->size();
for (; i != end; ++i)
{
auto docker_ptr = static_cast<docker*>(dockers[pos].get());
if (docker_ptr->flag_deleted)
if (static_cast<docker*>(*i)->flag_deleted)
continue;
docker_ptr->invoke(arg);
static_cast<docker*>(*i)->invoke(arg);
if (window_handle && (!detail::check_window(window_handle)))
break;
if (arg.propagation_stopped())
{
for (++pos; pos < dockers_len; ++pos)
for (++i; i != end; ++i)
{
auto docker_ptr = static_cast<docker*>(dockers[pos].get());
if (!docker_ptr->unignorable || docker_ptr->flag_deleted)
if (!static_cast<docker*>(*i)->unignorable || static_cast<docker*>(*i)->flag_deleted)
continue;
docker_ptr->invoke(arg);
static_cast<docker*>(*i)->invoke(arg);
if (window_handle && (!detail::check_window(window_handle)))
break;
}
break;
}
}
}
void clear()
{
internal_scope_guard lock;
if (dockers_)
dockers_.reset();
}
void remove(event_handle evt) override
{
internal_scope_guard lock;
if (dockers_)
{
for (auto i = dockers_->begin(), end = dockers_->end(); i != end; ++i)
{
if (reinterpret_cast<detail::docker_interface*>(evt) == i->get())
{
//Checks whether this event is working now.
if (emitting_count_ > 1)
{
static_cast<docker*>(i->get())->flag_deleted = true;
deleted_flags_ = true;
}
else
dockers_->erase(i);
break;
}
}
}
}
private:
template<typename Fn, bool IsBind>
struct factory
@ -294,11 +246,6 @@ namespace nana
};
}
static std::function<void(arg_reference)> build_second(fn_type&& fn, void(fn_type::*)(arg_reference))
{
return std::move(fn);
}
template<typename Tfn, typename Ret>
static std::function<void(arg_reference)> build_second(Tfn&& fn, Ret(fn_type::*)()const)
{
@ -308,11 +255,36 @@ namespace nana
};
}
static std::function<void(arg_reference)> build_second(fn_type&& fn, void(fn_type::*)(arg_reference))
{
return std::move(fn);
}
static std::function<void(arg_reference)> build_second(fn_type&& fn, void(fn_type::*)(arg_reference) const)
{
return std::move(fn);
}
static std::function<void(arg_reference)> build_second(fn_type& fn, void(fn_type::*)(arg_reference))
{
return fn;
}
static std::function<void(arg_reference)> build_second(fn_type& fn, void(fn_type::*)(arg_reference) const)
{
return fn;
}
static std::function<void(arg_reference)> build_second(const fn_type& fn, void(fn_type::*)(arg_reference))
{
return fn;
}
static std::function<void(arg_reference)> build_second(const fn_type& fn, void(fn_type::*)(arg_reference) const)
{
return fn;
}
template<typename Tfn, typename Ret, typename Arg2>
static std::function<void(arg_reference)> build_second(Tfn&& fn, Ret(fn_type::*)(Arg2))
{
@ -322,7 +294,7 @@ namespace nana
fn(arg);
};
}
template<typename Tfn, typename Ret, typename Arg2>
static std::function<void(arg_reference)> build_second(Tfn&& fn, Ret(fn_type::*)(Arg2)const)
{
@ -333,7 +305,7 @@ namespace nana
};
}
};
template<typename Ret, typename Arg2>
struct factory < std::function<Ret(Arg2)>, false>
{
@ -413,26 +385,22 @@ namespace nana
};
}
};
private:
unsigned emitting_count_{ 0 };
bool deleted_flags_{ false };
std::unique_ptr<std::vector<std::unique_ptr<detail::docker_interface>>> dockers_;
};
struct arg_mouse
: public event_arg
{
event_code evt_code; ///<
event_code evt_code; ///< what kind of mouse event?
::nana::window window_handle; ///< A handle to the event window
::nana::point pos; ///< cursor position in the event window
::nana::mouse button; ///< indicates a button which triggers the event
bool left_button; ///< mouse left button is pressed?
bool mid_button; ///< mouse middle button is pressed?
bool right_button; ///< mouse right button is pressed?
bool alt; ///< keyboard alt is pressed?
bool shift; ///< keyboard Shift is pressed?
bool ctrl; ///< keyboard Ctrl is pressed?
bool left_button; ///< true if mouse left button is pressed
bool mid_button; ///< true if mouse middle button is pressed
bool right_button; ///< true if mouse right button is pressed
bool alt; ///< true if keyboard alt is pressed
bool shift; ///< true if keyboard Shift is pressed
bool ctrl; ///< true if keyboard Ctrl is pressed
/// Checks if left button is operated,
bool is_left_button() const
@ -441,7 +409,8 @@ namespace nana
}
};
/// in arg_wheel event_code is event_code::mouse_wheel
/// \brief in arg_wheel event_code is event_code::mouse_wheel
/// The type arg_wheel is derived from arg_mouse, a handler
/// with prototype void(const arg_mouse&) can be set for mouse_wheel.
struct arg_wheel : public arg_mouse
@ -471,9 +440,18 @@ namespace nana
struct arg_focus : public event_arg
{
::nana::window window_handle; ///< A handle to the event window
::nana::native_window_type receiver; ///< it is a native window handle, and specified which window receives focus
bool getting; ///< the window received focus?
/// A constant to indicate how keyboard focus emitted.
enum class reason
{
general, ///< the focus is received by OS native window manager.
tabstop, ///< the focus is received by pressing tab.
mouse_press ///< the focus is received by pressing a mouse button.
};
::nana::window window_handle; ///< A handle to the event window
::nana::native_window_type receiver; ///< it is a native window handle, and specified which window receives focus
bool getting; ///< the window received focus?
reason focus_reason; ///< determines how the widget receives keyboard focus, it is ignored when 'getting' is equal to false
};
struct arg_keyboard : public event_arg
@ -481,7 +459,7 @@ namespace nana
event_code evt_code; ///< it is event_code::key_press in current event
::nana::window window_handle; ///< A handle to the event window
mutable wchar_t key; ///< the key corresponding to the key pressed
mutable bool ignore; ///< this member is not used
mutable bool ignore; ///< this member is only available for key_char event, set 'true' to ignore the input.
bool ctrl; ///< keyboard Ctrl is pressed?
bool shift; ///< keyboard Shift is pressed
};
@ -518,11 +496,11 @@ namespace nana
{
::nana::window window_handle; ///< A handle to the event window
};
/// a higher level event argument than just mouse down
struct arg_click : public event_arg
{
::nana::window window_handle; ///< A handle to the event window
const arg_mouse* mouse_args; ///< If it is not null, it refers to the mouse arguments for click event emitted by mouse, nullptr otherwise.
const arg_mouse* mouse_args{}; ///< If it is not null, it refers to the mouse arguments for click event emitted by mouse, nullptr otherwise.
};
/// provides some fundamental events that every widget owns.
@ -562,4 +540,6 @@ namespace nana
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

6
include/nana/gui/detail/handle_manager.hpp
View File

@ -25,6 +25,8 @@
#include <map>
#include <iterator>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -171,7 +173,7 @@ namespace nana
{
is_queue<std::is_same<cond_type, nana::null_type>::value, std::vector<handle_type> >::erase(handle, queue_);
cacher_.insert(handle, false);
trash_.emplace_back(i->first, i->second);
trash_.push_back(*i);
holder_.erase(i);
}
}
@ -288,4 +290,6 @@ namespace nana
};//end class handle_manager
}//end namespace detail
}// end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -14,6 +14,7 @@
#ifndef NANA_GUI_INNER_FWD_IMPLEMENT_HPP
#define NANA_GUI_INNER_FWD_IMPLEMENT_HPP
#include <nana/push_ignore_diagnostic>
#include "inner_fwd.hpp"
#include "basic_window.hpp"
#include "../../paint/graphics.hpp"
@ -111,20 +112,19 @@ namespace nana{
struct root_misc
{
typedef basic_window core_window_t;
core_window_t * window;
basic_window * window;
nana::paint::graphics root_graph;
shortkey_container shortkeys;
struct condition_tag
struct condition_rep
{
core_window_t* pressed{nullptr}; //The handle to a window which has been pressed by pressing left button of mouse.
core_window_t* pressed_by_space{ nullptr }; //The handle to a window which has been pressed by pressing spacebar.
core_window_t* hovered{nullptr}; //the latest window that mouse moved
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
}condition;
root_misc(core_window_t * wd, unsigned width, unsigned height)
root_misc(basic_window * wd, unsigned width, unsigned height)
: window(wd),
root_graph({ width, height })
{}
@ -172,4 +172,7 @@ namespace nana{
};
}
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_INNER_FWD_IMPLEMENT_HPP

14
include/nana/gui/detail/internal_scope_guard.hpp
View File

@ -1,7 +1,7 @@
/*
* Forward Declaration of Internal Scope Guard
* 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
@ -26,6 +26,18 @@ namespace nana
internal_scope_guard();
~internal_scope_guard();
};
class internal_revert_guard
{
internal_revert_guard(const internal_revert_guard&) = delete;
internal_revert_guard(internal_revert_guard&&) = delete;
internal_revert_guard& operator=(const internal_revert_guard&) = delete;
internal_revert_guard& operator=(internal_revert_guard&&) = delete;
public:
internal_revert_guard();
~internal_revert_guard();
};
}
#endif

5
include/nana/gui/detail/native_window_interface.hpp
View File

@ -1,7 +1,7 @@
/*
* Platform 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
@ -36,6 +36,9 @@ namespace detail
using native_string_type = ::nana::detail::native_string_type;
//Execute a function in a thread which is associated with the specified native window.
static void affinity_execute(native_window_type, const std::function<void()>&);
static nana::size primary_monitor_size();
static rectangle screen_area_from_point(const point&);
static window_result create_window(native_window_type, bool nested, const rectangle&, const appearance&);

14
include/nana/gui/detail/widget_colors.hpp → include/nana/gui/detail/widget_geometrics.hpp
View File

@ -1,17 +1,17 @@
/*
* Color Schemes
* Widget Geometrics
* 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/widget_colors.hpp
* @file: nana/gui/widget_geometrics.hpp
* @description:
*/
#ifndef NANA_DETAIL_WIDGET_COLORS_HPP
#define NANA_DETAIL_WIDGET_COLORS_HPP
#ifndef NANA_DETAIL_WIDGET_GEOMETRICS_HPP
#define NANA_DETAIL_WIDGET_GEOMETRICS_HPP
#include <nana/gui/basis.hpp>
#include <memory>
@ -33,9 +33,9 @@ namespace nana
std::shared_ptr<color> color_;
};//end namespace color_proxy
struct widget_colors
struct widget_geometrics
{
virtual ~widget_colors() = default;
virtual ~widget_geometrics() = default;
color_proxy activated{ static_cast<color_rgb>(0x60C8FD) };
color_proxy background{colors::button_face};

3
include/nana/gui/detail/window_layout.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_DETAIL_WINDOW_LAYOUT_HPP
#define NANA_GUI_DETAIL_WINDOW_LAYOUT_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/basis.hpp>
#include <vector>
@ -84,5 +85,7 @@ namespace detail
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_DETAIL_WINDOW_LAYOUT_HPP

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

@ -1,7 +1,7 @@
/*
/**
* Window Manager 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
@ -10,14 +10,16 @@
* @file: nana/gui/detail/window_manager.hpp
*
* <Knowledge: 1, 2007-8-17, "Difference between destroy and destroy_handle">
* destroy method destroys a window handle and the handles of its children, but it doesn't delete the handle which type is a root window or a frame
* destroy_handle method just destroys the handle which type is a root window or a frame
* destroy method destroys a window handle and the handles of its children, but it doesn't delete the handle which type is a root window
* destroy_handle method just destroys the handle which type is a root window
*
*/
#ifndef NANA_GUI_DETAIL_WINDOW_MANAGER_HPP
#define NANA_GUI_DETAIL_WINDOW_MANAGER_HPP
#include <nana/push_ignore_diagnostic>
#include <vector>
#include "window_layout.hpp"
#include "event_code.hpp"
@ -92,10 +94,12 @@ namespace detail
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*);
#ifndef WIDGET_FRAME_DEPRECATED
core_window_t* create_frame(core_window_t*, const rectangle&, widget*);
bool insert_frame(core_window_t* frame, native_window);
bool insert_frame(core_window_t* frame, core_window_t*);
#endif
void close(core_window_t*);
//destroy
@ -104,13 +108,13 @@ namespace detail
//destroy_handle
//@brief: Delete window handle, the handle type must be a root and a frame.
// Deletes a window whose category type is a root type or a frame type.
void destroy_handle(core_window_t*);
void default_icon(const paint::image& _small_icon, const paint::image& big_icon);
void icon(core_window_t*, const paint::image& small_icon, const paint::image& big_icon);
//show
//@brief: show or hide a window
bool show(core_window_t* wd, bool visible);
core_window_t* find_window(native_window_type root, int x, int y);
@ -129,20 +133,20 @@ namespace detail
bool update(core_window_t*, bool redraw, bool force, const rectangle* update_area = nullptr);
void refresh_tree(core_window_t*);
bool do_lazy_refresh(core_window_t*, bool force_copy_to_screen);
bool do_lazy_refresh(core_window_t*, bool force_copy_to_screen, bool refresh_tree = false);
bool get_graphics(core_window_t*, nana::paint::graphics&);
bool get_visual_rectangle(core_window_t*, nana::rectangle&);
std::vector<core_window_t*> get_children(core_window_t*) const;
bool set_parent(core_window_t* wd, core_window_t* new_parent);
core_window_t* set_focus(core_window_t*, bool root_has_been_focused);
core_window_t* set_focus(core_window_t*, bool root_has_been_focused, arg_focus::reason);
core_window_t* capture_redirect(core_window_t*);
void capture_ignore_children(bool ignore);
bool capture_window_entered(int root_x, int root_y, bool& prev);
core_window_t * capture_window() const;
core_window_t* capture_window(core_window_t*, bool value);
void capture_window(core_window_t*, bool capture, bool ignore_children_if_captured);
void enable_tabstop(core_window_t*);
core_window_t* tabstop(core_window_t*, bool forward) const; //forward means move to next in logic.
@ -195,4 +199,7 @@ namespace detail
};//end class window_manager
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

2
include/nana/gui/dragger.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_DRAGGER_HPP
#define NANA_GUI_DRAGGER_HPP
#include <nana/push_ignore_diagnostic>
#include "basis.hpp"
#include "../basic_types.hpp"
#include "../traits.hpp"
@ -44,4 +45,5 @@ namespace nana
dragger_impl_t * impl_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

4
include/nana/gui/drawing.hpp
View File

@ -11,6 +11,8 @@
*/
#ifndef NANA_GUI_DRAWING_HPP
#define NANA_GUI_DRAWING_HPP
#include <nana/push_ignore_diagnostic>
#include "widgets/widget.hpp"
#include "../traits.hpp"
namespace nana
@ -46,4 +48,6 @@ namespace nana
window handle_;
};//end class drawing
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -1,7 +1,7 @@
/*
* Elements of GUI Gadgets
* 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
@ -12,6 +12,7 @@
#ifndef NANA_GUI_ELEMENT_HPP
#define NANA_GUI_ELEMENT_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/paint/graphics.hpp>
#include <nana/pat/cloneable.hpp>
#include <vector>
@ -88,7 +89,6 @@ namespace nana
struct factory_interface
: public detail::factory_abstract
{
virtual ~factory_interface(){}
virtual ElementInterface* create() const = 0;
};
@ -349,4 +349,5 @@ namespace nana
}//end namespace element
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_ELEMENT_HPP

25
include/nana/gui/filebox.hpp
View File

@ -1,4 +1,4 @@
/*
/**
* Filebox
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
@ -7,7 +7,9 @@
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/filebox.hpp
* @file nana/gui/filebox.hpp
* @author Jinhao
* @brief a dialog to chose file(s), implemented "native" in windows but using nana for X11
*/
#ifndef NANA_GUI_FILEBOX_HPP
@ -37,18 +39,20 @@ namespace nana
/// Change owner window
void owner(window);
/// specify a title for the dialog
/// Set a new title for the dialog
/// @param string a text for title
/// @return old title.
::std::string title( ::std::string new_title); ///< . Set a new title for the dialog and \return the old title
/// @return the old title.
::std::string title( ::std::string new_title);
/** @brief specify a suggestion directory
* @param string a path of initial directory
/** @brief Suggest initial path used to locate a directory when the filebox starts.
* @param string initial_directory a path of initial directory
* @note the behavior of init_path is different between Win7 and Win2K/XP/Vista, but its behavior under Linux is conformed with Win7.
*/
filebox& init_path(const ::std::string&); ///< Suggested init path used to locate a directory when the filebox starts.
filebox& init_path(const ::std::string& initial_directory);
filebox& init_file(const ::std::string&); ///< Init file, if it contains a path, the init path is replaced by the path of init file.
/// \brief Add a filetype filter.
/// \brief Add a filetype filter.
/// To specify multiple filter in a single description, use a semicolon to separate the patterns(for example,"*.TXT;*.DOC;*.BAK").
filebox& add_filter(const ::std::string& description, ///< for example. "Text File"
const ::std::string& filetype ///< filter pattern(for example, "*.TXT")
@ -68,8 +72,7 @@ namespace nana
/// Display the filebox dialog
bool show() const;
/// Display the filebox dialog
/// A function object method alternative to show()
/// a function object method alternative to show() to display the filebox dialog,
bool operator()() const
{
return show();

2
include/nana/gui/layout_utility.hpp
View File

@ -18,7 +18,7 @@
namespace nana
{
//overlap test if overlaped between r1 and r2
bool overlap(const rectangle& r1, const rectangle& r2);
bool overlapped(const rectangle& r1, const rectangle& r2);
// overlap, compute the overlap area between r1 and r2. the r is for root
bool overlap(const rectangle& r1, const rectangle& r2, rectangle& r);

2
include/nana/gui/msgbox.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_MSGBOX_HPP
#define NANA_GUI_MSGBOX_HPP
#include <nana/push_ignore_diagnostic>
#include <sstream>
@ -253,5 +254,6 @@ namespace nana
::nana::rectangle valid_areas_[4];
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

4
include/nana/gui/notifier.hpp
View File

@ -1,7 +1,7 @@
/*
* Definition of Notifier
* 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
@ -14,6 +14,7 @@
#define NANA_GUI_NOTIFIER_HPP
#include <nana/gui/basis.hpp>
#include <nana/gui/detail/general_events.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -65,4 +66,5 @@ namespace nana
implement * impl_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -15,6 +15,7 @@
#ifndef NANA_GUI_PLACE_HPP
#define NANA_GUI_PLACE_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/basis.hpp>
#include <utility>
#include <memory>
@ -99,7 +100,7 @@ namespace nana
};
public:
/// reference to a field manipulator which refers to a field object created by place
typedef field_interface & field_reference;
using field_reference = field_interface &;
place();
place(window);///< Attaches to a specified widget.
@ -140,10 +141,11 @@ namespace nana
}
place& dock(const std::string& dockname, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory);
place& dock_create(const std::string& factory);
widget* dock_create(const std::string& factory);
private:
implement * impl_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //#ifndef NANA_GUI_PLACE_HPP

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

@ -38,7 +38,7 @@ namespace nana
struct widget_traits<widget>
{
using event_type = ::nana::general_events;
using scheme_type = ::nana::widget_colors;
using scheme_type = ::nana::widget_geometrics;
};
}
@ -46,7 +46,7 @@ namespace API
{
namespace detail
{
::nana::widget_colors* make_scheme(::nana::detail::scheme_factory_base&&);
::nana::widget_geometrics* make_scheme(::nana::detail::scheme_factory_interface&&);
}
void effects_edge_nimbus(window, effects::edge_nimbus);
@ -60,6 +60,8 @@ namespace API
//@brief: The interfaces defined in namespace dev are used for developing the nana.gui
namespace dev
{
void affinity_execute(window window_handle, const std::function<void()>&);
bool set_events(window, const std::shared_ptr<general_events>&);
template<typename Scheme>
@ -68,8 +70,8 @@ namespace API
return std::unique_ptr<Scheme>{static_cast<Scheme*>(API::detail::make_scheme(::nana::detail::scheme_factory<Scheme>()))};
}
void set_scheme(window, widget_colors*);
widget_colors* get_scheme(window);
void set_scheme(window, widget_geometrics*);
widget_geometrics* get_scheme(window);
void attach_drawer(widget&, drawer_trigger&);
::nana::detail::native_string_type window_caption(window) throw();
@ -78,8 +80,9 @@ namespace API
window create_window(window, bool nested, const rectangle&, const appearance&, widget* attached);
window create_widget(window, const rectangle&, widget* attached);
window create_lite_widget(window, const rectangle&, widget* attached);
#ifndef WIDGET_FRAME_DEPRECATED
window create_frame(window, const rectangle&, widget* attached);
#endif
paint::graphics* window_graphics(window);
void delay_restore(bool);
@ -88,10 +91,20 @@ namespace API
void set_menubar(window wd, bool attach);
void enable_space_click(window, bool enable);
/// Refreshs a widget surface
/*
* This function will copy the drawer surface into system window after the event process finished.
*/
void lazy_refresh();
}//end namespace dev
widget* get_widget(window);
/// Returns the widget pointer of the specified window.
/*
* @param window_handle A handle to a window owning the widget.
* @return A widget pointer.
*/
widget* get_widget(window window_handle);
namespace detail
{
@ -143,9 +156,17 @@ namespace API
};
}//end namespace detail
void exit();
void exit(); ///< close all windows in current thread
void exit_all(); ///< close all windows
std::string transform_shortkey_text(std::string text, wchar_t &shortkey, std::string::size_type *skpos);
/// @brief Searchs whether the text contains a '&' and removes the character for transforming.
/// If the text contains more than one '&' charachers, the others are ignored. e.g
/// text = "&&a&bcd&ef", the result should be "&abcdef", shortkey = 'b', and pos = 2.
std::string transform_shortkey_text
( std::string text, ///< the text is transformed
wchar_t &shortkey, ///< the character which indicates a short key.
std::string::size_type *skpos ///< retrives the shortkey position if it is not a null_ptr;
);
bool register_shortkey(window, unsigned long);
void unregister_shortkey(window);
@ -181,9 +202,12 @@ namespace API
void fullscreen(window, bool);
bool enabled_double_click(window, bool);
#ifndef WIDGET_FRAME_DEPRECATED
bool insert_frame(window frame, native_window_type);
native_window_type frame_container(window frame);
native_window_type frame_element(window frame, unsigned index);
#endif
void close_window(window);
void show_window(window, bool show); ///< Sets a window visible state.
void restore_window(window);
@ -230,7 +254,7 @@ namespace API
if (nullptr == wdg_colors)
throw std::invalid_argument("API::scheme(): bad parameter window handle, no events object or invalid window handle.");
if (std::is_same<::nana::widget_colors, scheme_type>::value)
if (std::is_same<::nana::widget_geometrics, scheme_type>::value)
return *static_cast<scheme_type*>(wdg_colors);
auto * comp_wdg_colors = dynamic_cast<scheme_type*>(wdg_colors);
@ -258,20 +282,12 @@ namespace API
void window_enabled(window, bool);
bool window_enabled(window);
/** @brief A widget drawer draws the widget surface in answering an event.
*
* This function will tell the drawer to copy the graphics into window after event answering.
* Tells Nana.GUI to copy the buffer of event window to screen after the event is processed.
* This function only works for a drawer_trigger, when a drawer_trigger receives an event,
* after drawing, a drawer_trigger should call lazy_refresh to tell the Nana.GUI to refresh
* the window to the screen after the event process finished.
/// Refresh the window and display it immediately calling the refresh function of its drawer_trigger.
/*
* The drawer::refresh() will be called. If the currently state is lazy_refrsh, the window is delayed to update the graphics until an event is finished.
* @param window_handle A handle to the window to be refreshed.
*/
void lazy_refresh();
/** @brief: calls refresh() of a widget's drawer. if currently state is lazy_refresh, Nana.GUI may paste the drawing on the window after an event processing.
* @param window: specify a window to be refreshed.
*/
void refresh_window(window); ///< Refreshs the window and display it immediately calling the refresh method of its drawer_trigger..
void refresh_window(window window_handle);
void refresh_window_tree(window); ///< Refreshs the specified window and all it’s children windows, then display it immediately
void update_window(window); ///< Copies the off-screen buffer to the screen for immediate display.
@ -283,14 +299,36 @@ namespace API
cursor window_cursor(window);
void activate_window(window);
/// Determines whether the specified window will get the keyboard focus when its root window gets native system focus.
bool is_focus_ready(window);
/// Returns the current keyboard focus window.
window focus_window();
/// Sets the keyboard focus for a specified window.
void focus_window(window);
/// Returns a window which has grabbed the mouse input.
window capture_window();
window capture_window(window, bool); ///< Enables or disables the window to grab the mouse input
void capture_ignore_children(bool ignore); ///< Enables or disables the captured window whether redirects the mouse input to its children if the mouse is over its children.
void modal_window(window); ///< Blocks the routine til the specified window is closed.
/// Enables a window to grab the mouse input.
/**
* @param window_handle A handle to a window to grab the mouse input.
* @param ignore_children Indicates whether to redirect the mouse input to its children if the mouse pointer is over its children.
*/
void set_capture(window window_handle, bool ignore_children);
/// Disable a window to grab the mouse input.
/**
* @param window handle A handle to a window to release grab of mouse input.
*/
void release_capture(window window_handle);
/// Blocks the execution and other windows' messages until the specified window is closed.
void modal_window(window);
/// Blocks the execution until the specified window is closesd.
void wait_for(window);
color fgcolor(window);
@ -300,20 +338,38 @@ namespace API
color activated_color(window);
color activated_color(window, const color&);
void create_caret(window, unsigned width, unsigned height);
void create_caret(window, const size&);
void destroy_caret(window);
void caret_effective_range(window, const rectangle&);
void caret_pos(window, const ::nana::point&);
nana::point caret_pos(window);
nana::size caret_size(window);
void caret_size(window, const size&);
void caret_visible(window, bool is_show);
bool caret_visible(window);
void tabstop(window); ///< Sets the window that owns the tabstop.
/// treu: The focus is not to be changed when Tab key is pressed, and a key_char event with tab will be generated.
void eat_tabstop(window, bool);
window move_tabstop(window, bool next); ///< Sets the focus to the window which tabstop is near to the specified window.
/// Opens an existing caret of a window.
/**
* This function returns an object to operate caret. The object doesn't create or destroy the caret.
* 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.
*/
::std::unique_ptr<caret_interface> open_caret(window window_handle, bool disable_throw = false);
/// Enables that the user can give input focus to the specified window using TAB key.
void tabstop(window);
/// Enables or disables a window to receive a key_char event for pressing TAB key.
/*
* @param window_handle A handle to the window to catch TAB key through key_char event.
* @param enable Indicates whether to enable or disable catch of TAB key. If this parameter is *true*, the window is
* received a key_char when pressing TAB key, and the input focus is not changed. If this parameter is *false*, the
* input focus is changed to the next tabstop window.
*/
void eat_tabstop(window window_handle, bool enable);
/// Sets the input focus to the window which the tabstop is near to the specified window.
/*
* @param window_handle A handle to the window.
* @param forward Indicates whether forward or backward window to be given the input focus.
* @return A handle to the window which to be given the input focus.
*/
window move_tabstop(window window_handle, bool forward);
/// Sets the window active state. If a window active state is false, the window will not obtain the focus when a mouse clicks on it wich will be obteined by take_if_has_active_false.
void take_active(window, bool has_active, window take_if_has_active_false);
@ -343,6 +399,7 @@ namespace API
void at_safe_place(window, std::function<void()>);
}//end namespace API
}//end namespace nana
#endif

2
include/nana/gui/timer.hpp
View File

@ -16,6 +16,7 @@
#ifndef NANA_GUI_TIMER_HPP
#define NANA_GUI_TIMER_HPP
#include <nana/gui/detail/general_events.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -58,4 +59,5 @@ namespace nana
implement * const impl_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -14,6 +14,8 @@
#define NANA_GUI_WIDGET_BUTTON_HPP
#include "widget.hpp"
#include <nana/gui/element.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana{
namespace drawerbase
@ -105,5 +107,7 @@ namespace nana{
void _m_caption(native_string_type&&) override;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

7
include/nana/gui/widgets/categorize.hpp
View File

@ -16,6 +16,7 @@
#include <nana/gui/widgets/widget.hpp>
#include <nana/pat/cloneable.hpp>
#include <nana/any.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -66,7 +67,7 @@ namespace nana
T null_val;
arg_categorize<T> arg(widget_, vp ? *vp : null_val);
widget_.events().selected.emit(arg);
widget_.events().selected.emit(arg, widget_.handle());
}
private:
::nana::categorize<T> & widget_;
@ -141,7 +142,7 @@ namespace nana
void mouse_leave(graph_reference, const arg_mouse&) override;
private:
std::unique_ptr<event_agent_interface> event_agent_;
scheme * scheme_;
scheme * scheme_{nullptr};
};
}//end namespace categorize
}//end namespace drawerbase
@ -258,5 +259,5 @@ namespace nana
}
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

3
include/nana/gui/widgets/checkbox.hpp
View File

@ -12,6 +12,8 @@
#ifndef NANA_GUI_WIDGET_CHECKBOX_HPP
#define NANA_GUI_WIDGET_CHECKBOX_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include <vector>
#include <memory>
@ -106,5 +108,6 @@ namespace drawerbase
std::vector<element_tag> ui_container_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

2
include/nana/gui/widgets/combox.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_WIDGETS_COMBOX_HPP
#define NANA_GUI_WIDGETS_COMBOX_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include "float_listbox.hpp"
#include "skeletons/text_editor_part.hpp"
@ -227,4 +228,5 @@ namespace nana
nana::any * _m_anyobj(std::size_t pos, bool alloc_if_empty) const override;
};
}
#include <nana/pop_ignore_diagnostic>
#endif

92
include/nana/gui/widgets/date_chooser.hpp
View File

@ -1,7 +1,7 @@
/**
* A date chooser 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
@ -12,86 +12,53 @@
#ifndef NANA_GUI_WIDGETS_DATE_CHOOSER_HPP
#define NANA_GUI_WIDGETS_DATE_CHOOSER_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include <nana/datetime.hpp>
namespace nana
{
class date_chooser;
struct arg_datechooser
: public event_arg
{
date_chooser * const widget;
arg_datechooser(date_chooser* wdg)
: widget(wdg)
{}
};
namespace drawerbase
{
namespace date_chooser
{
struct date_chooser_events
: public general_events
{
basic_event<arg_datechooser> date_changed;
};
class trigger : public drawer_trigger
{
class model;
public:
static const int topbar_height = 34;
static const int border_size = 3;
enum class transform_action{none, to_left, to_right, to_enter, to_leave};
enum class where{none, left_button, right_button, topbar, textarea};
enum class page{date, month};
struct drawing_basis
{
nana::point refpos;
double line_s;
double row_s;
};
trigger();
bool chose() const;
nana::date read() const;
void week_name(unsigned index, const std::string&);
private:
where _m_pos_where(graph_reference, const ::nana::point& pos);
void _m_draw_topbar(graph_reference);
void _m_make_drawing_basis(drawing_basis&, graph_reference, const nana::point& refpos);
void _m_draw_pos(drawing_basis &, graph_reference, int x, int y, const ::std::string&, bool primary, bool sel);
void _m_draw_pos(drawing_basis &, graph_reference, int x, int y, int number, bool primary, bool sel);
void _m_draw_ex_days(drawing_basis &, graph_reference, int begx, int begy, bool before);
void _m_draw_days(const nana::point& refpos, graph_reference);
void _m_draw_months(const nana::point& refpos, graph_reference);
bool _m_get_trace(point, int & res);
void _m_perf_transform(transform_action tfid, graph_reference, graph_reference dirtybuf, graph_reference newbuf, const nana::point& refpos);
~trigger();
model* get_model() const;
private:
void refresh(graph_reference) override;
void attached(widget_reference, graph_reference) override;
void mouse_move(graph_reference, const arg_mouse&) override;
void mouse_leave(graph_reference, const arg_mouse&) override;
void mouse_up(graph_reference, const arg_mouse&) override;
void key_press(graph_reference, const arg_keyboard&) override;
private:
::std::string weekstr_[7];
widget * widget_;
bool chose_;
page page_;
where pos_;
nana::point trace_pos_;
drawing_basis dbasis_;
struct
{
int year;
int month;
int day;
}chdate_;
struct
{
int year;
int month;
}chmonth_;
struct color_tag
{
::nana::color highlight;
::nana::color selected;
::nana::color normal;
::nana::color bgcolor;
}color_;
model * model_;
};
}//end namespace date_chooser
@ -100,19 +67,18 @@ namespace nana
/// \see nana::date
class date_chooser
: public widget_object<category::widget_tag, drawerbase::date_chooser::trigger>
: public widget_object<category::widget_tag, drawerbase::date_chooser::trigger, drawerbase::date_chooser::date_chooser_events>
{
public:
date_chooser();
date_chooser(window, bool visible);
date_chooser(window, const ::std::string& text, bool visible = true);
date_chooser(window, const char* text, bool visible = true);
date_chooser(window, const nana::rectangle& r = rectangle(), bool visible = true);
bool chose() const;
nana::date read() const;
void weekstr(unsigned index, const ::std::string&);///<Set the week strings which will be displayed for day, index is in range of [0, 6]
void weekstr(unsigned index, ::std::string);///<Set the week strings which will be displayed for day, index is in range of [0, 6]
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

3
include/nana/gui/widgets/detail/tree_cont.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_WIDGETS_DETAIL_TREE_CONT_HPP
#define NANA_GUI_WIDGETS_DETAIL_TREE_CONT_HPP
#include <stack>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -515,4 +516,6 @@ namespace detail
}//end namespace detail
}//end namespace widgets
}//end namesace nana
#include <nana/pop_ignore_diagnostic>
#endif

2
include/nana/gui/widgets/float_listbox.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_WIDGETS_FLOAT_LISTBOX_HPP
#define NANA_GUI_WIDGETS_FLOAT_LISTBOX_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include <vector>
@ -101,5 +102,6 @@ namespace nana
std::size_t index() const;
};
}
#include <nana/pop_ignore_diagnostic>
#endif

25
include/nana/gui/widgets/form.hpp
View File

@ -14,9 +14,12 @@
#define NANA_GUI_WIDGET_FORM_HPP
#include "widget.hpp"
#include <nana/gui/place.hpp>
namespace nana
{
class place;
namespace drawerbase
{
namespace form
@ -29,12 +32,29 @@ namespace nana
private:
widget* wd_{nullptr};
};
class form_base
: public widget_object<category::root_tag, drawerbase::form::trigger, detail::events_root_extension>
{
public:
form_base(window owner, bool nested, const rectangle&, const appearance&);
//place methods
place & get_place();
void div(const char* div_text);
place::field_reference operator[](const char* field_name);
void collocate() noexcept;
private:
std::unique_ptr<place> place_;
};
}//end namespace form
}//end namespace drawerbase
/// \brief Pop-up window. Is different from other window widgets: its default constructor create the window.
/// \see nana::appearance
class form: public widget_object<category::root_tag, drawerbase::form::trigger, detail::events_root_extension>
class form
: public drawerbase::form::form_base
{
public:
using appear = ::nana::appear;
@ -50,7 +70,8 @@ namespace nana
void wait_for_this();
};
class nested_form : public widget_object<category::root_tag, drawerbase::form::trigger, detail::events_root_extension>
class nested_form
: public drawerbase::form::form_base
{
public:
using appear = ::nana::appear;

3
include/nana/gui/widgets/frame.hpp
View File

@ -16,6 +16,8 @@
#define NANA_GUI_WIDGET_FRAME_HPP
#include "widget.hpp"
#ifndef WIDGET_FRAME_DEPRECATED
namespace nana
{
/**
@ -51,3 +53,4 @@ namespace nana
};
}//end namespace nana
#endif
#endif

5
include/nana/gui/widgets/label.hpp
View File

@ -12,8 +12,9 @@
#ifndef NANA_GUI_WIDGET_LABEL_HPP
#define NANA_GUI_WIDGET_LABEL_HPP
#include "widget.hpp"
#include "widget.hpp"
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -80,4 +81,6 @@ namespace nana
void _m_caption(native_string_type&&) override;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

File diff suppressed because it is too large Load Diff

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

@ -17,6 +17,8 @@
#include <nana/gui/timer.hpp>
#include <nana/pat/cloneable.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana
{
namespace drawerbase
@ -198,4 +200,6 @@ namespace nana
detail::popuper menu_popuper(menu&, mouse = mouse::right_button);
detail::popuper menu_popuper(menu&, window owner, const point&, mouse = mouse::right_button);
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

3
include/nana/gui/widgets/menubar.hpp
View File

@ -14,6 +14,7 @@
#define NANA_GUI_WIDGETS_MENUBAR_HPP
#include "widget.hpp"
#include "menu.hpp"
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -117,4 +118,6 @@ namespace nana
::nana::event_handle evt_resized_{nullptr};
};//end class menubar
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -13,6 +13,8 @@
*/
#ifndef NANA_GUI_WIDGET_PICTURE_HPP
#define NANA_GUI_WIDGET_PICTURE_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
namespace nana
@ -67,4 +69,6 @@ namespace nana
bool transparent() const;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

22
include/nana/gui/widgets/scroll.hpp
View File

@ -15,6 +15,7 @@
#include "widget.hpp"
#include <nana/gui/timer.hpp>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -205,14 +206,14 @@ namespace nana
void resized(graph_reference graph, const ::nana::arg_resized&) override
{
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
void mouse_enter(graph_reference graph, const ::nana::arg_mouse& arg) override
{
metrics_.what = drawer_.what(graph, arg.pos);
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
void mouse_move(graph_reference graph, const ::nana::arg_mouse& arg) override
@ -238,7 +239,7 @@ namespace nana
if (redraw)
{
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
}
@ -262,7 +263,7 @@ namespace nana
timer_.start();
break;
case buttons::scroll:
API::capture_window(widget_->handle(), true);
widget_->set_capture(true);
metrics_.scroll_mouse_offset = (Vertical ? arg.pos.y : arg.pos.x) - metrics_.scroll_pos;
break;
case buttons::forward:
@ -278,7 +279,7 @@ namespace nana
break;
}
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
}
@ -286,12 +287,12 @@ namespace nana
{
timer_.stop();
API::capture_window(widget_->handle(), false);
widget_->release_capture();
metrics_.pressed = false;
metrics_.what = drawer_.what(graph, arg.pos);
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
void mouse_leave(graph_reference graph, const arg_mouse&) override
@ -300,7 +301,7 @@ namespace nana
metrics_.what = buttons::none;
drawer_.draw(graph, buttons::none);
API::lazy_refresh();
API::dev::lazy_refresh();
}
void mouse_wheel(graph_reference graph, const arg_wheel& arg) override
@ -308,13 +309,13 @@ namespace nana
if (make_step(arg.upwards == false, 3))
{
drawer_.draw(graph, metrics_.what);
API::lazy_refresh();
API::dev::lazy_refresh();
}
}
private:
void _m_emit_value_changed()
{
widget_->events().value_changed.emit({ widget_->handle() });
widget_->events().value_changed.emit({ widget_->handle() }, widget_->handle());
}
void _m_tick()
@ -502,4 +503,5 @@ namespace nana
}
};//end class scroll
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -13,6 +13,8 @@
#ifndef NANA_GUI_SKELETONS_TEXT_EDITOR_HPP
#define NANA_GUI_SKELETONS_TEXT_EDITOR_HPP
#include <nana/push_ignore_diagnostic>
#include "textbase.hpp"
#include "text_editor_part.hpp"
#include <nana/gui/widgets/scroll.hpp>
@ -40,6 +42,12 @@ namespace nana{ namespace widgets
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;
@ -56,7 +64,7 @@ namespace nana{ namespace widgets
{
enabled_ = enb;
if (!enb)
commands_.clear();
clear();
}
bool enabled() const
@ -130,6 +138,7 @@ namespace nana{ namespace widgets
struct keywords;
class keyword_parser;
class helper_pencil;
public:
using char_type = wchar_t;
using size_type = textbase<char_type>::size_type;
@ -202,7 +211,7 @@ namespace nana{ namespace widgets
unsigned screen_lines() const;
bool getline(std::size_t pos, ::std::wstring&) const;
void text(std::wstring);
void text(std::wstring, bool end_caret);
std::wstring text() const;
/// Sets caret position through text coordinate.
@ -218,7 +227,7 @@ namespace nana{ namespace widgets
void set_end_caret();
bool hit_text_area(const point&) const;
bool hit_select_area(nana::upoint pos) const;
bool hit_select_area(nana::upoint pos, bool ignore_when_select_all) const;
bool move_select();
bool mask(wchar_t);
@ -229,6 +238,9 @@ namespace nana{ namespace widgets
/// Returns text position of each line that currently displays on screen
const std::vector<upoint>& text_position() const;
void focus_behavior(text_focus_behavior);
void select_behavior(bool move_to_end);
public:
void draw_corner();
void render(bool focused);
@ -249,17 +261,20 @@ namespace nana{ namespace widgets
const upoint& caret() const;
point caret_screen_pos() const;
bool scroll(bool upwards, bool vertical);
bool mouse_enter(bool);
bool focus_changed(const arg_focus&);
bool mouse_enter(bool entering);
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;
private:
void _m_pre_calc_lines(std::size_t line_off, std::size_t lines);
bool _m_accepts(char_type) const;
::nana::color _m_bgcolor() const;
bool _m_scroll_text(bool vertical);
void _m_on_scroll(const arg_mouse&);
void _m_scrollbar();
::nana::size _m_text_area() const;
void _m_get_scrollbar_size();
@ -267,7 +282,7 @@ namespace nana{ namespace widgets
::nana::upoint _m_put(::std::wstring);
::nana::upoint _m_erase_select();
bool _m_make_select_string(::std::wstring&) const;
::std::wstring _m_make_select_string() const;
static bool _m_resolve_text(const ::std::wstring&, std::vector<std::pair<std::size_t, std::size_t>> & lines);
bool _m_cancel_select(int align);
@ -295,14 +310,16 @@ namespace nana{ namespace widgets
void _m_offset_y(int y);
unsigned _m_char_by_pixels(const wchar_t*, std::size_t len, unsigned* pxbuf, int str_px, int pixels, bool is_rtl);
unsigned _m_pixels_by_char(const ::std::wstring&, std::size_t pos) const;
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);
private:
std::unique_ptr<editor_behavior_interface> behavior_;
undoable<command> undo_;
nana::window window_;
std::unique_ptr<caret_interface> caret_;
graph_reference graph_;
const text_editor_scheme* scheme_;
event_interface * event_handler_{ nullptr };
@ -353,10 +370,12 @@ namespace nana{ namespace widgets
struct selection
{
enum mode_selection_t{mode_no_selected, mode_mouse_selected, mode_method_selected};
enum class mode{ no_selected, mouse_selected, method_selected, move_selected };
mode_selection_t mode_selection;
bool dragged;
text_focus_behavior behavior;
bool move_to_end;
mode mode_selection;
bool ignore_press;
nana::upoint a, b;
}select_;
@ -372,5 +391,7 @@ namespace nana{ namespace widgets
}//end namespace widgets
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

15
include/nana/gui/widgets/skeletons/text_editor_part.hpp
View File

@ -2,7 +2,7 @@
#ifndef NANA_WIDGETS_SKELETONS_TEXT_EDITOR_SCHEME_HPP
#define NANA_WIDGETS_SKELETONS_TEXT_EDITOR_SCHEME_HPP
#include "../../detail/widget_colors.hpp"
#include "../../detail/widget_geometrics.hpp"
#include <vector>
namespace nana
@ -11,14 +11,25 @@ namespace nana
{
namespace skeletons
{
enum class text_focus_behavior
{
none,
select,
select_if_tabstop,
select_if_click,
select_if_tabstop_or_click
};
//forward declaration
class text_editor;
struct text_editor_scheme
: public ::nana::widget_colors
: public ::nana::widget_geometrics
{
color_proxy selection{static_cast<color_rgb>(0x3399FF)};
color_proxy selection_text{colors::white};
parameters::mouse_wheel mouse_wheel; ///< The number of lines/characters to scroll when the vertical/horizontal mouse wheel is moved.
};
class text_editor_event_interface

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

@ -15,13 +15,14 @@
#include <nana/gui/layout_utility.hpp>
#include <sstream>
#include <deque>
#include <vector>
#include <list>
#include <stack>
#include <stdexcept>
#include <nana/push_ignore_diagnostic>
namespace nana{ namespace widgets{ namespace skeletons
{
//The tokens are defined for representing a text, the tokens are divided
@ -86,26 +87,12 @@ namespace nana{ namespace widgets{ namespace skeletons
std::pair<unsigned, unsigned> binary_number() const
{
std::stringstream ss;
ss<<static_cast<std::string>(nana::charset(binary_.first))<<' '<<static_cast<std::string>(nana::charset(binary_.second));
std::pair<unsigned, unsigned> r;
ss>>r.first>>r.second;
return r;
return{ std::stoul(binary_.first), std::stoul(binary_.second) };
}
int number() const
{
std::stringstream ss;
ss<<static_cast<std::string>(nana::charset(idstr_));
//It's a hex number.
if(idstr_.size() > 2 && idstr_[0] == '0' && (idstr_[1] == 'x' || idstr_[1] == 'X'))
ss>>std::hex;
int n;
ss>>n;
return n;
return std::stoi(idstr_, nullptr, 0);
}
private:
static bool _m_unicode_word_breakable(wchar_t ch)
@ -192,13 +179,24 @@ namespace nana{ namespace widgets{ namespace skeletons
return token::tag_begin;
}
//Escape
if(ch == '\\')
if(this->format_enabled_ && (ch == '\\'))
{
if(iptr_ + 1 < endptr_)
{
ch = *(iptr_ + 1);
iptr_ += 2;
if ('<' == ch || '>' == ch) //two characters need to be escaped.
{
iptr_ += 2;
}
else
{
//ignore escape
ch = '\\';
iptr_++;
}
}
else
{
@ -206,8 +204,8 @@ namespace nana{ namespace widgets{ namespace skeletons
return token::eof;
}
}
++iptr_;
else
++iptr_;
idstr_.clear();
idstr_.append(1, ch);
@ -275,6 +273,8 @@ namespace nana{ namespace widgets{ namespace skeletons
return token::eof;
}
if(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || '_' == ch)
{
--iptr_;
@ -665,8 +665,7 @@ namespace nana{ namespace widgets{ namespace skeletons
case token::eof:
return;
default:
int * debug = 0; //for debug.
*debug = 0;
throw std::runtime_error("invalid token");
}
}
}
@ -941,4 +940,5 @@ namespace nana{ namespace widgets{ namespace skeletons
}//end namespace skeletons
}//end namespace widgets
}//end namepsace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_WIDGETS_SKELETONS_TEXT_TOKEN_STREAM

11
include/nana/gui/widgets/skeletons/textbase.hpp
View File

@ -13,6 +13,7 @@
#ifndef NANA_GUI_WIDGET_DETAIL_TEXTBASE_HPP
#define NANA_GUI_WIDGET_DETAIL_TEXTBASE_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/charset.hpp>
#include <nana/basic_types.hpp>
@ -134,7 +135,7 @@ namespace skeletons
while(ifs.good())
{
std::getline(ifs, str_mbs);
text_cont_.emplace_back(nana::charset(str_mbs));
text_cont_.emplace_back(static_cast<string_type&&>(nana::charset{ str_mbs }));
if(text_cont_.back().size() > attr_max_.size)
{
attr_max_.size = text_cont_.back().size();
@ -217,7 +218,7 @@ namespace skeletons
byte_order_translate_4bytes(str);
}
text_cont_.emplace_back(nana::charset(str, encoding));
text_cont_.emplace_back(static_cast<string_type&&>(nana::charset{ str, encoding }));
attr_max_.size = text_cont_.back().size();
attr_max_.line = 0;
@ -235,7 +236,7 @@ namespace skeletons
byte_order_translate_4bytes(str);
}
text_cont_.emplace_back(nana::charset(str, encoding));
text_cont_.emplace_back(static_cast<string_type&&>(nana::charset{ str, encoding }));
if(text_cont_.back().size() > attr_max_.size)
{
attr_max_.size = text_cont_.back().size();
@ -405,7 +406,7 @@ namespace skeletons
void erase_all()
{
std::deque<string_type>().swap(text_cont_);
text_cont_.clear();
attr_max_.reset();
text_cont_.emplace_back(); //text_cont_ must not be empty
@ -536,4 +537,6 @@ namespace skeletons
}//end namespace detail
}//end namespace widgets
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -11,6 +11,9 @@
*/
#ifndef NANA_GUI_WIDGETS_SLIDER_HPP
#define NANA_GUI_WIDGETS_SLIDER_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include <nana/pat/cloneable.hpp>
@ -30,6 +33,23 @@ namespace nana
{
namespace slider
{
struct scheme_impl
: public widget_geometrics
{
/// Colors
color_proxy color_adorn { static_cast<color_rgb>(0x3da3ce) };
color_proxy color_bar { static_cast<color_rgb>(0x878787) };
color_proxy color_slider { static_cast<color_rgb>(0x606060) };
color_proxy color_slider_highlighted{ static_cast<color_rgb>(0x2d93be) };
color_proxy color_vernier { colors::red };
color_proxy color_vernier_text { colors::white };
/// Geometrical parameters
unsigned vernier_text_margin{ 8 };
};
struct slider_events
: public general_events
{
@ -41,65 +61,66 @@ namespace nana
bilateral, forward, backward
};
class provider
class renderer_interface
{
public:
virtual ~provider() = default;
virtual std::string adorn_trace(unsigned vmax, unsigned vadorn) const = 0;
};
using graph_reference = ::nana::paint::graphics&;
using scheme = scheme_impl;
class renderer
{
public:
typedef ::nana::paint::graphics & graph_reference;
struct bar_t
struct data_bar
{
bool horizontal;
nana::rectangle r; //the rectangle of bar.
unsigned border_size; //border_size of bar.
bool vert; ///< Indicates whether the slider is vertical.
::nana::rectangle area; ///< Position and size of bar.
unsigned border_weight; ///< The border weight in pixels.
};
struct slider_t
struct data_slider
{
bool horizontal;
int pos;
unsigned border;
unsigned scale;
bool vert; ///< Indicates whether the slider is vertical.
double pos;
unsigned border_weight;
unsigned weight;
};
struct adorn_t
struct data_adorn
{
bool horizontal;
nana::point bound;
bool vert; ///< Indicates whether the slider is vertical.
::nana::point bound;
int fixedpos;
unsigned block;
unsigned vcur_scale; //pixels of vcur scale.
unsigned vcur_scale;
};
virtual ~renderer() = default;
struct data_vernier
{
bool vert; ///< Indicates whether the slider is vertical.
int position;
int end_position;
unsigned knob_weight;
virtual void background(window, graph_reference, bool isglass) = 0;
virtual void adorn(window, graph_reference, const adorn_t&) = 0;
virtual void adorn_textbox(window, graph_reference, const ::std::string&, const nana::rectangle&) = 0;
virtual void bar(window, graph_reference, const bar_t&) = 0;
virtual void slider(window, graph_reference, const slider_t&) = 0;
std::string text;
};
virtual ~renderer_interface() = default;
virtual void background(window, graph_reference, bool transparent, const scheme&) = 0;
virtual void adorn(window, graph_reference, const data_adorn&, const scheme&) = 0;
virtual void vernier(window, graph_reference, const data_vernier&, const scheme&) = 0;
virtual void bar(window, graph_reference, const data_bar&, const scheme&) = 0;
virtual void slider(window, graph_reference, mouse_action, const data_slider&, const scheme&) = 0;
};
class controller;
class trigger
: public drawer_trigger
{
class model;
public:
typedef controller controller_t;
trigger();
~trigger();
controller_t* ctrl() const;
model* get_model() const;
private:
void attached(widget_reference, graph_reference) override;
void detached() override;
void refresh(graph_reference) override;
void mouse_down(graph_reference, const arg_mouse&) override;
void mouse_up(graph_reference, const arg_mouse&) override;
@ -107,18 +128,19 @@ namespace nana
void mouse_leave(graph_reference, const arg_mouse&) override;
void resized(graph_reference, const arg_resized&) override;
private:
controller_t * impl_;
model * model_ptr_;
};
}//end namespace slider
}//end namespace drawerbase
/// A slider widget wich the user can drag for tracking
/// A slider widget wich the user can drag for tracking \todo add scheme ?
class slider
: public widget_object<category::widget_tag, drawerbase::slider::trigger, drawerbase::slider::slider_events>
: public widget_object<category::widget_tag, drawerbase::slider::trigger, drawerbase::slider::slider_events, drawerbase::slider::scheme_impl>
{
public:
typedef drawerbase::slider::renderer renderer; ///< The interface for user-defined renderer.
typedef drawerbase::slider::provider provider; ///< The interface for user-defined provider.
typedef drawerbase::slider::seekdir seekdir; ///< Defines the slider seek direction.
using renderer_interface = drawerbase::slider::renderer_interface; ///< The interface for customized renderer.
using seekdir = drawerbase::slider::seekdir; ///< Defines the slider seek direction.
slider();
slider(window, bool visible);
@ -127,19 +149,21 @@ namespace nana
void seek(seekdir); ///< Define the direction that user can seek by using mouse.
void vertical(bool);
bool vertical() const;
void vmax(unsigned);
unsigned vmax() const;
void maximum(unsigned);
unsigned maximum() const;
void value(unsigned);
unsigned value() const;
unsigned move_step(bool forward); ///< Increase or decrease the value of slider.
unsigned adorn() const;
pat::cloneable<renderer>& ext_renderer(); ///< Refers to the current renderer that slider is using.
void ext_renderer(const pat::cloneable<renderer>&); ///< Set the current renderer.
void ext_provider(const pat::cloneable<provider>&);
const pat::cloneable<renderer_interface>& renderer(); ///< Refers to the current renderer that slider is using.
void renderer(const pat::cloneable<renderer_interface>&); ///< Set the current renderer.
void vernier(std::function<std::string(unsigned maximum, unsigned cursor_value)> provider);
void transparent(bool);
bool transparent() const;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

6
include/nana/gui/widgets/spinbox.hpp
View File

@ -12,6 +12,8 @@
#ifndef NANA_GUI_WIDGET_SPINBOX_HPP
#define NANA_GUI_WIDGET_SPINBOX_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include "skeletons/text_editor_part.hpp"
@ -68,7 +70,7 @@ namespace nana
private:
implementation * const impl_;
};
};
}
}//end namespace drawerbase
/// Spinbox Widget
@ -110,5 +112,5 @@ namespace nana
void _m_caption(native_string_type&&);
}; //end class spinbox
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_GUI_WIDGET_SPINBOX_HPP

9
include/nana/gui/widgets/tabbar.hpp
View File

@ -13,6 +13,8 @@
*/
#ifndef NANA_GUI_WIDGET_TABBAR_HPP
#define NANA_GUI_WIDGET_TABBAR_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include <nana/pat/cloneable.hpp>
#include <nana/any.hpp>
@ -111,14 +113,14 @@ namespace nana
if(pos != npos)
{
drawer_trigger_.at_no_bound_check(pos) = T();
tabbar_.events().added.emit(arg_tabbar({ tabbar_, tabbar_[pos] }));
tabbar_.events().added.emit(arg_tabbar({ tabbar_, tabbar_[pos] }), tabbar_);
}
}
void activated(std::size_t pos) override
{
if(pos != npos)
tabbar_.events().activated.emit(arg_tabbar({ tabbar_, tabbar_[pos]}));
tabbar_.events().activated.emit(arg_tabbar({ tabbar_, tabbar_[pos]}), tabbar_);
}
bool removed(std::size_t pos, bool & close_attach) override
@ -126,7 +128,7 @@ namespace nana
if (pos != npos)
{
::nana::arg_tabbar_removed<T> arg(tabbar_, tabbar_[pos]);
tabbar_.events().removed.emit(arg);
tabbar_.events().removed.emit(arg, tabbar_);
close_attach = arg.close_attach_window;
return arg.remove;
}
@ -410,5 +412,6 @@ namespace nana
void erase(std::size_t pos, bool close_attached = true);
};
}
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -1,7 +1,7 @@
/**
* A Textbox 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
@ -11,6 +11,8 @@
*/
#ifndef NANA_GUI_WIDGET_TEXTBOX_HPP
#define NANA_GUI_WIDGET_TEXTBOX_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/gui/widgets/widget.hpp>
#include "skeletons/textbase_export_interface.hpp"
#include "skeletons/text_editor_part.hpp"
@ -98,6 +100,8 @@ namespace nana
:public widget_object<category::widget_tag, drawerbase::textbox::drawer, drawerbase::textbox::textbox_events, ::nana::widgets::skeletons::text_editor_scheme>
{
public:
using text_focus_behavior = widgets::skeletons::text_focus_behavior;
using text_positions = std::vector<upoint>;
/// The default constructor without creating the widget.
textbox();
@ -134,8 +138,14 @@ namespace nana
/// @param generator generates text for identing a line. If it is empty, textbox indents the line according to last line.
textbox& indention(bool, std::function<std::string()> generator = {});
//A workaround for reset, explicit default constructor syntax, because VC2013 incorrectly treats {} as {0}.
textbox& reset(const std::string& = std::string()); ///< discard the old text and set a new text
/// Discards the old text and set a new text. It also clears the filename/edited flags and undo command.
/// A workaround for reset, explicit default constructor syntax, because VC2013 incorrectly treats {} as {0}.
/*
* @param text A new text replaces the old text.
* @param end_caret Indicates whether to position the caret to the end of text.
* @return a reference of *this.
*/
textbox& reset(const std::string& text = std::string(), bool end_caret = true); ///< discard the old text and set a new text
/// The file of last store operation.
std::string filename() const;
@ -162,15 +172,18 @@ namespace nana
/// Appends an string. If `at_caret` is `true`, the string is inserted at the position of caret, otherwise, it is appended at end of the textbox.
textbox& append(const std::string& text, bool at_caret);
/// Determine wheter the text is line wrapped.
/// Determines whether the text is line wrapped.
bool line_wrapped() const;
textbox& line_wrapped(bool);
/// Determine whether the text is multi-line enabled.
/// Determines whether the text is multi-line enabled.
bool multi_lines() const;
textbox& multi_lines(bool);
/// Determines whether the textbox accepts user input
bool editable() const;
textbox& editable(bool);
void set_accept(std::function<bool(wchar_t)>);
textbox& tip_string(::std::string);
@ -207,6 +220,14 @@ namespace nana
/// Returns the height of line in pixels
unsigned line_pixels() const;
/// Sets the behavior when textbox gets focus.
void focus_behavior(text_focus_behavior);
/// Sets the caret move behavior when the content of textbox is selected.
/// 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);
protected:
//Overrides widget's virtual functions
native_string_type _m_caption() const throw() override;
@ -214,4 +235,6 @@ namespace nana
void _m_typeface(const paint::font&) override;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

3
include/nana/gui/widgets/toolbar.hpp
View File

@ -12,6 +12,7 @@
#ifndef NANA_GUI_WIDGET_TOOLBAR_HPP
#define NANA_GUI_WIDGET_TOOLBAR_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
@ -101,4 +102,6 @@ namespace nana
bool detached_;
};
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

12
include/nana/gui/widgets/treebox.hpp
View File

@ -17,6 +17,8 @@
#ifndef NANA_GUI_WIDGETS_TREEBOX_HPP
#define NANA_GUI_WIDGETS_TREEBOX_HPP
#include <nana/push_ignore_diagnostic>
#include "widget.hpp"
#include "detail/compset.hpp"
#include "detail/tree_cont.hpp"
@ -70,9 +72,7 @@ namespace nana
typedef compset_interface::item_attribute_t item_attribute_t;
typedef compset_interface::comp_attribute_t comp_attribute_t;
virtual ~renderer_interface()
{}
virtual ~renderer_interface() = default;
virtual void set_color(const nana::color& bgcolor, const nana::color& fgcolor) = 0;
virtual void bground(graph_reference, const compset_interface *) const = 0;
@ -307,14 +307,14 @@ namespace nana
{
_m_value() = t;
return *this;
};
}
template<typename T>
item_proxy & value(T&& t)
{
_m_value() = std::move(t);
return *this;
};
}
// Undocumentated methods for internal use
trigger::node_type * _m_node() const;
@ -452,4 +452,6 @@ namespace nana
item_proxy selected() const; ///< returns the selected node
};//end class treebox
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

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

@ -1,7 +1,7 @@
/**
* The fundamental widget class 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
@ -12,11 +12,11 @@
#ifndef NANA_GUI_WIDGET_HPP
#define NANA_GUI_WIDGET_HPP
#include "../basis.hpp"
#include <nana/push_ignore_diagnostic>
#include "../programming_interface.hpp"
#include <nana/internationalization.hpp>
#include <nana/gui/detail/drawer.hpp>
#include <functional>
namespace nana
{
@ -78,6 +78,15 @@ namespace nana
nana::size size() const;
void size(const nana::size&);
/// Enables the widget to grab the mouse input.
/*
* @param ignore_children Indicates whether to redirect the mouse input to its children if the mouse pointer is over its children.
*/
void set_capture(bool ignore_children);
/// Disables the widget to grab the mouse input.
void release_capture();
point pos() const;
void move(int x, int y);
@ -132,9 +141,25 @@ namespace nana
virtual nana::color _m_bgcolor() const;
};
namespace detail
{
class widget_base
: public widget
{
public:
~widget_base();
window handle() const override;
private:
void _m_notify_destroy() override final;
protected:
window handle_{ nullptr };
};
}
/// Base class of all the classes defined as a widget window. Defaultly a widget_tag
template<typename Category, typename DrawerTrigger, typename Events = ::nana::general_events, typename Scheme = ::nana::widget_colors>
class widget_object: public widget
template<typename Category, typename DrawerTrigger, typename Events = ::nana::general_events, typename Scheme = ::nana::widget_geometrics>
class widget_object: public detail::widget_base
{
protected:
typedef DrawerTrigger drawer_trigger_t;
@ -147,12 +172,6 @@ namespace nana
scheme_{ API::dev::make_scheme<Scheme>() }
{}
~widget_object()
{
if(handle_)
API::close_window(handle_);
}
event_type& events() const
{
return *events_;
@ -179,11 +198,6 @@ namespace nana
return (this->empty() == false);
}
window handle() const override
{
return handle_;
}
widget_object& borderless(bool enable)
{
API::widget_borderless(handle_, enable);
@ -214,13 +228,7 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
handle_ = nullptr;
}
private:
window handle_{nullptr};
DrawerTrigger trigger_;
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
@ -228,7 +236,7 @@ namespace nana
/// Base class of all the classes defined as a non-graphics-buffer widget window. The second template parameter DrawerTrigger is always ignored.\see nana::panel
template<typename DrawerTrigger, typename Events, typename Scheme>
class widget_object<category::lite_widget_tag, DrawerTrigger, Events, Scheme>: public widget
class widget_object<category::lite_widget_tag, DrawerTrigger, Events, Scheme>: public detail::widget_base
{
protected:
typedef DrawerTrigger drawer_trigger_t;
@ -240,12 +248,6 @@ namespace nana
: events_{ std::make_shared<Events>() }, scheme_{ API::dev::make_scheme<scheme_type>() }
{}
~widget_object()
{
if(handle_)
API::close_window(handle_);
}
event_type& events() const
{
return *events_;
@ -269,12 +271,7 @@ namespace nana
}
return (this->empty() == false);
}
window handle() const override
{
return handle_;
}
scheme_type& scheme() const
{
return *scheme_;
@ -284,13 +281,7 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
handle_ = nullptr;
}
private:
window handle_{nullptr};
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
};//end class widget_object
@ -298,7 +289,7 @@ namespace nana
/// Base class of all the classes defined as a root window. \see nana::form
template<typename DrawerTrigger, typename Events, typename Scheme>
class widget_object<category::root_tag, DrawerTrigger, Events, Scheme>: public widget
class widget_object<category::root_tag, DrawerTrigger, Events, Scheme>: public detail::widget_base
{
protected:
typedef DrawerTrigger drawer_trigger_t;
@ -324,12 +315,6 @@ namespace nana
_m_bind_and_attach();
}
~widget_object()
{
if(handle_)
API::close_window(handle_);
}
event_type& events() const
{
return *events_;
@ -340,11 +325,6 @@ namespace nana
API::activate_window(handle_);
}
window handle() const override
{
return handle_;
}
native_window_type native_handle() const
{
return API::root(handle_);
@ -435,25 +415,20 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
handle_ = nullptr;
}
private:
window handle_;
DrawerTrigger trigger_;
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
DrawerTrigger trigger_;
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
};//end class widget_object<root_tag>
#ifndef WIDGET_FRAME_DEPRECATED
/// Base class of all the classes defined as a frame window. \see nana::frame
template<typename Drawer, typename Events, typename Scheme>
class widget_object<category::frame_tag, Drawer, Events, Scheme>: public widget{};
/// Especialization. Base class of all the classes defined as a frame window. \see nana::frame
template<typename Events, typename Scheme>
class widget_object<category::frame_tag, int, Events, Scheme>: public widget
class widget_object<category::frame_tag, int, Events, Scheme>: public detail::widget_base
{
protected:
typedef int drawer_trigger_t;
@ -465,12 +440,6 @@ namespace nana
: events_{ std::make_shared<Events>() }, scheme_{ API::dev::make_scheme<scheme_type>() }
{}
~widget_object()
{
if(handle_)
API::close_window(handle_);
}
event_type& events() const
{
return *events_;
@ -494,11 +463,6 @@ namespace nana
return (this->empty() == false);
}
window handle() const override
{
return handle_;
}
scheme_type& scheme() const
{
return *scheme_;
@ -513,15 +477,12 @@ namespace nana
{
return *events_;
}
void _m_notify_destroy() override final
{
handle_ = nullptr;
}
private:
window handle_{nullptr};
std::shared_ptr<Events> events_;
std::unique_ptr<scheme_type> scheme_;
};//end class widget_object<category::frame_tag>
}//end namespace nana
#endif
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

30
include/nana/gui/wvl.hpp
View File

@ -1,14 +1,14 @@
/*
/**
* Nana GUI Library 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
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/gui/wvl.hpp
* @description:
* @file nana/gui/wvl.hpp
* @description
* the header file contains the files required for running of Nana.GUI
*/
@ -22,6 +22,7 @@
#include "msgbox.hpp"
#include "place.hpp"
namespace nana
{
namespace detail
@ -58,6 +59,25 @@ namespace nana
template<typename Form, bool IsVisible = true>
using form_loader = detail::form_loader<Form, IsVisible>;
void exec();
/// @brief Take control of the GUI and optionaly automaticaly tests it.
///
/// @detail It transfers to nana the program flow control, which begin pumping messages
/// from the underlying OS, interpreting and sending it with suitable arguments
/// to the nana widgets that registered a response in the corresponding event.
/// It also accept arguments to be used in case of automatic GUI testing.
/// Other Way the arguments are ignored.
void exec(
unsigned wait = 1, ///< for the GUI to be constructed, in seconds
unsigned wait_end = 1, ///< for the GUI to be destructed, in seconds
std::function<void()> = {} ///< emit events to mimics user actions and may asert results
);
/// send a click message to this widget - useffull in GUI testing
void click(widget& w);
/// in seconds
void Wait(unsigned wait = 0);
}//end namespace nana
#endif

22
include/nana/key_type.hpp
View File

@ -26,63 +26,63 @@ namespace nana
}; //end class key_interface
//Use less compare for equal compare [call it equal_by_less()?]
inline bool pred_equal_by_less(const key_interface * left, const key_interface* right)
inline bool pred_equal(const key_interface * left, const key_interface* right)
{
return (left->compare(right) == false) && (right->compare(left) == false);
return (left->same_type(right) && (left->compare(right) == false) && (right->compare(left) == false));
}
template<typename T>
struct type_escape
{
typedef T type;
using type = T;
};
template<>
struct type_escape<char*>
{
typedef std::string type;
using type = ::std::string;
};
template<>
struct type_escape<const char*>
{
typedef std::string type;
using type = ::std::string;
};
template<int Size>
struct type_escape<char[Size]>
{
typedef std::string type;
using type = ::std::string;
};
template<int Size>
struct type_escape<const char[Size]>
{
typedef std::string type;
using type = ::std::string;
};
template<>
struct type_escape<wchar_t*>
{
typedef std::wstring type;
using type = ::std::wstring;
};
template<>
struct type_escape<const wchar_t*>
{
typedef std::wstring type;
using type = ::std::wstring;
};
template<int Size>
struct type_escape<wchar_t[Size]>
{
typedef std::wstring type;
using type = ::std::wstring;
};
template<int Size>
struct type_escape<const wchar_t[Size]>
{
typedef std::wstring type;
using type = ::std::wstring;
};
}

4
include/nana/paint/detail/image_impl_interface.hpp
View File

@ -2,7 +2,7 @@
#define NANA_PAINT_DETAIL_IMAGE_IMPL_INTERFACE_HPP
#include "../image.hpp"
#include <nana/filesystem/filesystem.hpp>
#include <nana/filesystem/filesystem_ext.hpp>
namespace nana{ namespace paint{
@ -16,7 +16,7 @@ namespace nana{ namespace paint{
public:
typedef nana::paint::graphics& graph_reference;
virtual ~image_impl_interface() = 0; //The destructor is defined in ../image.cpp
virtual bool open(const nana::experimental::filesystem::path& file) = 0;
virtual bool open(const std::experimental::filesystem::path& file) = 0;
virtual bool open(const void* data, std::size_t bytes) = 0; // reads image from memory
virtual bool alpha_channel() const = 0;
virtual bool empty() const = 0;

10
include/nana/paint/detail/image_processor.hpp
View File

@ -330,19 +330,21 @@ namespace detail
}
const pixel_argb_t * s_end = s_rgb + rest;
auto rest_d_rgb = d_rgb;
for(auto i = s_rgb; i != s_end; ++i)
{
if(i->element.alpha_channel)
{
if(i->element.alpha_channel != 255)
{
d_rgb[3].element.red = unsigned(d_rgb[3].element.red * (255 - i->element.alpha_channel) + i->element.red * i->element.alpha_channel) / 255;
d_rgb[3].element.green = unsigned(d_rgb[3].element.green * (255 - i->element.alpha_channel) + i->element.green * i->element.alpha_channel) / 255;
d_rgb[3].element.blue = unsigned(d_rgb[3].element.blue * (255 - i->element.alpha_channel) + i->element.blue * i->element.alpha_channel) / 255;
rest_d_rgb->element.red = unsigned(rest_d_rgb->element.red * (255 - i->element.alpha_channel) + i->element.red * i->element.alpha_channel) / 255;
rest_d_rgb->element.green = unsigned(rest_d_rgb->element.green * (255 - i->element.alpha_channel) + i->element.green * i->element.alpha_channel) / 255;
rest_d_rgb->element.blue = unsigned(rest_d_rgb->element.blue * (255 - i->element.alpha_channel) + i->element.blue * i->element.alpha_channel) / 255;
}
else
d_rgb[3] = *i;
*rest_d_rgb = *i;
}
++rest_d_rgb;
}
d_rgb = pixel_at(d_rgb, d_step_bytes);
s_rgb = pixel_at(s_rgb, s_step_bytes);

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

@ -13,10 +13,11 @@
#ifndef NANA_PAINT_GRAPHICS_HPP
#define NANA_PAINT_GRAPHICS_HPP
#include <memory>
#include "../basic_types.hpp"
#include "../gui/basis.hpp"
#include "pixel_buffer.hpp"
#include <memory>
namespace nana
{
@ -111,6 +112,7 @@ namespace nana
void bitblt(const ::nana::rectangle& r_dst, const graphics& src); ///< Transfers the color data corresponding to r_dst from the src graphics to this graphics.
void bitblt(const ::nana::rectangle& r_dst, const graphics& src, const point& p_src);///< Transfers the color data corresponding to r_dst from the src graphics at point p_src to this graphics.
void blend(const ::nana::rectangle& r, const ::nana::color&, double fade_rate);
void blend(const ::nana::rectangle& s_r, graphics& dst, const point& d_pos, double fade_rate) const;///< blends with the dst object.
void blur(const ::nana::rectangle& r, std::size_t radius); ///< Blur process.
@ -144,8 +146,6 @@ namespace nana
unsigned bidi_string(const nana::point&, const wchar_t *, std::size_t len);
unsigned bidi_string(const point& pos, const char*, std::size_t len);
void blend(const ::nana::rectangle& r, const ::nana::color&, double fade_rate);
void set_pixel(int x, int y, const ::nana::color&);
void set_pixel(int x, int y);
@ -167,6 +167,7 @@ namespace nana
void rectangle(const ::nana::rectangle&, bool solid);
void rectangle(const ::nana::rectangle&, bool solid, const color&);
void frame_rectangle(const ::nana::rectangle&, const color& left, const color& top, const color& right, const color& bottom);
void frame_rectangle(const ::nana::rectangle&, const color&, unsigned gap);
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);

1
include/nana/paint/pixel_buffer.hpp
View File

@ -75,6 +75,7 @@ namespace nana{ namespace paint
void blend(const nana::rectangle& s_r, drawable_type dw_dst, const nana::point& d_pos, double fade_rate) const;
void blur(const nana::rectangle& r, std::size_t radius);
pixel_buffer rotate(double angle, const color& extend_color);
private:
std::shared_ptr<pixel_buffer_storage> storage_;
};

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

@ -9,7 +9,7 @@ namespace nana
class text_renderer
{
public:
typedef graphics & graph_reference;
using graph_reference = graphics &;
text_renderer(graph_reference graph, align = align::left);
@ -22,6 +22,35 @@ namespace nana
graph_reference graph_;
align text_align_;
};
/// Draw aligned string
class aligner
{
public:
using graph_reference = graphics&;
/// Constructor
/**
* @param graph Reference to a graphics object
* @param text_align Alignment of text
* @param text_align_if_too_long Alignment of text if the pixels of string is larger than text area
*/
aligner(graph_reference graph, align text_align = align::left);
aligner(graph_reference graph, align text_align, align text_align_if_too_long);
/// Draws a text with specified text alignment.
/**
* @param text Text to draw
* @param pos Postion where the text to draw
* @param width The width of text area. If the pixels of text is larger than this parameter, it draws ellipsis
*/
void draw(const std::string& text, point pos, unsigned width);
void draw(const std::wstring& text, point pos, unsigned width);
private:
graph_reference graph_;
align text_align_;
align text_align_ex_;
};
}
}

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

@ -13,6 +13,7 @@
#ifndef NANA_PAT_CLONEABLE_HPP
#define NANA_PAT_CLONEABLE_HPP
#include <nana/push_ignore_diagnostic>
#include <nana/c++defines.hpp>
#include <cstddef>
#include <type_traits>
@ -97,9 +98,7 @@ namespace nana{ namespace pat{
typedef int inner_bool::* operator_bool_t;
template<typename U>
struct member_enabled
: public std::enable_if<(!std::is_base_of<cloneable, typename std::remove_reference<U>::type>::value) && std::is_base_of<base_t, typename std::remove_reference<U>::type>::value, int>
{};
using member_enabled = std::enable_if<(!std::is_base_of<cloneable, typename std::remove_reference<U>::type>::value) && std::is_base_of<base_t, typename std::remove_reference<U>::type>::value, int>;
public:
cloneable() noexcept = default;
@ -207,5 +206,5 @@ namespace nana{ namespace pat{
using mutable_cloneable = cloneable<T, true>;
}//end namespace pat
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif

5
include/nana/pop_ignore_diagnostic Normal file
View File

@ -0,0 +1,5 @@
#if (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 6)
# pragma GCC diagnostic pop
#endif

4
include/nana/push_ignore_diagnostic Normal file
View File

@ -0,0 +1,4 @@
#if (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 6)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Weffc++"
#endif

6
include/nana/std_mutex.hpp
View File

@ -8,12 +8,12 @@
#include <windows.h>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <pthread.h>
//#include <thread>
//#include <pthread.h>
#include <errno.h>
#include <cstdio>
// http://lxr.free-electrons.com/source/include/uapi/asm-generic/errno.h#L53
#define EPROTO 71 /* Protocol error */
//#define EPROTO 71 /* Protocol error */
#include <mingw.thread.h>
#include <mingw.mutex.h>
#else

7
include/nana/std_thread.hpp
View File

@ -5,6 +5,7 @@
#if defined(STD_THREAD_NOT_SUPPORTED)
#if defined(NANA_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
#include <mingw.thread.h>
#else
#include <boost/thread.hpp>
@ -13,5 +14,11 @@ namespace std
typedef boost::thread thread;
}
#endif // (NANA_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ)
#else
#include <thread>
#endif // (STD_THREAD_NOT_SUPPORTED)
#endif // NANA_STD_THREAD_HPP

2
include/nana/system/shared_wrapper.hpp
View File

@ -30,7 +30,7 @@ namespace system
typedef void* module_t;
void* symbols(module_t handle, const char* symbol);
}; //end struct shared_helper
} //end namespace shared_helper
}//end namespace detail
class shared_wrapper

5
include/nana/unicode_bidi.hpp
View File

@ -1,6 +1,8 @@
#ifndef NANA_UNICODE_BIDI_HPP
#define NANA_UNICODE_BIDI_HPP
#include <vector>
#include <nana/push_ignore_diagnostic>
namespace nana
{
@ -60,7 +62,7 @@ namespace nana
void _m_resolve_weak_types();
void _m_resolve_neutral_types();
void _m_resolve_implicit_levels();
void _m_reordering_resolved_levels(const char_type*, std::vector<entity> & reordered);
void _m_reordering_resolved_levels(std::vector<entity> & reordered);
static bidi_category _m_bidi_category(bidi_char);
static bidi_char _m_char_dir(char_type);
private:
@ -71,5 +73,6 @@ namespace nana
};
}
#include <nana/pop_ignore_diagnostic>
#endif

105
include/nana/verbose_preprocessor.hpp
View File

@ -11,8 +11,8 @@
*
* @brief show the values of configuration constants during compilation to facilitate build debugging.
*
* Set VERBOSE_PREPROCESSOR to 1 to show the messages or to 0 for a normal build.
* Normally set to 0. Set to 1 only in case you want to debug the build system because it is extremely repetitive and slow.
* Define VERBOSE_PREPROCESSOR to show the messages or undefine for a normal build.
* Normally undefined. Define in case you want to debug the build system.
*
* @authors Ariel Vina-Rodriguez (qPCR4vir)
*
@ -25,25 +25,107 @@
#if defined(VERBOSE_PREPROCESSOR)
#include <nana/config.hpp>
#include <nana/deploy.hpp>
#define STRING2(x) #x
#define STRING(x) STRING2(x)
#pragma message ( "\nVerbose preprocessor =" STRING(VERBOSE_PREPROCESSOR)" , \n STOP_VERBOSE_PREPROCESSOR=" STRING(STOP_VERBOSE_PREPROCESSOR) )
#define SHOW_VALUE(x) " " #x " = " STRING2(x)
#pragma message ( "\nWindows: \n _WIN32=" STRING(_WIN32) ", \n __WIN32__ =" STRING(__WIN32__) " , \n WIN32=" STRING(WIN32)" , \n NANA_WINDOWS=" STRING(NANA_WINDOWS) )
#pragma message ( "\n -----> Verbose preprocessor" )
#pragma message ( SHOW_VALUE(VERBOSE_PREPROCESSOR) )
#pragma message ( SHOW_VALUE(STOP_VERBOSE_PREPROCESSOR) )
#pragma message ( "\nUNICODE: \n NANA_UNICODE=" STRING(NANA_UNICODE) ", \n _UNICODE =" STRING(_UNICODE) " , \n UNICODE=" STRING(UNICODE) )
#pragma message ( "\n -----> OS: \n --Windows: " )
#pragma message ( SHOW_VALUE(_WIN32) )
#pragma message ( SHOW_VALUE(__WIN32__) )
#pragma message ( SHOW_VALUE(WIN32) )
#pragma message ( SHOW_VALUE(NANA_WINDOWS) )
#pragma message ( "\nMinGW: \n __MINGW32__=" STRING(__MINGW32__) ", \n __MINGW64__=" STRING(__MINGW64__) " , \n MINGW=" STRING(MINGW) )
#pragma message ( "\n ---NIX: " )
#pragma message ( SHOW_VALUE(NANA_LINUX) )
#pragma message ( SHOW_VALUE(NANA_POSIX) )
#pragma message ( SHOW_VALUE(NANA_X11) )
#pragma message ( SHOW_VALUE(APPLE) )
#pragma message ( SHOW_VALUE(NANA_IGNORE_CONF) )
#pragma message ( "\nGNU: \n __GNUC__=" STRING(__GNUC__) ", \n __GNUC_MINOR__=" STRING(__GNUC_MINOR__) " , \n __GNUC_PATCHLEVEL__=" STRING(__GNUC_PATCHLEVEL__) )
#pragma message ( "\nSTD: \nSTD_CODECVT_NOT_SUPPORTED=" STRING(STD_CODECVT_NOT_SUPPORTED) " , \nSTD_THREAD_NOT_SUPPORTED=" STRING(STD_THREAD_NOT_SUPPORTED) )
#pragma message ( "\n -----> Compilers: \n MinGW: " )
#pragma message ( SHOW_VALUE(__MINGW32__) )
#pragma message ( SHOW_VALUE(__MINGW64__) )
#pragma message ( SHOW_VALUE(MINGW) )
#pragma message ( "\nSTD: \nUSE_github_com_meganz_mingw_std_threads=" STRING(USE_github_com_meganz_mingw_std_threads) " , \nSTD_THREAD_NOT_SUPPORTED=" STRING(STD_THREAD_NOT_SUPPORTED) )
#pragma message ( "\n ---MSC: " )
#pragma message ( SHOW_VALUE(_MSC_VER) )
#pragma message ( SHOW_VALUE(_MSC_FULL_VER) )
#pragma message ( "\nClang compiler: \n__clang__=" STRING(__clang__) ", \n__GLIBCPP__=" STRING(__GLIBCPP__) " , \n__GLIBCXX__=" STRING(__GLIBCXX__) )
#pragma message ( "\n ---GNU: " )
#pragma message ( SHOW_VALUE(__GNUC__) )
#pragma message ( SHOW_VALUE(__GNUC_MINOR__) )
#pragma message ( SHOW_VALUE(__GNUC_PATCHLEVEL__) )
#pragma message ( "\nMSC: \n_MSC_VER=" STRING(_MSC_VER) ", \n_MSC_FULL_VER=" STRING(_MSC_FULL_VER ) )
#pragma message ( "\n ---Clang compiler: " )
#pragma message ( SHOW_VALUE(__clang__) )
#pragma message ( SHOW_VALUE(__GLIBCPP__) )
#pragma message ( SHOW_VALUE(__GLIBCXX__) )
#pragma message ( "\n -----> STD: " )
#pragma message ( SHOW_VALUE(STD_CODECVT_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_THREAD_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_NUMERIC_CONVERSIONS_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_TO_STRING_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_TO_WSTRING_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(USE_github_com_meganz_mingw_std_threads) )
#pragma message ( SHOW_VALUE(NANA_ENABLE_MINGW_STD_THREADS_WITH_MEGANZ) )
#pragma message ( SHOW_VALUE(STD_THREAD_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_put_time_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_MAKE_UNIQUE_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_FILESYSTEM_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(BOOST_FILESYSTEM_AVAILABLE) )
#pragma message ( SHOW_VALUE(BOOST_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(STD_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(NANA_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(CXX_NO_INLINE_NAMESPACE) )
//#pragma message ( SHOW_VALUE(__has_include) )
#pragma message ( SHOW_VALUE(__cpp_lib_experimental_filesystem) )
#pragma message ( SHOW_VALUE(NANA_USING_NANA_FILESYSTEM) )
#pragma message ( SHOW_VALUE(NANA_USING_STD_FILESYSTEM) )
#pragma message ( SHOW_VALUE(NANA_USING_BOOST_FILESYSTEM) )
#pragma message ( "\n#include <nana/filesystem/filesystem.hpp> " )
#include <nana/filesystem/filesystem.hpp>
#pragma message ( SHOW_VALUE(STD_MAKE_UNIQUE_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(STD_FILESYSTEM_NOT_SUPPORTED) )
#pragma message ( SHOW_VALUE(BOOST_FILESYSTEM_AVAILABLE) )
#pragma message ( SHOW_VALUE(BOOST_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(STD_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(NANA_FILESYSTEM_FORCE) )
#pragma message ( SHOW_VALUE(CXX_NO_INLINE_NAMESPACE) )
//#pragma message ( SHOW_VALUE(__has_include) )
#pragma message ( SHOW_VALUE(__cpp_lib_experimental_filesystem) )
#pragma message ( SHOW_VALUE(NANA_USING_NANA_FILESYSTEM) )
#pragma message ( SHOW_VALUE(NANA_USING_STD_FILESYSTEM) )
#pragma message ( SHOW_VALUE(NANA_USING_BOOST_FILESYSTEM) )
#pragma message ( SHOW_VALUE(NANA_UNICODE) )
#pragma message ( SHOW_VALUE(_UNICODE) )
#pragma message ( SHOW_VALUE(UNICODE) )
#pragma message ( "\n -----> Libraries: " )
#pragma message ( SHOW_VALUE(NANA_ENABLE_AUDIO) )
#pragma message ( SHOW_VALUE(NANA_ENABLE_PNG) )
#pragma message ( SHOW_VALUE(USE_LIBPNG_FROM_OS) )
#pragma message ( SHOW_VALUE(NANA_LIBPNG) )
#pragma message ( SHOW_VALUE(NANA_ENABLE_JPEG) )
#pragma message ( SHOW_VALUE(USE_LIBJPEG_FROM_OS) )
#pragma message ( SHOW_VALUE(NANA_LIBJPEG) )
// #pragma message ( "\n =" STRING() ", \n =" STRING()" , \n =" STRING() )
#if defined(STOP_VERBOSE_PREPROCESSOR)
#error ("\nCompilation stopped to avoid annoying messages")
@ -52,5 +134,4 @@
#endif // VERBOSE_PREPROCESSOR
#endif //NANA_VERBOSE_PREPROCESSOR_H

5
source/audio/player.cpp
View File

@ -1,5 +1,8 @@
#include <nana/push_ignore_diagnostic>
#include <nana/audio/player.hpp>
#ifdef NANA_ENABLE_AUDIO
#include <nana/audio/detail/audio_stream.hpp>
@ -67,4 +70,4 @@ namespace nana{ namespace audio
}//end namespace audio
}//end namespace nana
#endif //NANA_ENABLE_AUDIO
#endif //NANA_ENABLE_AUDIO

165
source/basic_types.cpp
View File

@ -528,124 +528,25 @@ namespace nana
return (px_color().value != other.px_color().value);
}
color operator+(const color& x, const color& y)
{
double a = x.a_ + y.a_;
auto r = static_cast<unsigned>(x.r_ + y.r_);
auto g = static_cast<unsigned>(x.g_ + y.g_);
auto b = static_cast<unsigned>(x.b_ + y.b_);
return color{
r > 255 ? 255 : r,
g > 255 ? 255 : g,
b > 255 ? 255 : b,
a > 1.0 ? 1.0 : a };
}
//end class color
//struct point
point::point():x(0), y(0){}
point::point(int x, int y):x(x), y(y){}
point::point(const rectangle& r)
: x(r.x), y(r.y)
{}
point& point::operator=(const rectangle& r)
{
x = r.x;
y = r.y;
return *this;
}
bool point::operator==(const point& rhs) const
{
return ((x == rhs.x) && (y == rhs.y));
}
bool point::operator!=(const point& rhs) const
{
return ((x != rhs.x) || (y != rhs.y));
}
bool point::operator<(const point& rhs) const
{
return ((y < rhs.y) || (y == rhs.y && x < rhs.x));
}
bool point::operator<=(const point& rhs) const
{
return ((y < rhs.y) || (y == rhs.y && x <= rhs.x));
}
bool point::operator>(const point& rhs) const
{
return ((y > rhs.y) || (y == rhs.y && x > rhs.x));
}
bool point::operator>=(const point& rhs) const
{
return ((y > rhs.y) || (y == rhs.y && x >= rhs.x));
}
point point::operator-(const point& rhs) const
{
return{x - rhs.x, y - rhs.y};
}
point point::operator+(const point& rhs) const
{
return{ x + rhs.x, y + rhs.y };
}
point& point::operator-=(const point& rhs)
{
x -= rhs.x;
y -= rhs.y;
return *this;
}
point& point::operator+=(const point& rhs)
{
x += rhs.x;
y += rhs.y;
return *this;
}
//end struct point
//struct upoint
upoint::upoint():x(0), y(0){}
upoint::upoint(unsigned x, unsigned y):x(x), y(y){}
bool upoint::operator==(const upoint& rhs) const
{
return ((x == rhs.x) && (y == rhs.y));
}
bool upoint::operator!=(const upoint& rhs) const
{
return ((x != rhs.x) || (y != rhs.y));
}
bool upoint::operator<(const upoint& rhs) const
{
return ((y < rhs.y) || (y == rhs.y && x < rhs.x));
}
bool upoint::operator<=(const upoint& rhs) const
{
return ((y < rhs.y) || (y == rhs.y && x <= rhs.x));
}
bool upoint::operator>(const upoint& rhs) const
{
return ((y > rhs.y) || (y == rhs.y && x > rhs.x));
}
bool upoint::operator>=(const upoint& rhs) const
{
return ((y > rhs.y) || (y == rhs.y && x >= rhs.x));
}
//end struct upoint
//struct size
size::size():width(0), height(0){}
size::size(value_type width, value_type height) : width(width), height(height){}
size::size(const rectangle& r)
: width(r.width), height(r.height)
{}
size& size::operator=(const rectangle& r)
{
width = r.width;
height = r.height;
return *this;
}
bool size::empty() const
{
@ -657,6 +558,12 @@ namespace nana
return (0 <= pos.x && pos.x < static_cast<int>(width) && 0 <= pos.y && pos.y < static_cast<int>(height));
}
size& size::shift()
{
std::swap(width, height);
return *this;
}
bool size::operator==(const size& rhs) const
{
return (width == rhs.width) && (height == rhs.height);
@ -700,33 +607,38 @@ namespace nana
return (width != rhs.width) || (height != rhs.height) || (x != rhs.x) || (y != rhs.y);
}
rectangle & rectangle::operator=(const point& pos)
point rectangle::position() const noexcept
{
x = pos.x;
y = pos.y;
return{ x, y };
}
rectangle& rectangle::position(const point& p) noexcept
{
x = p.x;
y = p.y;
return *this;
}
rectangle & rectangle::operator=(const size & sz)
size rectangle::dimension() const noexcept
{
return{width, height};
}
rectangle& rectangle::dimension(const size& sz) noexcept
{
width = sz.width;
height = sz.height;
return *this;
}
rectangle& rectangle::set_pos(const point& pos)
{
x = pos.x;
y = pos.y;
return *this;
}
/*
rectangle& rectangle::set_size(const size& sz)
{
width = sz.width;
height = sz.height;
return *this;
}
*/
rectangle& rectangle::pare_off(int pixels)
{
@ -763,6 +675,13 @@ namespace nana
{
return (0 == width) || (0 == height);
}
rectangle& rectangle::shift()
{
std::swap(x, y);
std::swap(width, height);
return *this;
}
//end struct rectangle
//class rectangle_rotator

174
source/charset.cpp
View File

@ -1,4 +1,4 @@
/*
/**
* A Character Encoding Set Implementation
* Nana C++ Library(http://www.nanapro.org)
* Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
@ -7,9 +7,9 @@
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* @file: nana/charset.cpp
* @brief: A conversion between unicode characters and multi bytes characters
* @contributions:
* @file nana/charset.cpp
* @brief A conversion between unicode characters and multi bytes characters
* @contributions
* UTF16 4-byte decoding issue by Renke Yan.
* Pr0curo(pr#98)
*/
@ -20,6 +20,7 @@
#include <cwchar>
#include <clocale>
#include <cstring> //Added by Pr0curo(pr#98)
#include <memory>
//GCC 4.7.0 does not implement the <codecvt> and codecvt_utfx classes
#ifndef STD_CODECVT_NOT_SUPPORTED
@ -34,6 +35,7 @@ namespace nana
{
namespace utf
{
/// return a pointer to the code unit of the character at pos
const char* char_ptr(const char* text, unsigned pos)
{
auto ustr = reinterpret_cast<const unsigned char*>(text);
@ -48,10 +50,10 @@ namespace nana
continue;
}
if (uch < 0xC0)
if (uch < 0xC0) // use police ?
return nullptr;
if ((uch < 0xE0) && (ustr + 1 < end))
if ((uch < 0xE0) && (ustr + 1 < end)) //? *(ustr + 1) < 0xE0
ustr += 2;
else if (uch < 0xF0 && (ustr + 2 <= end))
ustr += 3;
@ -64,6 +66,7 @@ namespace nana
return reinterpret_cast<const char*>(ustr);
}
/// return a pointer to the code unit of the character at pos - reuse ^ ?
const char* char_ptr(const std::string& text_utf8, unsigned pos)
{
auto ustr = reinterpret_cast<const unsigned char*>(text_utf8.c_str());
@ -94,6 +97,7 @@ namespace nana
return reinterpret_cast<const char*>(ustr);
}
/// return a code point (max 16 bits?) and the len in code units of the character at pos
wchar_t char_at(const char* text_utf8, unsigned pos, unsigned * len)
{
if (!text_utf8)
@ -112,10 +116,10 @@ namespace nana
if (len)
*len = 1;
return *text_utf8;
return *text_utf8; // uch ?
}
if (uch < 0xC0)
if (uch < 0xC0) // use police or ??
{
if (len)
*len = 0;
@ -151,6 +155,7 @@ namespace nana
return 0;
}
/// return a code point (max 16 bits?) and the len in code units of the character at pos
wchar_t char_at(const ::std::string& text_utf8, unsigned pos, unsigned * len)
{
const char* ptr;
@ -210,22 +215,23 @@ namespace nana
}
namespace detail
{
{
/// candidate to be more general??
class locale_initializer
{
public:
static void init()
{
static bool initialized = false;
if(false == initialized)
{
initialized = true;
//Only set the C library locale
std::setlocale(LC_CTYPE, "");
}
if (initialized) return;
initialized = true;
//Only set the C library locale
std::setlocale(LC_CTYPE, "");
}
};
/// convert wchar C string from ? ANSI code page CP_ACP (windows) or LC_CTYPE c locale (-nix) into utf8 std::string
bool wc2mb(std::string& mbstr, const wchar_t * s)
{
if(nullptr == s || *s == 0)
@ -258,7 +264,8 @@ namespace nana
#endif
return true;
}
/// convert a char C-string from The system default Windows ANSI code page CP_ACP or from LC_CTYPE c locale (-nix) into utf16 std::wstring
bool mb2wc(std::wstring& wcstr, const char* s)
{
if(nullptr == s || *s == 0)
@ -291,6 +298,7 @@ namespace nana
return true;
}
/// convert a char C string from The system default Windows ANSI code page CP_ACP or LC_CTYPE c locale (-nix) into utf16 std::string
bool mb2wc(std::string& wcstr, const char* s)
{
if(nullptr == s || *s == 0)
@ -304,6 +312,7 @@ namespace nana
{
wcstr.resize((chars - 1) * sizeof(wchar_t));
::MultiByteToWideChar(CP_ACP, 0, s, -1, reinterpret_cast<wchar_t*>(&wcstr[0]), chars - 1);
// ^ the trick !
}
#else
locale_initializer::init();
@ -338,17 +347,98 @@ namespace nana
virtual std::wstring&& wstr_move() = 0;
};
/// playing with the idea - we need a mechanisme to set a user selected police - Testing an abtract interphase
struct encoding_error_police
{
virtual unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* end) = 0;
virtual ~encoding_error_police() = default;
};
/// the current nana default: it is safe - you may want to keep it ! use the other at your risk: mainly for debugging
struct utf8_error_police : public encoding_error_police
{
unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* end) override
{
current_code_unit = end;
return 0;
}
};
///
struct utf8_error_police_def_char : public encoding_error_police
{
static unsigned long def_error_mark ;
unsigned long error_mark{ def_error_mark };
utf8_error_police_def_char() = default;
utf8_error_police_def_char( unsigned long mark): error_mark{mark}{}
unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* end) override
{
if(current_code_unit < end)
++current_code_unit;
return error_mark;
}
};
unsigned long utf8_error_police_def_char::def_error_mark{ '*' };
///
struct utf8_error_police_throw : public encoding_error_police
{
unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* end) override
{
//utf8_Error::use_throw = true;
utf8_Error(std::string("The text is not encoded in UTF8: ") +
reinterpret_cast<const char*>( current_code_unit) ).emit();;
current_code_unit = end;
return 0;
}
};
struct utf8_error_police_latin : public encoding_error_police
{
unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* /*end*/) override
{
return *(current_code_unit++) ;
}
};
/// buggie?
struct utf8_error_police_system : public encoding_error_police
{
unsigned long next_code_point(const unsigned char*& current_code_unit, const unsigned char* /*end*/) override
{
std::wstring wc;
mb2wc(wc, reinterpret_cast<const char*>(current_code_unit));
current_code_unit++;
return wc[0]; // use utf16char but what endian?
}
};
// auto def_encoding_error_police = std::make_unique<utf8_error_police>(); // the nana default
// auto def_encoding_error_police = std::make_unique<utf8_error_police_latin>();
// auto def_encoding_error_police = std::make_unique<utf8_error_police_throw>();
// auto def_encoding_error_police = std::make_unique<utf8_error_police_def_char>('X');
auto def_encoding_error_police = std::make_unique<utf8_error_police_system>();
#ifndef STD_CODECVT_NOT_SUPPORTED
class charset_string
: public charset_encoding_interface
{
public:
charset_string(const std::string& s)
: data_(s), is_unicode_(false)
: data_(s)
{}
charset_string(std::string&& s)
: data_(std::move(s)), is_unicode_(false)
: data_(std::move(s))
{}
charset_string(const std::string& s, unicode encoding)
@ -501,9 +591,9 @@ namespace nana
}
private:
std::string data_;
std::wstring wdata_for_move_;
bool is_unicode_;
unicode utf_x_;
std::wstring wdata_for_move_{};
bool is_unicode_{ false };
unicode utf_x_{ unicode::utf8 };
};
class charset_wstring
@ -578,37 +668,42 @@ namespace nana
std::string data_for_move_;
};
#else
/// return the first code point and move the pointer to next character, springing to the end by errors
unsigned long utf8char(const unsigned char*& p, const unsigned char* end)
{
if(p != end)
{
if(*p < 0x80)
if(*p < 0x80) // ASCII char 0-127 or 0-0x80
{
return *(p++);
}
unsigned ch = *p;
unsigned long code;
if(ch < 0xC0)
if(ch < 0xC0) // error? - move to end. Posible ANSI or ISO code-page
{
p = end;
return 0;
//return *(p++); // temp: assume equal
//p = end;
//return 0;
return def_encoding_error_police->next_code_point(p, end);
}
else if(ch < 0xE0 && (p + 1 <= end))
else if(ch < 0xE0 && (p + 1 <= end)) // two byte chararcter
{
code = ((ch & 0x1F) << 6) | (p[1] & 0x3F);
p += 2;
}
else if(ch < 0xF0 && (p + 2 <= end))
else if(ch < 0xF0 && (p + 2 <= end)) // 3 byte character
{
code = ((((ch & 0xF) << 6) | (p[1] & 0x3F)) << 6) | (p[2] & 0x3F);
p += 3;
}
else if(ch < 0x1F && (p + 3 <= end))
else if(ch < 0x1F && (p + 3 <= end)) // 4 byte character
{
code = ((((((ch & 0x7) << 6) | (p[1] & 0x3F)) << 6) | (p[2] & 0x3F)) << 6) | (p[3] & 0x3F);
p += 4;
}
else
else // error, go to end
{
p = end;
return 0;
@ -950,11 +1045,11 @@ namespace nana
{
public:
charset_string(const std::string& s)
: data_(s), is_unicode_(false)
: data_(s)
{}
charset_string(std::string&& s)
: data_(std::move(s)), is_unicode_(false)
: data_(std::move(s))
{}
charset_string(const std::string& s, unicode encoding)
@ -1067,12 +1162,21 @@ namespace nana
{
switch(encoding)
{
#if defined(NANA_WINDOWS)
case unicode::utf8:
return utf16_to_utf8(wcstr);
case unicode::utf32:
return utf16_to_utf32(wcstr);
case unicode::utf16:
return wcstr;
#else //POSIX
case unicode::utf8:
return utf32_to_utf8(wcstr);
case unicode::utf16:
return utf32_to_utf16(wcstr);
case unicode::utf32:
return wcstr;
#endif
}
}
return {};
@ -1122,9 +1226,9 @@ namespace nana
}
private:
std::string data_;
std::wstring wdata_for_move_;
bool is_unicode_;
unicode utf_x_;
std::wstring wdata_for_move_{};
bool is_unicode_{ false };
unicode utf_x_{ unicode::utf8 };
};
@ -1195,7 +1299,7 @@ namespace nana
}
private:
std::wstring data_;
std::string data_for_move_;
std::string data_for_move_{};
};
#endif
}

67
source/datetime.cpp
View File

@ -17,62 +17,65 @@
#include <cassert>
namespace {
void localtime(struct tm& tm)
std::tm localtime()
{
#if defined(NANA_WINDOWS) && !defined(NANA_MINGW)
time_t t;
::time(&t);
std::tm tm;
if(localtime_s(&tm, &t) != 0)
{
assert(false);
}
return tm;
#else
time_t t = std::time(nullptr);
struct tm * tm_addr = std::localtime(&t);
assert(tm_addr);
tm = *tm_addr;
return *tm_addr;
#endif
}
::nana::date::value to_dateval(const std::tm& t)
{
return {static_cast<unsigned>(t.tm_year + 1900), static_cast<unsigned>(t.tm_mon + 1), static_cast<unsigned>(t.tm_mday)};
}
::nana::time::value to_timeval(const std::tm& t)
{
return {static_cast<unsigned>(t.tm_hour), static_cast<unsigned>(t.tm_min), static_cast<unsigned>(t.tm_sec)};
}
} // namespace anonymous
namespace nana
{
//class date
//class date
void date::set(const std::tm& t)
{
value_.year = t.tm_year + 1900;
value_.month = t.tm_mon + 1;
value_.day = t.tm_mday;
value_ = to_dateval(t);
}
date::date()
: value_(to_dateval(localtime()))
{
struct tm t;
localtime(t);
set(t);
}
date::date(const std::tm& t)
: value_(to_dateval(t))
{
set(t);
}
date::date(int year, int month, int day)
: value_({static_cast<unsigned>(year), static_cast<unsigned>(month), static_cast<unsigned>(day)})
{
if(1601 <= year && year < 30827 && 0 < month && month < 13 && day > 0)
{
if(day <= static_cast<int>(date::month_days(year, month)))
{
value_.year = year;
value_.month = month;
value_.day = day;
return;
}
}
struct tm t;
localtime(t);
set(t);
set(localtime());
}
date date::operator - (int off) const
@ -258,39 +261,27 @@ namespace nana
//class time
void time::set(const std::tm& t)
{
value_.hour = t.tm_hour;
value_.minute = t.tm_min;
value_.second = t.tm_sec;
value_ = to_timeval(t);
}
time::time()
: value_(to_timeval(localtime()))
{
struct tm t;
localtime(t);
set(t);
}
time::time(const std::tm& t)
: value_(to_timeval(t))
{
value_.hour = t.tm_hour;
value_.minute = t.tm_min;
value_.second = t.tm_sec;
}
time::time(unsigned hour, unsigned minute, unsigned second)
: value_({hour, minute, second})
{
if(hour < 24 && minute < 60 && second < 62)
{
value_.hour = hour;
value_.minute = minute;
value_.second = second;
return;
}
struct tm t;
localtime(t);
set(t);
}
set(localtime());
}
const time::value& time::read() const
{
return value_;

123
source/deploy.cpp
View File

@ -436,9 +436,54 @@ namespace std
}
#endif
//#ifdef STD_put_time_NOT_SUPPORTED
#include <ctime>
#include <cwchar>
namespace std
{
//Workaround for no implemenation of std::put_time in gcc < 5.
/* std unspecified return type */
//template< class CharT, class RTSTR >// let fail for CharT != char / wchar_t
//RTSTR put_time(const std::tm* tmb, const CharT* fmt);
//template< >
std::string put_time/*<char, std::string>*/(const std::tm* tmb, const char* fmt)
{
std::size_t sz = 200;
std::string str(sz, '\0');
sz = std::strftime(&str[0], str.size() - 1, fmt, tmb);
str.resize(sz);
return str;
}
//Defined in header <ctime>
// std::size_t strftime(char* str, std::size_t count, const char* format, const std::tm* time);
//template<>
//std::wstring put_time<wchar_t, std::wstring>(const std::tm* tmb, const wchar_t* fmt)
//{
// unsigned sz = 200;
// std::wstring str(sz, L'\0');
// sz = std::wcsftime(&str[0], str.size() - 1, fmt, tmb);
// str.resize(sz);
// return str;
//}
// http://en.cppreference.com/w/cpp/chrono/c/wcsftime
// Defined in header <cwchar>
// std::size_t wcsftime(wchar_t* str, std::size_t count, const wchar_t* format, const std::tm* time);
// Converts the date and time information from a given calendar time time to a null - terminated
// wide character string str according to format string format.Up to count bytes are written.
// Parameters
// str - pointer to the first element of the wchar_t array for output
// count - maximum number of wide characters to write
// format - pointer to a null - terminated wide character string specifying the format of conversion.
}
//#endif // STD_put_time_NOT_SUPPORTED
#include <iostream>
namespace nana
{
bool is_utf8(const char* str, unsigned len)
bool is_utf8(const char* str, std::size_t len)
{
auto ustr = reinterpret_cast<const unsigned char*>(str);
auto end = ustr + len;
@ -455,38 +500,95 @@ namespace nana
if (uv < 0xC0)
return false;
if ((uv < 0xE0) && (ustr + 1 < end))
if ((uv < 0xE0) && (end - ustr > 1))
ustr += 2;
else if (uv < 0xF0 && (ustr + 2 <= end))
else if ((uv < 0xF0) && (end - ustr > 2))
ustr += 3;
else if (uv < 0x1F && (ustr + 3 <= end))
else if ((uv < 0x1F) && (end - ustr > 3))
ustr += 4;
else
return false;
}
return true;
}
//class utf8_Error
#if defined(_MSC_VER)
# if (_MSC_VER < 1900)
//A workaround for lack support of C++11 inheriting constructors for VC2013
utf8_Error::utf8_Error(const std::string& msg)
: std::runtime_error(msg)
{}
# endif
#endif
void utf8_Error::emit()
{
if (use_throw)
throw utf8_Error(*this);
std::cerr << what();
}
//bool utf8_Error::use_throw{true};
bool utf8_Error::use_throw{ false };
//end class utf8_Error
void throw_not_utf8(const std::string& text)
{
if (!is_utf8(text.c_str(), text.length()))
throw std::invalid_argument("The text is not encoded in UTF8");
return utf8_Error(std::string("\nThe text is not encoded in UTF8: ") + text).emit();
}
void throw_not_utf8(const char* text, unsigned len)
void throw_not_utf8(const char* text, std::size_t len)
{
if (!is_utf8(text, len))
throw std::invalid_argument("The text is not encoded in UTF8");
return utf8_Error(std::string("\nThe text is not encoded in UTF8: ") + std::string(text, len) ).emit();
//throw std::invalid_argument("The text is not encoded in UTF8");
}
void throw_not_utf8(const char* text)
{
if (!is_utf8(text, std::strlen(text)))
throw std::invalid_argument("The text is not encoded in UTF8");
return utf8_Error(std::string("\nThe text is not encoded in UTF8: ") + text).emit();
//throw std::invalid_argument("The text is not encoded in UTF8");
}
std::string recode_to_utf8(std::string no_utf8)
{
return nana::charset(std::move(no_utf8)).to_bytes(nana::unicode::utf8);
}
/// this text needed change, it needed review ??
bool review_utf8(const std::string& text)
{
if (!is_utf8(text.c_str(), text.length()))
{
utf8_Error(std::string("\nThe const text is not encoded in UTF8: ") + text).emit();
return true; /// it needed change, it needed review !!
}
else
return false;
}
/// this text needed change, it needed review ??
bool review_utf8(std::string& text)
{
if (!is_utf8(text.c_str(), text.length()))
{
utf8_Error(std::string("\nThe text is not encoded in UTF8: ") + text).emit();
text=recode_to_utf8(text);
return true; /// it needed change, it needed review !!
}
else
return false;
}
const std::string& to_utf8(const std::string& str)
{
return str;
@ -599,3 +701,6 @@ namespace nana
}
#if defined(VERBOSE_PREPROCESSOR)
# include <nana/verbose_preprocessor.hpp>
#endif

9
source/detail/platform_spec_posix.cpp
View File

@ -16,6 +16,9 @@
#include <nana/detail/platform_spec_selector.hpp>
#if defined(NANA_POSIX) && defined(NANA_X11)
#include <nana/push_ignore_diagnostic>
#include <X11/Xlocale.h>
#include <locale>
#include <map>
@ -432,13 +435,13 @@ namespace detail
platform_spec::instance().unlock_xlib();
}
int X11_error_handler(Display* disp, XErrorEvent* err)
int X11_error_handler(Display*, XErrorEvent* err)
{
platform_spec::instance().error_code = err->error_code;
return 0;
}
int X11_fatal_handler(Display* disp)
int X11_fatal_handler(Display*)
{
return 0;
}
@ -1414,4 +1417,6 @@ namespace detail
}
}//end namespace detail
}//end namespace nana
#include <nana/pop_ignore_diagnostic>
#endif //NANA_POSIX && NANA_X11

175
source/detail/platform_spec_windows.cpp
View File

@ -1,7 +1,7 @@
/*
/**
* Platform Specification 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
@ -9,7 +9,7 @@
*
* @file: nana/detail/platform_spec.cpp
*
* This file provides basis class and data structrue that required by nana
* @brief basis classes and data structures required by nana
*/
#include <nana/detail/platform_spec_selector.hpp>
@ -19,9 +19,172 @@
#include <shellapi.h>
#include <stdexcept>
#if defined(_MSC_VER)
#include <VersionHelpers.h>
#endif // _MSVC
///////////////////////////////////////////////////////////////////////////////////////////////////////
/******************************************************************
* *
* 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)
////////////////////////////////////////////////////////////////////////////////////////////////////
//#if defined(_MSC_VER)
////#include <VersionHelpers.h>
//bool IsWindowsVistaOrGreater() { return false; }
//bool //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;
//}
//
//
//
//#endif // _MSVC
namespace nana
{

16
source/detail/x11/msg_dispatcher.hpp
View File

@ -1,6 +1,6 @@
/*
* Message Dispatcher Implementation
* Copyright(C) 2003-2013 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
@ -164,7 +164,7 @@ namespace detail
private:
void _m_msg_driver()
{
int fd_X11 = ConnectionNumber(display_);
const int fd_X11 = ConnectionNumber(display_);
msg_packet_tag msg_pack;
XEvent event;
@ -177,6 +177,18 @@ namespace detail
if(pending)
{
::XNextEvent(display_, &event);
if(KeyRelease == event.type)
{
//Check whether the key is pressed, because X will send KeyRelease when pressing and
//holding a key if auto repeat is on.
char keymap[32];
::XQueryKeymap(display_, keymap);
if(keymap[event.xkey.keycode / 8] & (1 << (event.xkey.keycode % 8)))
continue;
}
if(::XFilterEvent(&event, None))
continue;
}

243
source/filesystem/filesystem.cpp
View File

@ -11,8 +11,11 @@
* provide some interface for file managment
*/
#include <nana/filesystem/filesystem.hpp>
#include <nana/filesystem/filesystem_ext.hpp>
#include <vector>
#include <sstream>
#include <iomanip> //put_time
#if defined(NANA_WINDOWS)
#include <windows.h>
@ -36,13 +39,134 @@
#include <stdlib.h>
#endif
namespace fs = std::experimental::filesystem;
namespace nana { namespace experimental {
#ifndef CXX_NO_INLINE_NAMESPACE
inline namespace v1 {
#endif
namespace filesystem
namespace nana
{
namespace filesystem_ext
{
fs::path path_user()
{
#if defined(NANA_WINDOWS)
wchar_t pstr[MAX_PATH];
if (SUCCEEDED(SHGetFolderPath(0, CSIDL_PROFILE, 0, SHGFP_TYPE_CURRENT, pstr)))
return pstr;
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
const char * pstr = ::getenv("HOME");
if (pstr)
return pstr;
#endif
return fs::path();
}
std::string pretty_file_size(const fs::path& path)
{
try {
auto bytes = fs::file_size(path);
const char * ustr[] = { " KB", " MB", " GB", " TB" };
std::stringstream ss;
if (bytes < 1024)
ss << bytes << " Bytes";
else
{
double cap = bytes / 1024.0;
std::size_t uid = 0;
while ((cap >= 1024.0) && (uid < sizeof(ustr) / sizeof(char *)))
{
cap /= 1024.0;
++uid;
}
ss << cap;
auto s = ss.str();
auto pos = s.find('.');
if (pos != s.npos)
{
if (pos + 2 < s.size())
s.erase(pos + 2);
}
return s + ustr[uid];
}
return ss.str();
}
catch (...) {}
return{};
}
std::string pretty_file_date(const fs::path& path) // todo: move to .cpp
{
try {
auto ftime = fs::last_write_time(path);
// crash: VS2015 will not read the time for some files (for example: C:/hiberfil.sys)
// and will return file_time_type(-1) without throwing
// https://msdn.microsoft.com/en-us/library/dn823784.aspx
if (ftime == ((fs::file_time_type::min)())) return{};
//std::time_t cftime = decltype(ftime)::clock::to_time_t(ftime);
//A workaround for VC2013
using time_point = decltype(ftime);
auto cftime = time_point::clock::to_time_t(ftime);
std::stringstream tm;
tm << std::put_time(std::localtime(&cftime), "%Y-%m-%d, %H:%M:%S");
return tm.str();
}
catch (...) {
return{};
}
}
bool modified_file_time(const fs::path& p, struct tm& t)
{
#if defined(NANA_WINDOWS)
WIN32_FILE_ATTRIBUTE_DATA attr;
if (::GetFileAttributesEx(p.c_str(), GetFileExInfoStandard, &attr))
{
FILETIME local_file_time;
if (::FileTimeToLocalFileTime(&attr.ftLastWriteTime, &local_file_time))
{
SYSTEMTIME st;
::FileTimeToSystemTime(&local_file_time, &st);
t.tm_year = st.wYear - 1900;
t.tm_mon = st.wMonth - 1;
t.tm_mday = st.wDay;
t.tm_wday = st.wDayOfWeek - 1;
t.tm_yday = nana::date::day_in_year(st.wYear, st.wMonth, st.wDay);
t.tm_hour = st.wHour;
t.tm_min = st.wMinute;
t.tm_sec = st.wSecond;
return true;
}
}
#elif defined(NANA_POSIX)
struct stat attr;
if (0 == ::stat(p.c_str(), &attr))
{
t = *(::localtime(&attr.st_ctime));
return true;
}
#endif
return false;
}
}
}
#if NANA_USING_NANA_FILESYSTEM
namespace nana_fs = nana::experimental::filesystem;
namespace nana { namespace experimental { namespace filesystem
{
#ifndef CXX_NO_INLINE_NAMESPACE
inline namespace v1 {
#endif
//class filesystem_error
filesystem_error::filesystem_error(const std::string& msg, std::error_code err)
: std::system_error(err, msg)
@ -59,12 +183,12 @@ namespace nana { namespace experimental {
path2_(path2)
{}
const path& filesystem_error::path1() const
const path& filesystem_error::path1() const noexcept
{
return path1_;
}
const path&filesystem_error::path2() const
const path& filesystem_error::path2() const noexcept
{
return path2_;
}
@ -110,7 +234,8 @@ namespace nana { namespace experimental {
return pathstr_.compare(p.pathstr_);
}
bool path::empty() const
/// true if the path is empty, false otherwise. ??
bool path::empty() const noexcept
{
#if defined(NANA_WINDOWS)
return (::GetFileAttributes(pathstr_.c_str()) == INVALID_FILE_ATTRIBUTES);
@ -122,24 +247,27 @@ namespace nana { namespace experimental {
path path::extension() const
{
// todo: make more globlal
#if defined(NANA_WINDOWS)
auto pos = pathstr_.find_last_of(L"\\/.");
auto SLorP=L"\\/.";
auto P=L'.';
#else
auto pos = pathstr_.find_last_of("\\/.");
auto SLorP="\\/.";
auto P='.';
#endif
if ((pos == pathstr_.npos) || (pathstr_[pos] != '.'))
return path();
auto pos = pathstr_.find_last_of(SLorP);
if (pos + 1 == pathstr_.size())
return path();
if ( ( pos == pathstr_.npos)
|| ( pathstr_[pos] != P )
|| ( pos + 1 == pathstr_.size() ))
return path();
return path(pathstr_.substr(pos));
}
path path::parent_path() const
{
return{filesystem::parent_path(pathstr_)};
return{nana_fs::parent_path(pathstr_)};
}
file_type path::what() const
@ -338,17 +466,17 @@ namespace nana { namespace experimental {
}
//class directory_entry
directory_entry::directory_entry(const filesystem::path& p)
directory_entry::directory_entry(const nana_fs::path& p)
:path_{ p }
{}
//modifiers
void directory_entry::assign(const filesystem::path& p)
void directory_entry::assign(const nana_fs::path& p)
{
path_ = p;
}
void directory_entry::replace_filename(const filesystem::path& p)
void directory_entry::replace_filename(const nana_fs::path& p)
{
path_ = path_.parent_path() / p;
}
@ -356,15 +484,15 @@ namespace nana { namespace experimental {
//observers
file_status directory_entry::status() const
{
return filesystem::status(path_);
return nana_fs::status(path_);
}
directory_entry::operator const filesystem::path&() const
{
return path_;
}
//directory_entry::operator const nana_fs::path&() const
//{
// return path_;
//}
const path& directory_entry::path() const
const nana_fs::path& directory_entry::path() const
{
return path_;
}
@ -384,7 +512,7 @@ namespace nana { namespace experimental {
}
};
directory_iterator::directory_iterator()
directory_iterator::directory_iterator() noexcept
: end_(true),
handle_(nullptr)
{}
@ -414,14 +542,10 @@ namespace nana { namespace experimental {
bool directory_iterator::equal(const directory_iterator& x) const
{
if (end_ && (end_ == x.end_)) return true;
return (value_.path().filename() == x.value_.path().filename());
return (value_.path().filename() == x.value_.path().filename());
}
// enable directory_iterator range-based for statements
directory_iterator directory_iterator::begin() { return *this; }
directory_iterator directory_iterator::end() { return{}; }
void directory_iterator::_m_prepare(const path& file_path)
{
path_ = file_path.native();
@ -751,41 +875,15 @@ namespace nana { namespace experimental {
#endif
}
bool modified_file_time(const path& p, struct tm& t)
file_time_type last_write_time(const path& p)
{
#if defined(NANA_WINDOWS)
WIN32_FILE_ATTRIBUTE_DATA attr;
if (::GetFileAttributesEx(p.c_str(), GetFileExInfoStandard, &attr))
{
FILETIME local_file_time;
if (::FileTimeToLocalFileTime(&attr.ftLastWriteTime, &local_file_time))
{
SYSTEMTIME st;
::FileTimeToSystemTime(&local_file_time, &st);
t.tm_year = st.wYear - 1900;
t.tm_mon = st.wMonth - 1;
t.tm_mday = st.wDay;
t.tm_wday = st.wDayOfWeek - 1;
t.tm_yday = nana::date::day_in_year(st.wYear, st.wMonth, st.wDay);
t.tm_hour = st.wHour;
t.tm_min = st.wMinute;
t.tm_sec = st.wSecond;
return true;
}
}
#elif defined(NANA_POSIX)
struct stat attr;
if (0 == ::stat(p.c_str(), &attr))
{
t = *(::localtime(&attr.st_ctime));
return true;
}
#endif
return false;
struct tm t;
nana::filesystem_ext::modified_file_time(p, t);
std::chrono::system_clock::time_point dateTime =std::chrono::system_clock::from_time_t( mktime(&t) );
return dateTime;
}
bool create_directory(const path& p)
{
#if defined(NANA_WINDOWS)
@ -806,6 +904,7 @@ namespace nana { namespace experimental {
bool remove(const path& p, std::error_code & ec)
{
ec.clear();
auto stat = status(p);
if (stat.type() == file_type::directory)
return detail::rm_dir(p);
@ -813,20 +912,6 @@ namespace nana { namespace experimental {
return detail::rm_file(p);
}
path path_user()
{
#if defined(NANA_WINDOWS)
wchar_t pstr[MAX_PATH];
if (SUCCEEDED(SHGetFolderPath(0, CSIDL_PROFILE, 0, SHGFP_TYPE_CURRENT, pstr)))
return pstr;
#elif defined(NANA_LINUX) || defined(NANA_MACOS)
const char * pstr = ::getenv("HOME");
if (pstr)
return pstr;
#endif
return path();
}
path current_path()
{
#if defined(NANA_WINDOWS)
@ -879,3 +964,5 @@ namespace nana { namespace experimental {
}//end namespace filesystem
} //end namespace experimental
}//end namespace nana
#endif

49
source/gui/basis.cpp
View File

@ -14,21 +14,38 @@
#include <nana/gui/basis.hpp>
namespace nana
using namespace nana;
using namespace nana::parameters;
//struct appearance
appearance::appearance()
:taskbar(true), floating(false), no_activate(false),
minimize(true), maximize(true), sizable(true),
decoration(true)
{}
appearance::appearance(bool has_decorate, bool taskbar, bool is_float, bool no_activate, bool min, bool max, bool sizable)
: taskbar(taskbar), floating(is_float), no_activate(no_activate),
minimize(min), maximize(max), sizable(sizable),
decoration(has_decorate)
{}
//end struct appearance
#if defined(NANA_WINDOWS)
# include <windows.h>
#endif
mouse_wheel::mouse_wheel()
: lines(3), characters(3)
{
//struct appearance
//@brief: Window appearance structure
appearance::appearance()
:taskbar(true), floating(false), no_activate(false),
minimize(true), maximize(true), sizable(true),
decoration(true)
{}
appearance::appearance(bool has_decorate, bool taskbar, bool is_float, bool no_activate, bool min, bool max, bool sizable)
: taskbar(taskbar), floating(is_float), no_activate(no_activate),
minimize(min), maximize(max), sizable(sizable),
decoration(has_decorate)
{}
//end struct appearance
}//end namespace nana
#if defined(NANA_WINDOWS)
// https://msdn.microsoft.com/en-us/library/ms997498.aspx
//#define SPI_SETWHEELSCROLLCHARS 0x006D
# ifndef SPI_GETWHEELSCROLLCHARS
# define SPI_GETWHEELSCROLLCHARS 0x006C
# endif
::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &lines, 0);
::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &characters, 0);
#endif
}

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

@ -17,226 +17,243 @@ namespace nana
{
namespace detail
{
//class caret_descriptor
caret_descriptor::caret_descriptor(core_window_t* wd, unsigned width, unsigned height)
:wd_(wd), size_(width, height), visible_state_(visible_state::invisible), out_of_range_(false)
//class caret
caret::caret(basic_window* owner, const size& size):
owner_(owner),
size_(size)
{}
caret_descriptor::~caret_descriptor()
caret::~caret()
{
if(wd_) native_interface::caret_destroy(wd_->root);
if (owner_)
native_interface::caret_destroy(owner_->root);
}
void caret_descriptor::set_active(bool active)
void caret::activate(bool activity)
{
if(wd_)
if (owner_)
{
if(active)
if (activity)
{
native_interface::caret_create(wd_->root, size_);
native_interface::caret_create(owner_->root, size_);
visible_state_ = visible_state::invisible;
this->position(point_.x, point_.y);
visibility_ = visible_state::invisible;
this->position(position_);
}
else
native_interface::caret_destroy(wd_->root);
native_interface::caret_destroy(owner_->root);
wd_->root_widget->other.attribute.root->ime_enabled = active;
owner_->root_widget->other.attribute.root->ime_enabled = activity;
}
}
auto caret_descriptor::window() const ->core_window_t*
basic_window* caret::owner() const noexcept
{
return wd_;
return owner_;
}
void caret_descriptor::position(int x, int y)
void caret::update()
{
point_.x = x;
point_.y = y;
auto pos = position_;
auto size = size_;
update();
}
void caret_descriptor::effective_range(nana::rectangle rect)
{
//Chech rect
if (rect.width && rect.height && rect.right() > 0 && rect.bottom() > 0)
{
if(rect.x < 0)
{
rect.width += rect.x;
rect.x = 0;
}
if(rect.y < 0)
{
rect.height += rect.y;
rect.y = 0;
}
if(effective_range_ != rect)
{
effective_range_ = rect;
update();
}
}
}
nana::point caret_descriptor::position() const
{
return point_;
}
void caret_descriptor::visible(bool is_show)
{
auto pre_displayed = (visible_state::displayed == visible_state_);
if (is_show)
{
visible_state_ = visible_state::visible;
if (wd_->displayed() && (! out_of_range_))
visible_state_ = visible_state::displayed;
}
else
visible_state_ = visible_state::invisible;
if (pre_displayed != (visible_state::displayed == visible_state_))
native_interface::caret_visible(wd_->root, !pre_displayed);
}
bool caret_descriptor::visible() const
{
return (visible_state::invisible != visible_state_);
}
nana::size caret_descriptor::size() const
{
return size_;
}
void caret_descriptor::size(const nana::size& s)
{
size_ = s;
update();
if (visible_state::invisible != visible_state_)
visible(true);
}
void caret_descriptor::update()
{
nana::point pos = point_;
nana::size size = size_;
nana::rectangle rect = effective_range_;
if(0 == effective_range_.width || 0 == effective_range_.height)
auto rect = effect_range_;
if (0 == effect_range_.width || 0 == effect_range_.height)
{
rect.x = rect.y = 0;
rect = wd_->dimension;
rect.dimension(owner_->dimension);
}
else
{
pos.x += effective_range_.x;
pos.y += effective_range_.y;
pos += effect_range_.position();
}
if( (pos.x + static_cast<int>(size.width) <= rect.x) || (pos.x >= rect.right()) ||
if ((pos.x + static_cast<int>(size.width) <= rect.x) || (pos.x >= rect.right()) ||
(pos.y + static_cast<int>(size.height) <= rect.y) || (pos.y >= rect.bottom())
)
{//Out of Range without overlap
if(false == out_of_range_)
if (false == out_of_range_)
{
out_of_range_ = true;
if (visible_state::invisible != visible_state_)
if (visible_state::invisible != visibility_)
visible(false);
}
}
else
{
if(pos.x < rect.x)
if (pos.x < rect.x)
{
size.width -= (rect.x - pos.x);
pos.x = rect.x;
}
else if(pos.x + static_cast<int>(size.width) > rect.right())
else if (pos.x + static_cast<int>(size.width) > rect.right())
{
size.width -= pos.x + size.width - rect.right();
}
if(pos.y < rect.y)
if (pos.y < rect.y)
{
size.width -= (rect.y - pos.y);
pos.y = rect.y;
}
else if(pos.y + static_cast<int>(size.height) > rect.bottom())
else if (pos.y + static_cast<int>(size.height) > rect.bottom())
size.height -= pos.y + size.height - rect.bottom();
if(out_of_range_)
if (out_of_range_)
{
if (paint_size_ == size)
if (visual_size_ == size)
visible(true);
out_of_range_ = false;
}
if(paint_size_ != size)
if (visual_size_ != size)
{
bool vs = (visible_state::invisible != visible_state_);
native_interface::caret_destroy(wd_->root);
native_interface::caret_create(wd_->root, size);
bool vs = (visible_state::invisible != visibility_);
native_interface::caret_destroy(owner_->root);
native_interface::caret_create(owner_->root, size);
visible_state_ = visible_state::invisible;
visibility_ = visible_state::invisible;
if (vs)
visible(true);
paint_size_ = size;
visual_size_ = size;
}
native_interface::caret_pos(wd_->root, wd_->pos_root + pos);
native_interface::caret_pos(owner_->root, owner_->pos_root + pos);
}
}
//end class caret_descriptor
//Implement caret_interface functions
void caret::disable_throw() noexcept
{
//This function is useless for class caret, see caret_proxy.
}
void caret::effective_range(const rectangle& r)
{
auto range = r;
//Chech rect
if (range.width && range.height && range.right() > 0 && range.bottom() > 0)
{
if (range.x < 0)
{
range.width += range.x;
range.x = 0;
}
if (range.y < 0)
{
range.height += range.y;
range.y = 0;
}
if (effect_range_ != range)
{
effect_range_ = range;
update();
}
}
}
void caret::position(const point& pos)
{
position_ = pos;
update();
}
point caret::position() const
{
return position_;
}
size caret::dimension() const
{
return size_;
}
void caret::dimension(const size& s)
{
size_ = s;
update();
if (visible_state::invisible != visibility_)
visible(true);
}
void caret::visible(bool visibility)
{
auto pre_displayed = (visible_state::displayed == visibility_);
if (visibility)
{
visibility_ = visible_state::visible;
if (owner_->displayed() && (!out_of_range_))
visibility_ = visible_state::displayed;
}
else
visibility_ = visible_state::invisible;
if (pre_displayed != (visible_state::displayed == visibility_))
native_interface::caret_visible(owner_->root, !pre_displayed);
}
bool caret::visible() const
{
return (visible_state::invisible != visibility_);
}
//end class caret
//struct basic_window
//struct basic_window::other_tag
basic_window::other_tag::other_tag(category::flags categ)
: category(categ), active_window(nullptr), upd_state(update_state::none)
{
#ifndef WIDGET_FRAME_DEPRECATED
switch(categ)
{
case category::root_tag::value:
case category::flags::root:
attribute.root = new attr_root_tag;
break;
case category::frame_tag::value:
case category::flags::frame:
attribute.frame = new attr_frame_tag;
break;
default:
attribute.root = nullptr;
}
#else
if (category::flags::root == categ)
attribute.root = new attr_root_tag;
else
attribute.root = nullptr;
#endif
}
basic_window::other_tag::~other_tag()
{
#ifndef WIDGET_FRAME_DEPRECATED
switch(category)
{
case category::root_tag::value:
case category::flags::root:
delete attribute.root;
break;
case category::frame_tag::value:
case category::flags::frame:
delete attribute.frame;
break;
default: break;
}
#endif
if (category::flags::root == category)
delete attribute.root;
}
//end struct basic_window::other_tag
//basic_window
//@brief: constructor for the root window
basic_window::basic_window(basic_window* owner, std::unique_ptr<widget_notifier_interface>&& wdg_notifier, category::root_tag**)
: widget_notifier(std::move(wdg_notifier)), other(category::root_tag::value)
: widget_notifier(std::move(wdg_notifier)), other(category::flags::root)
{
drawer.bind(this);
_m_init_pos_and_size(nullptr, rectangle());
@ -245,8 +262,8 @@ namespace nana
basic_window::~basic_window()
{
delete together.caret;
together.caret = nullptr;
delete annex.caret_ptr;
annex.caret_ptr = nullptr;
delete effect.bground;
effect.bground = nullptr;
@ -256,7 +273,7 @@ namespace nana
//@brief: bind a native window and baisc_window
void basic_window::bind_native_window(native_window_type wd, unsigned width, unsigned height, unsigned extra_width, unsigned extra_height, nana::paint::graphics& graphics)
{
if(category::root_tag::value == this->other.category)
if(category::flags::root == this->other.category)
{
this->root = wd;
dimension.width = width;
@ -268,11 +285,13 @@ namespace nana
}
}
#ifndef WIDGET_FRAME_DEPRECATED
void basic_window::frame_window(native_window_type wd)
{
if(category::frame_tag::value == this->other.category)
if(category::flags::frame == this->other.category)
other.attribute.frame->container = wd;
}
#endif
bool basic_window::is_ancestor_of(const basic_window* wd) const
{
@ -312,7 +331,7 @@ namespace nana
const basic_window* get_child_caret(const basic_window* wd, bool this_is_a_child)
{
if (this_is_a_child && wd->together.caret)
if (this_is_a_child && wd->annex.caret_ptr)
return wd;
for (auto child : wd->children)
@ -346,10 +365,16 @@ namespace nana
return anc;
}
void basic_window::set_action(mouse_action act)
{
flags.action_before = flags.action;
flags.action = act;
}
void basic_window::_m_init_pos_and_size(basic_window* parent, const rectangle& r)
{
pos_owner = pos_root = r;
dimension = r;
pos_owner = pos_root = r.position();
dimension = r.dimension();
if (parent)
pos_root += parent->pos_root;
@ -357,12 +382,12 @@ namespace nana
void basic_window::_m_initialize(basic_window* agrparent)
{
if(other.category == category::root_tag::value)
if(category::flags::root == other.category)
{
if(agrparent && (nana::system::this_thread_id() != agrparent->thread_id))
agrparent = nullptr;
while(agrparent && (agrparent->other.category != category::root_tag::value))
while(agrparent && (category::flags::root != agrparent->other.category))
agrparent = agrparent->parent;
owner = agrparent;
@ -390,6 +415,8 @@ namespace nana
flags.fullscreen = false;
flags.tab = nana::detail::tab_type::none;
flags.action = mouse_action::normal;
flags.action_before = mouse_action::normal;
flags.refreshing = false;
flags.destroying = false;
flags.borderless = false;
@ -404,8 +431,6 @@ namespace nana
effect.bground = nullptr;
effect.bground_fade_rate = 0;
together.caret = nullptr;
extra_width = extra_height = 0;
//The window must keep its thread_id same as its parent if it is a child.
@ -417,15 +442,15 @@ namespace nana
bool basic_window::set_events(const std::shared_ptr<general_events>& p)
{
if (together.events_ptr)
if (annex.events_ptr)
return false;
together.events_ptr = p;
annex.events_ptr = p;
return true;
}
general_events * basic_window::get_events() const
{
return together.events_ptr.get();
return annex.events_ptr.get();
}
//end struct basic_window
}//end namespace detail

Some files were not shown because too many files have changed in this diff Show More