New Version: 3.2.0

Using just 0 as prefix for octal number can lead to confusion
where numbers could be interpreted the wrong way (oct instead of
dec).
Lets follow the same convention as Python 3 and Ecma 262 level 6
and use '0o' as prefix which can not be confused inadvertently.

.gitignore

@@ -1,4 +1,5 @@
 .*
+*~
 Makefile
 *.o
 lib*.a

3rdparty/CMakeLists.txt

@@ -0,0 +1,4 @@
+if (NOT SYSTEM_EXPAT)
+	add_subdirectory(expat)
+endif()
+

3rdparty/expat/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+configure_file (
+    "${PROJECT_SOURCE_DIR}/3rdparty/expat/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/3rdparty/expat/expat_config.h"
+)
+
+set(expat_sources 
+	asciitab.h
+        hashtable.h
+        iasciitab.h
+        latin1tab.h
+        nametab.h
+        utf8tab.h
+        xmldef.h
+        xmlparse.h
+        xmlrole.h
+        xmltok.h
+        xmltok_impl.h
+        hashtable.c
+        xmlparse.c
+        xmlrole.c
+        xmltok.c
+        internal.h
+        ascii.h
+        sg_expat.h
+        sg_expat_external.h 
+	)
+
+foreach(s ${expat_sources})
+	set_property(GLOBAL
+		APPEND PROPERTY LOCAL_EXPAT_SOURCES 
+        "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+endforeach()

3rdparty/expat/sg_expat.h

@@ -15,7 +15,7 @@
 #endif
 
 #include <stdlib.h>
-#include "expat_external.h"
+#include "sg_expat_external.h"
 
 #ifdef __cplusplus
 extern "C" {

3rdparty/expat/xmlparse.c

@@ -23,7 +23,7 @@
 #endif /* ndef COMPILED_FROM_DSP */
 
 #include "ascii.h"
-#include "expat.h"
+#include "sg_expat.h"
 
 #ifdef XML_UNICODE
 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

3rdparty/expat/xmlrole.c

@@ -18,7 +18,7 @@
 #endif
 #endif /* ndef COMPILED_FROM_DSP */
 
-#include "expat_external.h"
+#include "sg_expat_external.h"
 #include "internal.h"
 #include "xmlrole.h"
 #include "ascii.h"

3rdparty/expat/xmltok.c

@@ -18,7 +18,7 @@
 #endif
 #endif /* ndef COMPILED_FROM_DSP */
 
-#include "expat_external.h"
+#include "sg_expat_external.h"
 #include "internal.h"
 #include "xmltok.h"
 #include "nametab.h"

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required (VERSION 2.6.4)
 include (CheckFunctionExists)
 include (CheckIncludeFile)
 include (CheckCXXSourceCompiles)
-
+include (CheckCXXCompilerFlag)
 
 project(SimGear)
 
@@ -10,6 +10,8 @@ project(SimGear)
 file(READ version versionFile)
 string(STRIP ${versionFile} SIMGEAR_VERSION)
 
+set(FIND_LIBRARY_USE_LIB64_PATHS ON)
+
 # use simgear version also as the SO version (if building SOs)
 SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
 
@@ -21,33 +23,31 @@ if(InSourceBuild)
     message(WARNING  "  mkdir ../sgbuild && cd ../sgbuild && cmake ${CMAKE_SOURCE_DIR}")
 endif(InSourceBuild)
 
-if (NOT EMBEDDED_SIMGEAR)
-    #packaging
-    SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
-    SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
-    SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
-    SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
-    SET(CPACK_GENERATOR "TBZ2")
-    SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
 
 
-    # split version string into components, note CMAKE_MATCH_0 is the entire regexp match
-    string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
-    set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
-    set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
-    set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
 
-    message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
 
-    set(CPACK_SOURCE_GENERATOR TBZ2)
-    set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
-    set(CPACK_SOURCE_IGNORE_FILES
-      "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
 
-    message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
-    
-    include (CPack)
-endif()
+message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)
 
 # We have some custom .cmake scripts not in the official distribution.
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")
@@ -87,13 +87,6 @@ if(NOT "${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "")
     message(STATUS "additional library directories: ${ADDITIONAL_LIBRARY_PATHS}")
 endif()
 
-if(NOT MSVC)
-    # TBD: are these really necessary? Aren't they considered by cmake automatically?
-    list(APPEND ADDITIONAL_LIBRARY_PATHS
-         /opt/local
-         /usr/local
-         /usr)
-endif()
 #####################################################################################
 
 if (NOT MSVC)
@@ -107,9 +100,6 @@ set(SYSTEM_EXPAT OFF)
 endif()
 
 option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
-option(JPEG_FACTORY     "Enable JPEG-factory support" OFF)
-option(SG_SVN_CLIENT    "Set to ON to build SimGear with built-in SVN support" OFF)
-option(ENABLE_LIBSVN    "Set to ON to build SimGear with libsvnclient support" ON)
 option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
 option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
 option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
@@ -170,9 +160,12 @@ if (MSVC AND MSVC_3RDPARTY_ROOT)
 endif (MSVC AND MSVC_3RDPARTY_ROOT)
 
 if(APPLE)
-  find_library(CORE_SERVICES_LIBRARY CoreServices)
+  find_library(COCOA_LIBRARY Cocoa)
 endif()
 
+# Somehow this only works if included before searching for Boost...
+include(BoostTestTargets)
+
 find_package(Boost REQUIRED)
 set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
 
@@ -188,36 +181,9 @@ else()
         message(STATUS "Sound support: ENABLED")
     endif(ENABLE_SOUND)
     
-    find_package(OpenSceneGraph 3.0.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgUtil)
+    find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgUtil)
 endif(SIMGEAR_HEADLESS)
 
-if(JPEG_FACTORY)
-    message(STATUS "JPEG-factory: ENABLED")
-    find_package(JPEG REQUIRED)
-    include_directories(${JPEG_INCLUDE_DIR})
-else()
-    message(STATUS "JPEG-factory: DISABLED")
-endif(JPEG_FACTORY)
-
-if (SG_SVN_CLIENT)
-    message(STATUS "Using built-in subversion client code")
-elseif(ENABLE_LIBSVN)
-    find_package(SvnClient)
-
-    if(LIBSVN_FOUND)
-        message(STATUS "Subversion client support: ENABLED")
-        set(HAVE_SVN_CLIENT_H 1)
-        set(HAVE_LIBSVN_CLIENT_1 1)
-    else()
-        # Oops. ENABLE_LIBSVN is ON, but svn is still missing.
-        # Provide clearly visible warning/hint, so builders know what else they should install (or disable).
-        message(WARNING "Failed to enable subversion client support. Unable to find required subversion client library. Some features may not be available (scenery download).")
-        message(WARNING "Install 'libsvn' library/DLL (libsvn-devel/libsvnclient/...). Otherwise disable subversion support (set 'ENABLE_LIBSVN' to 'OFF').")
-    endif(LIBSVN_FOUND)
-else()
-    message(STATUS "Subversion client support: DISABLED")
-endif(SG_SVN_CLIENT)
-
 find_package(ZLIB REQUIRED)
 find_package(Threads REQUIRED)
 
@@ -225,12 +191,19 @@ if (SYSTEM_EXPAT)
     message(STATUS "Requested to use system Expat library, forcing SIMGEAR_SHARED to true")
     set(SIMGEAR_SHARED ON)
     find_package(EXPAT REQUIRED)
-    include_directories(${EXPAT_INCLUDE_DIRS})
+
 else()
     message(STATUS "Using built-in expat code")
-    add_definitions(-DHAVE_EXPAT_CONFIG_H)
+    # XML_STATIC is important to avoid sg_expat_external.h
+    # declaring symbols as declspec(import)
+    add_definitions(-DHAVE_EXPAT_CONFIG_H -DXML_STATIC)
+    set(EXPAT_INCLUDE_DIRS 
+	    ${PROJECT_SOURCE_DIR}/3rdparty/expat 
+	    ${PROJECT_BINARY_DIR}/3rdparty/expat)
 endif(SYSTEM_EXPAT)
 
+include_directories(${EXPAT_INCLUDE_DIRS})
+
 check_include_file(inttypes.h HAVE_INTTYPES_H)
 check_include_file(sys/time.h HAVE_SYS_TIME_H)
 check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
@@ -279,6 +252,22 @@ if(HAVE_CLOCK_GETTIME)
     endif(HAVE_RT)
 endif(HAVE_CLOCK_GETTIME)
 
+set(DL_LIBRARY "")
+check_cxx_source_compiles(
+    "#include <dlfcn.h>
+    int main(void) {
+        return 0;
+    }
+    "
+    HAVE_DLFCN_H)
+
+if(HAVE_DLFCN_H)
+    check_library_exists(dl dlerror "" HAVE_DL)
+    if(HAVE_DL)
+        set(DL_LIBRARY "dl")
+    endif()
+endif()
+
 SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
 SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
@@ -312,6 +301,14 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(WARNING_FLAGS_C   "-Wall")
 endif()
 
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+# boost goes haywire wrt static asserts
+    check_cxx_compiler_flag(-Wno-unused-local-typedefs HAS_NOWARN_UNUSED_TYPEDEFS)
+    if(HAS_NOWARN_UNUSED_TYPEDEFS)
+        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-unused-local-typedefs")
+    endif()
+endif()
+
 if(WIN32)
 
     if(MINGW)
@@ -341,16 +338,16 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")
 
-include_directories(${PROJECT_SOURCE_DIR})
-include_directories(${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
-include_directories(${PROJECT_BINARY_DIR}/simgear)
-include_directories(${PROJECT_BINARY_DIR}/simgear/xml)
+# use BEFORE to ensure local directories are used first, 
+# ahead of system-installed libs
+include_directories(BEFORE ${PROJECT_SOURCE_DIR})
+include_directories(BEFORE ${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
+include_directories(BEFORE ${PROJECT_BINARY_DIR}/simgear)
 
 include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
     ${Boost_INCLUDE_DIRS} 
     ${ZLIB_INCLUDE_DIR} 
     ${OPENAL_INCLUDE_DIR}
-    ${LibArchive_INCLUDE_DIRS}
 )
 
 add_definitions(-DHAVE_CONFIG_H)
@@ -362,11 +359,6 @@ configure_file (
   "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
   )
 
-configure_file (
-    "${PROJECT_SOURCE_DIR}/simgear/xml/expat_config_cmake.in"
-    "${PROJECT_BINARY_DIR}/simgear/xml/expat_config.h"
-)
-
 if(ENABLE_TESTS)
     # enable CTest / make test target
     message(STATUS "Tests: ENABLED")
@@ -378,31 +370,24 @@ else()
 endif(ENABLE_TESTS)
 
 # always set TEST_LIBS as it is also used by other tools/applications
-# TODO maybe better rename?
-if(SIMGEAR_SHARED)
-    set( TEST_LIBS
-        SimGearCore)
-else()
-    set( TEST_LIBS
-        SimGearCore
-        ${CMAKE_THREAD_LIBS_INIT}
-        ${ZLIB_LIBRARY}
-        ${WINSOCK_LIBRARY}
-        ${RT_LIBRARY}
-        ${CORE_SERVICES_LIBRARY})
-endif()
+set(TEST_LIBS_INTERNAL_CORE
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${ZLIB_LIBRARY}
+    ${WINSOCK_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${COCOA_LIBRARY})
+set(TEST_LIBS SimGearCore ${TEST_LIBS_INTERNAL_CORE})
 
 if(NOT SIMGEAR_HEADLESS)
-    set( TEST_LIBS
-        SimGearScene
-        ${TEST_LIBS}
-        ${OPENGL_LIBRARIES})
+    set(TEST_LIBS SimGearScene ${OPENGL_LIBRARIES} ${TEST_LIBS})
 endif()
 
 install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
+
+add_subdirectory(3rdparty)
 add_subdirectory(simgear)
 
-if (NOT EMBEDDED_SIMGEAR)
 #-----------------------------------------------------------------------------
 ### uninstall target
 #-----------------------------------------------------------------------------
@@ -413,5 +398,4 @@ CONFIGURE_FILE(
 ADD_CUSTOM_TARGET(uninstall
   "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
   
-endif()
 

CMakeModules/BoostTestTargets.cmake

@@ -0,0 +1,256 @@
+# - Add tests using boost::test
+#
+# Add this line to your test files in place of including a basic boost test header:
+#  #include <BoostTestTargetConfig.h>
+#
+# If you cannot do that and must use the included form for a given test,
+# include the line
+#  // OVERRIDE_BOOST_TEST_INCLUDED_WARNING
+# in the same file with the boost test include.
+#
+#  include(BoostTestTargets)
+#  add_boost_test(<testdriver_name> SOURCES <source1> [<more sources...>]
+#   [FAIL_REGULAR_EXPRESSION <additional fail regex>]
+#   [LAUNCHER <generic launcher script>]
+#   [LIBRARIES <library> [<library>...]]
+#   [RESOURCES <resource> [<resource>...]]
+#   [TESTS <testcasename> [<testcasename>...]])
+#
+#  If for some reason you need access to the executable target created,
+#  it can be found in ${${testdriver_name}_TARGET_NAME} as specified when
+#  you called add_boost_test
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Requires:
+# 	GetForceIncludeDefinitions
+# 	CopyResourcesToBuildTree
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# 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)
+
+if(__add_boost_test)
+	return()
+endif()
+set(__add_boost_test YES)
+
+set(BOOST_TEST_TARGET_PREFIX "test")
+
+if(NOT Boost_FOUND)
+	find_package(Boost 1.34.0 QUIET)
+endif()
+if("${Boost_VERSION}0" LESS "1034000")
+	set(_shared_msg
+		"NOTE: boost::test-based targets and tests cannot "
+		"be added: boost >= 1.34.0 required but not found. "
+		"(found: '${Boost_VERSION}'; want >=103400) ")
+	if(BUILD_TESTING)
+		message(FATAL_ERROR
+			${_shared_msg}
+			"You may disable BUILD_TESTING to continue without the "
+			"tests.")
+	else()
+		message(STATUS
+			${_shared_msg}
+			"BUILD_TESTING disabled, so continuing anyway.")
+	endif()
+endif()
+
+include(GetForceIncludeDefinitions)
+include(CopyResourcesToBuildTree)
+
+if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+	set(_boosttesttargets_libs)
+	set(_boostConfig "BoostTestTargetsIncluded.h")
+	if(NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		find_package(Boost 1.34.0 QUIET COMPONENTS unit_test_framework)
+	endif()
+	if(Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		set(_boosttesttargets_libs "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}")
+		if(Boost_USE_STATIC_LIBS)
+			set(_boostConfig "BoostTestTargetsStatic.h")
+		else()
+			set(_boostConfig "BoostTestTargetsDynamic.h")
+		endif()
+	endif()
+	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+	configure_file("${_moddir}/${_boostConfig}"
+		"${CMAKE_CURRENT_BINARY_DIR}/BoostTestTargetConfig.h"
+		COPYONLY)
+	include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+endif()
+
+function(add_boost_test _name)
+	if(NOT BUILD_TESTING)
+		return()
+	endif()
+
+	# parse arguments
+	set(_nowhere)
+	set(_curdest _nowhere)
+	set(_val_args
+		SOURCES
+		FAIL_REGULAR_EXPRESSION
+		LAUNCHER
+		LIBRARIES
+		RESOURCES
+		TESTS)
+	set(_bool_args
+		USE_COMPILED_LIBRARY)
+	foreach(_arg ${_val_args} ${_bool_args})
+		set(${_arg})
+	endforeach()
+	foreach(_element ${ARGN})
+		list(FIND _val_args "${_element}" _val_arg_find)
+		list(FIND _bool_args "${_element}" _bool_arg_find)
+		if("${_val_arg_find}" GREATER "-1")
+			set(_curdest "${_element}")
+		elseif("${_bool_arg_find}" GREATER "-1")
+			set("${_element}" ON)
+			set(_curdest _nowhere)
+		else()
+			list(APPEND ${_curdest} "${_element}")
+		endif()
+	endforeach()
+
+	if(_nowhere)
+		message(FATAL_ERROR "Syntax error in use of add_boost_test!")
+	endif()
+
+	if(NOT SOURCES)
+		message(FATAL_ERROR
+			"Syntax error in use of add_boost_test: at least one source file required!")
+	endif()
+
+	if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+
+		include_directories(${Boost_INCLUDE_DIRS})
+
+		set(includeType)
+		foreach(src ${SOURCES})
+			file(READ ${src} thefile)
+			if("${thefile}" MATCHES ".*BoostTestTargetConfig.h.*")
+				set(includeType CONFIGURED)
+				set(includeFileLoc ${src})
+				break()
+			elseif("${thefile}" MATCHES ".*boost/test/included/unit_test.hpp.*")
+				set(includeType INCLUDED)
+				set(includeFileLoc ${src})
+				set(_boosttesttargets_libs)	# clear this out - linking would be a bad idea
+				if(NOT
+					"${thefile}"
+					MATCHES
+					".*OVERRIDE_BOOST_TEST_INCLUDED_WARNING.*")
+					message("Please replace the include line in ${src} with this alternate include line instead:")
+					message("  \#include <BoostTestTargetConfig.h>")
+					message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+				endif()
+				break()
+			endif()
+		endforeach()
+
+		if(NOT _boostTestTargetsNagged${_name} STREQUAL "${includeType}")
+			if("includeType" STREQUAL "CONFIGURED")
+				message(STATUS
+					"Test '${_name}' uses the CMake-configurable form of the boost test framework - congrats! (Including File: ${includeFileLoc})")
+			elseif("${includeType}" STREQUAL "INCLUDED")
+				message("In test '${_name}': ${includeFileLoc} uses the 'included' form of the boost unit test framework.")
+			else()
+				message("In test '${_name}': Didn't detect the CMake-configurable boost test include.")
+				message("Please replace your existing boost test include in that test with the following:")
+				message("  \#include <BoostTestTargetConfig.h>")
+				message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+			endif()
+		endif()
+		set(_boostTestTargetsNagged${_name}
+			"${includeType}"
+			CACHE
+			INTERNAL
+			""
+			FORCE)
+
+
+		if(RESOURCES)
+			list(APPEND SOURCES ${RESOURCES})
+		endif()
+
+		# Generate a unique target name, using the relative binary dir
+		# and provided name. (transform all / into _ and remove all other
+		# non-alphabet characters)
+		file(RELATIVE_PATH
+			targetpath
+			"${CMAKE_BINARY_DIR}"
+			"${CMAKE_CURRENT_BINARY_DIR}")
+		string(REGEX REPLACE "[^A-Za-z/_]" "" targetpath "${targetpath}")
+		string(REPLACE "/" "_" targetpath "${targetpath}")
+
+		set(_target_name ${BOOST_TEST_TARGET_PREFIX}-${targetpath}-${_name})
+		set(${_name}_TARGET_NAME "${_target_name}" PARENT_SCOPE)
+
+		# Build the test.
+		add_executable(${_target_name} ${SOURCES})
+
+		list(APPEND LIBRARIES ${_boosttesttargets_libs})
+
+		if(LIBRARIES)
+			target_link_libraries(${_target_name} ${LIBRARIES})
+		endif()
+
+		if(RESOURCES)
+			set_property(TARGET ${_target_name} PROPERTY RESOURCE ${RESOURCES})
+			copy_resources_to_build_tree(${_target_name})
+		endif()
+
+		if(NOT Boost_TEST_FLAGS)
+#			set(Boost_TEST_FLAGS --catch_system_error=yes --output_format=XML)
+			set(Boost_TEST_FLAGS --catch_system_error=yes)
+		endif()
+
+		# TODO: Figure out why only recent boost handles individual test running properly
+
+		if(LAUNCHER)
+			set(_test_command ${LAUNCHER} "\$<TARGET_FILE:${_target_name}>")
+		else()
+			set(_test_command ${_target_name})
+		endif()
+
+		if(TESTS AND ( "${Boost_VERSION}" VERSION_GREATER "103799" ))
+			foreach(_test ${TESTS})
+				add_test(
+					${_name}-${_test}
+					${_test_command} --run_test=${_test} ${Boost_TEST_FLAGS}
+				)
+				if(FAIL_REGULAR_EXPRESSION)
+					set_tests_properties(${_name}-${_test}
+						PROPERTIES
+						FAIL_REGULAR_EXPRESSION
+						"${FAIL_REGULAR_EXPRESSION}")
+				endif()
+			endforeach()
+		else()
+			add_test(
+				${_name}-boost_test
+				${_test_command} ${Boost_TEST_FLAGS}
+			)
+			if(FAIL_REGULAR_EXPRESSION)
+				set_tests_properties(${_name}-boost_test
+					PROPERTIES
+					FAIL_REGULAR_EXPRESSION
+					"${FAIL_REGULAR_EXPRESSION}")
+			endif()
+		endif()
+
+		# CppCheck the test if we can.
+		if(COMMAND add_cppcheck)
+			add_cppcheck(${_target_name} STYLE UNUSED_FUNCTIONS)
+		endif()
+
+	endif()
+endfunction()

CMakeModules/BoostTestTargetsDynamic.h

@@ -0,0 +1,8 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF dynamic library
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>

CMakeModules/BoostTestTargetsIncluded.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF included framework
+
+#include <boost/test/included/unit_test.hpp>

CMakeModules/BoostTestTargetsStatic.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF static library
+
+#include <boost/test/unit_test.hpp>

CMakeModules/CopyResourcesToBuildTree.cmake

@@ -0,0 +1,83 @@
+# - Copy the resources your app needs to the build tree.
+#
+#  copy_resources_to_build_tree(<target_name>)
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# 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)
+
+if(__copy_resources_to_build_tree)
+	return()
+endif()
+set(__copy_resources_to_build_tree YES)
+
+function(copy_resources_to_build_tree _target)
+	get_target_property(_resources ${_target} RESOURCE)
+	if(NOT _resources)
+		# Bail if no resources
+		message(STATUS
+			"Told to copy resources for target ${_target}, but "
+			"no resources are set!")
+		return()
+	endif()
+
+	get_target_property(_path ${_target} LOCATION)
+	get_filename_component(_path "${_path}" PATH)
+
+	if(NOT MSVC AND NOT "${CMAKE_GENERATOR}" MATCHES "Makefiles")
+		foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+			get_target_property(_path${_config} ${_target} LOCATION_${_config})
+			get_filename_component(_path${_config} "${_path${_config}}" PATH)
+			add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E make_directory "${_path${_config}}/"
+						COMMENT "Creating directory ${_path${_config}}/")
+		endforeach()
+	endif()
+
+	foreach(_res ${_resources})
+		if(NOT IS_ABSOLUTE "${_res}")
+			get_filename_component(_res "${_res}" ABSOLUTE)
+		endif()
+		get_filename_component(_name "${_res}" NAME)
+
+		if(MSVC)
+			# Working dir is solution file dir, not exe file dir.
+			add_custom_command(TARGET ${_target}
+				POST_BUILD
+				COMMAND
+				${CMAKE_COMMAND}
+				ARGS -E copy "${_res}" "${CMAKE_BINARY_DIR}/"
+				COMMENT "Copying ${_name} to ${CMAKE_BINARY_DIR}/ for MSVC")
+		else()
+			if("${CMAKE_GENERATOR}" MATCHES "Makefiles")
+				add_custom_command(TARGET ${_target}
+					POST_BUILD
+					COMMAND
+					${CMAKE_COMMAND}
+					ARGS -E copy "${_res}" "${_path}/"
+					COMMENT "Copying ${_name} to ${_path}/")
+			else()
+				foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+					add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E copy "${_res}" "${_path${_config}}"
+						COMMENT "Copying ${_name} to ${_path${_config}}")
+				endforeach()
+
+			endif()
+		endif()
+	endforeach()
+endfunction()

CMakeModules/FindSvnClient.cmake

@@ -1,83 +0,0 @@
-# Find Subversion client libraries, and dependencies
-# including APR (Apache Portable Runtime)
-
-include (CheckFunctionExists)
-include (CheckIncludeFile)
-include (CheckLibraryExists)
-
-macro(find_static_component comp libs)
-    # account for alternative Windows svn distribution naming
-    if(MSVC)
-      set(compLib "lib${comp}")
-    else(MSVC)
-      set(compLib "${comp}")
-    endif(MSVC)
-    
-    string(TOUPPER "${comp}" compLibBase)
-    set( compLibName ${compLibBase}_LIBRARY )
-
-    # NO_DEFAULT_PATH is important on Mac - we need to ensure subversion
-    # libraires in dist/ or Macports are picked over the Apple version 
-    # in /usr, since that's what we will ship.
-    # On other platforms we do need default paths though, i.e. since Linux
-    # distros may use architecture-specific directories (like
-    # /usr/lib/x86_64-linux-gnu) which we cannot hardcode/guess here.
-    FIND_LIBRARY(${compLibName}
-if(APPLE)
-      NO_DEFAULT_PATH
-endif(APPLE)
-      NAMES ${compLib}
-      HINTS $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX} ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib
-      PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
-      PATHS ${ADDITIONAL_LIBRARY_PATHS}
-    )
-
-	list(APPEND ${libs} ${${compLibName}})
-endmacro()
-
-find_program(HAVE_APR_CONFIG apr-1-config)
-if(HAVE_APR_CONFIG) 
-        
-    execute_process(COMMAND apr-1-config --cppflags --includes
-        OUTPUT_VARIABLE APR_CFLAGS
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-        
-    execute_process(COMMAND apr-1-config --link-ld
-        OUTPUT_VARIABLE RAW_APR_LIBS
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    
-# clean up some vars, or other CMake pieces complain
-	string(STRIP "${RAW_APR_LIBS}" APR_LIBS)
-
-else(HAVE_APR_CONFIG)
-    message(STATUS "apr-1-config not found, implement manual search for APR")
-endif(HAVE_APR_CONFIG)
-
-if(HAVE_APR_CONFIG OR MSVC)
-	find_path(LIBSVN_INCLUDE_DIR svn_client.h
-      NO_DEFAULT_PATH
-	  HINTS
-	  $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX} ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include
-	  PATH_SUFFIXES include/subversion-1
-	  PATHS
-      /opt/local
-	  /usr/local
-	  /usr
-	)
-	
-	set(LIBSVN_LIBRARIES "")
-	if (MSVC)
-		find_static_component("apr-1" LIBSVN_LIBRARIES)
-	else (MSVC)
-		list(APPEND LIBSVN_LIBRARIES ${APR_LIBS})
-	endif (MSVC)
-	find_static_component("svn_client-1" LIBSVN_LIBRARIES)
-	find_static_component("svn_subr-1" LIBSVN_LIBRARIES)
-	find_static_component("svn_ra-1" LIBSVN_LIBRARIES)
-
-	include(FindPackageHandleStandardArgs)
-	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG LIBSVN_LIBRARIES LIBSVN_INCLUDE_DIR)
-        if(NOT LIBSVN_FOUND)
-		set(LIBSVN_LIBRARIES "")
-        endif(NOT LIBSVN_FOUND)
-endif(HAVE_APR_CONFIG OR MSVC)

CMakeModules/GetForceIncludeDefinitions.cmake

@@ -0,0 +1,44 @@
+# - Get the platform-appropriate flags to add to force inclusion of a file
+#
+# The most common use of this is to use a generated config.h-type file
+# placed out of the source tree in all files.
+#
+#  get_force_include_definitions(var forcedincludefiles...) -
+#   where var is the name of  your desired output variable, and everything
+#   else is a source file to forcibly include.
+#   a list item to be filtered.
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# 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)
+
+if(__get_force_include_definitions)
+	return()
+endif()
+set(__get_force_include_definitions YES)
+
+function(get_force_include_definitions var)
+	set(_flagprefix)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(_flag "-include")
+	elseif(MSVC)
+		set(_flag "/FI")
+	else()
+		message(SEND_ERROR "You don't seem to be using MSVC or GCC, but")
+		message(SEND_ERROR "the project called get_force_include_definitions.")
+		message(SEND_ERROR "Contact this project with the name of your")
+		message(FATAL_ERROR "compiler and preferably the flag to force includes")
+	endif()
+
+	set(_out)
+	foreach(_item ${ARGN})
+		list(APPEND _out "${_flag} \"${_item}\"")
+	endforeach()
+	set(${var} "${_out}" PARENT_SCOPE)
+endfunction()

simgear/CMakeLists.txt

@@ -45,54 +45,29 @@ install (FILES ${HEADERS}  DESTINATION include/simgear/)
 get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
 get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
 get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
-
-if(LIBSVN_FOUND)
-	add_definitions(${APR_CFLAGS})
-	include_directories(${LIBSVN_INCLUDE_DIR})
-endif()
+get_property(localExpatSources GLOBAL PROPERTY LOCAL_EXPAT_SOURCES)
 
 if(SIMGEAR_SHARED)
     message(STATUS "Library building mode: SHARED LIBRARIES")
-    add_library(SimGearCore SHARED ${coreSources})
+    add_library(SimGearCore SHARED ${coreSources} ${localExpatSources})
 
-  # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
-  #  message(STATUS "public header: ${publicHeaders}")
-  #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
     set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
-
     set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
     set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
-
-    target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY} 
-        ${LibArchive_LIBRARIES}
-        ${EXPAT_LIBRARIES}
-        ${CMAKE_THREAD_LIBS_INIT}
-        ${CORE_SERVICES_LIBRARY})
-
-    if(LIBSVN_FOUND)
-        target_link_libraries(SimGearCore ${LIBSVN_LIBRARIES})
-    endif(LIBSVN_FOUND)
-
+    install(TARGETS SimGearCore EXPORT SimGearCoreConfig LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install(EXPORT SimGearCoreConfig DESTINATION share/SimGearCore)
+    
     if(NOT SIMGEAR_HEADLESS)
         add_library(SimGearScene SHARED ${sceneSources})
-      # set_property(TARGET SimGearScene PROPERTY FRAMEWORK 1)
-      # set_property(TARGET SimGearScene PROPERTY PUBLIC_HEADER "${publicHeaders}")
         set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
         set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
         set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
 
-        target_link_libraries(SimGearScene
-            SimGearCore
-            ${ZLIB_LIBRARY}
-            ${OPENSCENEGRAPH_LIBRARIES}
-            ${OPENAL_LIBRARY}
-            ${OPENGL_LIBRARY}
-            ${JPEG_LIBRARY})
-    
-        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+        # EXPORT SimGearSceneConfig
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
+    #    install(EXPORT SimGearSceneConfig DESTINATION share/SimGearScene)
     endif()
     
-    install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 else()
     message(STATUS "Library building mode: STATIC LIBRARIES")
 
@@ -114,7 +89,7 @@ else()
 		source_group("${name}\\Headers" FILES ${g2})
 	endforeach()
 
-    add_library(SimGearCore STATIC ${coreSources})
+    add_library(SimGearCore STATIC ${coreSources} ${localExpatSources})
     install(TARGETS SimGearCore ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
     
     if(NOT SIMGEAR_HEADLESS)
@@ -141,6 +116,24 @@ else()
     endif(NOT SIMGEAR_HEADLESS)
 endif(SIMGEAR_SHARED)
 
+target_link_libraries(SimGearCore
+    ${ZLIB_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${EXPAT_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${COCOA_LIBRARY})
+
+if(NOT SIMGEAR_HEADLESS)
+    target_link_libraries(SimGearScene
+        SimGearCore
+        ${ZLIB_LIBRARY}
+        ${OPENSCENEGRAPH_LIBRARIES}
+        ${OPENAL_LIBRARY}
+        ${OPENGL_LIBRARY}
+        ${JPEG_LIBRARY})
+endif()
+
 if(ENABLE_RTI)
     # Ugly first aid to make hla compile agian
     set_property(SOURCE hla/RTI13InteractionClass.cxx hla/RTI13ObjectClass.cxx

simgear/bucket/CMakeLists.txt

@@ -4,4 +4,13 @@ include (SimGearComponent)
 set(HEADERS newbucket.hxx)
 set(SOURCES newbucket.cxx)
 
-simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
+
+
+if(ENABLE_TESTS)
+
+add_executable(test_bucket test_bucket.cxx)
+add_test(test_bucket ${EXECUTABLE_OUTPUT_PATH}/test_bucket)
+target_link_libraries(test_bucket ${TEST_LIBS})
+
+endif(ENABLE_TESTS)

simgear/bucket/newbucket.cxx

@@ -27,36 +27,56 @@
 #  include <simgear_config.h>
 #endif
 
-#include <math.h>
+#include <cmath>
+#include <cstdio> // some platforms need this for ::snprintf
+#include <iostream>
 
 #include <simgear/misc/sg_path.hxx>
+#include <simgear/debug/logstream.hxx>
 
 #include "newbucket.hxx"
 
 
 // default constructor
-SGBucket::SGBucket() {
+SGBucket::SGBucket() :
+    lon(-1000),
+    lat(-1000),
+    x(0),
+    y(0)
+{
 }
 
+bool SGBucket::isValid() const
+{
+    // The most northerly valid latitude is 89, not 90. There is no tile
+    // whose *bottom* latitude is 90. Similar there is no tile whose left egde
+    // is 180 longitude.
+    return (lon >= -180) &&
+            (lon < 180) &&
+            (lat >= -90) &&
+            (lat < 90) &&
+            (x < 8) && (y < 8);
+}
+
+void SGBucket::make_bad()
+{
+    lon = -1000;
+    lat = -1000;
+}
+
+#ifndef NO_DEPRECATED_API
 
 // constructor for specified location
 SGBucket::SGBucket(const double dlon, const double dlat) {
     set_bucket(dlon, dlat);
 }
+#endif
 
 SGBucket::SGBucket(const SGGeod& geod) {
-    set_bucket(geod);
+    innerSet(geod.getLongitudeDeg(),
+             geod.getLatitudeDeg());
 }
 
-// create an impossible bucket if false
-SGBucket::SGBucket(const bool is_good) {
-    set_bucket(0.0, 0.0);
-    if ( !is_good ) {
-	lon = -1000;
-    }
-}
-
-
 // Parse a unique scenery tile index and find the lon, lat, x, and y
 SGBucket::SGBucket(const long int bindex) {
     long int index = bindex;
@@ -75,48 +95,59 @@ SGBucket::SGBucket(const long int bindex) {
     x = index;
 }
 
+/* Calculate the greatest integral value less than
+ * or equal to the given value (floor(x)),
+ * but attribute coordinates close to the boundary to the next
+ * (increasing) integral
+ */
+static int floorWithEpsilon(double x)
+{
+    return static_cast<int>(floor(x + SG_EPSILON));
+}
+
+#ifndef NO_DEPRECATED_API
+
+void SGBucket::set_bucket(double dlon, double dlat)
+{
+    innerSet(dlon, dlat);
+}
+
+
+void SGBucket::set_bucket(const SGGeod& geod)
+{
+    innerSet(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+}
+
+#endif
 
 // Set the bucket params for the specified lat and lon
-void SGBucket::set_bucket( double *lonlat ) {
-    set_bucket( lonlat[0], lonlat[1] );
-}	
-
-
-// Set the bucket params for the specified lat and lon
-void SGBucket::set_bucket( double dlon, double dlat ) {
+void SGBucket::innerSet( double dlon, double dlat )
+{
+    if ((dlon < -180.0) || (dlon >= 180.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
+        dlon = SGMiscd::normalizePeriodic(-180.0, 180.0, dlon);
+    }
+    
+    if ((dlat < -90.0) || (dlat > 90.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed latitude" << dlat);
+        dlat = SGMiscd::clip(dlat, -90.0, 90.0);
+    }
+    
     //
-    // latitude first
+    // longitude first
     //
     double span = sg_bucket_span( dlat );
-    double diff = dlon - (double)(int)dlon;
-
-    // cout << "diff = " << diff << "  span = " << span << endl;
-
-    /* Calculate the greatest integral longitude less than
-     * or equal to the given longitude (floor(dlon)),
-     * but attribute coordinates near the east border
-     * to the next tile.
-     */
-    if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
-	lon = (int)dlon;
-    } else {
-	lon = (int)dlon - 1;
-    }
-
+    // we do NOT need to special case lon=180 here, since
+    // normalizePeriodic will never return 180; it will
+    // return -180, which is what we want.
+    lon = floorWithEpsilon(dlon);
+    
     // find subdivision or super lon if needed
-    if ( span < SG_EPSILON ) {
-        /* sg_bucket_span() never returns 0.0
-         * or anything near it, so this really
-         * should not occur at any time.
-         */
-	// polar cap
-	lon = 0;
-	x = 0;
-    } else if ( span <= 1.0 ) {
+    if ( span <= 1.0 ) {
         /* We have more than one tile per degree of
          * longitude, so we need an x offset.
          */
-	x = (int)((dlon - lon) / span);
+        x = floorWithEpsilon((dlon - lon) / span);
     } else {
         /* We have one or more degrees per tile,
          * so we need to find the base longitude
@@ -129,48 +160,28 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
          *
          * That way, the Greenwich Meridian is always
          * a tile border.
-         *
-         * This gets us into trouble with the polar caps,
-         * which have width 360 and thus either span
-         * the range from 0 to 360 or from -360 to 0
-         * degrees, depending on whether lon is positive
-         * or negative!
-         *
-         * We also get into trouble with the 8 degree tiles
-         * north of 88N and south of 88S, because the west-
-         * and east-most tiles in that range will cover 184W
-         * to 176W and 176E to 184E respectively, with their
-         * center at 180E/W!
          */
-        lon=(int)floor(floor((lon+SG_EPSILON)/span)*span);
-        /* Correct the polar cap issue */
-        if ( lon < -180 ) {
-            lon = -180;
-        }
-	x = 0;
+        lon=static_cast<int>(floor(lon / span) * span);
+        x = 0;
     }
 
     //
     // then latitude
     //
-    diff = dlat - (double)(int)dlat;
-
-    /* Again, a modified floor() function (see longitude) */
-    if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
-	lat = (int)dlat;
+    lat = floorWithEpsilon(dlat);
+    
+    // special case when passing in the north pole point (possibly due to
+    // clipping latitude above). Ensures we generate a valid bucket in this
+    // scenario
+    if (lat == 90) {
+        lat = 89;
+        y = 7;
     } else {
-	lat = (int)dlat - 1;
+        /* Latitude base and offset are easier, as
+         * tiles always are 1/8 degree of latitude wide.
+         */
+        y = floorWithEpsilon((dlat - lat) * 8);
     }
-    /* Latitude base and offset are easier, as
-     * tiles always are 1/8 degree of latitude wide.
-     */
-    y = (int)((dlat - lat) * 8);
-}
-
-
-void SGBucket::set_bucket(const SGGeod& geod)
-{
-    set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
 }
 
 // Build the path name for this bucket
@@ -212,7 +223,7 @@ std::string SGBucket::gen_base_path() const {
 	main_lat *= -1;
     }
 
-    sprintf(raw_path, "%c%03d%c%02d/%c%03d%c%02d", 
+    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d",
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);
 
@@ -233,17 +244,32 @@ double SGBucket::get_height() const {
     return SG_BUCKET_SPAN;
 }
 
-
-// return width of the tile in meters
-double SGBucket::get_width_m() const {
-    double clat = (int)get_center_lat();
-    if ( clat > 0 ) {
-	clat = (int)clat + 0.5;
-    } else {
-	clat = (int)clat - 0.5;
+double SGBucket::get_highest_lat() const
+{
+    unsigned char adjustedY = y;
+    if (lat >= 0) {
+        // tile is north of the equator, so we want the top edge. Add one
+        // to y to achieve this.
+        ++adjustedY;
     }
-    double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
+    
+	return lat + (adjustedY / 8.0);
+}
+
+
+// return width of the tile in meters. This function is used by the
+// tile-manager to estimate how many tiles are in the view distance, so
+// we care about the smallest width, which occurs at the highest latitude.
+double SGBucket::get_width_m() const
+{
+    double clat_rad = get_highest_lat() * SGD_DEGREES_TO_RADIANS;
     double cos_lat = cos( clat_rad );
+    if (fabs(cos_lat) < SG_EPSILON) {
+        // happens for polar tiles, since we pass in a latitude of 90
+        // return an arbitrary small value so all tiles are loaded
+        return 10.0;
+    }
+    
     double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
     double local_perimeter = local_radius * SGD_2PI;
     double degree_width = local_perimeter / 360.0;
@@ -260,7 +286,41 @@ double SGBucket::get_height_m() const {
     return SG_BUCKET_SPAN * degree_height;
 }
 
+SGBucket SGBucket::sibling(int dx, int dy) const
+{
+    if (!isValid()) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
+        return SGBucket();
+    }
+    
+    double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
+    // return invalid here instead of clipping, so callers can discard
+    // invalid buckets without having to check if it's an existing one
+    if ((clat < -90.0) || (clat > 90.0)) {
+        return SGBucket();
+    }
+    
+    // find the lon span for the new latitude
+    double span = sg_bucket_span( clat );
+    
+    double tmp = get_center_lon() + dx * span;
+    tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
+    
+    SGBucket b;
+    b.innerSet(tmp, clat);
+    return b;
+}
 
+std::string SGBucket::gen_index_str() const
+{
+	char tmp[20];
+	::snprintf(tmp, 20, "%ld",
+                 (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                 + (y << 3) + x);
+	return (std::string)tmp;
+}
+
+#ifndef NO_DEPRECATED_API
 // find the bucket which is offset by the specified tile units in the
 // X & Y direction.  We need the current lon and lat to resolve
 // ambiguities when going from a wider tile to a narrower one above or
@@ -287,7 +347,7 @@ SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {
 
     return result;
 }
-
+#endif
 
 // calculate the offset between two buckets
 void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
@@ -348,10 +408,22 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
 void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
     double lon, lat, span;
 
-    for (lat = min.getLatitudeDeg(); lat <= max.getLatitudeDeg(); lat += SG_BUCKET_SPAN) {
+    for (lat = min.getLatitudeDeg(); lat < max.getLatitudeDeg()+SG_BUCKET_SPAN; lat += SG_BUCKET_SPAN) {
         span = sg_bucket_span( lat );
-        for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span) {
-            list.push_back( SGBucket(lon , lat) );
+        for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
+        {
+            SGBucket b(SGGeod::fromDeg(lon, lat));
+            if (!b.isValid()) {
+                continue;
+            }
+            
+            list.push_back(b);
         }
     }
 }
+
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b )
+{
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
+}
+

simgear/bucket/newbucket.hxx

@@ -39,11 +39,12 @@
 #include <simgear/math/SGMath.hxx>
 
 #include <cmath>
-#include <cstdio> // sprintf()
-#include <ostream>
 #include <string>
+#include <iosfwd>
 #include <vector>
 
+// #define NO_DEPRECATED_API
+
 /**
  * standard size of a bucket in degrees (1/8 of a degree)
  */
@@ -99,23 +100,31 @@ class SGBucket {
 private:
     short lon;        // longitude index (-180 to 179)
     short lat;        // latitude index (-90 to 89)
-    char x;          // x subdivision (0 to 7)
-    char y;          // y subdivision (0 to 7)
+    unsigned char x;          // x subdivision (0 to 7)
+    unsigned char y;          // y subdivision (0 to 7)
 
+    void innerSet( double dlon, double dlat );
 public:
 
     /**
-     * Default constructor.
+     * Default constructor, creates an invalid SGBucket
      */
     SGBucket();
 
+    /**
+     * Check if this bucket refers to a valid tile, or not.
+     */
+    bool isValid() const;
+    
+#ifndef NO_DEPRECATED_API
     /**
      * Construct a bucket given a specific location.
      * @param dlon longitude specified in degrees
      * @param dlat latitude specified in degrees
      */
     SGBucket(const double dlon, const double dlat);
-
+#endif
+    
     /**
      * Construct a bucket given a specific location.
      * @param dlon longitude specified in degrees
@@ -123,33 +132,12 @@ public:
      */
     SGBucket(const SGGeod& geod);
 
-    /** Construct a bucket.
-     *  @param is_good if false, create an invalid bucket.  This is
-     *  useful * if you are comparing cur_bucket to last_bucket and
-     *  you want to * make sure last_bucket starts out as something
-     *  impossible.
-     */
-    SGBucket(const bool is_good);
-
     /** Construct a bucket given a unique bucket index number.
      * @param bindex unique bucket index
      */
     SGBucket(const long int bindex);
 
-    /**
-     * Reset a bucket to represent a new lat and lon
-     * @param dlon longitude specified in degrees
-     * @param dlat latitude specified in degrees
-     */
-    void set_bucket( double dlon, double dlat );
-
-    /**
-     * Reset a bucket to represent a new lat and lon
-     * @param lonlat an array of double[2] holding lon and lat
-     * (specified) in degrees
-     */
-    void set_bucket( double *lonlat );
-
+#ifndef NO_DEPRECATED_API
     /**
      * Reset a bucket to represent a new lat and lon
      * @param dlon longitude specified in degrees
@@ -157,17 +145,23 @@ public:
      */
     void set_bucket(const SGGeod& geod);
 
+
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    void set_bucket( double dlon, double dlat );
+#endif
+    
     /**
      * Create an impossible bucket.
      * This is useful if you are comparing cur_bucket to last_bucket
      * and you want to make sure last_bucket starts out as something
      * impossible.
      */
-    inline void make_bad() {
-	set_bucket(0.0, 0.0);
-	lon = -1000;
-    }
-
+    void make_bad();
+    
     /**
      * Generate the unique scenery tile index for this bucket
      *
@@ -192,14 +186,8 @@ public:
      * string form.
      * @return tile index in string form
      */
-    inline std::string gen_index_str() const {
-	char tmp[20];
-	std::sprintf(tmp, "%ld", 
-                     (((long)lon + 180) << 14) + ((lat + 90) << 6)
-                     + (y << 3) + x);
-	return (std::string)tmp;
-    }
-
+    std::string gen_index_str() const;
+    
     /**
      * Build the base path name for this bucket.
      * @return base path in string form
@@ -226,6 +214,13 @@ public:
 	return lat + y / 8.0 + SG_HALF_BUCKET_SPAN;
     }
 
+    /**
+     * @return the highest (furthest from the equator) latitude of this
+     * tile. This is the top edge for tiles north of the equator, and
+     * the bottom edge for tiles south
+     */
+    double get_highest_lat() const;
+    
     /**
      * @return the width of the tile in degrees.
      */
@@ -287,6 +282,11 @@ public:
      */
     inline int get_y() const { return y; }
 
+    /**
+     * @return bucket offset from this by dx,dy
+     */
+    SGBucket sibling(int dx, int dy) const;
+    
     // friends
 
     friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
@@ -298,7 +298,7 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
         return !(lhs == rhs);
     }
 
-
+#ifndef NO_DEPRECATED_API
 /**
  * \relates SGBucket
  * Return the bucket which is offset from the specified dlon, dlat by
@@ -310,6 +310,7 @@ inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
  * @return offset bucket
  */
 SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
+#endif
 
 
 /**
@@ -337,12 +338,7 @@ void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>&
  * @param out output stream
  * @param b bucket
  */
-inline std::ostream&
-operator<< ( std::ostream& out, const SGBucket& b )
-{
-    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
-}
-
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b );
 
 /**
  * Compare two bucket structures for equality.

simgear/bucket/test_bucket.cxx

@@ -0,0 +1,283 @@
+/**************************************************************************
+ * test_bucket.cxx -- unit-tests for SGBucket class
+ *
+ * Copyright (C) 2014  James Turner - <zakalawe@mac.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+#include <simgear/bucket/newbucket.hxx>
+#include <simgear/misc/test_macros.hxx>
+
+void testBucketSpans()
+{
+    COMPARE(sg_bucket_span(0.0), 0.125);
+    COMPARE(sg_bucket_span(-20), 0.125);
+    COMPARE(sg_bucket_span(-40), 0.25);
+    COMPARE(sg_bucket_span(89.9), 12.0);
+    COMPARE(sg_bucket_span(88.1), 4.0);
+    COMPARE(sg_bucket_span(-89.9), 12.0);
+}
+
+void testBasic()
+{
+    SGBucket b1(5.1, 55.05);
+    COMPARE(b1.get_chunk_lon(), 5);
+    COMPARE(b1.get_chunk_lat(), 55);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 0);
+    COMPARE(b1.gen_index(), 3040320);
+    COMPARE(b1.gen_base_path(), "e000n50/e005n55");
+    VERIFY(b1.isValid());
+    
+    SGBucket b2(-10.1, -43.8);
+    COMPARE(b2.get_chunk_lon(), -11);
+    COMPARE(b2.get_chunk_lat(), -44);
+    COMPARE(b2.get_x(), 3);
+    COMPARE(b2.get_y(), 1); // latitude chunks numbered bottom to top, it seems
+    COMPARE(b2.gen_base_path(), "w020s50/w011s44");
+    VERIFY(b2.isValid());
+    
+    SGBucket b3(123.48, 9.01);
+    COMPARE(b3.get_chunk_lon(), 123);
+    COMPARE(b3.get_chunk_lat(), 9);
+    COMPARE(b3.get_x(), 3);
+    COMPARE(b3.get_y(), 0);
+    COMPARE(b3.gen_base_path(), "e120n00/e123n09");
+    VERIFY(b3.isValid());
+    
+    SGBucket defBuck;
+    VERIFY(!defBuck.isValid());
+    
+    b3.make_bad();
+    VERIFY(!b3.isValid());
+
+    SGBucket atAntiMeridian(180.0, 12.3);
+    VERIFY(atAntiMeridian.isValid());
+    COMPARE(atAntiMeridian.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian.get_x(), 0);
+    
+    SGBucket atAntiMeridian2(-180.0, -78.1);
+    VERIFY(atAntiMeridian2.isValid());
+    COMPARE(atAntiMeridian2.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian2.get_x(), 0);
+    
+// check comparisom operator overload
+    SGBucket b4(5.11, 55.1);
+    VERIFY(b1 == b4); // should be equal
+    VERIFY(b1 == b1);
+    VERIFY(b1 != defBuck);
+    VERIFY(b1 != b2);
+    
+// check wrapping/clipping of inputs
+    SGBucket wrapMeridian(-200.0, 45.0);
+    COMPARE(wrapMeridian.get_chunk_lon(), 160);
+    
+    SGBucket clipPole(48.9, 91);
+    COMPARE(clipPole.get_chunk_lat(), 89);
+}
+
+void testPolar()
+{
+    SGBucket b1(0.0, 89.92);
+    SGBucket b2(10.0, 89.96);
+    COMPARE(b1.get_chunk_lat(), 89);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 7);
+    
+    COMPARE_EP(b1.get_highest_lat(), 90.0);
+    COMPARE_EP(b1.get_width_m(), 10.0);
+    
+    COMPARE(b2.get_chunk_lat(), 89);
+    COMPARE(b2.get_chunk_lon(), 0);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 7);
+    
+    COMPARE(b1.gen_index(), b2.gen_index());
+    
+    SGGeod actualNorthPole1 = b1.get_corner(2);
+    SGGeod actualNorthPole2 = b1.get_corner(3);
+    COMPARE_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
+    COMPARE_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
+
+    SGBucket b3(-2, 89.88);
+    SGBucket b4(-7, 89.88);
+    COMPARE(b3.gen_index(), b4.gen_index());
+    
+    // south pole
+    SGBucket b5(-170, -89.88);
+    SGBucket b6(-179, -89.88);
+    
+    COMPARE(b5.get_chunk_lat(), -90);
+    COMPARE(b5.get_chunk_lon(), -180);
+    COMPARE(b5.get_x(), 0);
+    COMPARE(b5.get_y(), 0);
+    COMPARE(b5.gen_index(), b6.gen_index());
+    COMPARE_EP(b5.get_highest_lat(), -90.0);
+    COMPARE_EP(b5.get_width_m(), 10.0);
+    
+    SGGeod actualSouthPole1 = b5.get_corner(0);
+    SGGeod actualSouthPole2 = b5.get_corner(1);
+    COMPARE_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole1.getLongitudeDeg(), -180);
+    COMPARE_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole2.getLongitudeDeg(), -168);
+    
+    SGBucket b7(200, 89.88);
+    COMPARE(b7.get_chunk_lon(), -168);
+
+}
+
+// test the tiles just below the pole (between 86 & 89 degrees N/S)
+void testNearPolar()
+{
+    SGBucket b1(1, 88.5);
+    SGBucket b2(-1, 88.8);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_chunk_lat(), 88);
+    VERIFY(b1.gen_index() != b2.gen_index());
+
+    SGBucket b3(176.1, 88.5);
+    COMPARE(b3.get_chunk_lon(), 176);
+    
+    SGBucket b4(-178, 88.5);
+    COMPARE(b4.get_chunk_lon(), -180);
+}
+
+void testOffset()
+{
+    // bucket just below the 22 degree cutoff, so the next tile north
+    // is twice the width
+    SGBucket b1(-59.8, 21.9);
+    COMPARE(b1.get_chunk_lat(), 21);
+    COMPARE(b1.get_chunk_lon(), -60);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 7);
+    
+    // offset vertically
+    SGBucket b2(b1.sibling(0, 1));
+    COMPARE(b2.get_chunk_lat(), 22);
+    COMPARE(b2.get_chunk_lon(), -60);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 0);
+
+    COMPARE(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
+    
+    // offset vertically and horizontally. We compute horizontal (x)
+    // movement at the target latitude, so this should move 0.25 * -3 degrees,
+    // NOT 0.125 * -3 degrees.
+    SGBucket b3(b1.sibling(-3, 1));
+    COMPARE(b3.get_chunk_lat(), 22);
+    COMPARE(b3.get_chunk_lon(), -61);
+    COMPARE(b3.get_x(), 1);
+    COMPARE(b3.get_y(), 0);
+    
+    COMPARE(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
+}
+
+void testPolarOffset()
+{
+    SGBucket b1(-11.7, -89.6);
+    COMPARE(b1.get_chunk_lat(), -90);
+    COMPARE(b1.get_chunk_lon(), -12);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 3);
+    
+    // offset horizontally
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), -90);
+    COMPARE(b2.get_chunk_lon(), -36);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 3);
+    
+    COMPARE(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
+    
+// offset and wrap
+    SGBucket b3(-170, 89.1);
+    SGBucket b4(b3.sibling(-1, 0));
+    COMPARE(b4.get_chunk_lat(), 89);
+    COMPARE(b4.get_chunk_lon(), 168);
+    COMPARE(b4.get_x(), 0);
+    COMPARE(b4.get_y(), 0);
+    
+    COMPARE(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
+
+    
+    SGBucket b5(177, 87.3);
+    SGBucket b6(b5.sibling(1, 1));
+    COMPARE(b6.get_chunk_lat(), 87);
+    COMPARE(b6.get_chunk_lon(), -180);
+    COMPARE(b6.get_x(), 0);
+    COMPARE(b6.get_y(), 3);
+    
+    COMPARE(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
+
+    // offset vertically towards the pole
+    SGBucket b7(b1.sibling(0, -5));
+    VERIFY(!b7.isValid());
+    
+    VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
+}
+
+// test behaviour of bucket-offset near the anti-meridian (180-meridian)
+void testOffsetWrap()
+{
+    // near the equator
+    SGBucket b1(-179.8, 16.8);
+    COMPARE(b1.get_chunk_lat(), 16);
+    COMPARE(b1.get_chunk_lon(), -180);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 6);
+    
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), 16);
+    COMPARE(b2.get_chunk_lon(), 179);
+    COMPARE(b2.get_x(), 7);
+    COMPARE(b2.get_y(), 6);
+    COMPARE(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
+    
+    
+}
+
+int main(int argc, char* argv[])
+{
+    testBucketSpans();
+    
+    testBasic();
+    testPolar();
+    testNearPolar();
+    testOffset();
+    testOffsetWrap();
+    testPolarOffset();
+    
+    cout << "all tests passed OK" << endl;
+    return 0; // passed
+}
+

simgear/canvas/CMakeLists.txt

@@ -4,7 +4,6 @@ set(HEADERS
   canvas_fwd.hxx
   Canvas.hxx
   CanvasEvent.hxx
-  CanvasEventListener.hxx
   CanvasEventManager.hxx
   CanvasEventTypes.hxx
   CanvasEventVisitor.hxx
@@ -12,7 +11,7 @@ set(HEADERS
   CanvasObjectPlacement.hxx
   CanvasPlacement.hxx
   CanvasSystemAdapter.hxx
-  MouseEvent.hxx
+  CanvasWindow.hxx
   ODGauge.hxx
   VGInitOperation.hxx
 )
@@ -20,17 +19,19 @@ set(HEADERS
 set(SOURCES
   Canvas.cxx
   CanvasEvent.cxx
-  CanvasEventListener.cxx
   CanvasEventManager.cxx
   CanvasEventVisitor.cxx
   CanvasMgr.cxx
   CanvasObjectPlacement.cxx
   CanvasPlacement.cxx
+  CanvasWindow.cxx
   ODGauge.cxx
   VGInitOperation.cxx
 )
 
 add_subdirectory(ShivaVG/src)
 add_subdirectory(elements)
+add_subdirectory(events)
+add_subdirectory(layout)
 
 simgear_scene_component(canvas canvas "${SOURCES}" "${HEADERS}")

simgear/canvas/Canvas.cxx

@@ -19,8 +19,8 @@
 #include "Canvas.hxx"
 #include "CanvasEventManager.hxx"
 #include "CanvasEventVisitor.hxx"
-#include <simgear/canvas/MouseEvent.hxx>
-#include <simgear/canvas/CanvasPlacement.hxx>
+#include "CanvasPlacement.hxx"
+#include <simgear/canvas/events/MouseEvent.hxx>
 #include <simgear/scene/util/parse_color.hxx>
 #include <simgear/scene/util/RenderConstants.hxx>
 
@@ -48,8 +48,12 @@ namespace canvas
   void Canvas::CullCallback::operator()( osg::Node* node,
                                          osg::NodeVisitor* nv )
   {
-    if( (nv->getTraversalMask() & simgear::MODEL_BIT) && !_canvas.expired() )
-      _canvas.lock()->enableRendering();
+    if( (nv->getTraversalMask() & simgear::MODEL_BIT) )
+    {
+      CanvasPtr canvas = _canvas.lock();
+      if( canvas )
+        canvas->enableRendering();
+    }
 
     traverse(node, nv);
   }
@@ -72,6 +76,19 @@ namespace canvas
   {
     _status = 0;
     setStatusFlags(MISSING_SIZE_X | MISSING_SIZE_Y);
+
+    _root_group.reset( new Group(this, _node) );
+
+    // Remove automatically created property listener as we forward them on our
+    // own
+    _root_group->removeListener();
+    _cull_callback = new CullCallback(this);
+  }
+
+  //----------------------------------------------------------------------------
+  Canvas::~Canvas()
+  {
+
   }
 
   //----------------------------------------------------------------------------
@@ -84,19 +101,6 @@ namespace canvas
     }
   }
 
-  //----------------------------------------------------------------------------
-  void Canvas::setSystemAdapter(const SystemAdapterPtr& system_adapter)
-  {
-    _system_adapter = system_adapter;
-    _texture.setSystemAdapter(system_adapter);
-  }
-
-  //----------------------------------------------------------------------------
-  SystemAdapterPtr Canvas::getSystemAdapter() const
-  {
-    return _system_adapter;
-  }
-
   //----------------------------------------------------------------------------
   void Canvas::setCanvasMgr(CanvasMgr* canvas_mgr)
   {
@@ -187,6 +191,14 @@ namespace canvas
     return _root_group;
   }
 
+  //----------------------------------------------------------------------------
+  void Canvas::setLayout(const LayoutRef& layout)
+  {
+    _layout = layout;
+    _layout->setCanvas(this);
+    _status |= LAYOUT_DIRTY;
+  }
+
   //----------------------------------------------------------------------------
   void Canvas::enableRendering(bool force)
   {
@@ -198,11 +210,10 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Canvas::update(double delta_time_sec)
   {
-    if(    (!_texture.serviceable() && _status != STATUS_DIRTY)
-        || (_status & CREATE_FAILED) )
+    if( _status & (CREATE_FAILED | MISSING_SIZE) )
       return;
 
-    if( _status == STATUS_DIRTY )
+    if( _status & STATUS_DIRTY )
     {
       _texture.setSize(_size_x, _size_y);
 
@@ -221,15 +232,16 @@ namespace canvas
 
       osg::Camera* camera = _texture.getCamera();
 
+      // TODO Allow custom render order? For now just keep in order with
+      //      property tree.
+      camera->setRenderOrder(osg::Camera::PRE_RENDER, _node->getIndex());
+
       osg::Vec4 clear_color(0.0f, 0.0f, 0.0f , 1.0f);
       parseColor(_node->getStringValue("background"), clear_color);
       camera->setClearColor(clear_color);
 
       camera->addChild(_root_group->getMatrixTransform());
 
-      // Ensure objects are drawn in order of traversal
-      camera->getOrCreateStateSet()->setBinName("TraversalOrderBin");
-
       if( _texture.serviceable() )
       {
         setStatusFlags(STATUS_OK);
@@ -243,23 +255,36 @@ namespace canvas
       }
     }
 
+    if( _layout )
+    {
+      if( (_status & LAYOUT_DIRTY) )
+      {
+        _layout->setGeometry(SGRecti(0, 0, _view_width, _view_height));
+        _status &= ~LAYOUT_DIRTY;
+      }
+      else
+        _layout->update();
+    }
+
     if( _visible || _render_always )
     {
-      BOOST_FOREACH(CanvasWeakPtr canvas, _child_canvases)
+      BOOST_FOREACH(CanvasWeakPtr canvas_weak, _child_canvases)
       {
         // TODO should we check if the image the child canvas is displayed
         //      within is really visible?
-        if( !canvas.expired() )
-          canvas.lock()->_visible = true;
+        CanvasPtr canvas = canvas_weak.lock();
+        if( canvas )
+          canvas->_visible = true;
       }
 
       if( _render_dirty )
       {
         // Also mark all canvases this canvas is displayed within as dirty
-        BOOST_FOREACH(CanvasWeakPtr canvas, _parent_canvases)
+        BOOST_FOREACH(CanvasWeakPtr canvas_weak, _parent_canvases)
         {
-          if( !canvas.expired() )
-            canvas.lock()->_render_dirty = true;
+          CanvasPtr canvas = canvas_weak.lock();
+          if( canvas )
+            canvas->_render_dirty = true;
         }
       }
 
@@ -302,11 +327,7 @@ namespace canvas
       if( placement_factory != _placement_factories.end() )
       {
         Placements& placements = _placements[ node->getIndex() ] =
-          placement_factory->second
-          (
-            node,
-            boost::static_pointer_cast<Canvas>(_self.lock())
-          );
+          placement_factory->second(node, this);
         node->setStringValue
         (
           "status-msg",
@@ -319,12 +340,22 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  naRef Canvas::addEventListener(const nasal::CallContext& ctx)
+  bool Canvas::addEventListener( const std::string& type,
+                                 const EventListener& cb )
   {
     if( !_root_group.get() )
-      naRuntimeError(ctx.c, "Canvas: No root group!");
+      throw std::runtime_error("Canvas::addEventListener: no root group!");
 
-    return _root_group->addEventListener(ctx);
+    return _root_group->addEventListener(type, cb);
+  }
+
+  //----------------------------------------------------------------------------
+  bool Canvas::dispatchEvent(const EventPtr& event)
+  {
+    if( !_root_group.get() )
+      throw std::runtime_error("Canvas::dispatchEvent: no root group!");
+
+    return _root_group->dispatchEvent(event);
   }
 
   //----------------------------------------------------------------------------
@@ -379,6 +410,7 @@ namespace canvas
     if( _view_width == w )
       return;
     _view_width = w;
+    _status |= LAYOUT_DIRTY;
 
     _texture.setViewSize(_view_width, _view_height);
   }
@@ -389,6 +421,7 @@ namespace canvas
     if( _view_height == h )
       return;
     _view_height = h;
+    _status |= LAYOUT_DIRTY;
 
     _texture.setViewSize(_view_width, _view_height);
   }
@@ -414,18 +447,25 @@ namespace canvas
   //----------------------------------------------------------------------------
   bool Canvas::handleMouseEvent(const MouseEventPtr& event)
   {
-    if( !_root_group.get() )
+    if( !_root_group )
       return false;
 
     EventVisitor visitor( EventVisitor::TRAVERSE_DOWN,
                           event->getClientPos(),
-                          event->getDelta() );
+                          _root_group );
     if( !_root_group->accept(visitor) )
       return false;
 
     return _event_manager->handleEvent(event, visitor.getPropagationPath());
   }
 
+  //----------------------------------------------------------------------------
+  bool Canvas::propagateEvent( EventPtr const& event,
+                               EventPropagationPath const& path )
+  {
+    return _event_manager->propagateEvent(event, path);
+  }
+
   //----------------------------------------------------------------------------
   void Canvas::childAdded( SGPropertyNode * parent,
                            SGPropertyNode * child )
@@ -457,8 +497,10 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Canvas::valueChanged(SGPropertyNode* node)
   {
-    if(    boost::starts_with(node->getNameString(), "status")
-        || node->getParent()->getNameString() == "bounding-box" )
+    const std::string& name = node->getNameString();
+
+    if(    boost::starts_with(name, "status")
+        || boost::starts_with(name, "data-") )
       return;
     _render_dirty = true;
 
@@ -497,7 +539,7 @@ namespace canvas
     }
     else if( node->getParent() == _node )
     {
-      if( node->getNameString() == "background" )
+      if( name == "background" )
       {
         osg::Vec4 color;
         if( _texture.getCamera() && parseColor(node->getStringValue(), color) )
@@ -506,35 +548,41 @@ namespace canvas
           _render_dirty = true;
         }
       }
-      else if(    node->getNameString() == "mipmapping"
-              || node->getNameString() == "coverage-samples"
-              || node->getNameString() == "color-samples" )
+      else if(   name == "mipmapping"
+              || name == "coverage-samples"
+              || name == "color-samples" )
       {
         _sampling_dirty = true;
       }
-      else if( node->getNameString() == "additive-blend" )
+      else if( name == "additive-blend" )
       {
         _texture.useAdditiveBlend( node->getBoolValue() );
       }
-      else if( node->getNameString() == "render-always" )
+      else if( name == "render-always" )
       {
         _render_always = node->getBoolValue();
       }
-      else if( node->getNameString() == "size" )
+      else if( name == "size" )
       {
         if( node->getIndex() == 0 )
           setSizeX( node->getIntValue() );
         else if( node->getIndex() == 1 )
           setSizeY( node->getIntValue() );
       }
-      else if( node->getNameString() == "view" )
+      else if( name == "update" )
+      {
+        if( _root_group )
+          _root_group->update(0);
+        return update(0);
+      }
+      else if( name == "view" )
       {
         if( node->getIndex() == 0 )
           setViewWidth( node->getIntValue() );
         else if( node->getIndex() == 1 )
           setViewHeight( node->getIntValue() );
       }
-      else if( node->getNameString() == "freeze" )
+      else if( name == "freeze" )
         _texture.setRender( node->getBoolValue() );
       else
         handled = false;
@@ -585,27 +633,38 @@ namespace canvas
       (
         SG_GENERAL,
         SG_WARN,
-        "Canvas::addPlacementFactory: replace existing factor for type " << type
+        "Canvas::addPlacementFactory: replace existing factory '" << type << "'"
       );
 
     _placement_factories[type] = factory;
   }
 
   //----------------------------------------------------------------------------
-  void Canvas::setSelf(const PropertyBasedElementPtr& self)
+  void Canvas::removePlacementFactory(const std::string& type)
   {
-    PropertyBasedElement::setSelf(self);
+    PlacementFactoryMap::iterator it = _placement_factories.find(type);
+    if( it == _placement_factories.end() )
+      SG_LOG
+      (
+        SG_GENERAL,
+        SG_WARN,
+        "Canvas::removePlacementFactory: no such factory '" << type << "'"
+      );
+    else
+      _placement_factories.erase(it);
+  }
 
-    CanvasPtr canvas = boost::static_pointer_cast<Canvas>(self);
 
-    _root_group.reset( new Group(canvas, _node) );
-    _root_group->setSelf(_root_group);
+  //----------------------------------------------------------------------------
+  void Canvas::setSystemAdapter(const SystemAdapterPtr& system_adapter)
+  {
+    _system_adapter = system_adapter;
+  }
 
-    // Remove automatically created property listener as we forward them on our
-    // own
-    _root_group->removeListener();
-
-    _cull_callback = new CullCallback(canvas);
+  //----------------------------------------------------------------------------
+  SystemAdapterPtr Canvas::getSystemAdapter()
+  {
+    return _system_adapter;
   }
 
   //----------------------------------------------------------------------------
@@ -624,7 +683,7 @@ namespace canvas
       _status_msg = "Missing size-y";
     else if( _status & CREATE_FAILED )
       _status_msg = "Creating render target failed";
-    else if( _status == STATUS_DIRTY )
+    else if( _status & STATUS_DIRTY )
       _status_msg = "Creation pending...";
     else
       _status_msg = "Ok";
@@ -632,6 +691,7 @@ namespace canvas
 
   //----------------------------------------------------------------------------
   Canvas::PlacementFactoryMap Canvas::_placement_factories;
+  SystemAdapterPtr Canvas::_system_adapter;
 
 } // namespace canvas
 } // namespace simgear

simgear/canvas/Canvas.hxx

@@ -1,4 +1,4 @@
-// The canvas for rendering with the 2d API
+///@file The canvas for rendering with the 2d API
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -23,33 +23,40 @@
 #include "ODGauge.hxx"
 
 #include <simgear/canvas/elements/CanvasGroup.hxx>
+#include <simgear/canvas/layout/Layout.hxx>
 #include <simgear/math/SGRect.hxx>
+#include <simgear/nasal/cppbind/NasalObject.hxx>
 #include <simgear/props/PropertyBasedElement.hxx>
 #include <simgear/props/propertyObject.hxx>
+
 #include <osg/NodeCallback>
 #include <osg/observer_ptr>
 
-#include <memory>
+#include <boost/scoped_ptr.hpp>
 #include <string>
 
 namespace simgear
 {
+/// Canvas 2D drawing API
 namespace canvas
 {
   class CanvasMgr;
   class MouseEvent;
 
   class Canvas:
-    public PropertyBasedElement
+    public PropertyBasedElement,
+    public nasal::Object
   {
     public:
 
       enum StatusFlags
       {
         STATUS_OK,
-        STATUS_DIRTY     = 1,
-        MISSING_SIZE_X = STATUS_DIRTY << 1,
+        STATUS_DIRTY   = 1,
+        LAYOUT_DIRTY   = STATUS_DIRTY << 1,
+        MISSING_SIZE_X = LAYOUT_DIRTY << 1,
         MISSING_SIZE_Y = MISSING_SIZE_X << 1,
+        MISSING_SIZE   = MISSING_SIZE_X | MISSING_SIZE_Y,
         CREATE_FAILED  = MISSING_SIZE_Y << 1
       };
 
@@ -71,11 +78,9 @@ namespace canvas
       typedef osg::ref_ptr<CullCallback> CullCallbackPtr;
 
       Canvas(SGPropertyNode* node);
+      virtual ~Canvas();
       virtual void onDestroy();
 
-      void setSystemAdapter(const SystemAdapterPtr& system_adapter);
-      SystemAdapterPtr getSystemAdapter() const;
-
       void setCanvasMgr(CanvasMgr* canvas_mgr);
       CanvasMgr* getCanvasMgr() const;
 
@@ -122,6 +127,12 @@ namespace canvas
        */
       GroupPtr getRootGroup();
 
+      /**
+       * Set the layout of the canvas (the layout will automatically update with
+       * the viewport size of the canvas)
+       */
+      void setLayout(const LayoutRef& layout);
+
       /**
        * Enable rendering for the next frame
        *
@@ -132,7 +143,8 @@ namespace canvas
 
       void update(double delta_time_sec);
 
-      naRef addEventListener(const nasal::CallContext& ctx);
+      bool addEventListener(const std::string& type, const EventListener& cb);
+      bool dispatchEvent(const EventPtr& event);
 
       void setSizeX(int sx);
       void setSizeY(int sy);
@@ -148,6 +160,8 @@ namespace canvas
       SGRect<int> getViewport() const;
 
       bool handleMouseEvent(const MouseEventPtr& event);
+      bool propagateEvent( EventPtr const& event,
+                           EventPropagationPath const& path );
 
       virtual void childAdded( SGPropertyNode * parent,
                                SGPropertyNode * child );
@@ -162,13 +176,23 @@ namespace canvas
       void reloadPlacements( const std::string& type = std::string() );
       static void addPlacementFactory( const std::string& type,
                                        PlacementFactory factory );
+      static void removePlacementFactory(const std::string& type);
+
+      /**
+       * Set global SystemAdapter for all Canvas/ODGauge instances.
+       *
+       * The SystemAdapter is responsible for application specific operations
+       * like loading images/fonts and adding/removing cameras to the scene
+       * graph.
+       */
+      static void setSystemAdapter(const SystemAdapterPtr& system_adapter);
+      static SystemAdapterPtr getSystemAdapter();
 
     protected:
 
-      SystemAdapterPtr  _system_adapter;
       CanvasMgr        *_canvas_mgr;
 
-      std::auto_ptr<EventManager>   _event_manager;
+      boost::scoped_ptr<EventManager> _event_manager;
 
       int _size_x,
           _size_y,
@@ -183,7 +207,9 @@ namespace canvas
            _visible;
 
       ODGauge _texture;
-      GroupPtr _root_group;
+
+      GroupPtr  _root_group;
+      LayoutRef _layout;
 
       CullCallbackPtr _cull_callback;
       bool _render_always; //<! Used to disable automatic lazy rendering (culling)
@@ -197,11 +223,12 @@ namespace canvas
       typedef std::map<std::string, PlacementFactory> PlacementFactoryMap;
       static PlacementFactoryMap _placement_factories;
 
-      virtual void setSelf(const PropertyBasedElementPtr& self);
       void setStatusFlags(unsigned int flags, bool set = true);
 
     private:
 
+      static SystemAdapterPtr _system_adapter;
+
       Canvas(const Canvas&); // = delete;
       Canvas& operator=(const Canvas&); // = delete;
   };

simgear/canvas/CanvasEvent.cxx

@@ -26,6 +26,7 @@ namespace canvas
   //----------------------------------------------------------------------------
   Event::Event():
     type(UNKNOWN),
+    time(-1),
     propagation_stopped(false)
   {
 
@@ -38,7 +39,13 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  Event::Type Event::getType() const
+  bool Event::canBubble() const
+  {
+    return true;
+  }
+
+  //----------------------------------------------------------------------------
+  int Event::getType() const
   {
     return type;
   }
@@ -46,14 +53,7 @@ namespace canvas
   //----------------------------------------------------------------------------
   std::string Event::getTypeString() const
   {
-    switch( type )
-    {
-#     define ENUM_MAPPING(name, str) case name: return str;
-#       include "CanvasEventTypes.hxx"
-#     undef ENUM_MAPPING
-      default:
-        return "unknown";
-    }
+    return typeToStr(type);
   }
 
   //----------------------------------------------------------------------------
@@ -62,6 +62,12 @@ namespace canvas
     return target;
   }
 
+  //----------------------------------------------------------------------------
+  ElementWeakPtr Event::getCurrentTarget() const
+  {
+    return current_target;
+  }
+
   //----------------------------------------------------------------------------
   double Event::getTime() const
   {
@@ -75,23 +81,57 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  Event::Type Event::strToType(const std::string& str)
+  int Event::getOrRegisterType(const std::string& type_str)
+  {
+    int type = strToType(type_str);
+
+    if( type == UNKNOWN )
+    {
+      // Register new type
+      TypeMap& type_map = getTypeMap();
+      type = type_map.size() + 1; // ids start with 1 (after UNKNOWN)
+      type_map.insert(TypeMap::value_type(type_str, type));
+    }
+
+    return type;
+  }
+
+  //----------------------------------------------------------------------------
+  int Event::strToType(const std::string& str)
+  {
+    TypeMap const& type_map = getTypeMap();
+
+    TypeMap::map_by<name>::const_iterator it = type_map.by<name>().find(str);
+    if( it == type_map.by<name>().end() )
+      return UNKNOWN;
+    return it->second;
+  }
+
+  //----------------------------------------------------------------------------
+  std::string Event::typeToStr(int type)
+  {
+    TypeMap const& type_map = getTypeMap();
+
+    TypeMap::map_by<id>::const_iterator it = type_map.by<id>().find(type);
+    if( it == type_map.by<id>().end() )
+      return "unknown";
+    return it->second;
+  }
+
+  //----------------------------------------------------------------------------
+  Event::TypeMap& Event::getTypeMap()
   {
-    typedef std::map<std::string, Type> TypeMap;
     static TypeMap type_map;
 
     if( type_map.empty() )
     {
-#     define ENUM_MAPPING(type, str) type_map[ str ] = type;
-#       include "CanvasEventTypes.hxx"
-#     undef ENUM_MAPPING
+#   define ENUM_MAPPING(type, str)\
+      type_map.insert(TypeMap::value_type(str, type));
+#     include "CanvasEventTypes.hxx"
+#   undef ENUM_MAPPING
     }
 
-    TypeMap::const_iterator it = type_map.find(str);
-    if( it == type_map.end() )
-      return UNKNOWN;
-
-    return it->second;
+    return type_map;
   }
 
 } // namespace canvas

simgear/canvas/CanvasEvent.hxx

@@ -20,13 +20,15 @@
 #define CANVAS_EVENT_HXX_
 
 #include "canvas_fwd.hxx"
+#include <boost/bimap.hpp>
 
 namespace simgear
 {
 namespace canvas
 {
 
-  class Event
+  class Event:
+    public SGReferenced
   {
     public:
 
@@ -36,12 +38,13 @@ namespace canvas
 #       define ENUM_MAPPING(name, str) name,
 #         include "CanvasEventTypes.hxx"
 #       undef ENUM_MAPPING
-        USER_TYPE ///<! first unused id to be used for user defined types (not
-                  ///   implemented yet)
+        CUSTOM_EVENT ///< all user defined event types share the same id. They
+                     ///  are just differentiated by using the type string.
       };
 
-      Type              type;
-      ElementWeakPtr    target;
+      int               type;
+      ElementWeakPtr    target,
+                        current_target;
       double            time;
       bool              propagation_stopped;
 
@@ -51,16 +54,41 @@ namespace canvas
       // of the actual event instances.
       virtual ~Event();
 
-      Type getType() const;
+      /**
+       * Get whether this events support bubbling
+       */
+      virtual bool canBubble() const;
+
+      /**
+       * Set type of event.
+       *
+       * If no such type exists it is registered.
+       */
+      void setType(const std::string& type);
+
+      int getType() const;
       std::string getTypeString() const;
 
       ElementWeakPtr getTarget() const;
+      ElementWeakPtr getCurrentTarget() const;
 
       double getTime() const;
 
       void stopPropagation();
 
-      static Type strToType(const std::string& str);
+      static int getOrRegisterType(const std::string& type);
+      static int strToType(const std::string& type);
+      static std::string typeToStr(int type);
+
+    protected:
+      struct name {};
+      struct id {};
+      typedef boost::bimaps::bimap<
+        boost::bimaps::tagged<std::string, name>,
+        boost::bimaps::tagged<int, id>
+      > TypeMap;
+
+      static TypeMap& getTypeMap();
 
   };
 

simgear/canvas/CanvasEventManager.cxx

@@ -17,8 +17,9 @@
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
 #include "CanvasEventManager.hxx"
-#include "MouseEvent.hxx"
+#include <simgear/canvas/events/MouseEvent.hxx>
 #include <simgear/canvas/elements/CanvasElement.hxx>
+#include <cmath>
 
 namespace simgear
 {
@@ -60,6 +61,16 @@ namespace canvas
     return !path.empty() && time > 0;
   }
 
+  //----------------------------------------------------------------------------
+  void EventManager::MouseEventInfo::set( const MouseEventPtr& event,
+                                          const EventPropagationPath& p )
+  {
+    path = p;
+    time = event->time;
+    button = event->button;
+    pos = event->screen_pos;
+  }
+
   //----------------------------------------------------------------------------
   EventManager::EventManager():
     _current_click_count(0)
@@ -71,39 +82,58 @@ namespace canvas
   bool EventManager::handleEvent( const MouseEventPtr& event,
                                   const EventPropagationPath& path )
   {
+    bool handled = false;
     switch( event->type )
     {
       case Event::MOUSE_DOWN:
-        _last_mouse_down = StampedPropagationPath(path, event->getTime());
+        _last_mouse_down.set(event, path);
         break;
       case Event::MOUSE_UP:
       {
-        if( _last_mouse_down.path.empty() )
-          // Ignore mouse up without any previous mouse down
-          return false;
+        // If the mouse has moved while a button was down (aka. dragging) we
+        // need to notify the original element that the mouse has left it, and
+        // the new element that it has been entered
+        if( _last_mouse_down.path != path )
+          handled |= handleMove(event, path);
 
         // normal mouseup
-        propagateEvent(event, path);
+        handled |= propagateEvent(event, path);
+
+        if( !_last_mouse_down.valid() )
+          // Ignore mouse up without any previous mouse down
+          return handled;
 
         // now handle click/dblclick
-        if( checkClickDistance(path, _last_mouse_down.path) )
-          handleClick(event, getCommonAncestor(_last_mouse_down.path, path));
+        if( checkClickDistance(event->screen_pos, _last_mouse_down.pos) )
+          handled |=
+            handleClick(event, getCommonAncestor(_last_mouse_down.path, path));
 
         _last_mouse_down.clear();
 
-        return true;
+        return handled;
       }
       case Event::DRAG:
         if( !_last_mouse_down.valid() )
           return false;
         else
+        {
+          // OSG does not set button for drag events.
+          event->button = _last_mouse_down.button;
           return propagateEvent(event, _last_mouse_down.path);
+        }
       case Event::MOUSE_MOVE:
-        handleMove(event, path);
+        handled |= handleMove(event, path);
         break;
       case Event::MOUSE_LEAVE:
         // Mouse leaves window and therefore also current mouseover element
         handleMove(event, EventPropagationPath());
+
+        // Event is only send if mouse is moved outside the window or dragging
+        // has ended somewhere outside the window. In both cases a mouse button
+        // has been released, so no more mouse down or click...
+        _last_mouse_down.clear();
+        _last_click.clear();
+
         return true;
       case Event::WHEEL:
         break;
@@ -111,11 +141,76 @@ namespace canvas
         return false;
     }
 
-    return propagateEvent(event, path);
+    return handled | propagateEvent(event, path);
   }
 
   //----------------------------------------------------------------------------
-  void EventManager::handleClick( const MouseEventPtr& event,
+  bool EventManager::propagateEvent( const EventPtr& event,
+                                     const EventPropagationPath& path )
+  {
+    event->target = path.back().element;
+    MouseEventPtr mouse_event = dynamic_cast<MouseEvent*>(event.get());
+
+    // Event propagation similar to DOM Level 3 event flow:
+    // http://www.w3.org/TR/DOM-Level-3-Events/#event-flow
+
+    // Position update only needed for drag event (as event needs to be
+    // delivered to element of initial mousedown, but with update positions)
+    if( mouse_event && mouse_event->type == MouseEvent::DRAG )
+    {
+      osg::Vec2f local_pos = mouse_event->client_pos;
+
+      // Capturing phase (currently just update position)
+      for( EventPropagationPath::const_iterator it = path.begin();
+                                                it != path.end();
+                                              ++it )
+      {
+        ElementPtr el = it->element.lock();
+        if( !el )
+          continue;
+
+        it->local_pos = local_pos = el->posToLocal(local_pos);
+      }
+    }
+
+    bool const do_bubble = event->canBubble();
+
+    // Bubbling phase
+    for( EventPropagationPath::const_reverse_iterator
+           it = path.rbegin();
+           it != path.rend();
+         ++it )
+    {
+      ElementPtr el = it->element.lock();
+
+      if( !el )
+      {
+        // Ignore element if it has been destroyed while traversing the event
+        // (eg. removed by another event handler)
+        if( do_bubble )
+          continue;
+        else
+          break;
+      }
+
+      // TODO provide functions to convert delta to local coordinates on demand.
+      //      Maybe also provide a clone method for events as local coordinates
+      //      might differ between different elements receiving the same event.
+      if( mouse_event )
+        mouse_event->local_pos = it->local_pos;
+
+      event->current_target = el;
+      el->handleEvent(event);
+
+      if( event->propagation_stopped || !do_bubble )
+        return true;
+    }
+
+    return true;
+  }
+
+  //----------------------------------------------------------------------------
+  bool EventManager::handleClick( const MouseEventPtr& event,
                                   const EventPropagationPath& path )
   {
     MouseEventPtr click(new MouseEvent(*event));
@@ -130,8 +225,10 @@ namespace canvas
 
       if( _current_click_count > 1 )
       {
-        // Reset current click count if moved too far
-        if( !checkClickDistance(path, _last_click.path) )
+        // Reset current click count if moved too far or different button has
+        // been clicked
+        if(   !checkClickDistance(event->screen_pos, _last_click.pos)
+            || _last_click.button != event->button )
           _current_click_count = 1;
       }
     }
@@ -145,28 +242,33 @@ namespace canvas
       dbl_click->type = Event::DBL_CLICK;
     }
 
-    propagateEvent(click, path);
+    bool handled = propagateEvent(click, path);
 
     if( dbl_click )
-      propagateEvent(dbl_click, getCommonAncestor(_last_click.path, path));
+      handled |= propagateEvent( dbl_click,
+                                 getCommonAncestor(_last_click.path, path) );
 
-    _last_click = StampedPropagationPath(path, event->getTime());
+    _last_click.set(event, path);
+
+    return handled;
   }
 
   //----------------------------------------------------------------------------
-  void EventManager::handleMove( const MouseEventPtr& event,
+  bool EventManager::handleMove( const MouseEventPtr& event,
                                  const EventPropagationPath& path )
   {
     EventPropagationPath& last_path = _last_mouse_over.path;
     if( last_path == path )
-      return;
+      return false;
+
+    bool handled = false;
 
     // Leave old element
     if( !last_path.empty() )
     {
       MouseEventPtr mouseout(new MouseEvent(*event));
       mouseout->type = Event::MOUSE_OUT;
-      propagateEvent(mouseout, last_path);
+      handled |= propagateEvent(mouseout, last_path);
 
       // Send a mouseleave event to all ancestors of the currently left element
       // which are not ancestor of the new element currently entered
@@ -178,7 +280,7 @@ namespace canvas
 
         MouseEventPtr mouseleave(new MouseEvent(*event));
         mouseleave->type = Event::MOUSE_LEAVE;
-        propagateEvent(mouseleave, path_leave);
+        handled |= propagateEvent(mouseleave, path_leave);
 
         path_leave.pop_back();
       }
@@ -189,7 +291,7 @@ namespace canvas
     {
       MouseEventPtr mouseover(new MouseEvent(*event));
       mouseover->type = Event::MOUSE_OVER;
-      propagateEvent(mouseover, path);
+      handled |= propagateEvent(mouseover, path);
 
       // Send a mouseenter event to all ancestors of the currently entered
       // element which are not ancestor of the old element currently being
@@ -204,77 +306,22 @@ namespace canvas
 
         MouseEventPtr mouseenter(new MouseEvent(*event));
         mouseenter->type = Event::MOUSE_ENTER;
-        propagateEvent(mouseenter, path_enter);
+        handled |= propagateEvent(mouseenter, path_enter);
       }
     }
 
     _last_mouse_over.path = path;
-  }
-
-  //----------------------------------------------------------------------------
-  bool EventManager::propagateEvent( const EventPtr& event,
-                                     const EventPropagationPath& path )
-  {
-    event->target = path.back().element;
-    MouseEventPtr mouse_event = boost::dynamic_pointer_cast<MouseEvent>(event);
-
-    // Event propagation similar to DOM Level 3 event flow:
-    // http://www.w3.org/TR/DOM-Level-3-Events/#event-flow
-
-    // Capturing phase
-//    for( EventPropagationPath::const_iterator it = path.begin();
-//                                              it != path.end();
-//                                            ++it )
-//    {
-//      if( !it->element.expired() )
-//        std::cout << it->element.lock()->getProps()->getPath() << std::endl;
-//    }
-
-    // Bubbling phase
-    for( EventPropagationPath::const_reverse_iterator
-           it = path.rbegin();
-           it != path.rend();
-         ++it )
-    {
-      ElementPtr el = it->element.lock();
-
-      if( !el )
-        // Ignore element if it has been destroyed while traversing the event
-        // (eg. removed by another event handler)
-        continue;
-
-      // TODO provide functions to convert delta to local coordinates on demand.
-      //      Maybe also provide a clone method for events as local coordinates
-      //      might differ between different elements receiving the same event.
-      if( mouse_event ) //&& event->type != Event::DRAG )
-      {
-        // TODO transform pos and delta for drag events. Maybe we should just
-        //      store the global coordinates and convert to local coordinates
-        //      on demand.
-
-        // Position and delta are specified in local coordinate system of
-        // current element
-        mouse_event->local_pos = it->local_pos;
-        //mouse_event->delta = it->local_delta;
-      }
-
-      el->handleEvent(event);
-
-      if( event->propagation_stopped )
-        return true;
-    }
-
-    return true;
+    return handled;
   }
 
   //----------------------------------------------------------------------------
   bool
-  EventManager::checkClickDistance( const EventPropagationPath& path1,
-                                    const EventPropagationPath& path2 ) const
+  EventManager::checkClickDistance( const osg::Vec2f& pos1,
+                                    const osg::Vec2f& pos2 ) const
   {
-    osg::Vec2 delta = path1.front().local_pos - path2.front().local_pos;
-    return delta.x() < drag_threshold
-        && delta.y() < drag_threshold;
+    osg::Vec2 delta = pos1 - pos2;
+    return std::fabs(delta.x()) < drag_threshold
+        && std::fabs(delta.y()) < drag_threshold;
   }
 
   //----------------------------------------------------------------------------

simgear/canvas/CanvasEventManager.hxx

@@ -29,11 +29,18 @@ namespace canvas
 
   struct EventTarget
   {
-    ElementWeakPtr  element;
-    osg::Vec2f      local_pos,
-                    local_delta;
+    ElementWeakPtr      element;
+
+    // Used as storage by EventManager during event propagation
+    mutable osg::Vec2f  local_pos;
+
+    EventTarget( Element* el,
+                 const osg::Vec2f pos = osg::Vec2f() ):
+      element(el),
+      local_pos(pos)
+    {}
   };
-  typedef std::deque<EventTarget> EventPropagationPath;
+
   inline bool operator==(const EventTarget& t1, const EventTarget& t2)
   {
     return t1.element.lock() == t2.element.lock();
@@ -47,6 +54,9 @@ namespace canvas
       bool handleEvent( const MouseEventPtr& event,
                         const EventPropagationPath& path );
 
+      bool propagateEvent( const EventPtr& event,
+                           const EventPropagationPath& path );
+
     protected:
       struct StampedPropagationPath
       {
@@ -62,33 +72,39 @@ namespace canvas
 
       // TODO if we really need the paths modify to not copy around the paths
       //      that much.
-      StampedPropagationPath _last_mouse_down,
-                             _last_click,
-                             _last_mouse_over;
+      StampedPropagationPath _last_mouse_over;
       size_t _current_click_count;
 
+      struct MouseEventInfo:
+        public StampedPropagationPath
+      {
+        int button;
+        osg::Vec2f pos;
+
+        void set( const MouseEventPtr& event,
+                  const EventPropagationPath& path );
+      } _last_mouse_down,
+        _last_click;
+
       /**
        * Propagate click event and handle multi-click (eg. create dblclick)
        */
-      void handleClick( const MouseEventPtr& event,
+      bool handleClick( const MouseEventPtr& event,
                         const EventPropagationPath& path );
 
       /**
        * Handle mouseover/enter/out/leave
        */
-      void handleMove( const MouseEventPtr& event,
+      bool handleMove( const MouseEventPtr& event,
                        const EventPropagationPath& path );
 
-      bool propagateEvent( const EventPtr& event,
-                           const EventPropagationPath& path );
-
       /**
        * Check if two click events (either mousedown/up or two consecutive
        * clicks) are inside a maximum distance to still create a click or
        * dblclick event respectively.
        */
-      bool checkClickDistance( const EventPropagationPath& path1,
-                               const EventPropagationPath& path2 ) const;
+      bool checkClickDistance( const osg::Vec2f& pos1,
+                               const osg::Vec2f& pos2 ) const;
       EventPropagationPath
       getCommonAncestor( const EventPropagationPath& path1,
                          const EventPropagationPath& path2 ) const;

simgear/canvas/CanvasEventVisitor.cxx

@@ -20,7 +20,6 @@
 #include "CanvasEvent.hxx"
 #include "CanvasEventVisitor.hxx"
 #include <simgear/canvas/elements/CanvasElement.hxx>
-#include <iostream>
 
 namespace simgear
 {
@@ -30,14 +29,12 @@ namespace canvas
   //----------------------------------------------------------------------------
   EventVisitor::EventVisitor( TraverseMode mode,
                               const osg::Vec2f& pos,
-                              const osg::Vec2f& delta ):
-    _traverse_mode( mode )
+                              const ElementPtr& root ):
+    _traverse_mode( mode ),
+    _root(root)
   {
     if( mode == TRAVERSE_DOWN )
-    {
-      EventTarget target = {ElementWeakPtr(), pos, delta};
-      _target_path.push_back(target);
-    }
+      _target_path.push_back( EventTarget(NULL, pos) );
   }
 
   //----------------------------------------------------------------------------
@@ -61,32 +58,20 @@ namespace canvas
     // We only need to check for hits while traversing down
     if( _traverse_mode == TRAVERSE_DOWN )
     {
-      // Transform event to local coordinates
-      const osg::Matrix& m = el.getMatrixTransform()->getInverseMatrix();
       const osg::Vec2f& pos = _target_path.back().local_pos;
-      const osg::Vec2f local_pos
-      (
-        m(0, 0) * pos[0] + m(1, 0) * pos[1] + m(3, 0),
-        m(0, 1) * pos[0] + m(1, 1) * pos[1] + m(3, 1)
-      );
+      const osg::Vec2f local_pos = el.posToLocal(pos);
 
-      // Don't check collision with root element (2nd element in _target_path)
-      // do event listeners attached to the canvas itself (its root group)
-      // always get called even if no element has been hit.
-      if( _target_path.size() > 1 && !el.hitBound(pos, local_pos) )
+      // Don't check specified root element for collision, as its purpose is to
+      // catch all events which have no target. This allows for example calling
+      // event listeners attached to the canvas itself (its root group) even if
+      // no element has been hit.
+      if(    _root.get() != &el
+          && !el.hitBound(_target_path.front().local_pos, pos, local_pos) )
         return false;
 
-      const osg::Vec2f& delta = _target_path.back().local_delta;
-      const osg::Vec2f local_delta
-      (
-        m(0, 0) * delta[0] + m(1, 0) * delta[1],
-        m(0, 1) * delta[0] + m(1, 1) * delta[1]
-      );
+      _target_path.push_back( EventTarget(&el, local_pos) );
 
-      EventTarget target = {el.getWeakPtr(), local_pos, local_delta};
-      _target_path.push_back(target);
-
-      if( el.traverse(*this) || _target_path.size() <= 2 )
+      if( el.traverse(*this) || &el == _root.get() )
         return true;
 
       _target_path.pop_back();

simgear/canvas/CanvasEventVisitor.hxx

@@ -38,9 +38,15 @@ namespace canvas
         TRAVERSE_DOWN
       };
 
+      /**
+       *
+       * @param mode
+       * @param pos     Mouse position
+       * @param root    Element to dispatch events to if no element is hit
+       */
       EventVisitor( TraverseMode mode,
                     const osg::Vec2f& pos,
-                    const osg::Vec2f& delta );
+                    const ElementPtr& root = ElementPtr() );
       virtual ~EventVisitor();
       virtual bool traverse(Element& el);
       virtual bool apply(Element& el);
@@ -51,6 +57,7 @@ namespace canvas
 
       TraverseMode          _traverse_mode;
       EventPropagationPath  _target_path;
+      ElementPtr            _root;
 
   };
 

simgear/canvas/CanvasMgr.cxx

@@ -18,6 +18,7 @@
 
 #include "CanvasMgr.hxx"
 #include "Canvas.hxx"
+#include "CanvasEventManager.hxx"
 
 #include <boost/bind.hpp>
 
@@ -35,10 +36,8 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  CanvasMgr::CanvasMgr( SGPropertyNode_ptr node,
-                        SystemAdapterPtr system_adapter ):
-    PropertyBasedMgr(node, "texture", &canvasFactory),
-    _system_adapter(system_adapter)
+  CanvasMgr::CanvasMgr(SGPropertyNode_ptr node):
+    PropertyBasedMgr(node, "texture", &canvasFactory)
   {
 
   }
@@ -46,26 +45,25 @@ namespace canvas
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::createCanvas(const std::string& name)
   {
-    return boost::static_pointer_cast<Canvas>( createElement(name) );
+    return static_cast<Canvas*>( createElement(name).get() );
   }
 
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::getCanvas(size_t index) const
   {
-    return boost::static_pointer_cast<Canvas>( getElement(index) );
+    return static_cast<Canvas*>( getElement(index).get() );
   }
 
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::getCanvas(const std::string& name) const
   {
-    return boost::static_pointer_cast<Canvas>( getElement(name) );
+    return static_cast<Canvas*>( getElement(name).get() );
   }
 
   //----------------------------------------------------------------------------
   void CanvasMgr::elementCreated(PropertyBasedElementPtr element)
   {
-    CanvasPtr canvas = boost::static_pointer_cast<Canvas>(element);
-    canvas->setSystemAdapter(_system_adapter);
+    CanvasPtr canvas = static_cast<Canvas*>(element.get());
     canvas->setCanvasMgr(this);
   }
 

simgear/canvas/CanvasMgr.hxx

@@ -33,13 +33,9 @@ namespace canvas
     public:
 
       /**
-       * @param node            Root node of branch used to control canvasses
-       * @param system_adapter  Adapter for connecting between canvas and
-       *                        application framework
-       *
+       * @param node    Root node of branch used to control canvasses
        */
-      CanvasMgr( SGPropertyNode_ptr node,
-                 SystemAdapterPtr system_adapter );
+      CanvasMgr(SGPropertyNode_ptr node);
 
       /**
        * Create a new canvas
@@ -65,8 +61,6 @@ namespace canvas
 
     protected:
 
-      SystemAdapterPtr _system_adapter;
-
       virtual void elementCreated(PropertyBasedElementPtr element);
   };
 

simgear/canvas/CanvasObjectPlacement.cxx

@@ -21,7 +21,7 @@
 
 #include "Canvas.hxx"
 #include "CanvasObjectPlacement.hxx"
-#include "MouseEvent.hxx"
+#include <simgear/canvas/events/MouseEvent.hxx>
 
 #include <simgear/props/props.hxx>
 #include <simgear/scene/util/SGPickCallback.hxx>

simgear/canvas/CanvasObjectPlacement.hxx

@@ -1,4 +1,4 @@
-// Canvas placement for placing a canvas texture onto osg objects.
+///@file Placement for putting a canvas texture onto OpenSceneGraph objects.
 //
 // It also provides a SGPickCallback for passing mouse events to the canvas and
 // manages emissive lighting of the placed canvas.
@@ -19,7 +19,7 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
-#ifndef CANVAS_PICK_PLACEMENT_HXX_
+#ifndef CANVAS_OBJECT_PLACEMENT_HXX_
 #define CANVAS_OBJECT_PLACEMENT_HXX_
 
 #include "CanvasPlacement.hxx"
@@ -33,6 +33,9 @@ namespace simgear
 namespace canvas
 {
 
+  /**
+   * Place a Canvas onto an osg object (as texture).
+   */
   class ObjectPlacement:
     public Placement
   {
@@ -72,4 +75,4 @@ namespace canvas
 } // namespace canvas
 } // namespace simgear
 
-#endif /* CANVAS_PICK_PLACEMENT_HXX_ */
+#endif /* CANVAS_OBJECT_PLACEMENT_HXX_ */

simgear/canvas/CanvasSystemAdapter.hxx

@@ -20,10 +20,12 @@
 #define SG_CANVAS_SYSTEM_ADAPTER_HXX_
 
 #include "canvas_fwd.hxx"
-#include <simgear/nasal/nasal.h>
+
+class SGSubsystem;
 
 namespace simgear
 {
+namespace HTTP { class Client; }
 namespace canvas
 {
 
@@ -36,29 +38,8 @@ namespace canvas
       virtual void addCamera(osg::Camera* camera) const = 0;
       virtual void removeCamera(osg::Camera* camera) const = 0;
       virtual osg::Image* getImage(const std::string& path) const = 0;
-
-      virtual naContext getNasalContext() const = 0;
-
-      /**
-       * Save passed reference to Nasal object from being deleted by the
-       * garbage collector.
-       */
-      virtual int gcSave(naRef r) = 0;
-
-      /**
-       * Release an object previously passed to ::gcSave to allow it being
-       * cleaned up by the garbage collector.
-       */
-      virtual void gcRelease(int key) = 0;
-
-      /**
-       * Call a Nasal function with the given environment and arguments.
-       */
-      virtual naRef callMethod( naRef code,
-                                naRef self,
-                                int argc,
-                                naRef* args,
-                                naRef locals ) = 0;
+      virtual SGSubsystem* getSubsystem(const std::string& name) const = 0;
+      virtual HTTP::Client* getHTTPClient() const = 0;
   };
 
 } // namespace canvas

simgear/canvas/CanvasWindow.cxx

@@ -0,0 +1,330 @@
+// Window for placing a Canvas onto it (for dialogs, menus, etc.)
+//
+// Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "CanvasMgr.hxx"
+#include "CanvasSystemAdapter.hxx"
+#include "CanvasWindow.hxx"
+
+#include <simgear/canvas/Canvas.hxx>
+#include <simgear/scene/util/OsgMath.hxx>
+
+#include <osgGA/GUIEventHandler>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/foreach.hpp>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  const std::string Window::TYPE_NAME = "window";
+
+  //----------------------------------------------------------------------------
+  Window::Window( const CanvasWeakPtr& canvas,
+                  const SGPropertyNode_ptr& node,
+                  const Style& parent_style,
+                  Element* parent ):
+    Image(canvas, node, parent_style, parent),
+    _attributes_dirty(0),
+    _resizable(false),
+    _capture_events(true),
+    _resize_top(node, "resize-top"),
+    _resize_right(node, "resize-right"),
+    _resize_bottom(node, "resize-bottom"),
+    _resize_left(node, "resize-left"),
+    _resize_status(node, "resize-status")
+  {
+    node->setFloatValue("source/right", 1);
+    node->setFloatValue("source/bottom", 1);
+    node->setBoolValue("source/normalized", true);
+  }
+
+  //----------------------------------------------------------------------------
+  Window::~Window()
+  {
+    if( _canvas_decoration )
+      _canvas_decoration->destroy();
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::update(double delta_time_sec)
+  {
+    if( _attributes_dirty & DECORATION )
+    {
+      updateDecoration();
+      _attributes_dirty &= ~DECORATION;
+    }
+
+    Image::update(delta_time_sec);
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::valueChanged(SGPropertyNode * node)
+  {
+    bool handled = false;
+    if( node->getParent() == _node )
+    {
+      handled = true;
+      const std::string& name = node->getNameString();
+      if( name  == "resize" )
+        _resizable = node->getBoolValue();
+      else if( name == "update" )
+        update(0);
+      else if( name == "capture-events" )
+        _capture_events = node->getBoolValue();
+      else if( name == "decoration-border" )
+        parseDecorationBorder(node->getStringValue());
+      else if(    boost::starts_with(name, "shadow-")
+               || name == "content-size" )
+        _attributes_dirty |= DECORATION;
+      else
+        handled = false;
+    }
+
+    if( !handled )
+      Image::valueChanged(node);
+  }
+
+  //----------------------------------------------------------------------------
+  osg::Group* Window::getGroup()
+  {
+    return getMatrixTransform();
+  }
+
+  //----------------------------------------------------------------------------
+  const SGVec2<float> Window::getPosition() const
+  {
+    const osg::Matrix& m = getMatrixTransform()->getMatrix();
+    return SGVec2<float>( m(3, 0), m(3, 1) );
+  }
+
+  //----------------------------------------------------------------------------
+  const SGRect<float> Window::getScreenRegion() const
+  {
+    return getPosition() + getRegion();
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::setCanvasContent(CanvasPtr canvas)
+  {
+    _canvas_content = canvas;
+    if( _layout )
+    {
+      canvas->setLayout(_layout);
+      _layout.clear();
+    }
+
+    if( _image_content )
+      // Placement within decoration canvas
+      _image_content->setSrcCanvas(canvas);
+    else
+      setSrcCanvas(canvas);
+  }
+
+  //----------------------------------------------------------------------------
+  CanvasWeakPtr Window::getCanvasContent() const
+  {
+    return _canvas_content;
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::setLayout(const LayoutRef& layout)
+  {
+    CanvasPtr canvas = _canvas_content.lock();
+    if( canvas )
+      canvas->setLayout(layout);
+    else
+      _layout = layout; // keep layout until content canvas is set
+  }
+
+  //----------------------------------------------------------------------------
+  CanvasPtr Window::getCanvasDecoration() const
+  {
+    return _canvas_decoration;
+  }
+
+  //----------------------------------------------------------------------------
+  bool Window::isResizable() const
+  {
+    return _resizable;
+  }
+
+  //----------------------------------------------------------------------------
+  bool Window::isCapturingEvents() const
+  {
+    return _capture_events;
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::raise()
+  {
+    // on writing the z-index the window always is moved to the top of all other
+    // windows with the same z-index.
+    set<int>("z-index", get<int>("z-index", 0));
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::handleResize( uint8_t mode,
+                             const osg::Vec2f& offset )
+  {
+    if( mode == NONE )
+    {
+      _resize_status = 0;
+      return;
+    }
+    else if( mode & INIT )
+    {
+      _resize_top    = getRegion().t();
+      _resize_right  = getRegion().r();
+      _resize_bottom = getRegion().b();
+      _resize_left   = getRegion().l();
+      _resize_status = 1;
+    }
+
+    if( mode & BOTTOM )
+      _resize_bottom = getRegion().b() + offset.y();
+    else if( mode & TOP )
+      _resize_top = getRegion().t() + offset.y();
+
+    if( mode & canvas::Window::RIGHT )
+      _resize_right = getRegion().r() + offset.x();
+    else if( mode & canvas::Window::LEFT )
+      _resize_left = getRegion().l() + offset.x();
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::parseDecorationBorder(const std::string& str)
+  {
+    _decoration_border = simgear::CSSBorder::parse(str);
+    _attributes_dirty |= DECORATION;
+  }
+
+  //----------------------------------------------------------------------------
+  void Window::updateDecoration()
+  {
+    int shadow_radius = get<float>("shadow-radius") + 0.5;
+    if( shadow_radius < 2 )
+      shadow_radius = 0;
+
+    CanvasPtr content = _canvas_content.lock();
+    SGRect<int> content_view
+    (
+      0,
+      0,
+      get<int>("content-size[0]", content ? content->getViewWidth()  : 400),
+      get<int>("content-size[1]", content ? content->getViewHeight() : 300)
+    );
+
+    if( _decoration_border.isNone() && !shadow_radius )
+    {
+      setSrcCanvas(content);
+      set<int>("size[0]", content_view.width());
+      set<int>("size[1]", content_view.height());
+
+      _image_content.reset();
+      _image_shadow.reset();
+      if( _canvas_decoration )
+        _canvas_decoration->destroy();
+      _canvas_decoration.reset();
+      return;
+    }
+
+    if( !_canvas_decoration )
+    {
+      CanvasMgr* mgr = dynamic_cast<CanvasMgr*>(
+        Canvas::getSystemAdapter()->getSubsystem("Canvas")
+      );
+
+      if( !mgr )
+      {
+        SG_LOG(SG_GENERAL, SG_WARN, "canvas::Window: no canvas manager!");
+        return;
+      }
+
+      _canvas_decoration = mgr->createCanvas("window-decoration");
+      _canvas_decoration->getProps()
+                        ->setStringValue("background", "rgba(0,0,0,0)");
+      setSrcCanvas(_canvas_decoration);
+
+      _image_content = _canvas_decoration->getRootGroup()
+                                         ->createChild<Image>("content");
+      _image_content->setSrcCanvas(content);
+
+      // Draw content on top of decoration
+      _image_content->set<int>("z-index", 1);
+    }
+
+    GroupPtr group_decoration =
+      _canvas_decoration->getOrCreateGroup("decoration");
+    group_decoration->set<int>("tf/t[0]", shadow_radius);
+    group_decoration->set<int>("tf/t[1]", shadow_radius);
+    // TODO do we need clipping or shall we trust the decorator not to draw over
+    //      the shadow?
+
+    CSSBorder::Offsets const border =
+      _decoration_border.getAbsOffsets(content_view);
+
+    int shad2 = 2 * shadow_radius,
+        outer_width  = border.l + content_view.width()  + border.r + shad2,
+        outer_height = border.t + content_view.height() + border.b + shad2;
+
+    _canvas_decoration->setSizeX( outer_width );
+    _canvas_decoration->setSizeY( outer_height );
+    _canvas_decoration->setViewWidth( outer_width );
+    _canvas_decoration->setViewHeight( outer_height );
+
+    set<int>("size[0]", outer_width - shad2);
+    set<int>("size[1]", outer_height - shad2);
+    set<int>("outset", shadow_radius);
+
+    assert(_image_content);
+    _image_content->set<int>("x", shadow_radius + border.l);
+    _image_content->set<int>("y", shadow_radius + border.t);
+    _image_content->set<int>("size[0]", content_view.width());
+    _image_content->set<int>("size[1]", content_view.height());
+
+    if( !shadow_radius )
+    {
+      if( _image_shadow )
+      {
+        _image_shadow->destroy();
+        _image_shadow.reset();
+      }
+      return;
+    }
+
+    int shadow_inset = std::max<int>(get<float>("shadow-inset") + 0.5, 0),
+        slice_width  = shadow_radius + shadow_inset;
+
+    _image_shadow = _canvas_decoration->getRootGroup()
+                                      ->getOrCreateChild<Image>("shadow");
+    _image_shadow->set<std::string>("src", "gui/images/shadow.png");
+    _image_shadow->set<float>("slice", 7);
+    _image_shadow->set<std::string>("fill", "#000000");
+    _image_shadow->set<float>("slice-width", slice_width);
+    _image_shadow->set<int>("size[0]", outer_width);
+    _image_shadow->set<int>("size[1]", outer_height);
+
+    // Draw shadow below decoration
+    _image_shadow->set<int>("z-index", -1);
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/CanvasWindow.hxx

@@ -0,0 +1,131 @@
+// Window for placing a Canvas onto it (for dialogs, menus, etc.)
+//
+// Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef CANVAS_WINDOW_HXX_
+#define CANVAS_WINDOW_HXX_
+
+#include <simgear/canvas/elements/CanvasImage.hxx>
+#include <simgear/canvas/layout/Layout.hxx>
+#include <simgear/canvas/events/MouseEvent.hxx>
+#include <simgear/props/PropertyBasedElement.hxx>
+#include <simgear/props/propertyObject.hxx>
+#include <simgear/misc/CSSBorder.hxx>
+
+#include <osg/Geode>
+#include <osg/Geometry>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  class Window:
+    public Image,
+    public LayoutItem
+  {
+    public:
+      static const std::string TYPE_NAME;
+
+      enum Resize
+      {
+        NONE    = 0,
+        LEFT    = 1,
+        RIGHT   = LEFT << 1,
+        TOP     = RIGHT << 1,
+        BOTTOM  = TOP << 1,
+        INIT    = BOTTOM << 1
+      };
+
+      /**
+       * @param node    Property node containing settings for this window:
+       *                  capture-events    Disable/Enable event capturing
+       *                  content-size[0-1] Size of content area (excluding
+       *                                    decoration border)
+       *                  decoration-border Size of decoration border
+       *                  resize            Enable resize cursor and properties
+       *                  shadow-inset      Inset of shadow image
+       *                  shadow-radius     Radius/outset of shadow image
+       */
+      Window( const CanvasWeakPtr& canvas,
+              const SGPropertyNode_ptr& node,
+              const Style& parent_style = Style(),
+              Element* parent = 0 );
+      virtual ~Window();
+
+      virtual void update(double delta_time_sec);
+      virtual void valueChanged(SGPropertyNode* node);
+
+      osg::Group* getGroup();
+      const SGVec2<float> getPosition() const;
+      const SGRect<float>  getScreenRegion() const;
+
+      void setCanvasContent(CanvasPtr canvas);
+      simgear::canvas::CanvasWeakPtr getCanvasContent() const;
+
+      void setLayout(const LayoutRef& layout);
+
+      CanvasPtr getCanvasDecoration() const;
+
+      bool isResizable() const;
+      bool isCapturingEvents() const;
+
+      /**
+       * Moves window on top of all other windows with the same z-index.
+       *
+       * @note If no z-index is set it defaults to 0.
+       */
+      void raise();
+
+      void handleResize( uint8_t mode,
+                         const osg::Vec2f& offset = osg::Vec2f() );
+
+    protected:
+
+      enum Attributes
+      {
+        DECORATION = 1
+      };
+
+      uint32_t  _attributes_dirty;
+
+      CanvasPtr        _canvas_decoration;
+      CanvasWeakPtr    _canvas_content;
+      LayoutRef        _layout;
+
+      ImagePtr _image_content,
+               _image_shadow;
+
+      bool _resizable,
+           _capture_events;
+
+      PropertyObject<int> _resize_top,
+                          _resize_right,
+                          _resize_bottom,
+                          _resize_left,
+                          _resize_status;
+
+      CSSBorder _decoration_border;
+
+      void parseDecorationBorder(const std::string& str);
+      void updateDecoration();
+  };
+
+} // namespace canvas
+} // namespace simgear
+
+#endif /* CANVAS_WINDOW_HXX_ */

simgear/canvas/ODGauge.cxx

@@ -29,6 +29,7 @@
 #endif
 
 #include "ODGauge.hxx"
+#include "Canvas.hxx"
 #include "CanvasSystemAdapter.hxx"
 
 #include <simgear/debug/logstream.hxx>
@@ -43,6 +44,7 @@
 #include <osg/ShadeModel>
 #include <osg/StateSet>
 #include <osg/FrameBufferObject> // for GL_DEPTH_STENCIL_EXT on Windows
+#include <osgUtil/RenderBin>
 
 #include <cassert>
 
@@ -51,6 +53,58 @@ namespace simgear
 namespace canvas
 {
 
+  class PreOrderBin:
+    public osgUtil::RenderBin
+  {
+    public:
+
+      PreOrderBin()
+      {}
+      PreOrderBin( const RenderBin& rhs,
+                   const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY ):
+        RenderBin(rhs, copyop)
+      {}
+
+      virtual osg::Object* cloneType() const
+      {
+        return new PreOrderBin();
+      }
+      virtual osg::Object* clone(const osg::CopyOp& copyop) const
+      {
+        return new PreOrderBin(*this,copyop);
+      }
+      virtual bool isSameKindAs(const osg::Object* obj) const
+      {
+        return dynamic_cast<const PreOrderBin*>(obj) != 0L;
+      }
+      virtual const char* className() const
+      {
+        return "PreOrderBin";
+      }
+
+      virtual void sort()
+      {
+        // Do not sort to keep traversal order...
+      }
+  };
+
+#ifndef OSG_INIT_SINGLETON_PROXY
+  /**
+   * http://svn.openscenegraph.org/osg/OpenSceneGraph/trunk/include/osg/Object
+   *
+   * Helper macro that creates a static proxy object to call singleton function
+   * on it's construction, ensuring that the singleton gets initialized at
+   * startup.
+   */
+#  define OSG_INIT_SINGLETON_PROXY(ProxyName, Func)\
+          static struct ProxyName{ ProxyName() { Func; } } s_##ProxyName;
+#endif
+
+  OSG_INIT_SINGLETON_PROXY(
+    PreOrderBinProxy,
+    (osgUtil::RenderBin::addRenderBinPrototype("PreOrderBin", new PreOrderBin))
+  );
+
   //----------------------------------------------------------------------------
   ODGauge::ODGauge():
     _size_x( -1 ),
@@ -70,12 +124,6 @@ namespace canvas
     clear();
   }
 
-  //----------------------------------------------------------------------------
-  void ODGauge::setSystemAdapter(const SystemAdapterPtr& system_adapter)
-  {
-    _system_adapter = system_adapter;
-  }
-
   //----------------------------------------------------------------------------
   void ODGauge::setSize(int size_x, int size_y)
   {
@@ -209,8 +257,8 @@ namespace canvas
     updateSampling();
     updateBlendMode();
 
-    if( _system_adapter )
-      _system_adapter->addCamera(camera.get());
+    if( Canvas::getSystemAdapter() )
+      Canvas::getSystemAdapter()->addCamera(camera.get());
 
     _flags |= AVAILABLE;
   }
@@ -226,8 +274,8 @@ namespace canvas
   //----------------------------------------------------------------------------
   void ODGauge::clear()
   {
-    if( camera.valid() && _system_adapter )
-      _system_adapter->removeCamera(camera.get());
+    if( camera.valid() && Canvas::getSystemAdapter() )
+      Canvas::getSystemAdapter()->removeCamera(camera.get());
     camera.release();
     texture.release();
 

simgear/canvas/ODGauge.hxx

@@ -53,8 +53,6 @@ namespace canvas
       ODGauge();
       virtual ~ODGauge();
 
-      void setSystemAdapter(const SystemAdapterPtr& system_adapter);
-
       /**
        * Set the size of the render target.
        *
@@ -136,8 +134,6 @@ namespace canvas
 
     protected:
 
-      SystemAdapterPtr _system_adapter;
-
       int _size_x,
           _size_y,
           _view_width,

simgear/canvas/ShivaVG/src/shConfig.h

@@ -38,4 +38,9 @@
 
 #endif
 
+// We currently do not support using images (inside paths). If we were going to
+// use it loading and unloading needs to happen within OpenSceneGraph to handle
+// synchronization correctly in multithreading mode.
+#define SH_NO_IMAGE
+
 #endif // __SHCONFIG_H

simgear/canvas/ShivaVG/src/shContext.c

@@ -53,7 +53,7 @@ VG_API_CALL VGboolean vgCreateContextSH(VGint width, VGint height)
   
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
-  gluOrtho2D(0,width,0,height);
+  glOrtho(0, width, 0, height, -1, 1);
   
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();*/
@@ -79,7 +79,7 @@ VG_API_CALL void vgResizeSurfaceSH(VGint width, VGint height)
   
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
-  gluOrtho2D(0,width,0,height);
+  glOrtho(0, width, 0, height, -1, 1);
   
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

simgear/canvas/ShivaVG/src/shDefs.h

@@ -34,7 +34,7 @@
 #include <math.h>
 #include <float.h>
 
-#ifndef VG_API_MACOSX
+#if !defined(VG_API_MACOSX) && !defined(__FreeBSD__)
 #  include <malloc.h>
 #endif
 
@@ -158,18 +158,14 @@ SHfloat getMaxFloat();
 
 #if defined(VG_API_LINUX)
     #include <GL/gl.h>
-    #include <GL/glu.h>
     #include <GL/glx.h>
 #elif defined(VG_API_MACOSX)
     #include <OpenGL/gl.h>
-    #include <OpenGL/glu.h>
 #elif defined(VG_API_WINDOWS)
     #include <GL/gl.h>
-    #include <GL/glu.h>
 #else
     #define GL_GLEXT_LEGACY /* don't include glext.h */
     #include <GL/gl.h>
-    #include <GL/glu.h>
     #include <GL/glx.h>
 #endif
 

simgear/canvas/ShivaVG/src/shImage.c

@@ -37,6 +37,7 @@
 #define _ARRAY_DEFINE
 #include "shArrayBase.h"
 
+#ifndef SH_NO_IMAGE
 
 /*-----------------------------------------------------------
  * Prepares the proper pixel pack/unpack info for the given
@@ -440,6 +441,7 @@ void shLoadColor(SHColor *c, const void *data, SHImageFormatDesc *f)
   if (f->rmask == 0x0) { c->r = 1.0f; c->g = 1.0f; c->b = 1.0f; }
 }
 
+#endif // SH_NO_IMAGE
 
 /*----------------------------------------------
  * Color and Image constructors and destructors
@@ -461,18 +463,28 @@ void SHImage_ctor(SHImage *i)
   i->data = NULL;
   i->width = 0;
   i->height = 0;
+
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   glGenTextures(1, &i->texture);
+#endif
 }
 
 void SHImage_dtor(SHImage *i)
 {
   if (i->data != NULL)
     free(i->data);
-  
+
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   if (glIsTexture(i->texture))
     glDeleteTextures(1, &i->texture);
+#endif
 }
 
+#ifndef SH_NO_IMAGE
 /*--------------------------------------------------------
  * Finds appropriate OpenGL texture size for the size of
  * the given image
@@ -553,6 +565,7 @@ void shUpdateImageTexture(SHImage *i, VGContext *c)
                i->texwidth, i->texheight, 0,
                i->fd.glformat, i->fd.gltype, i->data);
 }
+#endif // SH_NO_IMAGE
 
 /*----------------------------------------------------------
  * Creates a new image object and returns the handle to it
@@ -562,6 +575,10 @@ VG_API_CALL VGImage vgCreateImage(VGImageFormat format,
                                   VGint width, VGint height,
                                   VGbitfield allowedQuality)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+  return VG_INVALID_HANDLE;
+#else
   SHImage *i = NULL;
   SHImageFormatDesc fd;
   VG_GETCONTEXT(VG_INVALID_HANDLE);
@@ -614,12 +631,16 @@ VG_API_CALL VGImage vgCreateImage(VGImageFormat format,
   
   /* Add to resource list */
   shImageArrayPushBack(&context->images, i);
-  
+
   VG_RETURN((VGImage)i);
+#endif // SH_NO_IMAGE
 }
 
 VG_API_CALL void vgDestroyImage(VGImage image)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHint index;
   VG_GETCONTEXT(VG_NO_RETVAL);
   
@@ -630,8 +651,9 @@ VG_API_CALL void vgDestroyImage(VGImage image)
   /* Delete object and remove resource */
   SH_DELETEOBJ(SHImage, (SHImage*)image);
   shImageArrayRemoveAt(&context->images, index);
-  
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*---------------------------------------------------
@@ -642,6 +664,9 @@ VG_API_CALL void vgDestroyImage(VGImage image)
 VG_API_CALL void vgClearImage(VGImage image,
                               VGint x, VGint y, VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *i;
   SHColor clear;
   SHuint8 *data;
@@ -682,9 +707,13 @@ VG_API_CALL void vgClearImage(VGImage image,
     }}
   
   shUpdateImageTexture(i, context);
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
+#ifndef SH_NO_IMAGE
+
 /*------------------------------------------------------------
  * Generic function for copying a rectangle area of pixels
  * of size (width,height) among two data buffers. The size of
@@ -795,6 +824,8 @@ void shCopyPixels(SHuint8 *dst, VGImageFormat dstFormat, SHint dstStride,
   }
 }
 
+#endif // SH_NO_IMAGE
+
 /*---------------------------------------------------------
  * Copies a rectangle area of pixels of size (width,height)
  * from given data buffer to image surface at destination
@@ -806,6 +837,9 @@ VG_API_CALL void vgImageSubData(VGImage image,
                                 VGImageFormat dataFormat,
                                 VGint x, VGint y, VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *i;
   VG_GETCONTEXT(VG_NO_RETVAL);
   
@@ -836,7 +870,9 @@ VG_API_CALL void vgImageSubData(VGImage image,
                x, y, 0, 0, width, height);
   
   shUpdateImageTexture(i, context);
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*---------------------------------------------------------
@@ -851,6 +887,9 @@ VG_API_CALL void vgGetImageSubData(VGImage image,
                                    VGint x, VGint y,
                                    VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *i;
   VG_GETCONTEXT(VG_NO_RETVAL);
   
@@ -878,9 +917,10 @@ VG_API_CALL void vgGetImageSubData(VGImage image,
   shCopyPixels(data, dataFormat, dataStride,
                i->data, i->fd.vgformat, i->texwidth * i->fd.bytes,
                width, height, i->width, i->height,
-               0,0,x,x,width,height);
-  
+               0,0,x,y,width,height);
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*----------------------------------------------------------
@@ -894,6 +934,9 @@ VG_API_CALL void vgCopyImage(VGImage dst, VGint dx, VGint dy,
                              VGint width, VGint height,
                              VGboolean dither)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *s, *d;
   SHuint8 *pixels;
 
@@ -933,7 +976,9 @@ VG_API_CALL void vgCopyImage(VGImage dst, VGint dx, VGint dy,
   free(pixels);
   
   shUpdateImageTexture(d, context);
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*---------------------------------------------------------
@@ -946,6 +991,9 @@ VG_API_CALL void vgSetPixels(VGint dx, VGint dy,
                              VGImage src, VGint sx, VGint sy,
                              VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *i;
   SHuint8 *pixels;
   SHImageFormatDesc winfd;
@@ -986,6 +1034,7 @@ VG_API_CALL void vgSetPixels(VGint dx, VGint dy,
   free(pixels);
 
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*---------------------------------------------------------
@@ -999,6 +1048,9 @@ VG_API_CALL void vgWritePixels(const void * data, VGint dataStride,
                                VGint dx, VGint dy,
                                VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHuint8 *pixels;
   SHImageFormatDesc winfd;
 
@@ -1043,7 +1095,8 @@ VG_API_CALL void vgWritePixels(const void * data, VGint dataStride,
   
   free(pixels);
 
-  VG_RETURN(VG_NO_RETVAL); 
+  VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*-----------------------------------------------------------
@@ -1056,6 +1109,9 @@ VG_API_CALL void vgGetPixels(VGImage dst, VGint dx, VGint dy,
                              VGint sx, VGint sy,
                              VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHImage *i;
   SHuint8 *pixels;
   SHImageFormatDesc winfd;
@@ -1093,7 +1149,9 @@ VG_API_CALL void vgGetPixels(VGImage dst, VGint dx, VGint dy,
   free(pixels);
   
   shUpdateImageTexture(i, context);
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*-----------------------------------------------------------
@@ -1107,6 +1165,9 @@ VG_API_CALL void vgReadPixels(void * data, VGint dataStride,
                               VGint sx, VGint sy,
                               VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   SHuint8 *pixels;
   SHImageFormatDesc winfd;
   VG_GETCONTEXT(VG_NO_RETVAL);
@@ -1146,8 +1207,9 @@ VG_API_CALL void vgReadPixels(void * data, VGint dataStride,
                0, 0, 0, 0, width, height);
 
   free(pixels);
-  
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 /*----------------------------------------------------------
@@ -1160,6 +1222,9 @@ VG_API_CALL void vgCopyPixels(VGint dx, VGint dy,
                               VGint sx, VGint sy,
                               VGint width, VGint height)
 {
+#ifdef SH_NO_IMAGE
+  printf("ShivaVG: images not supported!");
+#else
   VG_GETCONTEXT(VG_NO_RETVAL);
   
   VG_RETURN_ERR_IF(width <= 0 || height <= 0,
@@ -1170,8 +1235,9 @@ VG_API_CALL void vgCopyPixels(VGint dx, VGint dy,
   glRasterPos2i(dx, dy);
   glCopyPixels(sx, sy, width, height, GL_COLOR);
   glRasterPos2i(0, 0);
-  
+
   VG_RETURN(VG_NO_RETVAL);
+#endif // SH_NO_IMAGE
 }
 
 VG_API_CALL VGImage vgChildImage(VGImage parent,

simgear/canvas/ShivaVG/src/shPaint.c

@@ -36,6 +36,9 @@
 #define _ARRAY_DEFINE
 #include "shArrayBase.h"
 
+// We currently do not use gradients which need textures, so disable them to
+// prevent freeing resources outside the correct OpenGL thread/context.
+#define SH_NO_PAINT_TEXTURE
 
 void SHPaint_ctor(SHPaint *p)
 {
@@ -51,20 +54,26 @@ void SHPaint_ctor(SHPaint *p)
   for (i=0; i<4; ++i) p->linearGradient[i] = 0.0f;
   for (i=0; i<5; ++i) p->radialGradient[i] = 0.0f;
   p->pattern = VG_INVALID_HANDLE;
-  
+
+#ifndef SH_NO_PAINT_TEXTURE
   glGenTextures(1, &p->texture);
   glBindTexture(GL_TEXTURE_1D, p->texture);
   glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, SH_GRADIENT_TEX_SIZE, 0,
                GL_RGBA, GL_FLOAT, NULL);
+#else
+  p->texture = 0;
+#endif
 }
 
 void SHPaint_dtor(SHPaint *p)
 {
   SH_DEINITOBJ(SHStopArray, p->instops);
   SH_DEINITOBJ(SHStopArray, p->stops);
-  
+
+#ifndef SH_NO_PAINT_TEXTURE
   if (glIsTexture(p->texture))
     glDeleteTextures(1, &p->texture);
+#endif
 }
 
 VG_API_CALL VGPaint vgCreatePaint(void)
@@ -143,6 +152,7 @@ VG_API_CALL void vgPaintPattern(VGPaint paint, VGImage pattern)
 
 void shUpdateColorRampTexture(SHPaint *p)
 {
+#ifndef SH_NO_PAINT_TEXTURE
   SHint s=0;
   SHStop *stop1, *stop2;
   SHfloat rgba[SH_GRADIENT_TEX_COORDSIZE];
@@ -177,12 +187,15 @@ void shUpdateColorRampTexture(SHPaint *p)
       CSTORE_RGBA1D_F(c, rgba, x);
     }
   }
-  
+
   /* Update texture image */
   glBindTexture(GL_TEXTURE_1D, p->texture);
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glTexSubImage1D(GL_TEXTURE_1D, 0, 0, SH_GRADIENT_TEX_SIZE,
                   GL_RGBA, GL_FLOAT, rgba);
+#else
+  printf("ShivaVG: gradients not supported!");
+#endif
 }
 
 void shValidateInputStops(SHPaint *p)
@@ -344,6 +357,7 @@ void shGenerateStops(SHPaint *p, SHfloat minOffset, SHfloat maxOffset,
 
 void shSetGradientTexGLState(SHPaint *p)
 {
+#ifndef SH_NO_PAINT_TEXTURE
   glBindTexture(GL_TEXTURE_1D, p->texture);
   glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -359,6 +373,9 @@ void shSetGradientTexGLState(SHPaint *p)
   
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
   glColor4f(1,1,1,1);
+#else
+  printf("ShivaVG: gradients not supported!");
+#endif
 }
 
 void shSetPatternTexGLState(SHPaint *p, VGContext *c)

simgear/canvas/ShivaVG/src/shPipeline.c

@@ -314,9 +314,9 @@ VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes)
   }
   
   /* TODO: Turn antialiasing on/off */
-  glDisable(GL_LINE_SMOOTH);
-  glDisable(GL_POLYGON_SMOOTH);
-  glEnable(GL_MULTISAMPLE);
+//  glDisable(GL_LINE_SMOOTH);
+//  glDisable(GL_POLYGON_SMOOTH);
+//  glEnable(GL_MULTISAMPLE);
   
   /* Pick paint if available or default*/
   fill = (context->fillPaint ? context->fillPaint : &context->defaultPaint);
@@ -364,26 +364,27 @@ VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes)
     /* TODO: Is there any way to do this safely along
        with the paint generation pass?? */
     glDisable(GL_BLEND);
-    glDisable(GL_MULTISAMPLE);
+//    glDisable(GL_MULTISAMPLE);
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
     shDrawBoundBox(context, p, VG_FILL_PATH);
     
     /* Reset state */
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glDisable(GL_STENCIL_TEST);
-    glDisable(GL_BLEND);
+//    glDisable(GL_BLEND);
   }
   
   /* TODO: Turn antialiasing on/off */
-  glDisable(GL_LINE_SMOOTH);
-  glDisable(GL_POLYGON_SMOOTH);
-  glEnable(GL_MULTISAMPLE);
+//  glDisable(GL_LINE_SMOOTH);
+//  glDisable(GL_POLYGON_SMOOTH);
+//  glEnable(GL_MULTISAMPLE);
   
   if ((paintModes & VG_STROKE_PATH) &&
       context->strokeLineWidth > 0.0f) {
-    
-    if (1) {/*context->strokeLineWidth > 1.0f) {*/
 
+#if 0
+    if (1) {/*context->strokeLineWidth > 1.0f) {*/
+#endif
       if (shIsStrokeCacheValid( context, p ) == VG_FALSE)
       {
         /* Generate stroke triangles in user space */
@@ -411,15 +412,15 @@ VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes)
       
       /* Clear stencil for sure */
       glDisable(GL_BLEND);
-      glDisable(GL_MULTISAMPLE);
+//      glDisable(GL_MULTISAMPLE);
       glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
       shDrawBoundBox(context, p, VG_STROKE_PATH);
       
       /* Reset state */
       glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glDisable(GL_STENCIL_TEST);
-      glDisable(GL_BLEND);
-      
+//      glDisable(GL_BLEND);
+#if 0
     }else{
       
       /* Simulate thin stroke by alpha */
@@ -438,6 +439,7 @@ VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes)
       glDisable(GL_BLEND);
       glDisable(GL_LINE_SMOOTH);
     }
+#endif
   }
   
   

simgear/canvas/ShivaVG/src/shVectors.c

@@ -124,11 +124,13 @@ int shLineLineXsection(SHVector2 *o1, SHVector2 *v1,
   SHfloat DX = rightU * (-v2->y) - rightD * (-v2->x);
 /*SHfloat DY = v1.x   * rightD  - v1.y   * rightU;*/
   
-  SHfloat t1 = DX / D;
+  SHfloat t1;
   
   if (D == 0.0f)
     return 0;
-  
+
+  t1 = DX / D;
+
   xsection->x = o1->x + t1*v1->x;
   xsection->y = o1->y + t1*v1->y;
   return 1;

simgear/canvas/canvas_fwd.hxx

@@ -39,8 +39,8 @@ namespace canvas
 
 #define SG_FWD_DECL(name)\
   class name;\
-  typedef boost::shared_ptr<name> name##Ptr;\
-  typedef boost::weak_ptr<name> name##WeakPtr;
+  typedef SGSharedPtr<name> name##Ptr;\
+  typedef SGWeakPtr<name> name##WeakPtr;
 
   SG_FWD_DECL(Canvas)
   SG_FWD_DECL(Element)
@@ -49,10 +49,19 @@ namespace canvas
   SG_FWD_DECL(Map)
   SG_FWD_DECL(Path)
   SG_FWD_DECL(Text)
+  SG_FWD_DECL(Window)
 
   SG_FWD_DECL(Event)
-  SG_FWD_DECL(EventListener)
+  SG_FWD_DECL(CustomEvent)
   SG_FWD_DECL(MouseEvent)
+
+#undef SG_FWD_DECL
+
+#define SG_FWD_DECL(name)\
+  class name;\
+  typedef boost::shared_ptr<name> name##Ptr;\
+  typedef boost::weak_ptr<name> name##WeakPtr;
+
   SG_FWD_DECL(Placement)
   SG_FWD_DECL(SystemAdapter)
 
@@ -61,6 +70,9 @@ namespace canvas
   class EventManager;
   class EventVisitor;
 
+  struct EventTarget;
+  typedef std::deque<EventTarget> EventPropagationPath;
+
   typedef std::map<std::string, const SGPropertyNode*> Style;
   typedef ElementPtr (*ElementFactory)( const CanvasWeakPtr&,
                                         const SGPropertyNode_ptr&,
@@ -73,6 +85,8 @@ namespace canvas
   typedef boost::function<Placements( SGPropertyNode*,
                                       CanvasPtr )> PlacementFactory;
 
+  typedef boost::function<void(const EventPtr&)> EventListener;
+
 } // namespace canvas
 } // namespace simgear
 

simgear/canvas/elements/CMakeLists.txt

@@ -23,4 +23,9 @@ set(SOURCES
 )
 
 simgear_scene_component(canvas-elements canvas/elements "${SOURCES}" "${HEADERS}")
-simgear_component(canvas-elements/detail canvas/elements/detail "" "${DETAIL_HEADERS}")
+simgear_component(canvas-elements/detail canvas/elements/detail "" "${DETAIL_HEADERS}")
+
+add_boost_test(canvas_element
+  SOURCES canvas_element_test.cpp
+  LIBRARIES ${TEST_LIBS}
+)

simgear/canvas/elements/CanvasElement.cxx

@@ -18,9 +18,10 @@
 
 #include "CanvasElement.hxx"
 #include <simgear/canvas/Canvas.hxx>
-#include <simgear/canvas/CanvasEventListener.hxx>
 #include <simgear/canvas/CanvasEventVisitor.hxx>
-#include <simgear/canvas/MouseEvent.hxx>
+#include <simgear/canvas/events/MouseEvent.hxx>
+#include <simgear/math/SGMisc.hxx>
+#include <simgear/misc/strutils.hxx>
 #include <simgear/scene/material/parseBlendFunc.hxx>
 
 #include <osg/Drawable>
@@ -29,11 +30,10 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/tokenizer.hpp>
 
 #include <cassert>
+#include <cmath>
 #include <cstring>
 
 namespace simgear
@@ -42,6 +42,129 @@ namespace canvas
 {
   const std::string NAME_TRANSFORM = "tf";
 
+  /**
+   * glScissor with coordinates relative to different reference frames.
+   */
+  class Element::RelativeScissor:
+    public osg::Scissor
+  {
+    public:
+
+      ReferenceFrame                _coord_reference;
+      osg::observer_ptr<osg::Node>  _node;
+
+      RelativeScissor(osg::Node* node = NULL):
+        _coord_reference(GLOBAL),
+        _node(node)
+      {
+        _width = 0;
+        _height = 0;
+      }
+
+      /** Copy constructor using CopyOp to manage deep vs shallow copy. */
+      RelativeScissor( const RelativeScissor& vp,
+                       const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY ):
+        Scissor(vp, copyop),
+        _coord_reference(vp._coord_reference),
+        _node(vp._node)
+      {}
+
+      META_StateAttribute(simgear, RelativeScissor, SCISSOR);
+
+      /** Return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */
+      virtual int compare(const StateAttribute& sa) const
+      {
+        // check the types are equal and then create the rhs variable
+        // used by the COMPARE_StateAttribute_Parameter macros below.
+        COMPARE_StateAttribute_Types(RelativeScissor,sa)
+
+        // compare each parameter in turn against the rhs.
+        COMPARE_StateAttribute_Parameter(_x)
+        COMPARE_StateAttribute_Parameter(_y)
+        COMPARE_StateAttribute_Parameter(_width)
+        COMPARE_StateAttribute_Parameter(_height)
+        COMPARE_StateAttribute_Parameter(_coord_reference)
+        COMPARE_StateAttribute_Parameter(_node)
+
+        return 0; // passed all the above comparison macros, must be equal.
+      }
+
+      virtual void apply(osg::State& state) const
+      {
+        if( _width <= 0 || _height <= 0 )
+          return;
+
+        const osg::Viewport* vp = state.getCurrentViewport();
+        float w2 = 0.5 * vp->width(),
+              h2 = 0.5 * vp->height();
+
+        osg::Matrix model_view
+        (
+          w2, 0,  0, 0,
+          0,  h2, 0, 0,
+          0,  0,  1, 0,
+          w2, h2, 0, 1
+        );
+        model_view.preMult(state.getProjectionMatrix());
+
+        if( _coord_reference != GLOBAL )
+        {
+          osg::Node* ref_obj = _node.get();
+
+          if( _coord_reference == PARENT )
+          {
+            if( _node->getNumParents() < 1 )
+            {
+              SG_LOG(SG_GL, SG_WARN, "RelativeScissor: missing parent.");
+              return;
+            }
+
+            ref_obj = _node->getParent(0);
+          }
+
+          osg::MatrixList const& parent_matrices = ref_obj->getWorldMatrices();
+          assert( !parent_matrices.empty() );
+          model_view.preMult(parent_matrices.front());
+        }
+
+        const osg::Vec2 scale( model_view(0,0), model_view(1,1)),
+                        offset(model_view(3,0), model_view(3,1));
+
+        // TODO check/warn for rotation?
+        GLint x = SGMiscf::roundToInt(scale.x() * _x + offset.x()),
+              y = SGMiscf::roundToInt(scale.y() * _y + offset.y()),
+              w = SGMiscf::roundToInt(std::fabs(scale.x()) * _width),
+              h = SGMiscf::roundToInt(std::fabs(scale.y()) * _height);
+
+        if( scale.x() < 0 )
+          x -= w;
+        if( scale.y() < 0 )
+          y -= h;
+
+        glScissor(x, y, w, h);
+      }
+
+      bool contains(const osg::Vec2f& pos) const
+      {
+        return _x <= pos.x() && pos.x() <= _x + _width
+            && _y <= pos.y() && pos.y() <= _y + _height;
+      }
+
+      bool contains( const osg::Vec2f& global_pos,
+                     const osg::Vec2f& parent_pos,
+                     const osg::Vec2f& local_pos ) const
+      {
+        switch( _coord_reference )
+        {
+          case GLOBAL: return contains(global_pos);
+          case PARENT: return contains(parent_pos);
+          case LOCAL:  return contains(local_pos);
+        }
+
+        return false;
+      }
+  };
+
   //----------------------------------------------------------------------------
   Element::OSGUserData::OSGUserData(ElementPtr element):
     element(element)
@@ -52,18 +175,19 @@ namespace canvas
   //----------------------------------------------------------------------------
   Element::~Element()
   {
+    if( !_transform.valid() )
+      return;
 
-  }
+    for(unsigned int i = 0; i < _transform->getNumChildren(); ++i)
+    {
+      OSGUserData* ud =
+        static_cast<OSGUserData*>(_transform->getChild(i)->getUserData());
 
-  //----------------------------------------------------------------------------
-  void Element::setSelf(const PropertyBasedElementPtr& self)
-  {
-    PropertyBasedElement::setSelf(self);
-
-    _transform->setUserData
-    (
-      new OSGUserData(boost::static_pointer_cast<Element>(self))
-    );
+      if( ud )
+        // Ensure parent is cleared to prevent accessing released memory if an
+        // element somehow survives longer than his parent.
+        ud->element->_parent = 0;
+    }
   }
 
   //----------------------------------------------------------------------------
@@ -78,86 +202,41 @@ namespace canvas
     {
       parent->removeChild(_transform.get());
     }
+
+    // Hide in case someone still holds a reference
+    setVisible(false);
+    removeListener();
+
+    _parent = 0;
+    _transform = 0;
   }
 
   //----------------------------------------------------------------------------
-  ElementWeakPtr Element::getWeakPtr() const
+  ElementPtr Element::getParent() const
   {
-    return boost::static_pointer_cast<Element>(_self.lock());
+    return _parent;
+  }
+
+  //----------------------------------------------------------------------------
+  CanvasWeakPtr Element::getCanvas() const
+  {
+    return _canvas;
   }
 
   //----------------------------------------------------------------------------
   void Element::update(double dt)
   {
-    if( !_transform->getNodeMask() )
-      // Don't do anything if element is hidden
+    if( !isVisible() )
       return;
 
-    if( _transform_dirty )
-    {
-      osg::Matrix m;
-      for( size_t i = 0; i < _transform_types.size(); ++i )
-      {
-        // Skip unused indizes...
-        if( _transform_types[i] == TT_NONE )
-          continue;
-
-        SGPropertyNode* tf_node = _node->getChild("tf", i, true);
-
-        // Build up the matrix representation of the current transform node
-        osg::Matrix tf;
-        switch( _transform_types[i] )
-        {
-          case TT_MATRIX:
-            tf = osg::Matrix( tf_node->getDoubleValue("m[0]", 1),
-                              tf_node->getDoubleValue("m[1]", 0),
-                              0,
-                              tf_node->getDoubleValue("m[6]", 0),
-
-                              tf_node->getDoubleValue("m[2]", 0),
-                              tf_node->getDoubleValue("m[3]", 1),
-                              0,
-                              tf_node->getDoubleValue("m[7]", 0),
-
-                              0,
-                              0,
-                              1,
-                              0,
-
-                              tf_node->getDoubleValue("m[4]", 0),
-                              tf_node->getDoubleValue("m[5]", 0),
-                              0,
-                              tf_node->getDoubleValue("m[8]", 1) );
-            break;
-          case TT_TRANSLATE:
-            tf.makeTranslate( osg::Vec3f( tf_node->getDoubleValue("t[0]", 0),
-                                          tf_node->getDoubleValue("t[1]", 0),
-                                          0 ) );
-            break;
-          case TT_ROTATE:
-            tf.makeRotate( tf_node->getDoubleValue("rot", 0), 0, 0, 1 );
-            break;
-          case TT_SCALE:
-          {
-            float sx = tf_node->getDoubleValue("s[0]", 1);
-            // sy defaults to sx...
-            tf.makeScale( sx, tf_node->getDoubleValue("s[1]", sx), 1 );
-            break;
-          }
-          default:
-            break;
-        }
-        m.postMult( tf );
-      }
-      _transform->setMatrix(m);
-      _transform_dirty = false;
-    }
+    // Trigger matrix update
+    getMatrix();
 
     // Update bounding box on manual update (manual updates pass zero dt)
     if( dt == 0 && _drawable )
       _drawable->getBound();
 
-    if( _attributes_dirty & BLEND_FUNC )
+    if( (_attributes_dirty & BLEND_FUNC) && _transform.valid() )
     {
       parseBlendFunc(
         _transform->getOrCreateStateSet(),
@@ -173,31 +252,18 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  naRef Element::addEventListener(const nasal::CallContext& ctx)
+  bool Element::addEventListener( const std::string& type_str,
+                                  const EventListener& cb )
   {
-    const std::string type_str = ctx.requireArg<std::string>(0);
-    naRef code = ctx.requireArg<naRef>(1);
-
     SG_LOG
     (
-      SG_NASAL,
+      SG_GENERAL,
       SG_INFO,
       "addEventListener(" << _node->getPath() << ", " << type_str << ")"
     );
 
-    Event::Type type = Event::strToType(type_str);
-    if( type == Event::UNKNOWN )
-      naRuntimeError( ctx.c,
-                      "addEventListener: Unknown event type %s",
-                      type_str.c_str() );
-
-    _listener[ type ].push_back
-    (
-      boost::make_shared<EventListener>( code,
-                                         _canvas.lock()->getSystemAdapter() )
-    );
-
-    return naNil();
+    _listener[ Event::getOrRegisterType(type_str) ].push_back(cb);
+    return true;
   }
 
   //----------------------------------------------------------------------------
@@ -209,7 +275,7 @@ namespace canvas
   //----------------------------------------------------------------------------
   bool Element::accept(EventVisitor& visitor)
   {
-    if( !_transform.valid() )
+    if( !isVisible() )
       return false;
 
     return visitor.apply(*this);
@@ -230,36 +296,80 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  bool Element::handleEvent(canvas::EventPtr event)
+  bool Element::handleEvent(const EventPtr& event)
   {
     ListenerMap::iterator listeners = _listener.find(event->getType());
     if( listeners == _listener.end() )
       return false;
 
-    BOOST_FOREACH(EventListenerPtr listener, listeners->second)
-      listener->call(event);
+    BOOST_FOREACH(EventListener const& listener, listeners->second)
+      try
+      {
+        listener(event);
+      }
+      catch( std::exception const& ex )
+      {
+        SG_LOG(
+          SG_GENERAL,
+          SG_WARN,
+          "canvas::Element: event handler error: '" << ex.what() << "'"
+        );
+      }
 
     return true;
   }
 
   //----------------------------------------------------------------------------
-  bool Element::hitBound( const osg::Vec2f& pos,
+  bool Element::dispatchEvent(const EventPtr& event)
+  {
+    EventPropagationPath path;
+    path.push_back( EventTarget(this) );
+
+    for( Element* parent = _parent;
+                  parent != NULL;
+                  parent = parent->_parent )
+      path.push_front( EventTarget(parent) );
+
+    CanvasPtr canvas = _canvas.lock();
+    if( !canvas )
+      return false;
+
+    return canvas->propagateEvent(event, path);
+  }
+
+  //----------------------------------------------------------------------------
+  bool Element::hitBound( const osg::Vec2f& global_pos,
+                          const osg::Vec2f& parent_pos,
                           const osg::Vec2f& local_pos ) const
   {
-    const osg::Vec3f pos3(pos, 0);
+    if( _scissor && !_scissor->contains(global_pos, parent_pos, local_pos) )
+      return false;
+
+    const osg::Vec3f pos3(parent_pos, 0);
 
     // Drawables have a bounding box...
     if( _drawable )
       return _drawable->getBound().contains(osg::Vec3f(local_pos, 0));
-    // ... for other elements, i.e. groups only a bounding sphere is available
+    else if( _transform.valid() )
+      // ... for other elements, i.e. groups only a bounding sphere is available
+      return _transform->getBound().contains(osg::Vec3f(parent_pos, 0));
     else
-      return _transform->getBound().contains(osg::Vec3f(pos, 0));
+      return false;
+  }
+
+
+  //----------------------------------------------------------------------------
+  void Element::setVisible(bool visible)
+  {
+    if( _transform.valid() )
+      // TODO check if we need another nodemask
+      _transform->setNodeMask(visible ? 0xffffffff : 0);
   }
 
   //----------------------------------------------------------------------------
   bool Element::isVisible() const
   {
-    return _transform->getNodeMask() != 0;
+    return _transform.valid() && _transform->getNodeMask() != 0;
   }
 
   //----------------------------------------------------------------------------
@@ -274,6 +384,18 @@ namespace canvas
     return _transform.get();
   }
 
+  //----------------------------------------------------------------------------
+  osg::Vec2f Element::posToLocal(const osg::Vec2f& pos) const
+  {
+    getMatrix();
+    const osg::Matrix& m = _transform->getInverseMatrix();
+    return osg::Vec2f
+    (
+      m(0, 0) * pos[0] + m(1, 0) * pos[1] + m(3, 0),
+      m(0, 1) * pos[0] + m(1, 1) * pos[1] + m(3, 1)
+    );
+  }
+
   //----------------------------------------------------------------------------
   void Element::childAdded(SGPropertyNode* parent, SGPropertyNode* child)
   {
@@ -284,7 +406,7 @@ namespace canvas
         _transform_types.resize( child->getIndex() + 1 );
 
       _transform_types[ child->getIndex() ] = TT_NONE;
-      _transform_dirty = true;
+      _attributes_dirty |= TRANSFORM;
       return;
     }
     else if(    parent->getParent() == _node
@@ -305,7 +427,7 @@ namespace canvas
       else if( name == "s" )
         type = TT_SCALE;
 
-      _transform_dirty = true;
+      _attributes_dirty |= TRANSFORM;
       return;
     }
 
@@ -315,29 +437,37 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Element::childRemoved(SGPropertyNode* parent, SGPropertyNode* child)
   {
-    if( parent == _node && child->getNameString() == NAME_TRANSFORM )
+    if( parent == _node )
     {
-      if( !_transform.valid() )
-        return;
-
-      if( child->getIndex() >= static_cast<int>(_transform_types.size()) )
+      if( child->getNameString() == NAME_TRANSFORM )
       {
-        SG_LOG
-        (
-          SG_GENERAL,
-          SG_WARN,
-          "Element::childRemoved: unknown transform: " << child->getPath()
-        );
+        if( !_transform.valid() )
+          return;
+
+        if( child->getIndex() >= static_cast<int>(_transform_types.size()) )
+        {
+          SG_LOG
+          (
+            SG_GENERAL,
+            SG_WARN,
+            "Element::childRemoved: unknown transform: " << child->getPath()
+          );
+          return;
+        }
+
+        _transform_types[ child->getIndex() ] = TT_NONE;
+
+        while( !_transform_types.empty() && _transform_types.back() == TT_NONE )
+          _transform_types.pop_back();
+
+        _attributes_dirty |= TRANSFORM;
         return;
       }
-
-      _transform_types[ child->getIndex() ] = TT_NONE;
-
-      while( !_transform_types.empty() && _transform_types.back() == TT_NONE )
-        _transform_types.pop_back();
-
-      _transform_dirty = true;
-      return;
+      else if( StyleInfo const* style = getStyleInfo(child->getNameString()) )
+      {
+        if( setStyle(getParentStyle(child), style) )
+          return;
+      }
     }
 
     childRemoved(child);
@@ -350,20 +480,29 @@ namespace canvas
     if( parent == _node )
     {
       const std::string& name = child->getNameString();
-      if( setStyle(child) )
+      if( boost::starts_with(name, "data-") )
         return;
+      else if( StyleInfo const* style_info = getStyleInfo(name) )
+      {
+        SGPropertyNode const* style = child;
+        if( isStyleEmpty(child) )
+        {
+          child->clearValue();
+          style = getParentStyle(child);
+        }
+        setStyle(style, style_info);
+        return;
+      }
       else if( name == "update" )
         return update(0);
-      else if( name == "visible" )
-        // TODO check if we need another nodemask
-        return _transform->setNodeMask( child->getBoolValue() ? 0xffffffff : 0 );
       else if( boost::starts_with(name, "blend-") )
         return (void)(_attributes_dirty |= BLEND_FUNC);
     }
-    else if(   parent->getParent() == _node
+    else if(   parent
+            && parent->getParent() == _node
             && parent->getNameString() == NAME_TRANSFORM )
     {
-      _transform_dirty = true;
+      _attributes_dirty |= TRANSFORM;
       return;
     }
 
@@ -371,29 +510,23 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  bool Element::setStyle(const SGPropertyNode* child)
+  bool Element::setStyle( const SGPropertyNode* child,
+                          const StyleInfo* style_info )
   {
-    StyleSetters::const_iterator setter =
-      _style_setters.find(child->getNameString());
-    if( setter == _style_setters.end() )
-      return false;
-
-    const StyleSetter* style_setter = &setter->second.setter;
-    while( style_setter )
-    {
-      if( style_setter->func(*this, child) )
-        return true;
-      style_setter = style_setter->next;
-    }
-    return false;
+    return canApplyStyle(child) && setStyleImpl(child, style_info);
   }
 
   //----------------------------------------------------------------------------
   void Element::setClip(const std::string& clip)
   {
+    osg::StateSet* ss = getOrCreateStateSet();
+    if( !ss )
+      return;
+
     if( clip.empty() || clip == "auto" )
     {
-      getOrCreateStateSet()->removeAttribute(osg::StateAttribute::SCISSOR);
+      ss->removeAttribute(osg::StateAttribute::SCISSOR);
+      _scissor = 0;
       return;
     }
 
@@ -406,17 +539,22 @@ namespace canvas
       return;
     }
 
-    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-    const boost::char_separator<char> del(", \t\npx");
-
-    tokenizer tokens(clip.begin() + RECT.size(), clip.end() - 1, del);
+    const std::string sep(", \t\npx");
     int comp = 0;
-    int values[4];
-    for( tokenizer::const_iterator tok = tokens.begin();
-         tok != tokens.end() && comp < 4;
-         ++tok, ++comp )
+    float values[4];
+
+    for(size_t pos = RECT.size(); comp < 4; ++comp)
     {
-      values[comp] = boost::lexical_cast<int>(*tok);
+      pos = clip.find_first_not_of(sep, pos);
+      if( pos == std::string::npos || pos == clip.size() - 1 )
+        break;
+
+      char *end = 0;
+      values[comp] = strtod(&clip[pos], &end);
+      if( end == &clip[pos] || !end )
+        break;
+
+      pos = end - &clip[0];
     }
 
     if( comp < 4 )
@@ -425,51 +563,58 @@ namespace canvas
       return;
     }
 
-    float scale_x = 1,
-          scale_y = 1;
+    float width = values[1] - values[3],
+          height = values[2] - values[0];
 
-    CanvasPtr canvas = _canvas.lock();
-    if( canvas )
+    if( width < 0 || height < 0 )
     {
-      // The scissor rectangle isn't affected by any transformation, so we need
-      // to convert to image/canvas coordinates on our selves.
-      scale_x = canvas->getSizeX()
-              / static_cast<float>(canvas->getViewWidth());
-      scale_y = canvas->getSizeY()
-              / static_cast<float>(canvas->getViewHeight());
+      SG_LOG(SG_GENERAL, SG_WARN, "Canvas: negative clip size: " << clip);
+      return;
     }
 
-    osg::Scissor* scissor = new osg::Scissor();
+    if( !_scissor )
+      _scissor = new RelativeScissor(_transform.get());
+
     // <top>, <right>, <bottom>, <left>
-    scissor->x() = scale_x * values[3];
-    scissor->y() = scale_y * values[0];
-    scissor->width() = scale_x * (values[1] - values[3]);
-    scissor->height() = scale_y * (values[2] - values[0]);
+    _scissor->x() = SGMiscf::roundToInt(values[3]);
+    _scissor->y() = SGMiscf::roundToInt(values[0]);
+    _scissor->width() = SGMiscf::roundToInt(width);
+    _scissor->height() = SGMiscf::roundToInt(height);
 
-    if( canvas )
-      // Canvas has y axis upside down
-      scissor->y() = canvas->getSizeY() - scissor->y() - scissor->height();
+    SGPropertyNode* clip_frame = _node->getChild("clip-frame", 0);
+    if( clip_frame )
+      valueChanged(clip_frame);
+    else
+      _scissor->_coord_reference = GLOBAL;
 
-    getOrCreateStateSet()->setAttributeAndModes(scissor);
+    ss->setAttributeAndModes(_scissor);
   }
 
   //----------------------------------------------------------------------------
-  void Element::setBoundingBox(const osg::BoundingBox& bb)
+  void Element::setClipFrame(ReferenceFrame rf)
   {
-    if( _bounding_box.empty() )
-    {
-      SGPropertyNode* bb_node = _node->getChild("bounding-box", 0, true);
-      _bounding_box.resize(4);
-      _bounding_box[0] = bb_node->getChild("min-x", 0, true);
-      _bounding_box[1] = bb_node->getChild("min-y", 0, true);
-      _bounding_box[2] = bb_node->getChild("max-x", 0, true);
-      _bounding_box[3] = bb_node->getChild("max-y", 0, true);
-    }
+    if( _scissor )
+      _scissor->_coord_reference = rf;
+  }
 
-    _bounding_box[0]->setFloatValue(bb._min.x());
-    _bounding_box[1]->setFloatValue(bb._min.y());
-    _bounding_box[2]->setFloatValue(bb._max.x());
-    _bounding_box[3]->setFloatValue(bb._max.y());
+  //----------------------------------------------------------------------------
+  osg::BoundingBox Element::getBoundingBox() const
+  {
+    if( _drawable )
+      return _drawable->getBound();
+
+    osg::BoundingBox bb;
+
+    if( _transform.valid() )
+      bb.expandBy(_transform->getBound());
+
+    return bb;
+  }
+
+  //----------------------------------------------------------------------------
+  osg::BoundingBox Element::getTightBoundingBox() const
+  {
+    return getTransformedBounds(getMatrix());
   }
 
   //----------------------------------------------------------------------------
@@ -481,11 +626,80 @@ namespace canvas
     osg::BoundingBox transformed;
     const osg::BoundingBox& bb = _drawable->getBound();
     for(int i = 0; i < 4; ++i)
-      transformed.expandBy( m * bb.corner(i) );
+      transformed.expandBy( bb.corner(i) * m );
 
     return transformed;
   }
 
+  //----------------------------------------------------------------------------
+  osg::Matrix Element::getMatrix() const
+  {
+    if( !_transform )
+      return osg::Matrix::identity();
+
+    if( !(_attributes_dirty & TRANSFORM) )
+      return _transform->getMatrix();
+
+    osg::Matrix m;
+    for( size_t i = 0; i < _transform_types.size(); ++i )
+    {
+      // Skip unused indizes...
+      if( _transform_types[i] == TT_NONE )
+        continue;
+
+      SGPropertyNode* tf_node = _node->getChild("tf", i, true);
+
+      // Build up the matrix representation of the current transform node
+      osg::Matrix tf;
+      switch( _transform_types[i] )
+      {
+        case TT_MATRIX:
+          tf = osg::Matrix( tf_node->getDoubleValue("m[0]", 1),
+                            tf_node->getDoubleValue("m[1]", 0),
+                            0,
+                            tf_node->getDoubleValue("m[6]", 0),
+
+                            tf_node->getDoubleValue("m[2]", 0),
+                            tf_node->getDoubleValue("m[3]", 1),
+                            0,
+                            tf_node->getDoubleValue("m[7]", 0),
+
+                            0,
+                            0,
+                            1,
+                            0,
+
+                            tf_node->getDoubleValue("m[4]", 0),
+                            tf_node->getDoubleValue("m[5]", 0),
+                            0,
+                            tf_node->getDoubleValue("m[8]", 1) );
+          break;
+        case TT_TRANSLATE:
+          tf.makeTranslate( osg::Vec3f( tf_node->getDoubleValue("t[0]", 0),
+                                        tf_node->getDoubleValue("t[1]", 0),
+                                        0 ) );
+          break;
+        case TT_ROTATE:
+          tf.makeRotate( tf_node->getDoubleValue("rot", 0), 0, 0, 1 );
+          break;
+        case TT_SCALE:
+        {
+          float sx = tf_node->getDoubleValue("s[0]", 1);
+          // sy defaults to sx...
+          tf.makeScale( sx, tf_node->getDoubleValue("s[1]", sx), 1 );
+          break;
+        }
+        default:
+          break;
+      }
+      m.postMult( tf );
+    }
+    _transform->setMatrix(m);
+    _attributes_dirty &= ~TRANSFORM;
+
+    return m;
+  }
+
   //----------------------------------------------------------------------------
   Element::StyleSetters Element::_style_setters;
 
@@ -498,11 +712,13 @@ namespace canvas
     _canvas( canvas ),
     _parent( parent ),
     _attributes_dirty( 0 ),
-    _transform_dirty( false ),
     _transform( new osg::MatrixTransform ),
     _style( parent_style ),
+    _scissor( 0 ),
     _drawable( 0 )
   {
+    staticInit();
+
     SG_LOG
     (
       SG_GL,
@@ -510,10 +726,96 @@ namespace canvas
       "New canvas element " << node->getPath()
     );
 
-    if( !isInit<Element>() )
+    // Ensure elements are drawn in order they appear in the element tree
+    _transform->getOrCreateStateSet()
+              ->setRenderBinDetails
+              (
+                0,
+                "PreOrderBin",
+                osg::StateSet::OVERRIDE_RENDERBIN_DETAILS
+              );
+
+    _transform->setUserData( new OSGUserData(this) );
+  }
+
+  //----------------------------------------------------------------------------
+  void Element::staticInit()
+  {
+    if( isInit<Element>() )
+      return;
+
+    addStyle("clip", "", &Element::setClip, false);
+    addStyle("clip-frame", "", &Element::setClipFrame, false);
+    addStyle("visible", "", &Element::setVisible, false);
+  }
+
+  //----------------------------------------------------------------------------
+  bool Element::isStyleEmpty(const SGPropertyNode* child) const
+  {
+    return !child
+        || simgear::strutils::strip(child->getStringValue()).empty();
+  }
+
+  //----------------------------------------------------------------------------
+  bool Element::canApplyStyle(const SGPropertyNode* child) const
+  {
+    if( _node == child->getParent() )
+      return true;
+
+    // Parent values do not override if element has own value
+    return isStyleEmpty( _node->getChild(child->getName()) );
+  }
+
+  //----------------------------------------------------------------------------
+  bool Element::setStyleImpl( const SGPropertyNode* child,
+                              const StyleInfo* style_info )
+  {
+    const StyleSetter* style_setter = style_info
+                                    ? &style_info->setter
+                                    : getStyleSetter(child->getNameString());
+    while( style_setter )
     {
-      addStyle("clip", "", &Element::setClip);
+      if( style_setter->func(*this, child) )
+        return true;
+      style_setter = style_setter->next;
     }
+    return false;
+  }
+
+  //----------------------------------------------------------------------------
+  const Element::StyleInfo*
+  Element::getStyleInfo(const std::string& name) const
+  {
+    StyleSetters::const_iterator setter = _style_setters.find(name);
+    if( setter == _style_setters.end() )
+      return 0;
+
+    return &setter->second;
+  }
+
+  //----------------------------------------------------------------------------
+  const Element::StyleSetter*
+  Element::getStyleSetter(const std::string& name) const
+  {
+    const StyleInfo* info = getStyleInfo(name);
+    return info ? &info->setter : 0;
+  }
+
+  //----------------------------------------------------------------------------
+  const SGPropertyNode*
+  Element::getParentStyle(const SGPropertyNode* child) const
+  {
+    // Try to get value from parent...
+    if( _parent )
+    {
+      Style::const_iterator style =
+        _parent->_style.find(child->getNameString());
+      if( style != _parent->_style.end() )
+        return style->second;
+    }
+
+    // ...or reset to default if none is available
+    return child; // TODO somehow get default value for each style?
   }
 
   //----------------------------------------------------------------------------
@@ -530,8 +832,12 @@ namespace canvas
   //----------------------------------------------------------------------------
   osg::StateSet* Element::getOrCreateStateSet()
   {
-    return _drawable ? _drawable->getOrCreateStateSet()
-                     : _transform->getOrCreateStateSet();
+    if( _drawable.valid() )
+      return _drawable->getOrCreateStateSet();
+    if( _transform.valid() )
+      return _transform->getOrCreateStateSet();
+
+    return 0;
   }
 
   //----------------------------------------------------------------------------

simgear/canvas/elements/CanvasElement.hxx

@@ -1,4 +1,4 @@
-// Interface for 2D Canvas elements
+///@file Interface for 2D Canvas elements
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -23,13 +23,13 @@
 #include <simgear/canvas/CanvasEvent.hxx>
 #include <simgear/props/PropertyBasedElement.hxx>
 #include <simgear/misc/stdint.hxx> // for uint32_t
-#include <simgear/nasal/cppbind/Ghost.hxx>
 
 #include <osg/BoundingBox>
 #include <osg/MatrixTransform>
 
 #include <boost/bind.hpp>
 #include <boost/function.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 
 namespace osg
 {
@@ -41,6 +41,9 @@ namespace simgear
 namespace canvas
 {
 
+  /**
+   * Baseclass for Elements displayed inside a Canvas.
+   */
   class Element:
     public PropertyBasedElement
   {
@@ -69,19 +72,31 @@ namespace canvas
       };
       struct StyleInfo
       {
-        StyleSetter setter; ///!< Function(s) for setting this style
-        std::string type;   ///!< Interpolation type
+        StyleSetter setter; ///< Function(s) for setting this style
+        std::string type;   ///< Interpolation type
+        bool inheritable;   ///< Whether children can inherit this style from
+                            ///  their parents
+      };
+
+      /**
+       * Coordinate reference frame (eg. "clip" property)
+       */
+      enum ReferenceFrame
+      {
+        GLOBAL, ///< Global coordinates
+        PARENT, ///< Coordinates relative to parent coordinate frame
+        LOCAL   ///< Coordinates relative to local coordinates (parent
+                ///  coordinates with local transformations applied)
       };
 
       /**
        *
        */
       virtual ~Element() = 0;
-
-      virtual void setSelf(const PropertyBasedElementPtr& self);
       virtual void onDestroy();
 
-      ElementWeakPtr getWeakPtr() const;
+      ElementPtr getParent() const;
+      CanvasWeakPtr getCanvas() const;
 
       /**
        * Called every frame to update internal state
@@ -90,34 +105,52 @@ namespace canvas
        */
       virtual void update(double dt);
 
-      naRef addEventListener(const nasal::CallContext& ctx);
+      bool addEventListener(const std::string& type, const EventListener& cb);
       virtual void clearEventListener();
 
       virtual bool accept(EventVisitor& visitor);
       virtual bool ascend(EventVisitor& visitor);
       virtual bool traverse(EventVisitor& visitor);
 
-      virtual bool handleEvent(canvas::EventPtr event);
+      virtual bool handleEvent(const EventPtr& event);
+      bool dispatchEvent(const EventPtr& event);
 
-      virtual bool hitBound( const osg::Vec2f& pos,
+      /**
+       *
+       * @param global_pos Position in global (canvas) coordinate frame
+       * @param parent_pos Position in parent coordinate frame
+       * @param local_pos  Position in local (element) coordinate frame
+       */
+      virtual bool hitBound( const osg::Vec2f& global_pos,
+                             const osg::Vec2f& parent_pos,
                              const osg::Vec2f& local_pos ) const;
 
       /**
-       * Get whether the element is visible or hidden (Can be changed with
-       * setting property "visible" accordingly).
+       * Set visibility of the element.
+       */
+      void setVisible(bool visible);
+
+      /**
+       * Get whether the element is visible or hidden.
        */
       bool isVisible() const;
 
       osg::MatrixTransform* getMatrixTransform();
       osg::MatrixTransform const* getMatrixTransform() const;
 
+      /**
+       * Transform position to local coordinages.
+       */
+      osg::Vec2f posToLocal(const osg::Vec2f& pos) const;
+
       virtual void childAdded( SGPropertyNode * parent,
                                SGPropertyNode * child );
       virtual void childRemoved( SGPropertyNode * parent,
                                  SGPropertyNode * child );
       virtual void valueChanged(SGPropertyNode * child);
 
-      virtual bool setStyle(const SGPropertyNode* child);
+      virtual bool setStyle( const SGPropertyNode* child,
+                             const StyleInfo* style_info = 0 );
 
       /**
        * Set clipping shape
@@ -128,15 +161,32 @@ namespace canvas
       void setClip(const std::string& clip);
 
       /**
-       * Write the given bounding box to the property tree
+       * Clipping coordinates reference frame
        */
-      void setBoundingBox(const osg::BoundingBox& bb);
+      void setClipFrame(ReferenceFrame rf);
+
+      /**
+       * Get bounding box (may not be as tight as bounding box returned by
+       * #getTightBoundingBox)
+       */
+      osg::BoundingBox getBoundingBox() const;
+
+      /**
+       * Get tight bounding box (child points are transformed to elements
+       * coordinate space before calculating the bounding box).
+       */
+      osg::BoundingBox getTightBoundingBox() const;
 
       /**
        * Get bounding box with children/drawables transformed by passed matrix
        */
       virtual osg::BoundingBox getTransformedBounds(const osg::Matrix& m) const;
 
+      /**
+       * Get the transformation matrix (product of all transforms)
+       */
+      osg::Matrix getMatrix() const;
+
       /**
        * Create an canvas Element
        *
@@ -149,19 +199,18 @@ namespace canvas
         ElementPtr
       >::type create( const CanvasWeakPtr& canvas,
                       const SGPropertyNode_ptr& node,
-                      const Style& style,
-                      Element* parent )
+                      const Style& style = Style(),
+                      Element* parent = NULL )
       {
-        ElementPtr el( new Derived(canvas, node, style, parent) );
-        el->setSelf(el);
-        return el;
+        return ElementPtr( new Derived(canvas, node, style, parent) );
       }
 
     protected:
 
       enum Attributes
       {
-        BLEND_FUNC = 0x0001,
+        TRANSFORM       = 1,
+        BLEND_FUNC      = TRANSFORM << 1,
         LAST_ATTRIBUTE  = BLEND_FUNC << 1
       };
 
@@ -174,25 +223,28 @@ namespace canvas
         TT_SCALE
       };
 
+      class RelativeScissor;
+
       CanvasWeakPtr _canvas;
       Element      *_parent;
 
-      uint32_t _attributes_dirty;
+      mutable uint32_t _attributes_dirty;
 
-      bool _transform_dirty;
       osg::observer_ptr<osg::MatrixTransform> _transform;
       std::vector<TransformType>              _transform_types;
 
-      Style                             _style;
-      std::vector<SGPropertyNode_ptr>   _bounding_box;
+      Style             _style;
+      RelativeScissor  *_scissor;
 
-      typedef std::vector<EventListenerPtr> Listener;
-      typedef std::map<Event::Type, Listener> ListenerMap;
+      typedef std::vector<EventListener> Listener;
+      typedef std::map<int, Listener> ListenerMap;
 
       ListenerMap _listener;
 
       typedef std::map<std::string, StyleInfo> StyleSetters;
-      static StyleSetters       _style_setters;
+      static StyleSetters _style_setters;
+
+      static void staticInit();
 
       Element( const CanvasWeakPtr& canvas,
                const SGPropertyNode_ptr& node,
@@ -207,7 +259,7 @@ namespace canvas
        * @tparam Derived    (Derived) class type
        */
       template<class Derived>
-      bool isInit() const
+      static bool isInit()
       {
         static bool is_init = false;
         if( is_init )
@@ -236,10 +288,12 @@ namespace canvas
         typename T2,
         class Derived
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
-                const boost::function<void (Derived&, T2)>& setter )
+                const boost::function<void (Derived&, T2)>& setter,
+                bool inheritable = true )
       {
         StyleInfo& style_info = _style_setters[ name ];
         if( !type.empty() )
@@ -255,6 +309,8 @@ namespace canvas
 
           style_info.type = type;
         }
+        // TODO check if changed?
+        style_info.inheritable = inheritable;
 
         StyleSetter* style = &style_info.setter;
         while( style->next )
@@ -276,28 +332,33 @@ namespace canvas
         typename T,
         class Derived
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
-                const boost::function<void (Derived&, T)>& setter )
+                const boost::function<void (Derived&, T)>& setter,
+                bool inheritable = true )
       {
-        return addStyle<T, T>(name, type, setter);
+        return addStyle<T, T>(name, type, setter, inheritable);
       }
 
       template<
         typename T,
         class Derived
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
-                void (Derived::*setter)(T) )
+                void (Derived::*setter)(T),
+                bool inheritable = true )
       {
         return addStyle<T, T>
         (
           name,
           type,
-          boost::function<void (Derived&, T)>(setter)
+          boost::function<void (Derived&, T)>(setter),
+          inheritable
         );
       }
 
@@ -306,32 +367,38 @@ namespace canvas
         typename T2,
         class Derived
       >
+      static
       StyleSetterFunc
       addStyle( const std::string& name,
                 const std::string& type,
-                void (Derived::*setter)(T2) )
+                void (Derived::*setter)(T2),
+                bool inheritable = true )
       {
         return addStyle<T1>
         (
           name,
           type,
-          boost::function<void (Derived&, T2)>(setter)
+          boost::function<void (Derived&, T2)>(setter),
+          inheritable
         );
       }
 
       template<
         class Derived
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
-                void (Derived::*setter)(const std::string&) )
+                void (Derived::*setter)(const std::string&),
+                bool inheritable = true )
       {
         return addStyle<const char*, const std::string&>
         (
           name,
           type,
-          boost::function<void (Derived&, const std::string&)>(setter)
+          boost::function<void (Derived&, const std::string&)>(setter),
+          inheritable
         );
       }
 
@@ -341,13 +408,21 @@ namespace canvas
         class Other,
         class OtherRef
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
                 void (Other::*setter)(T),
-                OtherRef Derived::*instance_ref )
+                OtherRef Derived::*instance_ref,
+                bool inheritable = true )
       {
-        return addStyle<T, T>(name, type, bindOther(setter, instance_ref));
+        return addStyle<T, T>
+        (
+          name,
+          type,
+          bindOther(setter, instance_ref),
+          inheritable
+        );
       }
 
       template<
@@ -357,13 +432,21 @@ namespace canvas
         class Other,
         class OtherRef
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
                 void (Other::*setter)(T2),
-                OtherRef Derived::*instance_ref )
+                OtherRef Derived::*instance_ref,
+                bool inheritable = true )
       {
-        return addStyle<T1>(name, type, bindOther(setter, instance_ref));
+        return addStyle<T1>
+        (
+          name,
+          type,
+          bindOther(setter, instance_ref),
+          inheritable
+        );
       }
 
       template<
@@ -373,13 +456,21 @@ namespace canvas
         class Other,
         class OtherRef
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
                 const boost::function<void (Other&, T2)>& setter,
-                OtherRef Derived::*instance_ref )
+                OtherRef Derived::*instance_ref,
+                bool inheritable = true )
       {
-        return addStyle<T1>(name, type, bindOther(setter, instance_ref));
+        return addStyle<T1>
+        (
+          name,
+          type,
+          bindOther(setter, instance_ref),
+          inheritable
+        );
       }
 
       template<
@@ -387,22 +478,26 @@ namespace canvas
         class Other,
         class OtherRef
       >
+      static
       StyleSetter
       addStyle( const std::string& name,
                 const std::string& type,
                 void (Other::*setter)(const std::string&),
-                OtherRef Derived::*instance_ref )
+                OtherRef Derived::*instance_ref,
+                bool inheritable = true )
       {
         return addStyle<const char*, const std::string&>
         (
           name,
           type,
           boost::function<void (Other&, const std::string&)>(setter),
-          instance_ref
+          instance_ref,
+          inheritable
         );
       }
 
       template<typename T, class Derived, class Other, class OtherRef>
+      static
       boost::function<void (Derived&, T)>
       bindOther( void (Other::*setter)(T), OtherRef Derived::*instance_ref )
       {
@@ -410,6 +505,7 @@ namespace canvas
       }
 
       template<typename T, class Derived, class Other, class OtherRef>
+      static
       boost::function<void (Derived&, T)>
       bindOther( const boost::function<void (Other&, T)>& setter,
                  OtherRef Derived::*instance_ref )
@@ -427,6 +523,7 @@ namespace canvas
       }
 
       template<typename T1, typename T2, class Derived>
+      static
       StyleSetterFuncUnchecked
       bindStyleSetter( const std::string& name,
                        const boost::function<void (Derived&, T2)>& setter )
@@ -441,6 +538,15 @@ namespace canvas
         );
       }
 
+      bool isStyleEmpty(const SGPropertyNode* child) const;
+      bool canApplyStyle(const SGPropertyNode* child) const;
+      bool setStyleImpl( const SGPropertyNode* child,
+                         const StyleInfo* style_info = 0 );
+
+      const StyleInfo* getStyleInfo(const std::string& name) const;
+      const StyleSetter* getStyleSetter(const std::string& name) const;
+      const SGPropertyNode* getParentStyle(const SGPropertyNode* child) const;
+
       virtual void childAdded(SGPropertyNode * child)  {}
       virtual void childRemoved(SGPropertyNode * child){}
       virtual void childChanged(SGPropertyNode * child){}
@@ -495,6 +601,27 @@ namespace canvas
   };
 
 } // namespace canvas
+
+  template<>
+  struct enum_traits<canvas::Element::ReferenceFrame>
+  {
+    static const char* name()
+    {
+      return "canvas::Element::ReferenceFrame";
+    }
+
+    static canvas::Element::ReferenceFrame defVal()
+    {
+      return canvas::Element::GLOBAL;
+    }
+
+    static bool validate(int frame)
+    {
+      return frame >= canvas::Element::GLOBAL
+          && frame <= canvas::Element::LOCAL;
+    }
+  };
+
 } // namespace simgear
 
 #endif /* CANVAS_ELEMENT_HXX_ */

simgear/canvas/elements/CanvasGroup.cxx

@@ -22,7 +22,7 @@
 #include "CanvasPath.hxx"
 #include "CanvasText.hxx"
 #include <simgear/canvas/CanvasEventVisitor.hxx>
-#include <simgear/canvas/MouseEvent.hxx>
+#include <simgear/canvas/events/MouseEvent.hxx>
 
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
@@ -38,6 +38,7 @@ namespace canvas
   template<typename ElementType>
   void add(ElementFactories& factories)
   {
+    ElementType::staticInit();
     factories[ElementType::TYPE_NAME] = &Element::create<ElementType>;
   }
 
@@ -45,6 +46,26 @@ namespace canvas
   ElementFactories Group::_child_factories;
   const std::string Group::TYPE_NAME = "group";
 
+  void warnTransformExpired(const char* member_name)
+  {
+    SG_LOG( SG_GENERAL,
+            SG_WARN,
+            "canvas::Group::" << member_name << ": Group has expired." );
+  }
+
+  //----------------------------------------------------------------------------
+  void Group::staticInit()
+  {
+    if( isInit<Group>() )
+      return;
+
+    add<Group>(_child_factories);
+    add<Image>(_child_factories);
+    add<Map  >(_child_factories);
+    add<Path >(_child_factories);
+    add<Text >(_child_factories);
+  }
+
   //----------------------------------------------------------------------------
   Group::Group( const CanvasWeakPtr& canvas,
                 const SGPropertyNode_ptr& node,
@@ -52,14 +73,7 @@ namespace canvas
                 Element* parent ):
     Element(canvas, node, parent_style, parent)
   {
-    if( !isInit<Group>() )
-    {
-      add<Group>(_child_factories);
-      add<Image>(_child_factories);
-      add<Map  >(_child_factories);
-      add<Path >(_child_factories);
-      add<Text >(_child_factories);
-    }
+    staticInit();
   }
 
   //----------------------------------------------------------------------------
@@ -119,15 +133,20 @@ namespace canvas
   //----------------------------------------------------------------------------
   ElementPtr Group::getElementById(const std::string& id)
   {
-    std::vector<GroupPtr> groups;
+    if( !_transform.valid() )
+    {
+      warnTransformExpired("getElementById");
+      return ElementPtr();
+    }
 
+    std::vector<GroupPtr> groups;
     for(size_t i = 0; i < _transform->getNumChildren(); ++i)
     {
       const ElementPtr& el = getChildByIndex(i);
       if( el->get<std::string>("id") == id )
         return el;
 
-      GroupPtr group = boost::dynamic_pointer_cast<Group>(el);
+      Group* group = dynamic_cast<Group*>(el.get());
       if( group )
         groups.push_back(group);
     }
@@ -145,6 +164,8 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Group::clearEventListener()
   {
+    if( !_transform.valid() )
+      return warnTransformExpired("clearEventListener");
 
     for(size_t i = 0; i < _transform->getNumChildren(); ++i)
       getChildByIndex(i)->clearEventListener();
@@ -174,21 +195,23 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  bool Group::setStyle(const SGPropertyNode* style)
+  bool Group::setStyle( const SGPropertyNode* style,
+                        const StyleInfo* style_info )
   {
-    // Don't propagate styles directly applicable to this group
-    if( Element::setStyle(style) )
-      return true;
-
-    if(    style->getParent() != _node
-        && _style.find(style->getNameString()) != _style.end() )
+    if( !canApplyStyle(style) )
       return false;
 
-    bool handled = false;
-    for(size_t i = 0; i < _transform->getNumChildren(); ++i)
+    bool handled = setStyleImpl(style, style_info);
+    if( style_info->inheritable )
     {
-      if( getChildByIndex(i)->setStyle(style) )
-        handled = true;
+      if( !_transform.valid() )
+      {
+        warnTransformExpired("setStyle");
+        return false;
+      }
+
+      for(size_t i = 0; i < _transform->getNumChildren(); ++i)
+        handled |= getChildByIndex(i)->setStyle(style, style_info);
     }
 
     return handled;
@@ -198,6 +221,11 @@ namespace canvas
   osg::BoundingBox Group::getTransformedBounds(const osg::Matrix& m) const
   {
     osg::BoundingBox bb;
+    if( !_transform.valid() )
+    {
+      warnTransformExpired("getTransformedBounds");
+      return bb;
+    }
 
     for(size_t i = 0; i < _transform->getNumChildren(); ++i)
     {
@@ -236,6 +264,9 @@ namespace canvas
     ElementFactory child_factory = getChildFactory( child->getNameString() );
     if( child_factory )
     {
+      if( !_transform.valid() )
+        return warnTransformExpired("childAdded");
+
       ElementPtr element = child_factory(_canvas, child, _style, this);
 
       // Add to osg scene graph...
@@ -247,12 +278,9 @@ namespace canvas
       return;
     }
 
-    if( !Element::setStyle(child) )
-    {
-      // Only add style if not applicable to group itself
+    StyleInfo const* style = getStyleInfo(child->getNameString());
+    if( style && style->inheritable )
       _style[ child->getNameString() ] = child;
-      setStyle(child);
-    }
   }
 
   //----------------------------------------------------------------------------
@@ -285,25 +313,25 @@ namespace canvas
     }
     else
     {
-      Style::iterator style = _style.find(node->getNameString());
-      if( style != _style.end() )
-        _style.erase(style);
+      _style.erase( node->getNameString() );
     }
   }
 
   //----------------------------------------------------------------------------
   void Group::childChanged(SGPropertyNode* node)
   {
-    if(    node->getParent()->getParent() == _node
+    SGPropertyNode* parent = node->getParent();
+    SGPropertyNode* grand_parent = parent ? parent->getParent() : NULL;
+
+    if(    grand_parent == _node
         && node->getNameString() == "z-index" )
-      return handleZIndexChanged( getChild(node->getParent()),
-                                  node->getIntValue() );
+      return handleZIndexChanged(getChild(parent), node->getIntValue());
   }
 
   //----------------------------------------------------------------------------
   void Group::handleZIndexChanged(ElementPtr child, int z_index)
   {
-    if( !child )
+    if( !child || !_transform.valid() )
       return;
 
     osg::ref_ptr<osg::MatrixTransform> tf = child->getMatrixTransform();
@@ -364,6 +392,12 @@ namespace canvas
   ElementPtr Group::findChild( const SGPropertyNode* node,
                                const std::string& id ) const
   {
+    if( !_transform.valid() )
+    {
+      warnTransformExpired("findChild");
+      return ElementPtr();
+    }
+
     for(size_t i = 0; i < _transform->getNumChildren(); ++i)
     {
       ElementPtr el = getChildByIndex(i);

simgear/canvas/elements/CanvasGroup.hxx

@@ -35,6 +35,7 @@ namespace canvas
   {
     public:
       static const std::string TYPE_NAME;
+      static void staticInit();
 
       typedef std::list< std::pair< const SGPropertyNode*,
                                     ElementPtr
@@ -55,28 +56,27 @@ namespace canvas
                                    const std::string& id );
 
       template<class T>
-      boost::shared_ptr<T> createChild(const std::string& id = "")
+      SGSharedPtr<T> createChild(const std::string& id = "")
       {
-        return boost::dynamic_pointer_cast<T>( createChild(T::TYPE_NAME, id) );
+        return dynamic_cast<T*>( createChild(T::TYPE_NAME, id).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getChild(const SGPropertyNode* node)
+      SGSharedPtr<T> getChild(const SGPropertyNode* node)
       {
-        return boost::dynamic_pointer_cast<T>( getChild(node) );
+        return dynamic_cast<T*>( getChild(node).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getChild(const std::string& id)
+      SGSharedPtr<T> getChild(const std::string& id)
       {
-        return boost::dynamic_pointer_cast<T>( getChild(id) );
+        return dynamic_cast<T*>( getChild(id).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getOrCreateChild(const std::string& id)
+      SGSharedPtr<T> getOrCreateChild(const std::string& id)
       {
-        return
-          boost::dynamic_pointer_cast<T>( getOrCreateChild(T::TYPE_NAME, id) );
+        return dynamic_cast<T*>( getOrCreateChild(T::TYPE_NAME, id).get() );
       }
 
       /**
@@ -92,7 +92,8 @@ namespace canvas
 
       virtual bool traverse(EventVisitor& visitor);
 
-      virtual bool setStyle(const SGPropertyNode* child);
+      virtual bool setStyle( const SGPropertyNode* child,
+                             const StyleInfo* style_info = 0 );
 
       virtual osg::BoundingBox getTransformedBounds(const osg::Matrix& m) const;
 

simgear/canvas/elements/CanvasImage.cxx

@@ -21,7 +21,7 @@
 #include <simgear/canvas/Canvas.hxx>
 #include <simgear/canvas/CanvasMgr.hxx>
 #include <simgear/canvas/CanvasSystemAdapter.hxx>
-#include <simgear/canvas/MouseEvent.hxx>
+#include <simgear/canvas/events/MouseEvent.hxx>
 #include <simgear/scene/util/OsgMath.hxx>
 #include <simgear/scene/util/parse_color.hxx>
 #include <simgear/misc/sg_path.hxx>
@@ -29,8 +29,7 @@
 #include <osg/Array>
 #include <osg/Geometry>
 #include <osg/PrimitiveSet>
-
-#include <boost/algorithm/string/predicate.hpp>
+#include <osgDB/Registry>
 
 namespace simgear
 {
@@ -75,8 +74,9 @@ namespace canvas
                            osg::Drawable* drawable,
                            osg::RenderInfo* renderInfo ) const
   {
-    if( !_canvas.expired() )
-      _canvas.lock()->enableRendering();
+    CanvasPtr canvas = _canvas.lock();
+    if( canvas )
+      canvas->enableRendering();
 
     if( !_cull_next_frame )
       // TODO check if window/image should be culled
@@ -89,6 +89,19 @@ namespace canvas
   //----------------------------------------------------------------------------
   const std::string Image::TYPE_NAME = "image";
 
+  //----------------------------------------------------------------------------
+  void Image::staticInit()
+  {
+    if( isInit<Image>() )
+      return;
+
+    addStyle("fill", "color", &Image::setFill);
+    addStyle("outset", "", &Image::setOutset);
+    addStyle("preserveAspectRatio", "", &Image::setPreserveAspectRatio);
+    addStyle("slice", "", &Image::setSlice);
+    addStyle("slice-width", "", &Image::setSliceWidth);
+  }
+
   //----------------------------------------------------------------------------
   Image::Image( const CanvasWeakPtr& canvas,
                 const SGPropertyNode_ptr& node,
@@ -100,6 +113,8 @@ namespace canvas
     _src_rect(0,0),
     _region(0,0)
   {
+    staticInit();
+
     _geom = new osg::Geometry;
     _geom->setUseDisplayList(false);
 
@@ -114,12 +129,11 @@ namespace canvas
 
     _texCoords = new osg::Vec2Array(4);
     _texCoords->setDataVariance(osg::Object::DYNAMIC);
-    _geom->setTexCoordArray(0, _texCoords);
+    _geom->setTexCoordArray(0, _texCoords, osg::Array::BIND_PER_VERTEX);
 
     _colors = new osg::Vec4Array(1);
     _colors->setDataVariance(osg::Object::DYNAMIC);
-    _geom->setColorArray(_colors);
-    _geom->setColorBinding(osg::Geometry::BIND_OVERALL);
+    _geom->setColorArray(_colors, osg::Array::BIND_OVERALL);
 
     _prim = new osg::DrawArrays(osg::PrimitiveSet::QUADS);
     _prim->set(osg::PrimitiveSet::QUADS, 0, 4);
@@ -128,23 +142,15 @@ namespace canvas
 
     setDrawable(_geom);
 
-    if( !isInit<Image>() )
-    {
-      addStyle("fill", "color", &Image::setFill);
-      addStyle("slice", "", &Image::setSlice);
-      addStyle("slice-width", "", &Image::setSliceWidth);
-      addStyle("outset", "", &Image::setOutset);
-    }
-
     setFill("#ffffff"); // TODO how should we handle default values?
-
     setupStyle();
   }
 
   //----------------------------------------------------------------------------
   Image::~Image()
   {
-
+    if( _http_request )
+      _http_request->abort("image destroyed");
   }
 
   //----------------------------------------------------------------------------
@@ -209,6 +215,10 @@ namespace canvas
       if( !_slice.isValid() )
       {
         setQuad(0, region.getMin(), region.getMax());
+
+        if( !_preserve_aspect_ratio.scaleToFill() )
+          // We need to update texture coordinates to keep the aspect ratio
+          _attributes_dirty |= SRC_RECT;
       }
       else
       {
@@ -267,7 +277,6 @@ namespace canvas
       _vertices->dirty();
       _attributes_dirty &= ~DEST_SIZE;
       _geom->dirtyBound();
-      setBoundingBox(_geom->getBound());
     }
 
     if( _attributes_dirty & SRC_RECT )
@@ -286,6 +295,66 @@ namespace canvas
 
       if( !_slice.isValid() )
       {
+        // Image scaling preserving aspect ratio. Change texture coordinates to
+        // scale image accordingly.
+        //
+        // TODO allow to specify what happens to not filled space (eg. color,
+        //      or texture repeat/mirror)
+        //
+        // http://www.w3.org/TR/SVG11/coords.html#PreserveAspectRatioAttribute
+        if( !_preserve_aspect_ratio.scaleToFill() )
+        {
+          osg::BoundingBox const& bb = getBoundingBox();
+          float dst_width = bb._max.x() - bb._min.x(),
+                dst_height = bb._max.y() - bb._min.y();
+          float scale_x = dst_width / tex_dim.width(),
+                scale_y = dst_height / tex_dim.height();
+
+          float scale = _preserve_aspect_ratio.scaleToFit()
+                      ? std::min(scale_x, scale_y)
+                      : std::max(scale_x, scale_y);
+
+          if( scale_x != scale )
+          {
+            float d = scale_x / scale - 1;
+            if(  _preserve_aspect_ratio.alignX()
+              == SVGpreserveAspectRatio::ALIGN_MIN )
+            {
+              src_rect.r() += d;
+            }
+            else if(  _preserve_aspect_ratio.alignX()
+                   == SVGpreserveAspectRatio::ALIGN_MAX )
+            {
+              src_rect.l() -= d;
+            }
+            else
+            {
+              src_rect.l() -= d / 2;
+              src_rect.r() += d / 2;
+            }
+          }
+
+          if( scale_y != scale )
+          {
+            float d = scale_y / scale - 1;
+            if(  _preserve_aspect_ratio.alignY()
+              == SVGpreserveAspectRatio::ALIGN_MIN )
+            {
+              src_rect.b() -= d;
+            }
+            else if(  _preserve_aspect_ratio.alignY()
+                   == SVGpreserveAspectRatio::ALIGN_MAX )
+            {
+              src_rect.t() += d;
+            }
+            else
+            {
+              src_rect.t() += d / 2;
+              src_rect.b() -= d / 2;
+            }
+          }
+        }
+
         setQuadUV(0, src_rect.getMin(), src_rect.getMax());
       }
       else
@@ -400,14 +469,29 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Image::setFill(const std::string& fill)
   {
-    osg::Vec4 color;
-    if( !parseColor(fill, color) )
+    osg::Vec4 color(1,1,1,1);
+    if(    !fill.empty() // If no color is given default to white
+        && !parseColor(fill, color) )
       return;
 
     _colors->front() = color;
     _colors->dirty();
   }
 
+  //----------------------------------------------------------------------------
+  void Image::setOutset(const std::string& outset)
+  {
+    _outset = CSSBorder::parse(outset);
+    _attributes_dirty |= DEST_SIZE;
+  }
+
+  //----------------------------------------------------------------------------
+  void Image::setPreserveAspectRatio(const std::string& scale)
+  {
+    _preserve_aspect_ratio = SVGpreserveAspectRatio::parse(scale);
+    _attributes_dirty |= SRC_RECT;
+  }
+
   //----------------------------------------------------------------------------
   void Image::setSlice(const std::string& slice)
   {
@@ -422,13 +506,6 @@ namespace canvas
     _attributes_dirty |= DEST_SIZE;
   }
 
-  //----------------------------------------------------------------------------
-  void Image::setOutset(const std::string& outset)
-  {
-    _outset = CSSBorder::parse(outset);
-    _attributes_dirty |= DEST_SIZE;
-  }
-
   //----------------------------------------------------------------------------
   const SGRect<float>& Image::getRegion() const
   {
@@ -436,7 +513,7 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  bool Image::handleEvent(EventPtr event)
+  bool Image::handleEvent(const EventPtr& event)
   {
     bool handled = Element::handleEvent(event);
 
@@ -444,11 +521,10 @@ namespace canvas
     if( !src_canvas )
       return handled;
 
-    MouseEventPtr mouse_event = boost::dynamic_pointer_cast<MouseEvent>(event);
+    MouseEventPtr mouse_event = dynamic_cast<MouseEvent*>(event.get());
     if( mouse_event )
     {
       mouse_event.reset( new MouseEvent(*mouse_event) );
-      event = mouse_event;
 
       mouse_event->client_pos = mouse_event->local_pos
                               - toOsg(_region.getMin());
@@ -468,9 +544,11 @@ namespace canvas
       mouse_event->client_pos.x() *= src_canvas->getViewWidth() / size.x();
       mouse_event->client_pos.y() *= src_canvas->getViewHeight()/ size.y();
       mouse_event->local_pos = mouse_event->client_pos;
+
+      handled |= src_canvas->handleMouseEvent(mouse_event);
     }
 
-    return handled | src_canvas->handleMouseEvent(mouse_event);
+    return handled;
   }
 
   //----------------------------------------------------------------------------
@@ -515,20 +593,41 @@ namespace canvas
 
       _attributes_dirty |= DEST_SIZE;
     }
-    else if( name == "file" )
+    else if( name == "src" || name == "file" )
     {
-      static const std::string CANVAS_PROTOCOL = "canvas://";
-      const std::string& path = child->getStringValue();
+      if( name == "file" )
+        SG_LOG(SG_GL, SG_WARN, "'file' is deprecated. Use 'src' instead");
 
-      CanvasPtr canvas = _canvas.lock();
-      if( !canvas )
+      // Abort pending request
+      if( _http_request )
       {
-        SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No canvas available");
-        return;
+        _http_request->abort("setting new image");
+        _http_request.reset();
       }
 
-      if( boost::starts_with(path, CANVAS_PROTOCOL) )
+      static const std::string PROTOCOL_SEP = "://";
+
+      std::string url = child->getStringValue(),
+                  protocol, path;
+
+      size_t sep_pos = url.find(PROTOCOL_SEP);
+      if( sep_pos != std::string::npos )
       {
+        protocol = url.substr(0, sep_pos);
+        path = url.substr(sep_pos + PROTOCOL_SEP.length());
+      }
+      else
+        path = url;
+
+      if( protocol == "canvas" )
+      {
+        CanvasPtr canvas = _canvas.lock();
+        if( !canvas )
+        {
+          SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No canvas available");
+          return;
+        }
+
         CanvasMgr* canvas_mgr = canvas->getCanvasMgr();
         if( !canvas_mgr )
         {
@@ -539,7 +638,7 @@ namespace canvas
         const SGPropertyNode* canvas_node =
           canvas_mgr->getPropertyRoot()
                     ->getParent()
-                    ->getNode( path.substr(CANVAS_PROTOCOL.size()) );
+                    ->getNode( path );
         if( !canvas_node )
         {
           SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No such canvas: " << path);
@@ -557,9 +656,19 @@ namespace canvas
 
         setSrcCanvas(src_canvas);
       }
+      else if( protocol == "http" || protocol == "https" )
+      // TODO check https
+      {
+        _http_request =
+          Canvas::getSystemAdapter()
+          ->getHTTPClient()
+          ->load(url)
+          // TODO handle capture of 'this'
+          ->done(this, &Image::handleImageLoadDone);
+      }
       else
       {
-        setImage( canvas->getSystemAdapter()->getImage(path) );
+        setImage( Canvas::getSystemAdapter()->getImage(path) );
       }
     }
   }
@@ -632,5 +741,65 @@ namespace canvas
     (*_texCoords)[i + 3].set(tl.x(), br.y());
   }
 
+  //----------------------------------------------------------------------------
+  void Image::handleImageLoadDone(HTTP::Request* req)
+  {
+    // Ignore stale/expired requests
+    if( _http_request != req )
+      return;
+    _http_request.reset();
+
+    if( req->responseCode() != 200 )
+    {
+      SG_LOG(SG_IO, SG_WARN, "failed to download '" << req->url() << "': "
+                                                    << req->responseReason());
+      return;
+    }
+
+    const std::string ext = SGPath(req->path()).extension(),
+                      mime = req->responseMime();
+
+    SG_LOG(SG_IO, SG_INFO, "received " << req->url() <<
+                           " (ext=" << ext << ", MIME=" << mime << ")");
+
+    const std::string& img_data =
+      static_cast<HTTP::MemoryRequest*>(req)->responseBody();
+    osgDB::Registry* reg = osgDB::Registry::instance();
+
+    // First try to detect image type by extension
+    osgDB::ReaderWriter* rw = reg->getReaderWriterForExtension(ext);
+    if( rw && loadImage(*rw, img_data, *req, "extension") )
+      return;
+
+    // Now try with MIME type
+    rw = reg->getReaderWriterForMimeType(mime);
+    if( rw && loadImage(*rw, img_data, *req, "MIME type") )
+      return;
+
+    SG_LOG(SG_IO, SG_WARN, "unable to read image '" << req->url() << "'");
+  }
+
+  //----------------------------------------------------------------------------
+  bool Image::loadImage( osgDB::ReaderWriter& reader,
+                         const std::string& data,
+                         HTTP::Request& request,
+                         const std::string& type )
+  {
+    SG_LOG(SG_IO, SG_DEBUG, "use image reader detected by " << type);
+
+    std::istringstream data_strm(data);
+    osgDB::ReaderWriter::ReadResult result = reader.readImage(data_strm);
+    if( result.success() )
+    {
+      setImage( result.takeImage() );
+      return true;
+    }
+
+    SG_LOG(SG_IO, SG_WARN, "failed to read image '" << request.url() << "': "
+                                                    << result.message());
+
+    return false;
+  }
+
 } // namespace canvas
 } // namespace simgear

simgear/canvas/elements/CanvasImage.hxx

@@ -22,11 +22,14 @@
 #include "CanvasElement.hxx"
 
 #include <simgear/canvas/canvas_fwd.hxx>
+#include <simgear/io/HTTPClient.hxx>
 #include <simgear/misc/CSSBorder.hxx>
+#include <simgear/misc/SVGpreserveAspectRatio.hxx>
 #include <osg/Texture2D>
 
 namespace simgear
 {
+namespace HTTP { class Request; }
 namespace canvas
 {
 
@@ -35,6 +38,7 @@ namespace canvas
   {
     public:
       static const std::string TYPE_NAME;
+      static void staticInit();
 
       /**
        * @param node    Property node containing settings for this image:
@@ -58,6 +62,17 @@ namespace canvas
       void setImage(osg::Image *img);
       void setFill(const std::string& fill);
 
+      /**
+       * @see http://www.w3.org/TR/css3-background/#border-image-outset
+       */
+      void setOutset(const std::string& outset);
+
+      /**
+       * @see
+       *   http://www.w3.org/TR/SVG11/coords.html#PreserveAspectRatioAttribute
+       */
+      void setPreserveAspectRatio(const std::string& scale);
+
       /**
        * Set image slice (aka. 9-scale)
        *
@@ -76,14 +91,9 @@ namespace canvas
        */
       void setSliceWidth(const std::string& width);
 
-      /**
-       * http://www.w3.org/TR/css3-background/#border-image-outset
-       */
-      void setOutset(const std::string& outset);
-
       const SGRect<float>& getRegion() const;
 
-      bool handleEvent(EventPtr event);
+      bool handleEvent(const EventPtr& event);
 
     protected:
 
@@ -102,9 +112,16 @@ namespace canvas
       void setQuad(size_t index, const SGVec2f& tl, const SGVec2f& br);
       void setQuadUV(size_t index, const SGVec2f& tl, const SGVec2f& br);
 
+      void handleImageLoadDone(HTTP::Request*);
+      bool loadImage( osgDB::ReaderWriter& reader,
+                      const std::string& data,
+                      HTTP::Request& request,
+                      const std::string& type );
+
       osg::ref_ptr<osg::Texture2D> _texture;
       // TODO optionally forward events to canvas
       CanvasWeakPtr _src_canvas;
+      HTTP::Request_ptr _http_request;
 
       osg::ref_ptr<osg::Geometry>  _geom;
       osg::ref_ptr<osg::DrawArrays>_prim;
@@ -116,9 +133,11 @@ namespace canvas
       SGRect<float>   _src_rect,
                       _region;
 
-      CSSBorder       _slice,
-                      _slice_width,
-                      _outset;
+      SVGpreserveAspectRatio _preserve_aspect_ratio;
+
+      CSSBorder       _outset,
+                      _slice,
+                      _slice_width;
   };
 
 } // namespace canvas

simgear/canvas/elements/CanvasMap.cxx

@@ -46,6 +46,17 @@ namespace canvas
   const std::string GEO = "-geo";
   const std::string Map::TYPE_NAME = "map";
 
+  //----------------------------------------------------------------------------
+  void Map::staticInit()
+  {
+    Group::staticInit();
+
+    if( isInit<Map>() )
+      return;
+
+    // Do some initialization if needed...
+  }
+
   //----------------------------------------------------------------------------
   Map::Map( const CanvasWeakPtr& canvas,
             const SGPropertyNode_ptr& node,
@@ -56,7 +67,7 @@ namespace canvas
     _projection(new SansonFlamsteedProjection),
     _projection_dirty(true)
   {
-
+    staticInit();
   }
 
   //----------------------------------------------------------------------------
@@ -194,6 +205,8 @@ namespace canvas
       _projection->setOrientation(child->getFloatValue());
     else if( child->getNameString() == "range" )
       _projection->setRange(child->getDoubleValue());
+    else if( child->getNameString() == "screen-range" )
+      _projection->setScreenRange(child->getDoubleValue());
     else
       return Group::childChanged(child);
 

simgear/canvas/elements/CanvasMap.hxx

@@ -36,6 +36,7 @@ namespace canvas
   {
     public:
       static const std::string TYPE_NAME;
+      static void staticInit();
 
       Map( const CanvasWeakPtr& canvas,
            const SGPropertyNode_ptr& node,

simgear/canvas/elements/CanvasPath.cxx

@@ -110,7 +110,7 @@ namespace canvas
        */
       void setFill(const std::string& fill)
       {
-        if( fill == "none" )
+        if( fill.empty() || fill == "none" )
         {
           _mode &= ~VG_FILL_PATH;
         }
@@ -150,7 +150,7 @@ namespace canvas
        */
       void setStroke(const std::string& stroke)
       {
-        if( stroke == "none" )
+        if( stroke.empty() || stroke == "none" )
         {
           _mode &= ~VG_STROKE_PATH;
         }
@@ -217,9 +217,10 @@ namespace canvas
         state->setClientActiveTextureUnit(0);
         state->disableAllVertexArrays();
 
-        glPushAttrib(~0u); // Don't use GL_ALL_ATTRIB_BITS as on my machine it
-                           // eg. doesn't include GL_MULTISAMPLE_BIT
-        glPushClientAttrib(~0u);
+        bool was_blend_enabled = state->getLastAppliedMode(GL_BLEND);
+        bool was_stencil_enabled = state->getLastAppliedMode(GL_STENCIL_TEST);
+        osg::StateAttribute const* blend_func =
+          state->getLastAppliedAttribute(osg::StateAttribute::BLENDFUNC);
 
         // Initialize/Update the paint
         if( _attributes_dirty & STROKE_COLOR )
@@ -269,15 +270,19 @@ namespace canvas
         if( err != VG_NO_ERROR )
           SG_LOG(SG_GL, SG_ALERT, "vgError: " << err);
 
-        glPopAttrib();
-        glPopClientAttrib();
+        // Restore OpenGL state (TODO check if more is needed or integrate
+        //                            better with OpenSceneGraph)
+        if( was_blend_enabled )   glEnable(GL_BLEND);
+        if( was_stencil_enabled ) glEnable(GL_STENCIL_TEST);
+        if( blend_func )          blend_func->apply(*state);
       }
 
       osg::BoundingBox getTransformedBounds(const osg::Matrix& mat) const
       {
         osg::BoundingBox bb;
 
-        osg::Vec2f cur; // VG "Current point" (in local coordinates)
+        osg::Vec2f cur(0, 0), // VG "Current point" (in local coordinates)
+                   sub(0, 0); // beginning of current sub path
         VGubyte cmd_index = 0;
         for( size_t i = 0,              ci = 0;
                     i < _cmds.size() && ci < _coords.size();
@@ -297,6 +302,7 @@ namespace canvas
           switch( cmd )
           {
             case VG_CLOSE_PATH:
+              cur = sub;
               break;
             case VG_MOVE_TO:
             case VG_LINE_TO:
@@ -352,7 +358,12 @@ namespace canvas
           }
 
           if( num_coords > 0 )
+          {
             cur = points[ num_coords - 1 ];
+
+            if( cmd == VG_MOVE_TO )
+              sub = cur;
+          }
         }
 
         return bb;
@@ -374,14 +385,11 @@ namespace canvas
         // vgPathBounds doesn't take stroke width into account
         float ext = 0.5 * _stroke_width;
 
-        osg::BoundingBox bb
+        return osg::BoundingBox
         (
           min[0] - ext,           min[1] - ext,           -0.1,
           min[0] + size[0] + ext, min[1] + size[1] + ext,  0.1
         );
-        _path_element->setBoundingBox(bb);
-
-        return bb;
       }
 
     private:
@@ -456,7 +464,12 @@ namespace canvas
         }
 
         if( _attributes_dirty & BOUNDING_BOX )
+        {
           dirtyBound();
+
+          // Recalculate bounding box now (prevent race condition)
+          getBound();
+        }
       }
 
       struct PathUpdateCallback:
@@ -472,6 +485,22 @@ namespace canvas
   //----------------------------------------------------------------------------
   const std::string Path::TYPE_NAME = "path";
 
+  //----------------------------------------------------------------------------
+  void Path::staticInit()
+  {
+    if( isInit<Path>() )
+      return;
+
+    PathDrawableRef Path::*path = &Path::_path;
+
+    addStyle("fill", "color", &PathDrawable::setFill, path);
+    addStyle("fill-rule", "", &PathDrawable::setFillRule, path);
+    addStyle("stroke", "color", &PathDrawable::setStroke, path);
+    addStyle("stroke-width", "numeric", &PathDrawable::setStrokeWidth, path);
+    addStyle("stroke-dasharray", "", &PathDrawable::setStrokeDashArray, path);
+    addStyle("stroke-linecap", "", &PathDrawable::setStrokeLinecap, path);
+  }
+
   //----------------------------------------------------------------------------
   Path::Path( const CanvasWeakPtr& canvas,
               const SGPropertyNode_ptr& node,
@@ -480,20 +509,9 @@ namespace canvas
     Element(canvas, node, parent_style, parent),
     _path( new PathDrawable(this) )
   {
+    staticInit();
+
     setDrawable(_path);
-
-    if( !isInit<Path>() )
-    {
-      PathDrawableRef Path::*path = &Path::_path;
-
-      addStyle("fill", "color", &PathDrawable::setFill, path);
-      addStyle("fill-rule", "", &PathDrawable::setFillRule, path);
-      addStyle("stroke", "color", &PathDrawable::setStroke, path);
-      addStyle("stroke-width", "numeric", &PathDrawable::setStrokeWidth, path);
-      addStyle("stroke-dasharray", "", &PathDrawable::setStrokeDashArray, path);
-      addStyle("stroke-linecap", "", &PathDrawable::setStrokeLinecap, path);
-    }
-
     setupStyle();
   }
 

simgear/canvas/elements/CanvasPath.hxx

@@ -31,6 +31,7 @@ namespace canvas
   {
     public:
       static const std::string TYPE_NAME;
+      static void staticInit();
 
       Path( const CanvasWeakPtr& canvas,
             const SGPropertyNode_ptr& node,

simgear/canvas/elements/CanvasText.cxx

@@ -20,7 +20,7 @@
 #include <simgear/canvas/Canvas.hxx>
 #include <simgear/canvas/CanvasSystemAdapter.hxx>
 #include <simgear/scene/util/parse_color.hxx>
-#include <simgear/structure/OSGVersion.hxx>
+#include <osg/Version>
 #include <osgText/Text>
 
 namespace simgear
@@ -36,9 +36,11 @@ namespace canvas
 
       void setFontResolution(int res);
       void setCharacterAspect(float aspect);
+      void setLineHeight(float factor);
       void setFill(const std::string& fill);
       void setBackgroundColor(const std::string& fill);
 
+      SGVec2i sizeForWidth(int w) const;
       osg::Vec2 handleHit(const osg::Vec2f& pos);
 
       virtual osg::BoundingBox computeBound() const;
@@ -54,7 +56,7 @@ namespace canvas
   Text::TextOSG::TextOSG(canvas::Text* text):
     _text_element(text)
   {
-
+    setBackdropImplementation(NO_DEPTH_BUFFER);
   }
 
   //----------------------------------------------------------------------------
@@ -69,6 +71,12 @@ namespace canvas
     setCharacterSize(getCharacterHeight(), aspect);
   }
 
+  //----------------------------------------------------------------------------
+  void Text::TextOSG::setLineHeight(float factor)
+  {
+    setLineSpacing(factor - 1);
+  }
+
   //----------------------------------------------------------------------------
   void Text::TextOSG::setFill(const std::string& fill)
   {
@@ -88,6 +96,281 @@ namespace canvas
       setBoundingBoxColor( color );
   }
 
+  //----------------------------------------------------------------------------
+  // simplified version of osgText::Text::computeGlyphRepresentation() to
+  // just calculate the size for a given weight. Glpyh calculations/creating
+  // is not necessary for this...
+  SGVec2i Text::TextOSG::sizeForWidth(int w) const
+  {
+    if( _text.empty() )
+      return SGVec2i(0, 0);
+
+    osgText::Font* activefont = const_cast<osgText::Font*>(getActiveFont());
+    if( !activefont )
+      return SGVec2i(-1, -1);
+
+    float max_width_safe = _maximumWidth;
+    const_cast<TextOSG*>(this)->_maximumWidth = w;
+
+    SGRecti bb;
+
+    osg::Vec2 startOfLine_coords(0.0f,0.0f);
+    osg::Vec2 cursor(startOfLine_coords);
+    osg::Vec2 local(0.0f,0.0f);
+
+    unsigned int previous_charcode = 0;
+    unsigned int line_length = 0;
+    bool horizontal = _layout != VERTICAL;
+    bool kerning = true;
+
+    float hr = _characterHeight;
+    float wr = hr / getCharacterAspectRatio();
+
+    // osg should really care more about const :-/
+    osgText::String& text = const_cast<osgText::String&>(_text);
+    typedef osgText::String::iterator TextIterator;
+
+    for( TextIterator itr = text.begin(); itr != text.end(); )
+    {
+      // record the start of the current line
+      TextIterator startOfLine_itr = itr;
+
+      // find the end of the current line.
+      osg::Vec2 endOfLine_coords(cursor);
+      TextIterator endOfLine_itr =
+        const_cast<TextOSG*>(this)->computeLastCharacterOnLine(
+          endOfLine_coords, itr, text.end()
+        );
+
+      line_length = endOfLine_itr - startOfLine_itr;
+
+      // Set line position to correct alignment.
+      switch( _layout )
+      {
+        case LEFT_TO_RIGHT:
+        {
+          switch( _alignment )
+          {
+            // nothing to be done for these
+            //case LEFT_TOP:
+            //case LEFT_CENTER:
+            //case LEFT_BOTTOM:
+            //case LEFT_BASE_LINE:
+            //case LEFT_BOTTOM_BASE_LINE:
+            //  break;
+            case CENTER_TOP:
+            case CENTER_CENTER:
+            case CENTER_BOTTOM:
+            case CENTER_BASE_LINE:
+            case CENTER_BOTTOM_BASE_LINE:
+              cursor.x() = (cursor.x() - endOfLine_coords.x()) * 0.5f;
+              break;
+            case RIGHT_TOP:
+            case RIGHT_CENTER:
+            case RIGHT_BOTTOM:
+            case RIGHT_BASE_LINE:
+            case RIGHT_BOTTOM_BASE_LINE:
+              cursor.x() = cursor.x() - endOfLine_coords.x();
+              break;
+            default:
+              break;
+          }
+          break;
+        }
+        case RIGHT_TO_LEFT:
+        {
+          switch( _alignment )
+          {
+            case LEFT_TOP:
+            case LEFT_CENTER:
+            case LEFT_BOTTOM:
+            case LEFT_BASE_LINE:
+            case LEFT_BOTTOM_BASE_LINE:
+              cursor.x() = 2 * cursor.x() - endOfLine_coords.x();
+              break;
+            case CENTER_TOP:
+            case CENTER_CENTER:
+            case CENTER_BOTTOM:
+            case CENTER_BASE_LINE:
+            case CENTER_BOTTOM_BASE_LINE:
+              cursor.x() = cursor.x()
+                  + (cursor.x() - endOfLine_coords.x()) * 0.5f;
+              break;
+              // nothing to be done for these
+              //case RIGHT_TOP:
+              //case RIGHT_CENTER:
+              //case RIGHT_BOTTOM:
+              //case RIGHT_BASE_LINE:
+              //case RIGHT_BOTTOM_BASE_LINE:
+              //  break;
+            default:
+              break;
+          }
+          break;
+        }
+        case VERTICAL:
+        {
+          switch( _alignment )
+          {
+            // TODO: current behaviour top baselines lined up in both cases - need to implement
+            //       top of characters alignment - Question is this necessary?
+            // ... otherwise, nothing to be done for these 6 cases
+            //case LEFT_TOP:
+            //case CENTER_TOP:
+            //case RIGHT_TOP:
+            //  break;
+            //case LEFT_BASE_LINE:
+            //case CENTER_BASE_LINE:
+            //case RIGHT_BASE_LINE:
+            //  break;
+            case LEFT_CENTER:
+            case CENTER_CENTER:
+            case RIGHT_CENTER:
+              cursor.y() = cursor.y()
+                  + (cursor.y() - endOfLine_coords.y()) * 0.5f;
+              break;
+            case LEFT_BOTTOM_BASE_LINE:
+            case CENTER_BOTTOM_BASE_LINE:
+            case RIGHT_BOTTOM_BASE_LINE:
+              cursor.y() = cursor.y() - (line_length * _characterHeight);
+              break;
+            case LEFT_BOTTOM:
+            case CENTER_BOTTOM:
+            case RIGHT_BOTTOM:
+              cursor.y() = 2 * cursor.y() - endOfLine_coords.y();
+              break;
+            default:
+              break;
+          }
+          break;
+        }
+      }
+
+      if( itr != endOfLine_itr )
+      {
+
+        for(;itr != endOfLine_itr;++itr)
+        {
+          unsigned int charcode = *itr;
+
+          osgText::Glyph* glyph = activefont->getGlyph(_fontSize, charcode);
+          if( glyph )
+          {
+            float width = (float) (glyph->getWidth()) * wr;
+            float height = (float) (glyph->getHeight()) * hr;
+
+            if( _layout == RIGHT_TO_LEFT )
+            {
+              cursor.x() -= glyph->getHorizontalAdvance() * wr;
+            }
+
+            // adjust cursor position w.r.t any kerning.
+            if( kerning && previous_charcode )
+            {
+              switch( _layout )
+              {
+                case LEFT_TO_RIGHT:
+                {
+                  osg::Vec2 delta( activefont->getKerning( previous_charcode,
+                                                           charcode,
+                                                           _kerningType ) );
+                  cursor.x() += delta.x() * wr;
+                  cursor.y() += delta.y() * hr;
+                  break;
+                }
+                case RIGHT_TO_LEFT:
+                {
+                  osg::Vec2 delta( activefont->getKerning( charcode,
+                                                           previous_charcode,
+                                                           _kerningType ) );
+                  cursor.x() -= delta.x() * wr;
+                  cursor.y() -= delta.y() * hr;
+                  break;
+                }
+                case VERTICAL:
+                  break; // no kerning when vertical.
+              }
+            }
+
+            local = cursor;
+            osg::Vec2 bearing( horizontal ? glyph->getHorizontalBearing()
+                                          : glyph->getVerticalBearing() );
+            local.x() += bearing.x() * wr;
+            local.y() += bearing.y() * hr;
+
+            // set up the coords of the quad
+            osg::Vec2 upLeft = local + osg::Vec2(0.f, height);
+            osg::Vec2 lowLeft = local;
+            osg::Vec2 lowRight = local + osg::Vec2(width, 0.f);
+            osg::Vec2 upRight = local + osg::Vec2(width, height);
+
+            // move the cursor onto the next character.
+            // also expand bounding box
+            switch( _layout )
+            {
+              case LEFT_TO_RIGHT:
+                cursor.x() += glyph->getHorizontalAdvance() * wr;
+                bb.expandBy(lowLeft.x(), lowLeft.y());
+                bb.expandBy(upRight.x(), upRight.y());
+                break;
+              case VERTICAL:
+                cursor.y() -= glyph->getVerticalAdvance() * hr;
+                bb.expandBy(upLeft.x(), upLeft.y());
+                bb.expandBy(lowRight.x(), lowRight.y());
+                break;
+              case RIGHT_TO_LEFT:
+                bb.expandBy(lowRight.x(), lowRight.y());
+                bb.expandBy(upLeft.x(), upLeft.y());
+                break;
+            }
+            previous_charcode = charcode;
+          }
+        }
+
+        // skip over spaces and return.
+        while( itr != text.end() && *itr == ' ' )
+          ++itr;
+        if( itr != text.end() && *itr == '\n' )
+          ++itr;
+      }
+      else
+      {
+        ++itr;
+      }
+
+      // move to new line.
+      switch( _layout )
+      {
+        case LEFT_TO_RIGHT:
+        {
+          startOfLine_coords.y() -= _characterHeight * (1.0 + _lineSpacing);
+          cursor = startOfLine_coords;
+          previous_charcode = 0;
+          break;
+        }
+        case RIGHT_TO_LEFT:
+        {
+          startOfLine_coords.y() -= _characterHeight * (1.0 + _lineSpacing);
+          cursor = startOfLine_coords;
+          previous_charcode = 0;
+          break;
+        }
+        case VERTICAL:
+        {
+          startOfLine_coords.x() += _characterHeight * (1.0 + _lineSpacing)
+                                  / getCharacterAspectRatio();
+          cursor = startOfLine_coords;
+          previous_charcode = 0;
+          break;
+        }
+      }
+    }
+
+    const_cast<TextOSG*>(this)->_maximumWidth = max_width_safe;
+
+    return bb.size();
+  }
+
   //----------------------------------------------------------------------------
   osg::Vec2 Text::TextOSG::handleHit(const osg::Vec2f& pos)
   {
@@ -172,18 +455,17 @@ namespace canvas
   osg::BoundingBox Text::TextOSG::computeBound() const
   {
     osg::BoundingBox bb = osgText::Text::computeBound();
-    if( !bb.valid() )
-      return bb;
 
-#if SG_OSG_VERSION_LESS_THAN(3,1,0)
-    // TODO bounding box still doesn't seem always right (eg. with center
-    //      horizontal alignment not completely accurate)
-    bb._min.y() += _offset.y();
-    bb._max.y() += _offset.y();
+#if OSG_VERSION_LESS_THAN(3,1,0)
+    if( bb.valid() )
+    {
+      // TODO bounding box still doesn't seem always right (eg. with center
+      //      horizontal alignment not completely accurate)
+      bb._min.y() += _offset.y();
+      bb._max.y() += _offset.y();
+    }
 #endif
 
-    _text_element->setBoundingBox(bb);
-
     return bb;
   }
 
@@ -254,6 +536,39 @@ namespace canvas
   //----------------------------------------------------------------------------
   const std::string Text::TYPE_NAME = "text";
 
+  //----------------------------------------------------------------------------
+  void Text::staticInit()
+  {
+    if( isInit<Text>() )
+      return;
+
+    osg::ref_ptr<TextOSG> Text::*text = &Text::_text;
+
+    addStyle("fill", "color", &TextOSG::setFill, text);
+    addStyle("background", "color", &TextOSG::setBackgroundColor, text);
+    addStyle("character-size",
+             "numeric",
+             static_cast<
+               void (TextOSG::*)(float)
+             > (&TextOSG::setCharacterSize),
+             text);
+    addStyle("character-aspect-ratio",
+             "numeric",
+             &TextOSG::setCharacterAspect, text);
+    addStyle("line-height", "numeric", &TextOSG::setLineHeight, text);
+    addStyle("font-resolution", "numeric", &TextOSG::setFontResolution, text);
+    addStyle("padding", "numeric", &TextOSG::setBoundingBoxMargin, text);
+    //  TEXT              = 1 default
+    //  BOUNDINGBOX       = 2
+    //  FILLEDBOUNDINGBOX = 4
+    //  ALIGNMENT         = 8
+    addStyle<int>("draw-mode", "", &TextOSG::setDrawMode, text);
+    addStyle("max-width", "numeric", &TextOSG::setMaximumWidth, text);
+    addStyle("font", "", &Text::setFont);
+    addStyle("alignment", "", &Text::setAlignment);
+    addStyle("text", "", &Text::setText, false);
+  }
+
   //----------------------------------------------------------------------------
   Text::Text( const CanvasWeakPtr& canvas,
               const SGPropertyNode_ptr& node,
@@ -262,39 +577,13 @@ namespace canvas
     Element(canvas, node, parent_style, parent),
     _text( new Text::TextOSG(this) )
   {
+    staticInit();
+
     setDrawable(_text);
     _text->setCharacterSizeMode(osgText::Text::OBJECT_COORDS);
     _text->setAxisAlignment(osgText::Text::USER_DEFINED_ROTATION);
     _text->setRotation(osg::Quat(osg::PI, osg::X_AXIS));
 
-    if( !isInit<Text>() )
-    {
-      osg::ref_ptr<TextOSG> Text::*text = &Text::_text;
-
-      addStyle("fill", "color", &TextOSG::setFill, text);
-      addStyle("background", "color", &TextOSG::setBackgroundColor, text);
-      addStyle("character-size",
-               "numeric",
-               static_cast<
-                 void (TextOSG::*)(float)
-               > (&TextOSG::setCharacterSize),
-               text);
-      addStyle("character-aspect-ratio",
-               "numeric",
-               &TextOSG::setCharacterAspect, text);
-      addStyle("font-resolution", "numeric", &TextOSG::setFontResolution, text);
-      addStyle("padding", "numeric", &TextOSG::setBoundingBoxMargin, text);
-      //  TEXT              = 1 default
-      //  BOUNDINGBOX       = 2
-      //  FILLEDBOUNDINGBOX = 4
-      //  ALIGNMENT         = 8
-      addStyle<int>("draw-mode", "", &TextOSG::setDrawMode, text);
-      addStyle("max-width", "numeric", &TextOSG::setMaximumWidth, text);
-      addStyle("font", "", &Text::setFont);
-      addStyle("alignment", "", &Text::setAlignment);
-      addStyle("text", "", &Text::setText);
-    }
-
     setupStyle();
   }
 
@@ -313,7 +602,7 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Text::setFont(const char* name)
   {
-    _text->setFont( _canvas.lock()->getSystemAdapter()->getFont(name) );
+    _text->setFont( Canvas::getSystemAdapter()->getFont(name) );
   }
 
   //----------------------------------------------------------------------------
@@ -356,6 +645,18 @@ namespace canvas
   }
 #endif
 
+  //----------------------------------------------------------------------------
+  int Text::heightForWidth(int w) const
+  {
+    return _text->sizeForWidth(w).y();
+  }
+
+  //----------------------------------------------------------------------------
+  int Text::maxWidth() const
+  {
+    return _text->sizeForWidth(INT_MAX).x();
+  }
+
   //----------------------------------------------------------------------------
   osg::Vec2 Text::getNearestCursor(const osg::Vec2& pos) const
   {

simgear/canvas/elements/CanvasText.hxx

@@ -34,6 +34,7 @@ namespace canvas
   {
     public:
       static const std::string TYPE_NAME;
+      static void staticInit();
 
       Text( const CanvasWeakPtr& canvas,
             const SGPropertyNode_ptr& node,
@@ -45,6 +46,8 @@ namespace canvas
       void setFont(const char* name);
       void setAlignment(const char* align);
 
+      int heightForWidth(int w) const;
+      int maxWidth() const;
       osg::Vec2 getNearestCursor(const osg::Vec2& pos) const;
 
     protected:

simgear/canvas/elements/canvas_element_test.cpp

@@ -0,0 +1,66 @@
+/// Unit tests for canvas::Element
+#define BOOST_TEST_MODULE canvas
+#include <BoostTestTargetConfig.h>
+
+#include "CanvasElement.hxx"
+#include "CanvasGroup.hxx"
+
+namespace sc = simgear::canvas;
+
+BOOST_AUTO_TEST_CASE( attr_data )
+{
+  // http://www.w3.org/TR/html5/dom.html#attr-data-*
+
+#define SG_CHECK_ATTR2PROP(attr, prop)\
+  BOOST_CHECK_EQUAL(sc::Element::attrToDataPropName(attr), prop)
+
+  // If name starts with "data-", for each "-" (U+002D) character in the name
+  // that is followed by a lowercase ASCII letter, remove the "-" (U+002D)
+  // character and replace the character that followed it by the same character
+  // converted to ASCII uppercase.
+
+  SG_CHECK_ATTR2PROP("no-data", "");
+  SG_CHECK_ATTR2PROP("data-blub", "blub");
+  SG_CHECK_ATTR2PROP("data-blub-x-y", "blubXY");
+  SG_CHECK_ATTR2PROP("data-blub-x-y-", "blubXY-");
+
+#undef SG_CHECK_ATTR2PROP
+
+#define SG_CHECK_PROP2ATTR(prop, attr)\
+  BOOST_CHECK_EQUAL(sc::Element::dataPropToAttrName(prop), attr)
+
+  // If name contains a "-" (U+002D) character followed by a lowercase ASCII
+  // letter, throw a SyntaxError exception (empty string) and abort these steps.
+  // For each uppercase ASCII letter in name, insert a "-" (U+002D) character
+  // before the character and replace the character with the same character
+  // converted to ASCII lowercase.
+  // Insert the string "data-" at the front of name.
+
+  SG_CHECK_PROP2ATTR("test", "data-test");
+  SG_CHECK_PROP2ATTR("testIt", "data-test-it");
+  SG_CHECK_PROP2ATTR("testIt-Hyphen", "data-test-it--hyphen");
+  SG_CHECK_PROP2ATTR("-test", "");
+  SG_CHECK_PROP2ATTR("test-", "data-test-");
+
+#undef SG_CHECK_PROP2ATTR
+
+  SGPropertyNode_ptr node = new SGPropertyNode;
+  sc::ElementPtr el =
+    sc::Element::create<sc::Group>(sc::CanvasWeakPtr(), node);
+
+  el->setDataProp("myData", 3);
+  BOOST_CHECK_EQUAL( el->getDataProp<int>("myData"), 3 );
+  BOOST_CHECK_EQUAL( node->getIntValue("data-my-data"), 3 );
+
+  SGPropertyNode* prop = el->getDataProp<SGPropertyNode*>("notExistingProp");
+  BOOST_CHECK( !prop );
+  prop = el->getDataProp<SGPropertyNode*>("myData");
+  BOOST_CHECK(  prop );
+  BOOST_CHECK_EQUAL( prop->getParent(), node );
+  BOOST_CHECK_EQUAL( prop->getIntValue(), 3 );
+
+  BOOST_CHECK( el->hasDataProp("myData") );
+  el->removeDataProp("myData");
+  BOOST_CHECK( !el->hasDataProp("myData") );
+  BOOST_CHECK_EQUAL( el->getDataProp("myData", 5), 5 );
+}

simgear/canvas/events/CMakeLists.txt

@@ -0,0 +1,18 @@
+include (SimGearComponent)
+
+set(HEADERS
+  CustomEvent.hxx
+  MouseEvent.hxx
+)
+
+set(SOURCES
+  CustomEvent.cxx
+  MouseEvent.cxx
+)
+
+simgear_scene_component(canvas-events canvas/events "${SOURCES}" "${HEADERS}")
+
+add_boost_test(canvas_event
+  SOURCES event_test.cpp
+  LIBRARIES ${TEST_LIBS}
+)

simgear/canvas/events/CustomEvent.cxx

@@ -0,0 +1,55 @@
+// Canvas user defined event
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "CustomEvent.hxx"
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  CustomEvent::CustomEvent( std::string const& type_str,
+                            bool bubbles,
+                            StringMap const& data ):
+    detail(data),
+    bubbles(bubbles)
+  {
+    type = getOrRegisterType(type_str);
+  }
+
+  //----------------------------------------------------------------------------
+  CustomEvent::CustomEvent( int type_id,
+                            bool bubbles,
+                            StringMap const& data ):
+    detail(data),
+    bubbles(bubbles)
+  {
+    type = type_id;
+//    TypeMap::map_by<id>::type const& type_map = getTypeMap().by<id>();
+//    assert( type_map.find(type_id) != type_map.end() );
+  }
+
+  //----------------------------------------------------------------------------
+  void CustomEvent::setDetail(StringMap const& data)
+  {
+    detail = data;
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/events/CustomEvent.hxx

@@ -0,0 +1,73 @@
+///@file Canvas user defined event
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef CANVAS_CUSTOM_EVENT_HXX_
+#define CANVAS_CUSTOM_EVENT_HXX_
+
+#include <simgear/canvas/CanvasEvent.hxx>
+#include <simgear/structure/map.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  class CustomEvent:
+    public Event
+  {
+    public:
+
+      /**
+       *
+       * @param type_str    Event type name (if name does not exist yet it will
+       *                    be registered as new event type)
+       * @param data        Optional user data stored in event
+       */
+      CustomEvent( std::string const& type_str,
+                   bool bubbles = false,
+                   StringMap const& data = StringMap() );
+
+      /**
+       *
+       * @param type_id     Event type id
+       * @param data        Optional user data stored in event
+       */
+      CustomEvent( int type_id,
+                   bool bubbles = false,
+                   StringMap const& data = StringMap() );
+
+      /**
+       * Set user data
+       */
+      void setDetail(StringMap const& data);
+
+      /**
+       * Get user data
+       */
+      StringMap const& getDetail() const { return detail; }
+
+      virtual bool canBubble() const { return bubbles; }
+
+      StringMap detail; //<! user data map
+      bool bubbles;
+  };
+
+} // namespace canvas
+} // namespace simgear
+
+#endif /* CANVAS_CUSTOM_EVENT_HXX_ */

simgear/canvas/events/MouseEvent.cxx

@@ -1,6 +1,6 @@
-// Listener for canvas (GUI) events being passed to a Nasal function/code
+// Mouse event
 //
-// Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -16,11 +16,7 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
-#include "CanvasEvent.hxx"
-#include "CanvasEventListener.hxx"
-#include "CanvasSystemAdapter.hxx"
-
-#include <simgear/nasal/cppbind/Ghost.hxx>
+#include "MouseEvent.hxx"
 
 namespace simgear
 {
@@ -28,43 +24,47 @@ namespace canvas
 {
 
   //----------------------------------------------------------------------------
-  EventListener::EventListener(naRef code, const SystemAdapterPtr& sys_adapter):
-    _code(code),
-    _gc_key(-1),
-    _sys(sys_adapter)
+  MouseEvent::MouseEvent():
+    button(0),
+    buttons(0),
+    modifiers(0),
+    click_count(0)
   {
-    assert( sys_adapter );
-    if(    !naIsCode(code)
-        && !naIsCCode(code)
-        && !naIsFunc(code) )
-      throw std::runtime_error
-      (
-        "canvas::EventListener: invalid function argument"
-      );
 
-    _gc_key = sys_adapter->gcSave(_code);
   }
 
   //----------------------------------------------------------------------------
-  EventListener::~EventListener()
+  MouseEvent::MouseEvent(const osgGA::GUIEventAdapter& ea):
+    button(0),
+    buttons(ea.getButtonMask()),
+    modifiers(ea.getModKeyMask()),
+    click_count(0)
   {
-    assert( !_sys.expired() );
-    _sys.lock()->gcRelease(_gc_key);
+    time = ea.getTime();
+
+    // Convert button mask to index
+    int button_mask = ea.getButton();
+    while( (button_mask >>= 1) > 0 )
+      button += 1;
   }
 
   //----------------------------------------------------------------------------
-  void EventListener::call(const canvas::EventPtr& event)
+  bool MouseEvent::canBubble() const
   {
-    SystemAdapterPtr sys = _sys.lock();
-
-    naRef args[] = {
-      nasal::Ghost<EventPtr>::create(sys->getNasalContext(), event)
+    // Check if event supports bubbling
+    const Event::Type types_no_bubbling[] = {
+      Event::MOUSE_ENTER,
+      Event::MOUSE_LEAVE,
     };
-    const int num_args = sizeof(args)/sizeof(args[0]);
+    const size_t num_types_no_bubbling = sizeof(types_no_bubbling)
+                                       / sizeof(types_no_bubbling[0]);
 
-    sys->callMethod(_code, naNil(), num_args, args, naNil());
+    for( size_t i = 0; i < num_types_no_bubbling; ++i )
+      if( type == types_no_bubbling[i] )
+        return false;
+
+    return true;
   }
 
-
 } // namespace canvas
 } // namespace simgear

simgear/canvas/events/MouseEvent.hxx

@@ -1,4 +1,4 @@
-// Mouse event
+///@file Mouse event
 //
 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
 //
@@ -19,7 +19,7 @@
 #ifndef CANVAS_MOUSE_EVENT_HXX_
 #define CANVAS_MOUSE_EVENT_HXX_
 
-#include "CanvasEvent.hxx"
+#include <simgear/canvas/CanvasEvent.hxx>
 #include <osgGA/GUIEventAdapter>
 
 namespace simgear
@@ -31,21 +31,10 @@ namespace canvas
     public Event
   {
     public:
-      MouseEvent():
-        button(-1),
-        state(-1),
-        mod(-1),
-        click_count(0)
-      {}
+      MouseEvent();
+      MouseEvent(const osgGA::GUIEventAdapter& ea);
 
-      MouseEvent(const osgGA::GUIEventAdapter& ea):
-        button(ea.getButton()),
-        state(ea.getButtonMask()),
-        mod(ea.getModKeyMask()),
-        click_count(0)
-      {
-        time = ea.getTime();
-      }
+      virtual bool canBubble() const;
 
       osg::Vec2f getScreenPos() const { return screen_pos; }
       osg::Vec2f getClientPos() const { return client_pos; }
@@ -64,6 +53,10 @@ namespace canvas
       float getDeltaX() const { return delta.x(); }
       float getDeltaY() const { return delta.y(); }
 
+      int getButton() const { return button; }
+      int getButtonMask() const { return buttons; }
+      int getModifiers() const { return modifiers; }
+
       int getCurrentClickCount() const { return click_count; }
 
       osg::Vec2f  screen_pos,   //<! Position in screen coordinates
@@ -71,8 +64,8 @@ namespace canvas
                   local_pos,    //<! Position in local/element coordinates
                   delta;
       int         button,       //<! Button for this event
-                  state,        //<! Current button state
-                  mod,          //<! Keyboard modifier state
+                  buttons,      //<! Current button state
+                  modifiers,    //<! Keyboard modifier state
                   click_count;  //<! Current click count
   };
 

simgear/canvas/events/event_test.cpp

@@ -0,0 +1,36 @@
+/// Unit tests for reference counting and smart pointer classes
+#define BOOST_TEST_MODULE structure
+#include <BoostTestTargetConfig.h>
+
+#include "MouseEvent.hxx"
+#include "CustomEvent.hxx"
+
+namespace sc = simgear::canvas;
+
+BOOST_AUTO_TEST_CASE( canvas_event_types )
+{
+  // Register type
+  BOOST_REQUIRE_EQUAL( sc::Event::strToType("test"),
+                       sc::Event::UNKNOWN );
+  BOOST_REQUIRE_EQUAL( sc::Event::getOrRegisterType("test"),
+                       sc::Event::CUSTOM_EVENT );
+  BOOST_REQUIRE_EQUAL( sc::Event::strToType("test"),
+                       sc::Event::CUSTOM_EVENT );
+  BOOST_REQUIRE_EQUAL( sc::Event::typeToStr(sc::Event::CUSTOM_EVENT),
+                       "test" );
+
+  // Basic internal type
+  BOOST_REQUIRE_EQUAL( sc::Event::typeToStr(sc::Event::MOUSE_DOWN),
+                       "mousedown" );
+  BOOST_REQUIRE_EQUAL( sc::Event::strToType("mousedown"),
+                       sc::Event::MOUSE_DOWN );
+
+  // Unknown type
+  BOOST_REQUIRE_EQUAL( sc::Event::typeToStr(123),
+                       "unknown" );
+
+  // Register type through custom event instance
+  sc::CustomEvent e("blub");
+  BOOST_REQUIRE_EQUAL( e.getTypeString(), "blub" );
+  BOOST_REQUIRE_NE( e.getType(), sc::Event::UNKNOWN );
+}

simgear/canvas/layout/BoxLayout.cxx

@@ -0,0 +1,488 @@
+// Align items horizontally or vertically in a box
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "BoxLayout.hxx"
+#include "SpacerItem.hxx"
+#include <simgear/canvas/Canvas.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  BoxLayout::BoxLayout(Direction dir):
+    _padding(5)
+  {
+    setDirection(dir);
+  }
+
+  //----------------------------------------------------------------------------
+  BoxLayout::~BoxLayout()
+  {
+    _parent.reset(); // No need to invalidate parent again...
+    clear();
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::addItem(const LayoutItemRef& item)
+  {
+    return addItem(item, 0);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::addItem(const LayoutItemRef& item, int stretch)
+  {
+    insertItem(-1, item, stretch);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::addStretch(int stretch)
+  {
+    insertStretch(-1, stretch);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::addSpacing(int size)
+  {
+    insertSpacing(-1, size);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::insertItem(int index, const LayoutItemRef& item, int stretch)
+  {
+    ItemData item_data = {0};
+    item_data.layout_item = item;
+    item_data.stretch = std::max(0, stretch);
+
+    item->setCanvas(_canvas);
+    item->setParent(this);
+
+    if( index < 0 )
+      _layout_items.push_back(item_data);
+    else
+      _layout_items.insert(_layout_items.begin() + index, item_data);
+
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::insertStretch(int index, int stretch)
+  {
+    insertItem(index, LayoutItemRef(new SpacerItem()), stretch);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::insertSpacing(int index, int size)
+  {
+    SGVec2i size_hint = horiz()
+                          ? SGVec2i(size, 0)
+                          : SGVec2i(0, size),
+                max_size  = size_hint;
+
+    insertItem(index, LayoutItemRef(new SpacerItem(size_hint, max_size)));
+  }
+
+  //----------------------------------------------------------------------------
+  size_t BoxLayout::count() const
+  {
+    return _layout_items.size();
+  }
+
+  //----------------------------------------------------------------------------
+  LayoutItemRef BoxLayout::itemAt(size_t index)
+  {
+    if( index >= _layout_items.size() )
+      return LayoutItemRef();
+
+    return _layout_items[index].layout_item;
+  }
+
+  //----------------------------------------------------------------------------
+  LayoutItemRef BoxLayout::takeAt(size_t index)
+  {
+    if( index >= _layout_items.size() )
+      return LayoutItemRef();
+
+    LayoutItems::iterator it = _layout_items.begin() + index;
+    LayoutItemRef item = it->layout_item;
+    item->onRemove();
+    _layout_items.erase(it);
+
+    invalidate();
+
+    return item;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::clear()
+  {
+    for( LayoutItems::iterator it = _layout_items.begin();
+                               it != _layout_items.end();
+                             ++it )
+    {
+      it->layout_item->onRemove();
+    }
+    _layout_items.clear();
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::setStretch(size_t index, int stretch)
+  {
+    if( index >= _layout_items.size() )
+      return;
+
+    _layout_items.at(index).stretch = std::max(0, stretch);
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  bool BoxLayout::setStretchFactor(const LayoutItemRef& item, int stretch)
+  {
+    for( LayoutItems::iterator it = _layout_items.begin();
+                               it != _layout_items.end();
+                             ++it )
+    {
+      if( item == it->layout_item )
+      {
+        it->stretch = std::max(0, stretch);
+        invalidate();
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  //----------------------------------------------------------------------------
+  int BoxLayout::stretch(size_t index) const
+  {
+    if( index >= _layout_items.size() )
+      return 0;
+
+    return _layout_items.at(index).stretch;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::setSpacing(int spacing)
+  {
+    if( spacing == _padding )
+      return;
+
+    _padding = spacing;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  int BoxLayout::spacing() const
+  {
+    return _padding;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::setDirection(Direction dir)
+  {
+    _direction = dir;
+    _get_layout_coord = &SGVec2i::x;
+    _get_fixed_coord = &SGVec2i::y;
+
+    if( !horiz() )
+      std::swap(_get_layout_coord, _get_fixed_coord);
+
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  BoxLayout::Direction BoxLayout::direction() const
+  {
+    return _direction;
+  }
+
+  //----------------------------------------------------------------------------
+  bool BoxLayout::hasHeightForWidth() const
+  {
+    if( _flags & SIZE_INFO_DIRTY )
+      updateSizeHints();
+
+    return _layout_data.has_hfw;
+  }
+
+  //----------------------------------------------------------------------------
+  int BoxLayout::heightForWidth(int w) const
+  {
+    if( !hasHeightForWidth() )
+      return -1;
+
+    updateWFHCache(w);
+    return _hfw_height;
+  }
+
+  //----------------------------------------------------------------------------
+  int BoxLayout::minimumHeightForWidth(int w) const
+  {
+    if( !hasHeightForWidth() )
+      return -1;
+
+    updateWFHCache(w);
+    return _hfw_min_height;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::setCanvas(const CanvasWeakPtr& canvas)
+  {
+    _canvas = canvas;
+
+    for(size_t i = 0; i < _layout_items.size(); ++i)
+      _layout_items[i].layout_item->setCanvas(canvas);
+  }
+
+  //----------------------------------------------------------------------------
+  bool BoxLayout::horiz() const
+  {
+    return (_direction == LeftToRight) || (_direction == RightToLeft);
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::updateSizeHints() const
+  {
+    SGVec2i min_size(0, 0),
+            max_size(0, 0),
+            size_hint(0, 0);
+
+    _layout_data.reset();
+    _hfw_width = _hfw_height = _hfw_min_height = -1;
+
+    bool is_first = true;
+
+    for(size_t i = 0; i < _layout_items.size(); ++i)
+    {
+      // TODO check visible
+
+      ItemData& item_data = _layout_items[i];
+      LayoutItem const& item = *item_data.layout_item;
+
+      item_data.min_size  = (item.minimumSize().*_get_layout_coord)();
+      item_data.max_size  = (item.maximumSize().*_get_layout_coord)();
+      item_data.size_hint = (item.sizeHint().*_get_layout_coord)();
+      item_data.has_hfw = item.hasHeightForWidth();
+
+      if( !dynamic_cast<SpacerItem*>(item_data.layout_item.get()) )
+      {
+        if( is_first )
+        {
+          item_data.padding_orig = 0;
+          is_first = false;
+        }
+        else
+        {
+          item_data.padding_orig = _padding;
+          _layout_data.padding += item_data.padding_orig;
+        }
+      }
+
+      // Add sizes of all children in layout direction
+      safeAdd(min_size.x(),  item_data.min_size);
+      safeAdd(max_size.x(),  item_data.max_size);
+      safeAdd(size_hint.x(), item_data.size_hint);
+
+      // Take maximum in fixed (non-layouted) direction
+      min_size.y()  = std::max( min_size.y(),
+                                (item.minimumSize().*_get_fixed_coord)() );
+      max_size.y()  = std::max( max_size.y(),
+                                (item.maximumSize().*_get_fixed_coord)() );
+      size_hint.y() = std::max( size_hint.y(),
+                                (item.sizeHint().*_get_fixed_coord)() );
+
+      _layout_data.has_hfw = _layout_data.has_hfw || item.hasHeightForWidth();
+    }
+
+    safeAdd(min_size.x(),  _layout_data.padding);
+    safeAdd(max_size.x(),  _layout_data.padding);
+    safeAdd(size_hint.x(), _layout_data.padding);
+
+    _layout_data.min_size = min_size.x();
+    _layout_data.max_size = max_size.x();
+    _layout_data.size_hint = size_hint.x();
+
+    _min_size.x()  = (min_size.*_get_layout_coord)();
+    _max_size.x()  = (max_size.*_get_layout_coord)();
+    _size_hint.x() = (size_hint.*_get_layout_coord)();
+
+    _min_size.y()  = (min_size.*_get_fixed_coord)();
+    _max_size.y()  = (max_size.*_get_fixed_coord)();
+    _size_hint.y() = (size_hint.*_get_fixed_coord)();
+
+    _flags &= ~SIZE_INFO_DIRTY;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::updateWFHCache(int w) const
+  {
+    if( w == _hfw_width )
+      return;
+
+    _hfw_height = 0;
+    _hfw_min_height = 0;
+
+    if( horiz() )
+    {
+      _layout_data.size = w;
+      const_cast<BoxLayout*>(this)->distribute(_layout_items, _layout_data);
+
+      for(size_t i = 0; i < _layout_items.size(); ++i)
+      {
+        ItemData const& data = _layout_items[i];
+        _hfw_height = std::max(_hfw_height, data.hfw(data.size));
+        _hfw_min_height = std::max(_hfw_min_height, data.mhfw(data.size));
+      }
+    }
+    else
+    {
+      for(size_t i = 0; i < _layout_items.size(); ++i)
+      {
+        ItemData const& data = _layout_items[i];
+        _hfw_height += data.hfw(w) + data.padding_orig;
+        _hfw_min_height += data.mhfw(w) + data.padding_orig;
+      }
+    }
+
+    _hfw_width = w;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i BoxLayout::sizeHintImpl() const
+  {
+    updateSizeHints();
+    return _size_hint;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i BoxLayout::minimumSizeImpl() const
+  {
+    updateSizeHints();
+    return _min_size;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i BoxLayout::maximumSizeImpl() const
+  {
+    updateSizeHints();
+    return _max_size;
+  }
+
+  //----------------------------------------------------------------------------
+  void BoxLayout::doLayout(const SGRecti& geom)
+  {
+    if( _flags & SIZE_INFO_DIRTY )
+      updateSizeHints();
+
+    // Store current size hints because vertical layouts containing
+    // height-for-width items the size hints are update for the actual width of
+    // the layout
+    int min_size_save = _layout_data.min_size,
+        size_hint_save = _layout_data.size_hint;
+
+    _layout_data.size = (geom.size().*_get_layout_coord)();
+
+    // update width dependent data for layouting of vertical layouts
+    if( _layout_data.has_hfw && !horiz() )
+    {
+      for(size_t i = 0; i < _layout_items.size(); ++i)
+      {
+        ItemData& data = _layout_items[i];
+        if( data.has_hfw )
+        {
+          int w = SGMisc<int>::clip( geom.width(),
+                                     data.layout_item->minimumSize().x(),
+                                     data.layout_item->maximumSize().x() );
+
+          data.min_size = data.mhfw(w);
+          data.size_hint = data.hfw(w);
+
+          // Update size hints for layouting with difference to size hints
+          // calculated by using the size hints provided (without trading
+          // height for width)
+          _layout_data.min_size  += data.min_size
+                                  - data.layout_item->minimumSize().y();
+          _layout_data.size_hint += data.size_hint
+                                  - data.layout_item->sizeHint().y();
+        }
+      }
+    }
+
+    // now do the actual layouting
+    distribute(_layout_items, _layout_data);
+
+    // Restore size hints possibly changed by vertical layouting
+    _layout_data.min_size = min_size_save;
+    _layout_data.size_hint = size_hint_save;
+
+    // and finally set the layouted geometry for each item
+    int fixed_size = (geom.size().*_get_fixed_coord)();
+    SGVec2i cur_pos( (geom.pos().*_get_layout_coord)(),
+                     (geom.pos().*_get_fixed_coord)() );
+
+    bool reverse = (_direction == RightToLeft) || (_direction == BottomToTop);
+    if( reverse )
+      cur_pos.x() += (geom.size().*_get_layout_coord)();
+
+    for(size_t i = 0; i < _layout_items.size(); ++i)
+    {
+      ItemData const& data = _layout_items[i];
+      cur_pos.x() += reverse ? -data.padding - data.size : data.padding;
+
+      SGVec2i size(
+        data.size,
+        std::min( (data.layout_item->maximumSize().*_get_fixed_coord)(),
+                  fixed_size )
+      );
+
+      // Center in fixed direction (TODO allow specifying alignment)
+      int offset_fixed = (fixed_size - size.y()) / 2;
+      cur_pos.y() += offset_fixed;
+
+      data.layout_item->setGeometry(SGRecti(
+        (cur_pos.*_get_layout_coord)(),
+        (cur_pos.*_get_fixed_coord)(),
+        (size.*_get_layout_coord)(),
+        (size.*_get_fixed_coord)()
+      ));
+
+      if( !reverse )
+        cur_pos.x() += data.size;
+      cur_pos.y() -= offset_fixed;
+    }
+  }
+
+  //----------------------------------------------------------------------------
+  HBoxLayout::HBoxLayout():
+    BoxLayout(LeftToRight)
+  {
+
+  }
+
+  //----------------------------------------------------------------------------
+  VBoxLayout::VBoxLayout():
+    BoxLayout(TopToBottom)
+  {
+
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/layout/BoxLayout.hxx

@@ -0,0 +1,154 @@
+// Align items horizontally or vertically in a box
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef SG_CANVAS_BOX_LAYOUT_HXX_
+#define SG_CANVAS_BOX_LAYOUT_HXX_
+
+#include "Layout.hxx"
+
+namespace simgear
+{
+namespace canvas
+{
+
+  class BoxLayout:
+    public Layout
+  {
+    public:
+
+      enum Direction
+      {
+        LeftToRight,
+        RightToLeft,
+        TopToBottom,
+        BottomToTop
+      };
+
+      BoxLayout(Direction dir);
+      ~BoxLayout();
+
+      virtual void addItem(const LayoutItemRef& item);
+
+      void addItem(const LayoutItemRef& item, int stretch);
+
+      void addStretch(int stretch = 0);
+
+      void addSpacing(int size);
+
+      void insertItem(int index, const LayoutItemRef& item, int stretch = 0);
+
+      void insertStretch(int index, int stretch = 0);
+
+      void insertSpacing(int index, int size);
+
+      virtual size_t count() const;
+      virtual LayoutItemRef itemAt(size_t index);
+      virtual LayoutItemRef takeAt(size_t index);
+      virtual void clear();
+
+      /**
+       * Set the stretch factor of the item at position @a index to @a stretch.
+       */
+      void setStretch(size_t index, int stretch);
+
+      /**
+       * Set the stretch factor of the given @a item to @a stretch, if it exists
+       * in this layout.
+       *
+       * @return true, if the @a item was found in the layout
+       */
+      bool setStretchFactor(const LayoutItemRef& item, int stretch);
+
+      /**
+       * Get the stretch factor of the item at position @a index
+       */
+      int stretch(size_t index) const;
+
+      virtual void setSpacing(int spacing);
+      virtual int spacing() const;
+
+      void setDirection(Direction dir);
+      Direction direction() const;
+
+      virtual bool hasHeightForWidth() const;
+      virtual int heightForWidth(int w) const;
+      virtual int minimumHeightForWidth(int w) const;
+
+      virtual void setCanvas(const CanvasWeakPtr& canvas);
+
+      bool horiz() const;
+
+    protected:
+
+      typedef const int& (SGVec2i::*CoordGetter)() const;
+      CoordGetter _get_layout_coord,    //<! getter for coordinate in layout
+                                        //   direction
+                  _get_fixed_coord;     //<! getter for coordinate in secondary
+                                        //   (fixed) direction
+
+      int _padding;
+      Direction _direction;
+
+      typedef std::vector<ItemData> LayoutItems;
+
+      mutable LayoutItems _layout_items;
+      mutable ItemData _layout_data;
+
+      // Cache for last height-for-width query
+      mutable int _hfw_width,
+                  _hfw_height,
+                  _hfw_min_height;
+
+      void updateSizeHints() const;
+      void updateWFHCache(int w) const;
+
+      virtual SGVec2i sizeHintImpl() const;
+      virtual SGVec2i minimumSizeImpl() const;
+      virtual SGVec2i maximumSizeImpl() const;
+
+      virtual void doLayout(const SGRecti& geom);
+  };
+
+  /**
+   * Shortcut for creating a horizontal box layout
+   */
+  class HBoxLayout:
+    public BoxLayout
+  {
+    public:
+      HBoxLayout();
+  };
+
+  /**
+   * Shortcut for creating a vertical box layout
+   */
+  class VBoxLayout:
+    public BoxLayout
+  {
+    public:
+      VBoxLayout();
+  };
+
+  typedef SGSharedPtr<BoxLayout> BoxLayoutRef;
+
+} // namespace canvas
+} // namespace simgear
+
+
+#endif /* SG_CANVAS_BOX_LAYOUT_HXX_ */
+

simgear/canvas/layout/CMakeLists.txt

@@ -0,0 +1,24 @@
+include (SimGearComponent)
+
+set(HEADERS
+  BoxLayout.hxx
+  Layout.hxx
+  LayoutItem.hxx
+  NasalWidget.hxx
+  SpacerItem.hxx
+)
+
+set(SOURCES
+  BoxLayout.cxx
+  Layout.cxx
+  LayoutItem.cxx
+  NasalWidget.cxx
+  SpacerItem.cxx
+)
+
+simgear_scene_component(canvas-layout canvas/layout "${SOURCES}" "${HEADERS}")
+
+add_boost_test(canvas_layout
+  SOURCES canvas_layout_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)

simgear/canvas/layout/Layout.cxx

@@ -0,0 +1,295 @@
+// Basic class for canvas layouts
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "Layout.hxx"
+#include <simgear/debug/logstream.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  void Layout::update()
+  {
+    if( !(_flags & (LAYOUT_DIRTY | SIZE_INFO_DIRTY)) )
+      return;
+
+    doLayout(_geometry);
+
+    _flags &= ~LAYOUT_DIRTY;
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::invalidate()
+  {
+    LayoutItem::invalidate();
+    _flags |= LAYOUT_DIRTY;
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::setGeometry(const SGRecti& geom)
+  {
+    if( geom != _geometry )
+    {
+      _geometry = geom;
+      _flags |= LAYOUT_DIRTY;
+    }
+
+    update();
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::removeItem(const LayoutItemRef& item)
+  {
+    size_t i = 0;
+    while( LayoutItemRef child = itemAt(i) )
+    {
+      if( item == child )
+        return (void)takeAt(i);
+
+      ++i;
+    }
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::clear()
+  {
+    while( itemAt(0) )
+      takeAt(0);
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::ItemData::reset()
+  {
+    layout_item = 0;
+    size_hint   = 0;
+    min_size    = 0;
+    max_size    = 0;
+    padding_orig= 0;
+    padding     = 0;
+    size        = 0;
+    stretch     = 0;
+    has_hfw     = false;
+    done        = false;
+  }
+
+  //----------------------------------------------------------------------------
+  int Layout::ItemData::hfw(int w) const
+  {
+    if( has_hfw )
+      return layout_item->heightForWidth(w);
+    else
+      return layout_item->sizeHint().y();
+  }
+
+  //----------------------------------------------------------------------------
+  int Layout::ItemData::mhfw(int w) const
+  {
+    if( has_hfw )
+      return layout_item->minimumHeightForWidth(w);
+    else
+      return layout_item->minimumSize().y();
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::safeAdd(int& a, int b)
+  {
+    if( SGLimits<int>::max() - b < a )
+      a = SGLimits<int>::max();
+    else
+      a += b;
+  }
+
+  //----------------------------------------------------------------------------
+  void Layout::distribute(std::vector<ItemData>& items, const ItemData& space)
+  {
+    const int num_children = static_cast<int>(items.size());
+    _num_not_done = num_children;
+
+    SG_LOG( SG_GUI,
+            SG_DEBUG,
+            "Layout::distribute(" << space.size << "px for "
+                                  << num_children << " items, s.t."
+                                  << " min=" << space.min_size
+                                  << ", hint=" << space.size_hint
+                                  << ", max=" << space.max_size << ")" );
+
+    if( space.size < space.min_size )
+    {
+      // TODO
+      SG_LOG( SG_GUI, SG_WARN, "Layout: not enough size (not implemented)");
+    }
+    else if( space.size < space.max_size )
+    {
+      _sum_stretch = 0;
+      _space_stretch = 0;
+
+      bool less_then_hint = space.size < space.size_hint;
+
+      // Give min_size/size_hint to all items
+      _space_left = space.size
+                  - (less_then_hint ? space.min_size : space.size_hint);
+      for(int i = 0; i < num_children; ++i)
+      {
+        ItemData& d = items[i];
+        d.size = less_then_hint ? d.min_size : d.size_hint;
+        d.padding = d.padding_orig;
+        d.done = d.size >= (less_then_hint ? d.size_hint : d.max_size);
+
+        SG_LOG(
+          SG_GUI,
+          SG_DEBUG,
+          i << ") initial=" << d.size
+            << ", min=" << d.min_size
+            << ", hint=" << d.size_hint
+            << ", max=" << d.max_size
+        );
+
+        if( d.done )
+        {
+          _num_not_done -= 1;
+          continue;
+        }
+
+        if( d.stretch > 0 )
+        {
+          _sum_stretch += d.stretch;
+          _space_stretch += d.size;
+        }
+      }
+
+      // Distribute remaining space to increase the size of each item up to its
+      // size_hint/max_size
+      while( _space_left > 0 )
+      {
+        if( _num_not_done <= 0 )
+        {
+          SG_LOG(SG_GUI, SG_WARN, "space left, but no more items?");
+          break;
+        }
+
+        int space_per_element = std::max(1, _space_left / _num_not_done);
+
+        SG_LOG(SG_GUI, SG_DEBUG, "space/element=" << space_per_element);
+
+        for(int i = 0; i < num_children; ++i)
+        {
+          ItemData& d = items[i];
+
+          SG_LOG(
+            SG_GUI,
+            SG_DEBUG,
+            i << ") left=" << _space_left
+              << ", not_done=" << _num_not_done
+              << ", sum=" << _sum_stretch
+              << ", stretch=" << _space_stretch
+              << ", stretch/unit=" << _space_stretch / std::max(1, _sum_stretch)
+          );
+
+          if( d.done )
+            continue;
+
+          if( _sum_stretch > 0 && d.stretch <= 0 )
+            d.done = true;
+          else
+          {
+            int target_size = 0;
+            int max_size = less_then_hint ? d.size_hint : d.max_size;
+
+            if( _sum_stretch > 0 )
+            {
+              target_size = (d.stretch * (_space_left + _space_stretch))
+                          / _sum_stretch;
+
+              // Item would be smaller than minimum size or larger than maximum
+              // size, so just keep bounded size and ignore stretch factor
+              if( target_size <= d.size || target_size >= max_size )
+              {
+                d.done = true;
+                _sum_stretch -= d.stretch;
+                _space_stretch -= d.size;
+
+                if( target_size >= max_size )
+                  target_size = max_size;
+                else
+                  target_size = d.size;
+              }
+              else
+                _space_stretch += target_size - d.size;
+            }
+            else
+            {
+              // Give space evenly to all remaining elements in this round
+              target_size = d.size + std::min(_space_left, space_per_element);
+
+              if( target_size >= max_size )
+              {
+                d.done = true;
+                target_size = max_size;
+              }
+            }
+
+            int old_size = d.size;
+            d.size = target_size;
+            _space_left -= d.size - old_size;
+          }
+
+          if( d.done )
+          {
+            _num_not_done -= 1;
+
+            if( _sum_stretch <= 0 && d.stretch > 0 )
+              // Distribute remaining space evenly to all non-stretchable items
+              // in a new round
+              break;
+          }
+        }
+      }
+    }
+    else
+    {
+      _space_left = space.size - space.max_size;
+      for(int i = 0; i < num_children; ++i)
+      {
+        ItemData& d = items[i];
+        d.size = d.max_size;
+
+        // Add superfluous space as padding
+        d.padding = d.padding_orig + _space_left
+                                   // Padding after last child...
+                                   / (_num_not_done + 1);
+
+        _space_left -= d.padding - d.padding_orig;
+        _num_not_done -= 1;
+      }
+    }
+
+    SG_LOG(SG_GUI, SG_DEBUG, "distribute:");
+    for(int i = 0; i < num_children; ++i)
+    {
+      ItemData const& d = items[i];
+      SG_LOG( SG_GUI,
+              SG_DEBUG,
+              i << ") pad=" << d.padding
+                << ", size = " << d.size );
+    }
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/layout/Layout.hxx

@@ -0,0 +1,133 @@
+// Basic class for canvas layouts
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef SG_CANVAS_LAYOUT_HXX_
+#define SG_CANVAS_LAYOUT_HXX_
+
+#include "LayoutItem.hxx"
+#include <vector>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  class Layout:
+    public LayoutItem
+  {
+    public:
+      void update();
+
+      virtual void invalidate();
+      virtual void setGeometry(const SGRecti& geom);
+
+      virtual void addItem(const LayoutItemRef& item) = 0;
+      virtual void setSpacing(int spacing) = 0;
+      virtual int spacing() const = 0;
+
+      /**
+       * Get the number of items.
+       */
+      virtual size_t count() const = 0;
+
+      /**
+       * Get the item at position @a index.
+       *
+       * If there is no such item the function must do nothing and return an
+       * empty reference.
+       */
+      virtual LayoutItemRef itemAt(size_t index) = 0;
+
+      /**
+       * Remove and get the item at position @a index.
+       *
+       * If there is no such item the function must do nothing and return an
+       * empty reference.
+       */
+      virtual LayoutItemRef takeAt(size_t index) = 0;
+
+      /**
+       * Remove the given @a item from the layout.
+       */
+      void removeItem(const LayoutItemRef& item);
+
+      /**
+       * Remove all items.
+       */
+      virtual void clear();
+
+    protected:
+      enum LayoutFlags
+      {
+        LAYOUT_DIRTY = LayoutItem::LAST_FLAG << 1,
+        LAST_FLAG = LAYOUT_DIRTY
+      };
+
+      struct ItemData
+      {
+        LayoutItemRef layout_item;
+        int     size_hint,
+                min_size,
+                max_size,
+                padding_orig, //<! original padding as specified by the user
+                padding,      //<! padding before element (layouted)
+                size,         //<! layouted size
+                stretch;      //<! stretch factor
+        bool    has_hfw : 1,  //<! height for width
+                done : 1;     //<! layouting done
+
+        /** Clear values (reset to default/empty state) */
+        void reset();
+
+        int hfw(int w) const;
+        int mhfw(int w) const;
+      };
+
+      /**
+       * Override to implement the actual layouting
+       */
+      virtual void doLayout(const SGRecti& geom) = 0;
+
+      /**
+       * Add two integers taking care of overflow (limit to INT_MAX)
+       */
+      static void safeAdd(int& a, int b);
+
+      /**
+       * Distribute the available @a space to all @a items
+       */
+      void distribute(std::vector<ItemData>& items, const ItemData& space);
+
+    private:
+
+      int _num_not_done, //<! number of children not layouted yet
+          _sum_stretch,  //<! sum of stretch factors of all not yet layouted
+                         //   children
+          _space_stretch,//<! space currently assigned to all not yet layouted
+                         //   stretchable children
+          _space_left;   //<! remaining space not used by any child yet
+
+  };
+
+  typedef SGSharedPtr<Layout> LayoutRef;
+
+} // namespace canvas
+} // namespace simgear
+
+
+#endif /* SG_CANVAS_LAYOUT_HXX_ */

simgear/canvas/layout/LayoutItem.cxx

@@ -0,0 +1,171 @@
+// Basic element for layouting canvas elements
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "LayoutItem.hxx"
+#include <simgear/canvas/Canvas.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+  const SGVec2i LayoutItem::MAX_SIZE( SGLimits<int>::max(),
+                                      SGLimits<int>::max() );
+
+  //----------------------------------------------------------------------------
+  LayoutItem::LayoutItem():
+    _flags(0),
+    _size_hint(0, 0),
+    _min_size(0, 0),
+    _max_size(MAX_SIZE)
+  {
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  LayoutItem::~LayoutItem()
+  {
+
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::sizeHint() const
+  {
+    if( _flags & SIZE_HINT_DIRTY )
+    {
+      _size_hint = sizeHintImpl();
+      _flags &= ~SIZE_HINT_DIRTY;
+    }
+
+    return _size_hint;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::minimumSize() const
+  {
+    if( _flags & MINIMUM_SIZE_DIRTY )
+    {
+      _min_size = minimumSizeImpl();
+      _flags &= ~MINIMUM_SIZE_DIRTY;
+    }
+
+    return _min_size;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::maximumSize() const
+  {
+    if( _flags & MAXIMUM_SIZE_DIRTY )
+    {
+      _max_size = maximumSizeImpl();
+      _flags &= ~MAXIMUM_SIZE_DIRTY;
+    }
+
+    return _max_size;
+  }
+
+  //----------------------------------------------------------------------------
+  bool LayoutItem::hasHeightForWidth() const
+  {
+    return false;
+  }
+
+  //----------------------------------------------------------------------------
+  int LayoutItem::heightForWidth(int w) const
+  {
+    return -1;
+  }
+
+  //------------------------------------------------------------------------------
+  int LayoutItem::minimumHeightForWidth(int w) const
+  {
+    return heightForWidth(w);
+  }
+
+  //----------------------------------------------------------------------------
+  void LayoutItem::invalidate()
+  {
+    _flags |= SIZE_INFO_DIRTY;
+    invalidateParent();
+  }
+
+  //----------------------------------------------------------------------------
+  void LayoutItem::invalidateParent()
+  {
+    LayoutItemRef parent = _parent.lock();
+    if( parent )
+      parent->invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void LayoutItem::setGeometry(const SGRecti& geom)
+  {
+    _geometry = geom;
+  }
+
+  //----------------------------------------------------------------------------
+  SGRecti LayoutItem::geometry() const
+  {
+    return _geometry;
+  }
+
+  //----------------------------------------------------------------------------
+  void LayoutItem::setCanvas(const CanvasWeakPtr& canvas)
+  {
+    _canvas = canvas;
+  }
+
+  //----------------------------------------------------------------------------
+  CanvasPtr LayoutItem::getCanvas() const
+  {
+    return _canvas.lock();
+  }
+
+  //----------------------------------------------------------------------------
+  void LayoutItem::setParent(const LayoutItemWeakRef& parent)
+  {
+    _parent = parent;
+    LayoutItemRef parent_ref = parent.lock();
+    setCanvas(parent_ref ? parent_ref->_canvas : CanvasWeakPtr());
+  }
+
+  //----------------------------------------------------------------------------
+  LayoutItemRef LayoutItem::getParent() const
+  {
+    return _parent.lock();
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::sizeHintImpl() const
+  {
+    return _size_hint;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::minimumSizeImpl() const
+  {
+    return _min_size;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i LayoutItem::maximumSizeImpl() const
+  {
+    return _max_size;
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/layout/LayoutItem.hxx

@@ -0,0 +1,149 @@
+///@file Basic element for layouting canvas elements
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef SG_CANVAS_LAYOUT_ITEM_HXX_
+#define SG_CANVAS_LAYOUT_ITEM_HXX_
+
+#include <simgear/canvas/canvas_fwd.hxx>
+#include <simgear/math/SGMath.hxx>
+#include <simgear/math/SGRect.hxx>
+#include <simgear/misc/stdint.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+  class LayoutItem;
+  typedef SGSharedPtr<LayoutItem> LayoutItemRef;
+  typedef SGWeakPtr<LayoutItem> LayoutItemWeakRef;
+
+  /**
+   * Base class for all layouting elements. Specializations either implement a
+   * layouting algorithm or a widget.
+   */
+  class LayoutItem:
+    public virtual SGVirtualWeakReferenced
+  {
+    public:
+
+      /** Maximum item size (indicating no limit) */
+      static const SGVec2i MAX_SIZE;
+
+      LayoutItem();
+      virtual ~LayoutItem();
+
+      /**
+       * Get the preferred size of this item.
+       */
+      SGVec2i sizeHint() const;
+
+      /**
+       * Get the minimum amount of the space this item requires.
+       */
+      SGVec2i minimumSize() const;
+
+      /**
+       * Get the maximum amount of space this item can use.
+       */
+      SGVec2i maximumSize() const;
+
+      virtual bool hasHeightForWidth() const;
+      virtual int heightForWidth(int w) const;
+      virtual int minimumHeightForWidth(int w) const;
+
+      /**
+       * Mark all cached data as invalid and require it to be recalculated.
+       */
+      virtual void invalidate();
+
+      /**
+       * Mark all cached data of parent item as invalid (if it is known)
+       */
+      void invalidateParent();
+
+      /**
+       * Set position and size of this element. For layouts this triggers a
+       * recalculation of the layout.
+       */
+      virtual void setGeometry(const SGRecti& geom);
+
+      /**
+       * Get position and size of this element.
+       */
+      virtual SGRecti geometry() const;
+
+      /**
+       * Set the canvas this item is attached to.
+       */
+      virtual void setCanvas(const CanvasWeakPtr& canvas);
+
+      /**
+       * Get the canvas this item is attached to.
+       */
+      CanvasPtr getCanvas() const;
+
+      /**
+       * Set the parent layout item (usually this is a layout).
+       */
+      void setParent(const LayoutItemWeakRef& parent);
+
+      /**
+       * Get the parent layout.
+       */
+      LayoutItemRef getParent() const;
+
+      /// Called before item is removed from a layout
+      virtual void onRemove() {}
+
+    protected:
+
+      friend class Canvas;
+
+      enum Flags
+      {
+        SIZE_HINT_DIRTY = 1,
+        MINIMUM_SIZE_DIRTY = SIZE_HINT_DIRTY << 1,
+        MAXIMUM_SIZE_DIRTY = MINIMUM_SIZE_DIRTY << 1,
+        SIZE_INFO_DIRTY = SIZE_HINT_DIRTY
+                        | MINIMUM_SIZE_DIRTY
+                        | MAXIMUM_SIZE_DIRTY,
+        LAST_FLAG = MAXIMUM_SIZE_DIRTY
+      };
+
+      CanvasWeakPtr     _canvas;
+      LayoutItemWeakRef _parent;
+
+      SGRecti           _geometry;
+
+      mutable uint32_t  _flags;
+      mutable SGVec2i   _size_hint,
+                        _min_size,
+                        _max_size;
+
+      virtual SGVec2i sizeHintImpl() const;
+      virtual SGVec2i minimumSizeImpl() const;
+      virtual SGVec2i maximumSizeImpl() const;
+
+  };
+
+} // namespace canvas
+} // namespace simgear
+
+#endif /* SG_CANVAS_LAYOUT_ITEM_HXX_ */

simgear/canvas/layout/NasalWidget.cxx

@@ -0,0 +1,295 @@
+// Glue for GUI layout items implemented in Nasal space
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "NasalWidget.hxx"
+
+#include <simgear/canvas/Canvas.hxx>
+#include <simgear/nasal/cppbind/Ghost.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  NasalWidget::NasalWidget(naRef impl):
+    Object(impl),
+    _layout_size_hint(32, 32),
+    _layout_min_size(16, 16),
+    _layout_max_size(MAX_SIZE),
+    _user_size_hint(0, 0),
+    _user_min_size(0, 0),
+    _user_max_size(MAX_SIZE)
+  {
+
+  }
+
+  //----------------------------------------------------------------------------
+  NasalWidget::~NasalWidget()
+  {
+    onRemove();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::invalidate()
+  {
+    LayoutItem::invalidate();
+    _flags |= LAYOUT_DIRTY;
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setGeometry(const SGRect<int>& geom)
+  {
+    if( _geometry != geom )
+      _geometry = geom;
+    else if( !(_flags & LAYOUT_DIRTY) || !_set_geometry )
+      return;
+
+    naContext c = naNewContext();
+    try
+    {
+      _set_geometry(nasal::to_nasal(c, this), geom);
+      _flags &= ~LAYOUT_DIRTY;
+    }
+    catch( std::exception const& ex )
+    {
+      SG_LOG(
+        SG_GUI,
+        SG_WARN,
+        "NasalWidget::setGeometry: callback error: '" << ex.what() << "'"
+      );
+    }
+    naFreeContext(c);
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::onRemove()
+  {
+    if( !_nasal_impl.valid() )
+      return;
+
+    typedef boost::function<void(nasal::Me)> Deleter;
+
+    naContext c = naNewContext();
+    try
+    {
+      Deleter del =
+        nasal::get_member<Deleter>(c, _nasal_impl.get_naRef(), "onRemove");
+      if( del )
+        del(nasal::to_nasal(c, this));
+    }
+    catch( std::exception const& ex )
+    {
+      SG_LOG(
+        SG_GUI,
+        SG_WARN,
+        "NasalWidget::onRemove: callback error: '" << ex.what() << "'"
+      );
+    }
+    naFreeContext(c);
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setSetGeometryFunc(const SetGeometryFunc& func)
+  {
+    _set_geometry = func;
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setHeightForWidthFunc(const HeightForWidthFunc& func)
+  {
+    _height_for_width = func;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setMinimumHeightForWidthFunc(const HeightForWidthFunc& func)
+  {
+    _min_height_for_width = func;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setSizeHint(const SGVec2i& s)
+  {
+    if( _user_size_hint == s )
+      return;
+
+    _user_size_hint = s;
+
+    // TODO just invalidate size_hint? Probably not a performance issue...
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setMinimumSize(const SGVec2i& s)
+  {
+    if( _user_min_size == s )
+      return;
+
+    _user_min_size = s;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setMaximumSize(const SGVec2i& s)
+  {
+    if( _user_max_size == s )
+      return;
+
+    _user_max_size = s;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setLayoutSizeHint(const SGVec2i& s)
+  {
+    if( _layout_size_hint == s )
+      return;
+
+    _layout_size_hint = s;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setLayoutMinimumSize(const SGVec2i& s)
+  {
+    if( _layout_min_size == s )
+      return;
+
+    _layout_min_size = s;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setLayoutMaximumSize(const SGVec2i& s)
+  {
+    if( _layout_max_size == s )
+      return;
+
+    _layout_max_size = s;
+    invalidate();
+  }
+
+  //----------------------------------------------------------------------------
+  bool NasalWidget::hasHeightForWidth() const
+  {
+    return !_height_for_width.empty() || !_min_height_for_width.empty();
+  }
+
+  //----------------------------------------------------------------------------
+  int NasalWidget::heightForWidth(int w) const
+  {
+    return callHeightForWidthFunc( _height_for_width.empty()
+                                 ? _min_height_for_width
+                                 : _height_for_width, w );
+  }
+
+  //----------------------------------------------------------------------------
+  int NasalWidget::minimumHeightForWidth(int w) const
+  {
+    return callHeightForWidthFunc( _min_height_for_width.empty()
+                                 ? _height_for_width
+                                 : _min_height_for_width, w );
+  }
+
+  //----------------------------------------------------------------------------
+  static naRef f_makeNasalWidget(const nasal::CallContext& ctx)
+  {
+    return ctx.to_nasal(NasalWidgetRef(
+      new NasalWidget( ctx.requireArg<naRef>(0) )
+    ));
+  }
+
+  //----------------------------------------------------------------------------
+  void NasalWidget::setupGhost(nasal::Hash& ns)
+  {
+    nasal::Ghost<NasalWidgetRef>::init("canvas.Widget")
+      .bases<LayoutItemRef>()
+      .bases<nasal::ObjectRef>()
+      .method("setSetGeometryFunc", &NasalWidget::setSetGeometryFunc)
+      .method("setMinimumHeightForWidthFunc",
+                                    &NasalWidget::setMinimumHeightForWidthFunc)
+      .method("setHeightForWidthFunc", &NasalWidget::setHeightForWidthFunc)
+      .method("setSizeHint", &NasalWidget::setSizeHint)
+      .method("setMinimumSize", &NasalWidget::setMinimumSize)
+      .method("setMaximumSize", &NasalWidget::setMaximumSize)
+      .method("setLayoutSizeHint", &NasalWidget::setLayoutSizeHint)
+      .method("setLayoutMinimumSize", &NasalWidget::setLayoutMinimumSize)
+      .method("setLayoutMaximumSize", &NasalWidget::setLayoutMaximumSize);
+
+    nasal::Hash widget_hash = ns.createHash("Widget");
+    widget_hash.set("new", &f_makeNasalWidget);
+  }
+
+  //----------------------------------------------------------------------------
+  int NasalWidget::callHeightForWidthFunc( const HeightForWidthFunc& hfw,
+                                           int w ) const
+  {
+    if( hfw.empty() )
+      return -1;
+
+    naContext c = naNewContext();
+    try
+    {
+      return hfw(nasal::to_nasal(c, const_cast<NasalWidget*>(this)), w);
+    }
+    catch( std::exception const& ex )
+    {
+      SG_LOG(
+        SG_GUI,
+        SG_WARN,
+        "NasalWidget.heightForWidth: callback error: '" << ex.what() << "'"
+      );
+    }
+    naFreeContext(c);
+
+    return -1;
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i NasalWidget::sizeHintImpl() const
+  {
+    return SGVec2i(
+      _user_size_hint.x() > 0 ? _user_size_hint.x() : _layout_size_hint.x(),
+      _user_size_hint.y() > 0 ? _user_size_hint.y() : _layout_size_hint.y()
+    );
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i NasalWidget::minimumSizeImpl() const
+  {
+    return SGVec2i(
+      _user_min_size.x() > 0 ? _user_min_size.x() : _layout_min_size.x(),
+      _user_min_size.y() > 0 ? _user_min_size.y() : _layout_min_size.y()
+    );
+  }
+
+  //----------------------------------------------------------------------------
+  SGVec2i NasalWidget::maximumSizeImpl() const
+  {
+    return SGVec2i(
+      _user_max_size.x() < MAX_SIZE.x() ? _user_max_size.x()
+                                        : _layout_max_size.x(),
+      _user_max_size.y() < MAX_SIZE.y() ? _user_max_size.y()
+                                        : _layout_max_size.y()
+    );
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/layout/NasalWidget.hxx

@@ -0,0 +1,129 @@
+///@file Glue for GUI widgets implemented in Nasal space
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#ifndef SG_CANVAS_NASAL_WIDGET_HXX_
+#define SG_CANVAS_NASAL_WIDGET_HXX_
+
+#include "LayoutItem.hxx"
+
+#include <simgear/nasal/cppbind/from_nasal.hxx>
+#include <simgear/nasal/cppbind/NasalHash.hxx>
+#include <simgear/nasal/cppbind/NasalObject.hxx>
+
+namespace simgear
+{
+namespace canvas
+{
+
+  /**
+   * Baseclass/ghost to create widgets with Nasal.
+   */
+  class NasalWidget:
+    public LayoutItem,
+    public nasal::Object
+  {
+    public:
+
+      typedef boost::function<void (nasal::Me, const SGRecti&)> SetGeometryFunc;
+      typedef boost::function<int (nasal::Me, int)> HeightForWidthFunc;
+
+      /**
+       *
+       * @param impl    Initial implementation hash (nasal part of
+       *                implementation)
+       */
+      NasalWidget(naRef impl);
+
+      ~NasalWidget();
+
+      virtual void invalidate();
+      virtual void setGeometry(const SGRecti& geom);
+      virtual void onRemove();
+
+      void setSetGeometryFunc(const SetGeometryFunc& func);
+      void setHeightForWidthFunc(const HeightForWidthFunc& func);
+      void setMinimumHeightForWidthFunc(const HeightForWidthFunc& func);
+
+      /** Set size hint.
+       *
+       * Overrides default size hint. Set to (0, 0) to fall back to default size
+       * hint.
+       */
+      void setSizeHint(const SGVec2i& s);
+
+      /** Set minimum size.
+       *
+       * Overrides default minimum size. Set to (0, 0) to fall back to default
+       * minimum size.
+       */
+      void setMinimumSize(const SGVec2i& s);
+
+      /** Set maximum size.
+       *
+       * Overrides default maximum size hint. Set to LayoutItem::MAX_SIZE to
+       * fall back to default maximum size.
+       */
+      void setMaximumSize(const SGVec2i& s);
+
+      void setLayoutSizeHint(const SGVec2i& s);
+      void setLayoutMinimumSize(const SGVec2i& s);
+      void setLayoutMaximumSize(const SGVec2i& s);
+
+      virtual bool hasHeightForWidth() const;
+      virtual int heightForWidth(int w) const;
+      virtual int minimumHeightForWidth(int w) const;
+
+      /**
+       * @param ns  Namespace to register the class interface
+       */
+      static void setupGhost(nasal::Hash& ns);
+
+    protected:
+      enum WidgetFlags
+      {
+        LAYOUT_DIRTY = LayoutItem::LAST_FLAG << 1,
+        LAST_FLAG = LAYOUT_DIRTY
+      };
+
+      SetGeometryFunc       _set_geometry;
+      HeightForWidthFunc    _height_for_width,
+                            _min_height_for_width;
+
+      SGVec2i _layout_size_hint,
+              _layout_min_size,
+              _layout_max_size,
+              _user_size_hint,
+              _user_min_size,
+              _user_max_size;
+
+      int callHeightForWidthFunc( const HeightForWidthFunc& hfw,
+                                  int w ) const;
+
+      virtual SGVec2i sizeHintImpl() const;
+      virtual SGVec2i minimumSizeImpl() const;
+      virtual SGVec2i maximumSizeImpl() const;
+
+  };
+
+  typedef SGSharedPtr<NasalWidget> NasalWidgetRef;
+
+} // namespace canvas
+} // namespace simgear
+
+
+#endif /* SG_CANVAS_NASAL_WIDGET_HXX_ */

simgear/canvas/layout/SpacerItem.cxx

@@ -0,0 +1,36 @@
+// Element providing blank space in a layout.
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#include "SpacerItem.hxx"
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  SpacerItem::SpacerItem( const SGVec2i& size,
+                          const SGVec2i& max_size )
+  {
+    _size_hint = size;
+    _min_size  = size;
+    _max_size  = max_size;
+  }
+
+} // namespace canvas
+} // namespace simgear

simgear/canvas/layout/SpacerItem.hxx

@@ -1,6 +1,6 @@
-// Listener for canvas (GUI) events being passed to a Nasal function/code
+///@file Element providing blank space in a layout.
 //
-// Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -16,33 +16,28 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
-#ifndef CANVAS_EVENT_LISTENER_HXX_
-#define CANVAS_EVENT_LISTENER_HXX_
+#ifndef SG_CANVAS_SPACER_ITEM_HXX_
+#define SG_CANVAS_SPACER_ITEM_HXX_
 
-#include "canvas_fwd.hxx"
-#include <simgear/nasal/naref.h>
+#include "LayoutItem.hxx"
 
 namespace simgear
 {
 namespace canvas
 {
-
-  class EventListener
+  /**
+   * Element for providing blank space in a layout.
+   */
+  class SpacerItem:
+    public LayoutItem
   {
     public:
-      EventListener( naRef code,
-                     const SystemAdapterPtr& sys_adapter );
-      ~EventListener();
+      SpacerItem( const SGVec2i& size = SGVec2i(0, 0),
+                  const SGVec2i& max_size = MAX_SIZE );
 
-      void call(const canvas::EventPtr& event);
-
-    protected:
-      naRef _code;
-      int _gc_key;
-      SystemAdapterWeakPtr _sys;
   };
 
 } // namespace canvas
 } // namespace simgear
 
-#endif /* CANVAS_EVENT_LISTENER_HXX_ */
+#endif /* SG_CANVAS_SPACER_ITEM_HXX_ */

simgear/canvas/layout/canvas_layout_test.cxx

@@ -0,0 +1,461 @@
+// Testing canvas layouting system
+//
+// Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+#define BOOST_TEST_MODULE canvas_layout
+#include <BoostTestTargetConfig.h>
+
+#include "BoxLayout.hxx"
+#include "NasalWidget.hxx"
+
+#include <simgear/debug/logstream.hxx>
+#include <cstdlib>
+
+//------------------------------------------------------------------------------
+struct SetLogLevelFixture
+{
+  SetLogLevelFixture()
+  {
+    sglog().set_log_priority(SG_DEBUG);
+  }
+};
+BOOST_GLOBAL_FIXTURE(SetLogLevelFixture);
+
+//------------------------------------------------------------------------------
+namespace sc = simgear::canvas;
+
+class TestWidget:
+  public sc::LayoutItem
+{
+  public:
+    TestWidget( const SGVec2i& min_size,
+                const SGVec2i& size_hint,
+                const SGVec2i& max_size = MAX_SIZE )
+    {
+      _size_hint = size_hint;
+      _min_size = min_size;
+      _max_size = max_size;
+    }
+
+    TestWidget(const TestWidget& rhs)
+    {
+      _size_hint = rhs._size_hint;
+      _min_size = rhs._min_size;
+      _max_size = rhs._max_size;
+    }
+
+    void setMinSize(const SGVec2i& size) { _min_size = size; }
+    void setMaxSize(const SGVec2i& size) { _max_size = size; }
+    void setSizeHint(const SGVec2i& size) { _size_hint = size; }
+
+    virtual void setGeometry(const SGRecti& geom) { _geom = geom; }
+    virtual SGRecti geometry() const { return _geom; }
+
+  protected:
+
+    SGRecti _geom;
+
+    virtual SGVec2i sizeHintImpl() const { return _size_hint; }
+    virtual SGVec2i minimumSizeImpl() const { return _min_size; }
+    virtual SGVec2i maximumSizeImpl() const { return _max_size; }
+};
+
+class TestWidgetHFW:
+  public TestWidget
+{
+  public:
+    TestWidgetHFW( const SGVec2i& min_size,
+                   const SGVec2i& size_hint,
+                   const SGVec2i& max_size = MAX_SIZE ):
+      TestWidget(min_size, size_hint, max_size)
+    {
+
+    }
+
+    virtual bool hasHeightForWidth() const
+    {
+      return true;
+    }
+
+    virtual int heightForWidth(int w) const
+    {
+      return _size_hint.x() * _size_hint.y() / w;
+    }
+
+    virtual int minimumHeightForWidth(int w) const
+    {
+      return _min_size.x() * _min_size.y() / w;
+    }
+};
+
+typedef SGSharedPtr<TestWidget> TestWidgetRef;
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( horizontal_layout )
+{
+  sc::BoxLayout box_layout(sc::BoxLayout::BottomToTop);
+  box_layout.setSpacing(5);
+
+  BOOST_CHECK_EQUAL(box_layout.direction(), sc::BoxLayout::BottomToTop);
+  BOOST_CHECK_EQUAL(box_layout.spacing(), 5);
+
+  box_layout.setDirection(sc::BoxLayout::LeftToRight);
+  box_layout.setSpacing(9);
+
+  BOOST_CHECK_EQUAL(box_layout.direction(), sc::BoxLayout::LeftToRight);
+  BOOST_CHECK_EQUAL(box_layout.spacing(), 9);
+
+  TestWidgetRef fixed_size_widget( new TestWidget( SGVec2i(16, 16),
+                                                   SGVec2i(16, 16),
+                                                   SGVec2i(16, 16) ) );
+  box_layout.addItem(fixed_size_widget);
+
+  BOOST_CHECK_EQUAL(box_layout.minimumSize(), SGVec2i(16, 16));
+  BOOST_CHECK_EQUAL(box_layout.sizeHint(), SGVec2i(16, 16));
+  BOOST_CHECK_EQUAL(box_layout.maximumSize(), SGVec2i(16, 16));
+
+  TestWidgetRef limited_resize_widget( new TestWidget( SGVec2i(16, 16),
+                                                       SGVec2i(32, 32),
+                                                       SGVec2i(256, 64) ) );
+  box_layout.addItem(limited_resize_widget);
+
+  // Combined sizes of both widget plus the padding between them
+  BOOST_CHECK_EQUAL(box_layout.minimumSize(), SGVec2i(41, 16));
+  BOOST_CHECK_EQUAL(box_layout.sizeHint(), SGVec2i(57, 32));
+  BOOST_CHECK_EQUAL(box_layout.maximumSize(), SGVec2i(281, 64));
+
+  // Test with different spacing/padding
+  box_layout.setSpacing(5);
+
+  BOOST_CHECK_EQUAL(box_layout.minimumSize(), SGVec2i(37, 16));
+  BOOST_CHECK_EQUAL(box_layout.sizeHint(), SGVec2i(53, 32));
+  BOOST_CHECK_EQUAL(box_layout.maximumSize(), SGVec2i(277, 64));
+
+  box_layout.setGeometry(SGRecti(0, 0, 128, 32));
+
+  // Fixed size for first widget and remaining space goes to second widget
+  BOOST_CHECK_EQUAL(fixed_size_widget->geometry(), SGRecti(0, 8, 16, 16));
+  BOOST_CHECK_EQUAL(limited_resize_widget->geometry(), SGRecti(21, 0, 107, 32));
+
+  TestWidgetRef stretch_widget( new TestWidget( SGVec2i(16, 16),
+                                                SGVec2i(32, 32),
+                                                SGVec2i(128, 32) ) );
+  box_layout.addItem(stretch_widget, 1);
+  box_layout.update();
+
+  BOOST_CHECK_EQUAL(box_layout.minimumSize(), SGVec2i(58, 16));
+  BOOST_CHECK_EQUAL(box_layout.sizeHint(), SGVec2i(90, 32));
+  BOOST_CHECK_EQUAL(box_layout.maximumSize(), SGVec2i(410, 64));
+
+  // Due to the stretch factor only the last widget gets additional space. All
+  // other widgets get the preferred size.
+  BOOST_CHECK_EQUAL(fixed_size_widget->geometry(), SGRecti(0, 8, 16, 16));
+  BOOST_CHECK_EQUAL(limited_resize_widget->geometry(), SGRecti(21, 0, 32, 32));
+  BOOST_CHECK_EQUAL(stretch_widget->geometry(), SGRecti(58, 0, 70, 32));
+
+  // Test stretch factor
+  TestWidgetRef fast_stretch( new TestWidget(*stretch_widget) );
+  sc::BoxLayout box_layout_stretch(sc::BoxLayout::LeftToRight);
+
+  box_layout_stretch.addItem(stretch_widget, 1);
+  box_layout_stretch.addItem(fast_stretch, 2);
+
+  box_layout_stretch.setGeometry(SGRecti(0,0,128,32));
+
+  BOOST_CHECK_EQUAL(stretch_widget->geometry(), SGRecti(0, 0, 41, 32));
+  BOOST_CHECK_EQUAL(fast_stretch->geometry(), SGRecti(46, 0, 82, 32));
+
+  box_layout_stretch.setGeometry(SGRecti(0,0,256,32));
+
+  BOOST_CHECK_EQUAL(stretch_widget->geometry(), SGRecti(0, 0, 123, 32));
+  BOOST_CHECK_EQUAL(fast_stretch->geometry(), SGRecti(128, 0, 128, 32));
+
+  // Test superflous space to padding
+  box_layout_stretch.setGeometry(SGRecti(0,0,512,32));
+
+  BOOST_CHECK_EQUAL(stretch_widget->geometry(), SGRecti(83, 0, 128, 32));
+  BOOST_CHECK_EQUAL(fast_stretch->geometry(), SGRecti(300, 0, 128, 32));
+
+  // Test more space then preferred, but less than maximum
+  {
+    sc::HBoxLayout hbox;
+    TestWidgetRef w1( new TestWidget( SGVec2i(16,   16),
+                                      SGVec2i(32,   32),
+                                      SGVec2i(9999, 32) ) ),
+                  w2( new TestWidget(*w1) );
+
+    hbox.addItem(w1);
+    hbox.addItem(w2);
+
+    hbox.setGeometry( SGRecti(0, 0, 256, 32) );
+
+    BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0,   0, 126, 32));
+    BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(131, 0, 125, 32));
+
+    hbox.setStretch(0, 1);
+    hbox.setStretch(1, 1);
+
+    BOOST_CHECK_EQUAL(hbox.stretch(0), 1);
+    BOOST_CHECK_EQUAL(hbox.stretch(1), 1);
+
+    hbox.update();
+
+    BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0,   0, 125, 32));
+    BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(130, 0, 126, 32));
+
+    BOOST_REQUIRE( hbox.setStretchFactor(w1, 2) );
+    BOOST_REQUIRE( hbox.setStretchFactor(w2, 3) );
+    BOOST_CHECK_EQUAL(hbox.stretch(0), 2);
+    BOOST_CHECK_EQUAL(hbox.stretch(1), 3);
+
+    hbox.removeItem(w1);
+
+    BOOST_CHECK( !hbox.setStretchFactor(w1, 0) );
+  }
+}
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( spacer_layouting )
+{
+  sc::HBoxLayout hbox;
+  TestWidgetRef w1( new TestWidget( SGVec2i(16, 16),
+                                    SGVec2i(32, 32),
+                                    SGVec2i(9999, 9999) ) ),
+                w2( new TestWidget(*w1) );
+
+  hbox.addItem(w1);
+  hbox.addItem(w2);
+  hbox.addStretch(1);
+
+  BOOST_CHECK_EQUAL(hbox.minimumSize(), SGVec2i(37, 16));
+  BOOST_CHECK_EQUAL(hbox.sizeHint(), SGVec2i(69, 32));
+  BOOST_CHECK_EQUAL(hbox.maximumSize(), sc::LayoutItem::MAX_SIZE);
+
+  hbox.setGeometry(SGRecti(0, 0, 256, 40));
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0,  0, 32, 40));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(37, 0, 32, 40));
+
+  // now center with increased spacing between both widgets
+  hbox.insertStretch(0, 1);
+  hbox.insertSpacing(2, 10);
+
+  BOOST_CHECK_EQUAL(hbox.minimumSize(), SGVec2i(47, 16));
+  BOOST_CHECK_EQUAL(hbox.sizeHint(), SGVec2i(79, 32));
+  BOOST_CHECK_EQUAL(hbox.maximumSize(), sc::LayoutItem::MAX_SIZE);
+
+  hbox.update();
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(88,  0, 32, 40));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(135, 0, 32, 40));
+}
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( vertical_layout)
+{
+  sc::BoxLayout vbox(sc::BoxLayout::TopToBottom);
+  vbox.setSpacing(7);
+
+  TestWidgetRef fixed_size_widget( new TestWidget( SGVec2i(16, 16),
+                                                   SGVec2i(16, 16),
+                                                   SGVec2i(16, 16) ) );
+  TestWidgetRef limited_resize_widget( new TestWidget( SGVec2i(16, 16),
+                                                       SGVec2i(32, 32),
+                                                       SGVec2i(256, 64) ) );
+
+  vbox.addItem(fixed_size_widget);
+  vbox.addItem(limited_resize_widget);
+
+  BOOST_CHECK_EQUAL(vbox.minimumSize(), SGVec2i(16, 39));
+  BOOST_CHECK_EQUAL(vbox.sizeHint(), SGVec2i(32, 55));
+  BOOST_CHECK_EQUAL(vbox.maximumSize(), SGVec2i(256, 87));
+
+  vbox.setGeometry(SGRecti(10, 20, 16, 55));
+
+  BOOST_CHECK_EQUAL(fixed_size_widget->geometry(), SGRecti(10, 20, 16, 16));
+  BOOST_CHECK_EQUAL(limited_resize_widget->geometry(), SGRecti(10, 43, 16, 32));
+
+  vbox.setDirection(sc::BoxLayout::BottomToTop);
+}
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( boxlayout_insert_remove )
+{
+  sc::HBoxLayout hbox;
+
+  BOOST_CHECK_EQUAL(hbox.count(), 0);
+  BOOST_CHECK(!hbox.itemAt(0));
+  BOOST_CHECK(!hbox.takeAt(0));
+
+  TestWidgetRef w1( new TestWidget( SGVec2i(16,   16),
+                                    SGVec2i(32,   32),
+                                    SGVec2i(9999, 32) ) ),
+                w2( new TestWidget(*w1) );
+
+  hbox.addItem(w1);
+  BOOST_CHECK_EQUAL(hbox.count(), 1);
+  BOOST_CHECK_EQUAL(hbox.itemAt(0), w1);
+
+  hbox.insertItem(0, w2);
+  BOOST_CHECK_EQUAL(hbox.count(), 2);
+  BOOST_CHECK_EQUAL(hbox.itemAt(0), w2);
+  BOOST_CHECK_EQUAL(hbox.itemAt(1), w1);
+
+  hbox.removeItem(w2);
+  BOOST_CHECK_EQUAL(hbox.count(), 1);
+  BOOST_CHECK_EQUAL(hbox.itemAt(0), w1);
+
+  hbox.addItem(w2);
+  BOOST_CHECK_EQUAL(hbox.count(), 2);
+
+  hbox.clear();
+  BOOST_CHECK_EQUAL(hbox.count(), 0);
+}
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( boxlayout_hfw )
+{
+  TestWidgetRef w1( new TestWidgetHFW( SGVec2i(16,   16),
+                                       SGVec2i(32,   32) ) ),
+                w2( new TestWidgetHFW( SGVec2i(24,   24),
+                                       SGVec2i(48,   48) ) );
+
+  BOOST_CHECK_EQUAL(w1->heightForWidth(16), 64);
+  BOOST_CHECK_EQUAL(w1->minimumHeightForWidth(16), 16);
+  BOOST_CHECK_EQUAL(w2->heightForWidth(24), 96);
+  BOOST_CHECK_EQUAL(w2->minimumHeightForWidth(24), 24);
+
+  TestWidgetRef w_no_hfw( new TestWidget( SGVec2i(16,   16),
+                                          SGVec2i(32,   32) ) );
+  BOOST_CHECK(!w_no_hfw->hasHeightForWidth());
+  BOOST_CHECK_EQUAL(w_no_hfw->heightForWidth(16), -1);
+  BOOST_CHECK_EQUAL(w_no_hfw->minimumHeightForWidth(16), -1);
+
+  // horizontal
+  sc::HBoxLayout hbox;
+  hbox.setSpacing(5);
+  hbox.addItem(w1);
+  hbox.addItem(w2);
+
+  BOOST_CHECK_EQUAL(hbox.heightForWidth(45), w2->heightForWidth(24));
+  BOOST_CHECK_EQUAL(hbox.heightForWidth(85), w2->heightForWidth(48));
+
+  hbox.addItem(w_no_hfw);
+
+  BOOST_CHECK_EQUAL(hbox.heightForWidth(66), 96);
+  BOOST_CHECK_EQUAL(hbox.heightForWidth(122), 48);
+  BOOST_CHECK_EQUAL(hbox.minimumHeightForWidth(66), 24);
+  BOOST_CHECK_EQUAL(hbox.minimumHeightForWidth(122), 16);
+
+  hbox.setGeometry(SGRecti(0, 0, 66, 24));
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0, 0,  16, 24));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(21, 0, 24, 24));
+  BOOST_CHECK_EQUAL(w_no_hfw->geometry(), SGRecti(50, 0, 16, 24));
+
+  // vertical
+  sc::VBoxLayout vbox;
+  vbox.setSpacing(5);
+  vbox.addItem(w1);
+  vbox.addItem(w2);
+
+  BOOST_CHECK_EQUAL(vbox.heightForWidth(24), 143);
+  BOOST_CHECK_EQUAL(vbox.heightForWidth(48), 74);
+  BOOST_CHECK_EQUAL(vbox.minimumHeightForWidth(24), 39);
+  BOOST_CHECK_EQUAL(vbox.minimumHeightForWidth(48), 22);
+
+  vbox.addItem(w_no_hfw);
+
+  BOOST_CHECK_EQUAL(vbox.heightForWidth(24), 180);
+  BOOST_CHECK_EQUAL(vbox.heightForWidth(48), 111);
+  BOOST_CHECK_EQUAL(vbox.minimumHeightForWidth(24), 60);
+  BOOST_CHECK_EQUAL(vbox.minimumHeightForWidth(48), 43);
+
+  SGVec2i min_size = vbox.minimumSize(),
+          size_hint = vbox.sizeHint();
+
+  BOOST_CHECK_EQUAL(min_size, SGVec2i(24, 66));
+  BOOST_CHECK_EQUAL(size_hint, SGVec2i(48, 122));
+
+  vbox.setGeometry(SGRecti(0, 0, 24, 122));
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0, 0,  24, 33));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(0, 38, 24, 47));
+  BOOST_CHECK_EQUAL(w_no_hfw->geometry(), SGRecti(0, 90, 24, 32));
+
+  // Vertical layouting modifies size hints, so check if they are correctly
+  // restored
+  BOOST_CHECK_EQUAL(min_size, vbox.minimumSize());
+  BOOST_CHECK_EQUAL(size_hint, vbox.sizeHint());
+
+  vbox.setGeometry(SGRecti(0, 0, 50, 122));
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0, 0,  50, 25));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(0, 30, 50, 51));
+  BOOST_CHECK_EQUAL(w_no_hfw->geometry(), SGRecti(0, 86, 50, 36));
+
+  // Same geometry as before -> should get same widget geometry
+  // (check internal size hint cache updates correctly)
+  vbox.setGeometry(SGRecti(0, 0, 24, 122));
+
+  BOOST_CHECK_EQUAL(w1->geometry(), SGRecti(0, 0,  24, 33));
+  BOOST_CHECK_EQUAL(w2->geometry(), SGRecti(0, 38, 24, 47));
+  BOOST_CHECK_EQUAL(w_no_hfw->geometry(), SGRecti(0, 90, 24, 32));
+}
+
+//------------------------------------------------------------------------------
+BOOST_AUTO_TEST_CASE( nasal_widget )
+{
+  naContext c = naNewContext();
+  naRef me = naNewHash(c);
+
+  sc::NasalWidgetRef w( new sc::NasalWidget(me) );
+
+  // Default layout sizes (no user set values)
+  BOOST_CHECK_EQUAL(w->minimumSize(), SGVec2i(16, 16));
+  BOOST_CHECK_EQUAL(w->sizeHint(),    SGVec2i(32, 32));
+  BOOST_CHECK_EQUAL(w->maximumSize(), sc::LayoutItem::MAX_SIZE);
+
+  // Changed layout sizes
+  w->setLayoutMinimumSize( SGVec2i(2, 12) );
+  w->setLayoutSizeHint(    SGVec2i(3, 13) );
+  w->setLayoutMaximumSize( SGVec2i(4, 14) );
+
+  BOOST_CHECK_EQUAL(w->minimumSize(), SGVec2i(2, 12));
+  BOOST_CHECK_EQUAL(w->sizeHint(),    SGVec2i(3, 13));
+  BOOST_CHECK_EQUAL(w->maximumSize(), SGVec2i(4, 14));
+
+  // User set values (overwrite layout sizes)
+  w->setMinimumSize( SGVec2i(15, 16) );
+  w->setSizeHint(    SGVec2i(17, 18) );
+  w->setMaximumSize( SGVec2i(19, 20) );
+
+  BOOST_CHECK_EQUAL(w->minimumSize(), SGVec2i(15, 16));
+  BOOST_CHECK_EQUAL(w->sizeHint(),    SGVec2i(17, 18));
+  BOOST_CHECK_EQUAL(w->maximumSize(), SGVec2i(19, 20));
+
+  // Only vertical user set values (layout/default for horizontal hints)
+  w->setMinimumSize( SGVec2i(0, 21) );
+  w->setSizeHint(    SGVec2i(0, 22) );
+  w->setMaximumSize( SGVec2i(SGLimits<int>::max(), 23) );
+
+  BOOST_CHECK_EQUAL(w->minimumSize(), SGVec2i(2, 21));
+  BOOST_CHECK_EQUAL(w->sizeHint(),    SGVec2i(3, 22));
+  BOOST_CHECK_EQUAL(w->maximumSize(), SGVec2i(4, 23));
+
+  naFreeContext(c);
+}

simgear/compiler.h

@@ -46,7 +46,7 @@
 #    warning GCC compilers prior to 3.4 are suspect  
 #  endif
 
-#  define GCC_VERSION (__GNUC__ * 10000 \
+#  define SG_GCC_VERSION (__GNUC__ * 10000 \
                      + __GNUC_MINOR__ * 100 \
                      + __GNUC_PATCHLEVEL__)
 #  define SG_COMPILER_STR "GNU C++ version " SG_STRINGIZE(__GNUC__) "." SG_STRINGIZE(__GNUC_MINOR__)

simgear/debug/BufferedLogCallback.cxx

@@ -34,18 +34,15 @@ class BufferedLogCallback::BufferedLogCallbackPrivate
 {
 public:
     SGMutex m_mutex;
-    sgDebugClass m_class;
-    sgDebugPriority m_priority;
     vector_cstring m_buffer;
     unsigned int m_stamp;
     unsigned int m_maxLength;
 };
    
 BufferedLogCallback::BufferedLogCallback(sgDebugClass c, sgDebugPriority p) :
+	simgear::LogCallback(c,p),
     d(new BufferedLogCallbackPrivate)
 {
-    d->m_class = c;
-    d->m_priority = p;
     d->m_stamp = 0;
     d->m_maxLength = 0xffff;
 }
@@ -63,7 +60,7 @@ void BufferedLogCallback::operator()(sgDebugClass c, sgDebugPriority p,
     SG_UNUSED(file);
     SG_UNUSED(line);
     
-    if ((c & d->m_class) == 0 || p < d->m_priority) return;
+    if (!shouldLog(c, p)) return;
     
     vector_cstring::value_type msg;
     if (aMessage.size() >= d->m_maxLength) {