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.

CMakeLists.txt

@@ -100,7 +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(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)
@@ -161,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")
 
@@ -179,17 +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)
-
 find_package(ZLIB REQUIRED)
 find_package(Threads REQUIRED)
 
@@ -269,7 +263,9 @@ check_cxx_source_compiles(
 
 if(HAVE_DLFCN_H)
     check_library_exists(dl dlerror "" HAVE_DL)
-    set(DL_LIBRARY "dl")
+    if(HAVE_DL)
+        set(DL_LIBRARY "dl")
+    endif()
 endif()
 
 SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
@@ -342,9 +338,11 @@ 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)
+# 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} 
@@ -378,7 +376,7 @@ set(TEST_LIBS_INTERNAL_CORE
     ${WINSOCK_LIBRARY}
     ${RT_LIBRARY}
     ${DL_LIBRARY}
-    ${CORE_SERVICES_LIBRARY})
+    ${COCOA_LIBRARY})
 set(TEST_LIBS SimGearCore ${TEST_LIBS_INTERNAL_CORE})
 
 if(NOT SIMGEAR_HEADLESS)

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/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

@@ -122,7 +122,7 @@ target_link_libraries(SimGearCore
     ${DL_LIBRARY}
     ${EXPAT_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${CORE_SERVICES_LIBRARY})
+    ${COCOA_LIBRARY})
 
 if(NOT SIMGEAR_HEADLESS)
     target_link_libraries(SimGearScene

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;
     }
 
-    snprintf(raw_path, 256, "%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

@@ -11,7 +11,7 @@ set(HEADERS
   CanvasObjectPlacement.hxx
   CanvasPlacement.hxx
   CanvasSystemAdapter.hxx
-  MouseEvent.hxx
+  CanvasWindow.hxx
   ODGauge.hxx
   VGInitOperation.hxx
 )
@@ -24,11 +24,14 @@ set(SOURCES
   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,13 @@ 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);
   }
 
   //----------------------------------------------------------------------------
@@ -180,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)
   {
@@ -191,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);
 
@@ -237,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;
         }
       }
 
@@ -296,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",
@@ -317,11 +344,20 @@ namespace canvas
                                  const EventListener& cb )
   {
     if( !_root_group.get() )
-      throw std::runtime_error("Canvas::AddEventListener: no root group!");
+      throw std::runtime_error("Canvas::addEventListener: no root group!");
 
     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);
+  }
+
   //----------------------------------------------------------------------------
   void Canvas::setSizeX(int sx)
   {
@@ -374,6 +410,7 @@ namespace canvas
     if( _view_width == w )
       return;
     _view_width = w;
+    _status |= LAYOUT_DIRTY;
 
     _texture.setViewSize(_view_width, _view_height);
   }
@@ -384,6 +421,7 @@ namespace canvas
     if( _view_height == h )
       return;
     _view_height = h;
+    _status |= LAYOUT_DIRTY;
 
     _texture.setViewSize(_view_width, _view_height);
   }
@@ -409,12 +447,11 @@ 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;
@@ -422,6 +459,13 @@ namespace canvas
     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 )
@@ -453,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;
 
@@ -493,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) )
@@ -502,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;
@@ -615,23 +667,6 @@ namespace canvas
     return _system_adapter;
   }
 
-  //----------------------------------------------------------------------------
-  void Canvas::setSelf(const PropertyBasedElementPtr& self)
-  {
-    PropertyBasedElement::setSelf(self);
-
-    CanvasPtr canvas = boost::static_pointer_cast<Canvas>(self);
-
-    _root_group.reset( new Group(canvas, _node) );
-    _root_group->setSelf(_root_group);
-
-    // Remove automatically created property listener as we forward them on our
-    // own
-    _root_group->removeListener();
-
-    _cull_callback = new CullCallback(canvas);
-  }
-
   //----------------------------------------------------------------------------
   void Canvas::setStatusFlags(unsigned int flags, bool set)
   {
@@ -648,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";

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,9 +23,12 @@
 #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>
 
@@ -34,22 +37,26 @@
 
 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
       };
 
@@ -120,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
        *
@@ -131,6 +144,7 @@ namespace canvas
       void update(double delta_time_sec);
 
       bool addEventListener(const std::string& type, const EventListener& cb);
+      bool dispatchEvent(const EventPtr& event);
 
       void setSizeX(int sx);
       void setSizeY(int sy);
@@ -146,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 );
@@ -191,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)
@@ -205,7 +223,6 @@ 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:

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);
   }
 
   //----------------------------------------------------------------------------
@@ -81,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,11 +38,11 @@ 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;
+      int               type;
       ElementWeakPtr    target,
                         current_target;
       double            time;
@@ -52,7 +54,19 @@ 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;
@@ -62,7 +76,19 @@ namespace canvas
 
       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,7 +17,7 @@
 // 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>
 
@@ -61,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)
@@ -76,7 +86,7 @@ namespace canvas
     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:
       {
@@ -89,12 +99,12 @@ namespace canvas
         // normal mouseup
         handled |= propagateEvent(event, path);
 
-        if( _last_mouse_down.path.empty() )
+        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) )
+        if( checkClickDistance(event->screen_pos, _last_mouse_down.pos) )
           handled |=
             handleClick(event, getCommonAncestor(_last_mouse_down.path, path));
 
@@ -106,7 +116,11 @@ namespace canvas
         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:
         handled |= handleMove(event, path);
         break;
@@ -130,6 +144,71 @@ namespace canvas
     return handled | propagateEvent(event, path);
   }
 
+  //----------------------------------------------------------------------------
+  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 )
@@ -146,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;
       }
     }
@@ -167,7 +248,7 @@ namespace canvas
       handled |= propagateEvent( dbl_click,
                                  getCommonAncestor(_last_click.path, path) );
 
-    _last_click = StampedPropagationPath(path, event->getTime());
+    _last_click.set(event, path);
 
     return handled;
   }
@@ -233,89 +314,12 @@ namespace canvas
     return handled;
   }
 
-  //----------------------------------------------------------------------------
-  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;
-//    }
-
-    // Check if event supports bubbling
-    const Event::Type types_no_bubbling[] = {
-      Event::MOUSE_ENTER,
-      Event::MOUSE_LEAVE,
-    };
-    const size_t num_types_no_bubbling = sizeof(types_no_bubbling)
-                                       / sizeof(types_no_bubbling[0]);
-    bool do_bubble = true;
-    for( size_t i = 0; i < num_types_no_bubbling; ++i )
-      if( event->type == types_no_bubbling[i] )
-      {
-        do_bubble = false;
-        break;
-      }
-
-    // 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 ) //&& 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;
-      }
-
-      event->current_target = el;
-      el->handleEvent(event);
-
-      if( event->propagation_stopped || !do_bubble )
-        return true;
-    }
-
-    return true;
-  }
-
   //----------------------------------------------------------------------------
   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;
+    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,11 +72,20 @@ 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)
        */
@@ -79,16 +98,13 @@ namespace canvas
       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,16 +29,12 @@ namespace canvas
   //----------------------------------------------------------------------------
   EventVisitor::EventVisitor( TraverseMode mode,
                               const osg::Vec2f& pos,
-                              const osg::Vec2f& delta,
                               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) );
   }
 
   //----------------------------------------------------------------------------
@@ -63,31 +58,18 @@ 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 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(pos, local_pos) )
+      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]
-      );
-
-      EventTarget target = {el.getWeakPtr(), local_pos, local_delta};
-      _target_path.push_back(target);
+      _target_path.push_back( EventTarget(&el, local_pos) );
 
       if( el.traverse(*this) || &el == _root.get() )
         return true;

simgear/canvas/CanvasEventVisitor.hxx

@@ -42,12 +42,10 @@ namespace canvas
        *
        * @param mode
        * @param pos     Mouse position
-       * @param delta   Mouse movement since last mouse move event
        * @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);

simgear/canvas/CanvasMgr.cxx

@@ -45,25 +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);
+    CanvasPtr canvas = static_cast<Canvas*>(element.get());
     canvas->setCanvasMgr(this);
   }
 

simgear/canvas/CanvasMgr.hxx

@@ -33,7 +33,7 @@ namespace canvas
     public:
 
       /**
-       * @param node            Root node of branch used to control canvasses
+       * @param node    Root node of branch used to control canvasses
        */
       CanvasMgr(SGPropertyNode_ptr node);
 

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

@@ -21,8 +21,11 @@
 
 #include "canvas_fwd.hxx"
 
+class SGSubsystem;
+
 namespace simgear
 {
+namespace HTTP { class Client; }
 namespace canvas
 {
 
@@ -35,6 +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 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/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,9 +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(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)
 
@@ -60,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&,

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

@@ -17,8 +17,9 @@
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
 #include "CanvasElement.hxx"
+#include <simgear/canvas/Canvas.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>
@@ -49,15 +50,50 @@ namespace canvas
   {
     public:
 
-      ReferenceFrame    _coord_reference;
-      osg::Matrix       _parent_inverse;
+      ReferenceFrame                _coord_reference;
+      osg::observer_ptr<osg::Node>  _node;
 
-      RelativeScissor():
-        _coord_reference(GLOBAL)
+      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();
@@ -73,17 +109,28 @@ namespace canvas
 
         if( _coord_reference != GLOBAL )
         {
-          model_view.preMult(state.getModelViewMatrix());
+          osg::Node* ref_obj = _node.get();
 
           if( _coord_reference == PARENT )
-            model_view.preMult(_parent_inverse);
+          {
+            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),
@@ -96,6 +143,26 @@ namespace canvas
 
         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;
+      }
   };
 
   //----------------------------------------------------------------------------
@@ -123,17 +190,6 @@ namespace canvas
     }
   }
 
-  //----------------------------------------------------------------------------
-  void Element::setSelf(const PropertyBasedElementPtr& self)
-  {
-    PropertyBasedElement::setSelf(self);
-
-    _transform->setUserData
-    (
-      new OSGUserData(boost::static_pointer_cast<Element>(self))
-    );
-  }
-
   //----------------------------------------------------------------------------
   void Element::onDestroy()
   {
@@ -146,101 +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;
   }
 
   //----------------------------------------------------------------------------
-  ElementPtr Element::getParent()
+  CanvasWeakPtr Element::getCanvas() const
   {
-    return _parent ? _parent->getWeakPtr().lock() : ElementPtr();
+    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;
-      _attributes_dirty |= SCISSOR_COORDS;
-    }
-
-    if( _attributes_dirty & SCISSOR_COORDS )
-    {
-      if( _scissor && _scissor->_coord_reference != GLOBAL )
-        _scissor->_parent_inverse = _transform->getInverseMatrix();
-
-      _attributes_dirty &= ~SCISSOR_COORDS;
-    }
+    // 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(),
@@ -266,17 +262,7 @@ namespace canvas
       "addEventListener(" << _node->getPath() << ", " << type_str << ")"
     );
 
-    Event::Type type = Event::strToType(type_str);
-    if( type == Event::UNKNOWN )
-    {
-      SG_LOG( SG_GENERAL,
-              SG_WARN,
-              "addEventListener: Unknown event type " << type_str );
-      return false;
-    }
-
-    _listener[ type ].push_back(cb);
-
+    _listener[ Event::getOrRegisterType(type_str) ].push_back(cb);
     return true;
   }
 
@@ -310,30 +296,74 @@ 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(EventListener const& listener, listeners->second)
-      listener(event);
+      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);
   }
 
   //----------------------------------------------------------------------------
@@ -354,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)
   {
@@ -364,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
@@ -385,7 +427,7 @@ namespace canvas
       else if( name == "s" )
         type = TT_SCALE;
 
-      _transform_dirty = true;
+      _attributes_dirty |= TRANSFORM;
       return;
     }
 
@@ -418,7 +460,7 @@ namespace canvas
         while( !_transform_types.empty() && _transform_types.back() == TT_NONE )
           _transform_types.pop_back();
 
-        _transform_dirty = true;
+        _attributes_dirty |= TRANSFORM;
         return;
       }
       else if( StyleInfo const* style = getStyleInfo(child->getNameString()) )
@@ -438,7 +480,9 @@ namespace canvas
     if( parent == _node )
     {
       const std::string& name = child->getNameString();
-      if( StyleInfo const* style_info = getStyleInfo(name) )
+      if( boost::starts_with(name, "data-") )
+        return;
+      else if( StyleInfo const* style_info = getStyleInfo(name) )
       {
         SGPropertyNode const* style = child;
         if( isStyleEmpty(child) )
@@ -451,16 +495,14 @@ namespace canvas
       }
       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;
     }
 
@@ -477,9 +519,13 @@ namespace canvas
   //----------------------------------------------------------------------------
   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;
     }
@@ -526,47 +572,49 @@ namespace canvas
       return;
     }
 
-    _scissor = new RelativeScissor();
+    if( !_scissor )
+      _scissor = new RelativeScissor(_transform.get());
+
     // <top>, <right>, <bottom>, <left>
     _scissor->x() = SGMiscf::roundToInt(values[3]);
     _scissor->y() = SGMiscf::roundToInt(values[0]);
     _scissor->width() = SGMiscf::roundToInt(width);
     _scissor->height() = SGMiscf::roundToInt(height);
 
-    getOrCreateStateSet()->setAttributeAndModes(_scissor);
-
     SGPropertyNode* clip_frame = _node->getChild("clip-frame", 0);
     if( clip_frame )
       valueChanged(clip_frame);
+    else
+      _scissor->_coord_reference = GLOBAL;
+
+    ss->setAttributeAndModes(_scissor);
   }
 
   //----------------------------------------------------------------------------
   void Element::setClipFrame(ReferenceFrame rf)
   {
     if( _scissor )
-    {
       _scissor->_coord_reference = rf;
-      _attributes_dirty |= SCISSOR_COORDS;
-    }
   }
 
   //----------------------------------------------------------------------------
-  void Element::setBoundingBox(const osg::BoundingBox& bb)
+  osg::BoundingBox Element::getBoundingBox() const
   {
-    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( _drawable )
+      return _drawable->getBound();
 
-    _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 bb;
+
+    if( _transform.valid() )
+      bb.expandBy(_transform->getBound());
+
+    return bb;
+  }
+
+  //----------------------------------------------------------------------------
+  osg::BoundingBox Element::getTightBoundingBox() const
+  {
+    return getTransformedBounds(getMatrix());
   }
 
   //----------------------------------------------------------------------------
@@ -583,6 +631,75 @@ namespace canvas
     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;
 
@@ -595,7 +712,6 @@ namespace canvas
     _canvas( canvas ),
     _parent( parent ),
     _attributes_dirty( 0 ),
-    _transform_dirty( false ),
     _transform( new osg::MatrixTransform ),
     _style( parent_style ),
     _scissor( 0 ),
@@ -618,6 +734,8 @@ namespace canvas
                 "PreOrderBin",
                 osg::StateSet::OVERRIDE_RENDERBIN_DETAILS
               );
+
+    _transform->setUserData( new OSGUserData(this) );
   }
 
   //----------------------------------------------------------------------------
@@ -628,6 +746,7 @@ namespace canvas
 
     addStyle("clip", "", &Element::setClip, false);
     addStyle("clip-frame", "", &Element::setClipFrame, false);
+    addStyle("visible", "", &Element::setVisible, false);
   }
 
   //----------------------------------------------------------------------------
@@ -713,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>
 //
@@ -41,6 +41,9 @@ namespace simgear
 namespace canvas
 {
 
+  /**
+   * Baseclass for Elements displayed inside a Canvas.
+   */
   class Element:
     public PropertyBasedElement
   {
@@ -69,10 +72,10 @@ namespace canvas
       };
       struct StyleInfo
       {
-        StyleSetter setter; ///!< Function(s) for setting this style
-        std::string type;   ///!< Interpolation type
-        bool inheritable;   ///!< Whether children can inherit this style from
-                            ///   their parents
+        StyleSetter setter; ///< Function(s) for setting this style
+        std::string type;   ///< Interpolation type
+        bool inheritable;   ///< Whether children can inherit this style from
+                            ///  their parents
       };
 
       /**
@@ -80,22 +83,20 @@ namespace canvas
        */
       enum ReferenceFrame
       {
-        GLOBAL, ///!< Global coordinates
-        PARENT, ///!< Coordinates relative to parent coordinate frame
-        LOCAL   ///!< Coordinates relative to local coordinates (parent
-                ///   coordinates with local transformations applied)
+        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();
+      ElementPtr getParent() const;
+      CanvasWeakPtr getCanvas() const;
 
       /**
        * Called every frame to update internal state
@@ -111,20 +112,37 @@ namespace canvas
       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,
@@ -148,15 +166,27 @@ namespace canvas
       void setClipFrame(ReferenceFrame rf);
 
       /**
-       * Write the given bounding box to the property tree
+       * Get bounding box (may not be as tight as bounding box returned by
+       * #getTightBoundingBox)
        */
-      void setBoundingBox(const osg::BoundingBox& bb);
+      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
        *
@@ -169,21 +199,19 @@ 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      = 1,
-        SCISSOR_COORDS  = BLEND_FUNC << 1,
-        LAST_ATTRIBUTE  = SCISSOR_COORDS << 1
+        TRANSFORM       = 1,
+        BLEND_FUNC      = TRANSFORM << 1,
+        LAST_ATTRIBUTE  = BLEND_FUNC << 1
       };
 
       enum TransformType
@@ -200,23 +228,21 @@ namespace canvas
       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;
-      RelativeScissor                  *_scissor;
+      Style             _style;
+      RelativeScissor  *_scissor;
 
       typedef std::vector<EventListener> Listener;
-      typedef std::map<Event::Type, Listener> ListenerMap;
+      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();
 

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>
@@ -146,7 +146,7 @@ namespace canvas
       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);
     }
@@ -320,10 +320,12 @@ namespace canvas
   //----------------------------------------------------------------------------
   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());
   }
 
   //----------------------------------------------------------------------------

simgear/canvas/elements/CanvasGroup.hxx

@@ -56,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() );
       }
 
       /**

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
@@ -96,9 +96,10 @@ namespace canvas
       return;
 
     addStyle("fill", "color", &Image::setFill);
+    addStyle("outset", "", &Image::setOutset);
+    addStyle("preserveAspectRatio", "", &Image::setPreserveAspectRatio);
     addStyle("slice", "", &Image::setSlice);
     addStyle("slice-width", "", &Image::setSliceWidth);
-    addStyle("outset", "", &Image::setOutset);
   }
 
   //----------------------------------------------------------------------------
@@ -128,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);
@@ -149,7 +149,8 @@ namespace canvas
   //----------------------------------------------------------------------------
   Image::~Image()
   {
-
+    if( _http_request )
+      _http_request->abort("image destroyed");
   }
 
   //----------------------------------------------------------------------------
@@ -214,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
       {
@@ -272,7 +277,6 @@ namespace canvas
       _vertices->dirty();
       _attributes_dirty &= ~DEST_SIZE;
       _geom->dirtyBound();
-      setBoundingBox(_geom->getBound());
     }
 
     if( _attributes_dirty & SRC_RECT )
@@ -291,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
@@ -414,6 +478,20 @@ namespace canvas
     _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)
   {
@@ -428,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
   {
@@ -442,7 +513,7 @@ namespace canvas
   }
 
   //----------------------------------------------------------------------------
-  bool Image::handleEvent(EventPtr event)
+  bool Image::handleEvent(const EventPtr& event)
   {
     bool handled = Element::handleEvent(event);
 
@@ -450,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());
@@ -474,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;
   }
 
   //----------------------------------------------------------------------------
@@ -521,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 )
         {
@@ -545,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);
@@ -563,6 +656,16 @@ 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) );
@@ -638,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
 {
 
@@ -59,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)
        *
@@ -77,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:
 
@@ -103,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;
@@ -117,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/CanvasPath.cxx

@@ -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:

simgear/canvas/elements/CanvasText.cxx

@@ -40,6 +40,7 @@ namespace canvas
       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;
@@ -95,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)
   {
@@ -179,18 +455,17 @@ namespace canvas
   osg::BoundingBox Text::TextOSG::computeBound() const
   {
     osg::BoundingBox bb = osgText::Text::computeBound();
-    if( !bb.valid() )
-      return bb;
 
 #if 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( 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;
   }
 
@@ -370,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

@@ -46,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

@@ -1,6 +1,6 @@
-// Wrapper class for keeping Nasal objects save from the garbage collector
+// Canvas user defined event
 //
-// Copyright (C) 2013  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,36 +16,40 @@
 // 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 "NasalObjectHolder.hxx"
-#include <simgear/nasal/nasal.h>
+#include "CustomEvent.hxx"
 
-namespace nasal
+namespace simgear
+{
+namespace canvas
 {
 
   //----------------------------------------------------------------------------
-  ObjectHolder::~ObjectHolder()
+  CustomEvent::CustomEvent( std::string const& type_str,
+                            bool bubbles,
+                            StringMap const& data ):
+    detail(data),
+    bubbles(bubbles)
   {
-    naGCRelease(_gc_key);
+    type = getOrRegisterType(type_str);
   }
 
   //----------------------------------------------------------------------------
-  naRef ObjectHolder::get_naRef() const
+  CustomEvent::CustomEvent( int type_id,
+                            bool bubbles,
+                            StringMap const& data ):
+    detail(data),
+    bubbles(bubbles)
   {
-    return _ref;
+    type = type_id;
+//    TypeMap::map_by<id>::type const& type_map = getTypeMap().by<id>();
+//    assert( type_map.find(type_id) != type_map.end() );
   }
 
   //----------------------------------------------------------------------------
-  ObjectHolderRef ObjectHolder::makeShared(naRef obj)
+  void CustomEvent::setDetail(StringMap const& data)
   {
-    return new ObjectHolder(obj);
+    detail = data;
   }
 
-  //----------------------------------------------------------------------------
-  ObjectHolder::ObjectHolder(naRef obj):
-    _ref(obj),
-    _gc_key(naGCSave(obj))
-  {
-
-  }
-
-} // namespace nasal
+} // 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

@@ -0,0 +1,70 @@
+// Mouse 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 "MouseEvent.hxx"
+
+namespace simgear
+{
+namespace canvas
+{
+
+  //----------------------------------------------------------------------------
+  MouseEvent::MouseEvent():
+    button(0),
+    buttons(0),
+    modifiers(0),
+    click_count(0)
+  {
+
+  }
+
+  //----------------------------------------------------------------------------
+  MouseEvent::MouseEvent(const osgGA::GUIEventAdapter& ea):
+    button(0),
+    buttons(ea.getButtonMask()),
+    modifiers(ea.getModKeyMask()),
+    click_count(0)
+  {
+    time = ea.getTime();
+
+    // Convert button mask to index
+    int button_mask = ea.getButton();
+    while( (button_mask >>= 1) > 0 )
+      button += 1;
+  }
+
+  //----------------------------------------------------------------------------
+  bool MouseEvent::canBubble() const
+  {
+    // Check if event supports bubbling
+    const Event::Type types_no_bubbling[] = {
+      Event::MOUSE_ENTER,
+      Event::MOUSE_LEAVE,
+    };
+    const size_t num_types_no_bubbling = sizeof(types_no_bubbling)
+                                       / sizeof(types_no_bubbling[0]);
+
+    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

@@ -0,0 +1,43 @@
+///@file 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
+
+#ifndef SG_CANVAS_SPACER_ITEM_HXX_
+#define SG_CANVAS_SPACER_ITEM_HXX_
+
+#include "LayoutItem.hxx"
+
+namespace simgear
+{
+namespace canvas
+{
+  /**
+   * Element for providing blank space in a layout.
+   */
+  class SpacerItem:
+    public LayoutItem
+  {
+    public:
+      SpacerItem( const SGVec2i& size = SGVec2i(0, 0),
+                  const SGVec2i& max_size = MAX_SIZE );
+
+  };
+
+} // namespace canvas
+} // namespace simgear
+
+#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/debug/debug_types.h

@@ -31,7 +31,8 @@ typedef enum {
     SG_ENVIRONMENT = 0x00100000,
     SG_SOUND       = 0x00200000,
     SG_NAVAID      = 0x00400000,
-    SG_UNDEFD      = 0x00800000, // For range checking
+    SG_GUI         = 0x00800000,
+    SG_UNDEFD      = 0x01000000, // For range checking
 
     SG_ALL         = 0xFFFFFFFF
 } sgDebugClass;

simgear/debug/logstream.cxx

@@ -70,6 +70,7 @@ const char* debugClassToString(sgDebugClass c)
     case SG_ENVIRONMENT:return "environment";
     case SG_SOUND:      return "sound";
     case SG_NAVAID:     return "navaid";
+    case SG_GUI:        return "gui";
     default:            return "unknown";
     }
 }
@@ -438,4 +439,4 @@ void requestConsole()
 	global_privateLogstream->requestConsole();
 }
 
-} // of namespace simgear 
+} // of namespace simgear

simgear/io/HTTPClient.cxx

@@ -122,27 +122,28 @@ public:
     // socket-level errors
     virtual void handleError(int error)
     {
-        if (error == ENOENT) {
-        // name lookup failure
-            // we won't have an active request yet, so the logic below won't
-            // fire to actually call setFailure. Let's fail all of the requests
+        const char* errStr = strerror(error);
+        if (!activeRequest)
+        {
+        // connection level failure, eg name lookup or routing
+        // we won't have an active request yet, so let's fail all of the
+        // requests since we presume it's a systematic failure for
+        // the host in question
             BOOST_FOREACH(Request_ptr req, sentRequests) {
-                req->setFailure(error, "hostname lookup failure");
+                req->setFailure(error, errStr);
             }
             
             BOOST_FOREACH(Request_ptr req, queuedRequests) {
-                req->setFailure(error, "hostname lookup failure");
+                req->setFailure(error, errStr);
             }
             
-        // name lookup failure, abandon all requests on this connection
             sentRequests.clear();
             queuedRequests.clear();
         }
         
         NetChat::handleError(error);
         if (activeRequest) {            
-            SG_LOG(SG_IO, SG_INFO, "HTTP socket error");
-            activeRequest->setFailure(error, "socket error");
+            activeRequest->setFailure(error, errStr);
             activeRequest = NULL;
             _contentDecoder.reset();
         }
@@ -252,6 +253,7 @@ public:
       
       if (state == STATE_CLOSED) {
           if (!connectToHost()) {
+            
               return;
           }
           

simgear/io/HTTPRequest.cxx

@@ -39,7 +39,7 @@ Request* Request::done(const Callback& cb)
   if( _ready_state == DONE )
     cb(this);
   else
-    _cb_done = cb;
+    _cb_done.push_back(cb);
 
   return this;
 }
@@ -50,7 +50,7 @@ Request* Request::fail(const Callback& cb)
   if( _ready_state == FAILED )
     cb(this);
   else
-    _cb_fail = cb;
+    _cb_fail.push_back(cb);
 
   return this;
 }
@@ -61,7 +61,7 @@ Request* Request::always(const Callback& cb)
   if( isComplete() )
     cb(this);
   else
-    _cb_always = cb;
+    _cb_always.push_back(cb);
 
   return this;
 }
@@ -272,6 +272,16 @@ std::string Request::hostAndPort() const
   return u.substr(schemeEnd + 3, hostEnd - (schemeEnd + 3));
 }
 
+//------------------------------------------------------------------------------
+std::string Request::responseMime() const
+{
+  std::string content_type = _responseHeaders.get("content-type");
+  if( content_type.empty() )
+    return "application/octet-stream";
+
+  return content_type.substr(0, content_type.find(';'));
+}
+
 //------------------------------------------------------------------------------
 void Request::setResponseLength(unsigned int l)
 {
@@ -294,7 +304,9 @@ void Request::setFailure(int code, const std::string& reason)
 {
   _responseStatus = code;
   _responseReason = reason;
-  setReadyState(FAILED);
+
+  if( !isComplete() )
+    setReadyState(FAILED);
 }
 
 //------------------------------------------------------------------------------
@@ -309,22 +321,19 @@ void Request::setReadyState(ReadyState state)
     onDone();
     onAlways();
 
-    if( _cb_done )
-      _cb_done(this);
+    _cb_done(this);
   }
   else if( state == FAILED )
   {
     onFail();
     onAlways();
 
-    if( _cb_fail )
-      _cb_fail(this);
+    _cb_fail(this);
   }
   else
     return;
 
-  if( _cb_always )
-    _cb_always(this);
+  _cb_always(this);
 }
 
 //------------------------------------------------------------------------------
@@ -336,9 +345,6 @@ void Request::abort()
 //----------------------------------------------------------------------------
 void Request::abort(const std::string& reason)
 {
-  if( isComplete() )
-    return;
-
   setFailure(-1, reason);
   _willClose = true;
 }

simgear/io/HTTPRequest.hxx

@@ -3,12 +3,13 @@
 
 #include <map>
 
+#include <simgear/structure/function_list.hxx>
 #include <simgear/structure/map.hxx>
 #include <simgear/structure/SGReferenced.hxx>
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/math/sg_types.hxx>
 
-#include <boost/function.hpp>
+#include <boost/bind.hpp>
 
 class SGPropertyNode;
 
@@ -46,15 +47,21 @@ public:
                                             { return _request_headers.get(key); }
 
     /**
-     * Set the handler to be called when the request successfully completes.
+     * Add a handler to be called when the request successfully completes.
      *
      * @note If the request is already complete, the handler is called
      *       immediately.
      */
     Request* done(const Callback& cb);
 
+    template<class C>
+    Request* done(C* instance, void (C::*mem_func)(Request*))
+    {
+      return done(boost::bind(mem_func, instance, _1));
+    }
+
     /**
-     * Set the handler to be called when the request completes or aborts with an
+     * Add a handler to be called when the request completes or aborts with an
      * error.
      *
      * @note If the request has already failed, the handler is called
@@ -62,15 +69,27 @@ public:
      */
     Request* fail(const Callback& cb);
 
+    template<class C>
+    Request* fail(C* instance, void (C::*mem_func)(Request*))
+    {
+      return fail(boost::bind(mem_func, instance, _1));
+    }
+
     /**
-     * Set the handler to be called when the request either successfully
-     * completes or fails.
+     * Add a handler to be called when the request either successfully completes
+     * or fails.
      *
      * @note If the request is already complete or has already failed, the
      *       handler is called immediately.
      */
     Request* always(const Callback& cb);
 
+    template<class C>
+    Request* always(C* instance, void (C::*mem_func)(Request*))
+    {
+      return always(boost::bind(mem_func, instance, _1));
+    }
+
     /**
      * Set the data for the body of the request. The request is automatically
      * send using the POST method.
@@ -99,6 +118,8 @@ public:
     StringMap const& responseHeaders() const
         { return _responseHeaders; }
 
+    std::string responseMime() const;
+
     virtual int responseCode() const
         { return _responseStatus; }
         
@@ -203,9 +224,9 @@ private:
     unsigned int  _responseLength;
     unsigned int  _receivedBodyBytes;
 
-    Callback      _cb_done,
-                  _cb_fail,
-                  _cb_always;
+    function_list<Callback> _cb_done,
+                            _cb_fail,
+                            _cb_always;
 
     ReadyState    _ready_state;
     bool          _willClose;

simgear/io/SVNDirectory.cxx

@@ -319,7 +319,6 @@ void SVNDirectory::mergeUpdateReportDetails(unsigned int depth,
     
     Dir d(localPath);
     if (depth >= MAX_UPDATE_REPORT_DEPTH) {
-        SG_LOG(SG_IO, SG_INFO, localPath << "exceeded MAX_UPDATE_REPORT_DEPTH, cleaning");
         d.removeChildren();
         return;
     }

simgear/io/SVNReportParser.cxx

@@ -377,8 +377,9 @@ public:
     memset(&md5Context, 0, sizeof(SG_MD5_CTX));
     SG_MD5Init(&md5Context);
     SG_MD5Update(&md5Context, (unsigned char*) output.data(), output.size());
-    SG_MD5Final(&md5Context);
-    decodedFileMd5 = strutils::encodeHex(md5Context.digest, 16);
+    unsigned char digest[MD5_DIGEST_LENGTH];
+    SG_MD5Final(digest, &md5Context);
+    decodedFileMd5 = strutils::encodeHex(digest, MD5_DIGEST_LENGTH);
 
     return true;
   }

simgear/io/decode_binobj.cxx

@@ -82,9 +82,9 @@ int main( int argc, char **argv ) {
     group_list pts_v = obj.get_pts_v();
     group_list pts_n = obj.get_pts_n();
     for ( i = 0; i < (int)pts_v.size(); ++i ) {
-	material = pt_materials[i];
-	vertex_index = pts_v[i];
-	normal_index = pts_n[i];
+        material = pt_materials[i];
+        vertex_index = pts_v[i];
+        normal_index = pts_n[i];
         cout << "# usemtl " << material << endl;
         cout << "pt ";
         for ( j = 0; j < (int)vertex_index.size(); ++j ) {
@@ -97,12 +97,12 @@ int main( int argc, char **argv ) {
     string_list tri_materials = obj.get_tri_materials();
     group_list tris_v = obj.get_tris_v();
     group_list tris_n = obj.get_tris_n();
-    group_list tris_tc = obj.get_tris_tc();
+    group_tci_list tris_tc = obj.get_tris_tcs();
     for ( i = 0; i < (int)tris_v.size(); ++i ) {
-	material = tri_materials[i];
-	vertex_index = tris_v[i];
-	normal_index = tris_n[i];
-	tex_index = tris_tc[i];
+        material = tri_materials[i];
+        vertex_index = tris_v[i];
+        normal_index = tris_n[i];
+        tex_index = tris_tc[0][i];
         cout << "# usemtl " << material << endl;
         cout << "f ";
         for ( j = 0; j < (int)vertex_index.size(); ++j ) {
@@ -120,12 +120,12 @@ int main( int argc, char **argv ) {
     string_list strip_materials = obj.get_strip_materials();
     group_list strips_v = obj.get_strips_v();
     group_list strips_n = obj.get_strips_n();
-    group_list strips_tc = obj.get_strips_tc();
+    group_tci_list strips_tc = obj.get_strips_tcs();
     for ( i = 0; i < (int)strips_v.size(); ++i ) {
-	material = strip_materials[i];
-	vertex_index = strips_v[i];
-	normal_index = strips_n[i];
-	tex_index = strips_tc[i];
+        material = strip_materials[i];
+        vertex_index = strips_v[i];
+        normal_index = strips_n[i];
+        tex_index = strips_tc[0][i];
         cout << "# usemtl " << material << endl;
         cout << "ts ";
         for ( j = 0; j < (int)vertex_index.size(); ++j ) {
@@ -142,12 +142,12 @@ int main( int argc, char **argv ) {
     string_list fan_materials = obj.get_fan_materials();
     group_list fans_v = obj.get_fans_v();
     group_list fans_n = obj.get_fans_n();
-    group_list fans_tc = obj.get_fans_tc();
+    group_tci_list fans_tc = obj.get_fans_tcs();
     for ( i = 0; i < (int)fans_v.size(); ++i ) {
-	material = fan_materials[i];
-	vertex_index = fans_v[i];
-	normal_index = fans_n[i];
-	tex_index = fans_tc[i];
+        material = fan_materials[i];
+        vertex_index = fans_v[i];
+        normal_index = fans_n[i];
+        tex_index = fans_tc[0][i];
         cout << "# usemtl " << material << endl;
         cout << "tf ";
         for ( j = 0; j < (int)vertex_index.size(); ++j ) {

simgear/io/sg_binobj.cxx

@@ -58,9 +58,11 @@ enum sgObjectTypes {
     SG_BOUNDING_SPHERE = 0,
 
     SG_VERTEX_LIST = 1,
-    SG_COLOR_LIST = 4,
     SG_NORMAL_LIST = 2,
     SG_TEXCOORD_LIST = 3,
+    SG_COLOR_LIST = 4,
+    SG_VA_FLOAT_LIST = 5,
+    SG_VA_INTEGER_LIST = 6,
 
     SG_POINTS = 9,
 
@@ -70,15 +72,32 @@ enum sgObjectTypes {
 };
 
 enum sgIndexTypes {
-    SG_IDX_VERTICES =  0x01,
-    SG_IDX_NORMALS =   0x02,
-    SG_IDX_COLORS =    0x04,
-    SG_IDX_TEXCOORDS = 0x08
+    SG_IDX_VERTICES =    0x01,
+    SG_IDX_NORMALS =     0x02,
+    SG_IDX_COLORS =      0x04,
+    SG_IDX_TEXCOORDS_0 = 0x08,
+    SG_IDX_TEXCOORDS_1 = 0x10,
+    SG_IDX_TEXCOORDS_2 = 0x20,
+    SG_IDX_TEXCOORDS_3 = 0x40,
+};
+
+enum sgVertexAttributeTypes {
+    // vertex attributes
+    SG_VA_INTEGER_0 = 0x00000001,
+    SG_VA_INTEGER_1 = 0x00000002,
+    SG_VA_INTEGER_2 = 0x00000004,
+    SG_VA_INTEGER_3 = 0x00000008,
+
+    SG_VA_FLOAT_0 =   0x00000100,
+    SG_VA_FLOAT_1 =   0x00000200,
+    SG_VA_FLOAT_2 =   0x00000400,
+    SG_VA_FLOAT_3 =   0x00000800,
 };
 
 enum sgPropertyTypes {
     SG_MATERIAL = 0,
-    SG_INDEX_TYPES = 1
+    SG_INDEX_TYPES = 1,
+    SG_VERT_ATTRIBS = 2
 };
 
 
@@ -130,6 +149,17 @@ public:
         }
     }
     
+    float readInt()
+    {
+        unsigned int* p = reinterpret_cast<unsigned int*>(ptr + offset);
+        if ( sgIsBigEndian() ) {            
+            sgEndianSwap((uint32_t *) p);
+        }
+        
+        offset += sizeof(unsigned int);
+        return *p;
+    }
+    
     SGVec3d readVec3d()
     {
         double* p = reinterpret_cast<double*>(ptr + offset);
@@ -202,15 +232,19 @@ template <class T>
 static void read_indices(char* buffer, 
                          size_t bytes,
                          int indexMask,
+                         int vaMask,
                          int_list& vertices, 
                          int_list& normals,
                          int_list& colors,
-                         int_list& texCoords)
+                         tci_list& texCoords,
+                         vai_list& vas
+                        )
 {
-    const int indexSize = sizeof(T) * std::bitset<32>(indexMask).count();
-    const int count = bytes / indexSize;
+    const int indexSize = sizeof(T) * std::bitset<32>((int)indexMask).count();
+    const int vaSize = sizeof(T) * std::bitset<32>((int)vaMask).count();
+    const int count = bytes / (indexSize + vaSize);
     
-// fix endian-ness of the whole lot, if required
+    // fix endian-ness of the whole lot, if required
     if (sgIsBigEndian()) {
         int indices = bytes / sizeof(T);
         T* src = reinterpret_cast<T*>(buffer);
@@ -224,7 +258,21 @@ static void read_indices(char* buffer,
         if (indexMask & SG_IDX_VERTICES) vertices.push_back(*src++);
         if (indexMask & SG_IDX_NORMALS) normals.push_back(*src++);
         if (indexMask & SG_IDX_COLORS) colors.push_back(*src++);
-        if (indexMask & SG_IDX_TEXCOORDS) texCoords.push_back(*src++);
+        if (indexMask & SG_IDX_TEXCOORDS_0) texCoords[0].push_back(*src++);
+        if (indexMask & SG_IDX_TEXCOORDS_1) texCoords[1].push_back(*src++);
+        if (indexMask & SG_IDX_TEXCOORDS_2) texCoords[2].push_back(*src++);
+        if (indexMask & SG_IDX_TEXCOORDS_3) texCoords[3].push_back(*src++);
+        
+        if ( vaMask ) {
+            if (vaMask & SG_VA_INTEGER_0) vas[0].push_back(*src++);
+            if (vaMask & SG_VA_INTEGER_1) vas[1].push_back(*src++);
+            if (vaMask & SG_VA_INTEGER_2) vas[2].push_back(*src++);
+            if (vaMask & SG_VA_INTEGER_3) vas[3].push_back(*src++);
+            if (vaMask & SG_VA_FLOAT_0) vas[4].push_back(*src++);
+            if (vaMask & SG_VA_FLOAT_1) vas[5].push_back(*src++);
+            if (vaMask & SG_VA_FLOAT_2) vas[6].push_back(*src++);
+            if (vaMask & SG_VA_FLOAT_3) vas[7].push_back(*src++);
+        }
     } // of elements in the index
 }
 
@@ -249,15 +297,19 @@ void write_indice(gzFile fp, uint32_t value)
 
 
 template <class T>
-void write_indices(gzFile fp, unsigned char indexMask, 
+void write_indices(gzFile fp, 
+    unsigned char indexMask, 
+    unsigned int vaMask,
     const int_list& vertices, 
     const int_list& normals, 
     const int_list& colors,
-    const int_list& texCoords)
+    const tci_list& texCoords,
+    const vai_list& vas )
 {
     unsigned int count = vertices.size();
-    const int indexSize = sizeof(T) * std::bitset<32>(indexMask).count();
-    sgWriteUInt(fp, indexSize * count);
+    const int indexSize = sizeof(T) * std::bitset<32>((int)indexMask).count();
+    const int vaSize = sizeof(T) * std::bitset<32>((int)vaMask).count();
+    sgWriteUInt(fp, (indexSize + vaSize) * count);
             
     for (unsigned int i=0; i < count; ++i) {
         write_indice(fp, static_cast<T>(vertices[i]));
@@ -268,8 +320,45 @@ void write_indices(gzFile fp, unsigned char indexMask,
         if (indexMask & SG_IDX_COLORS) {
             write_indice(fp, static_cast<T>(colors[i]));
         }
-        if (indexMask & SG_IDX_TEXCOORDS) {
-            write_indice(fp, static_cast<T>(texCoords[i]));
+        if (indexMask & SG_IDX_TEXCOORDS_0) {
+            write_indice(fp, static_cast<T>(texCoords[0][i]));
+        }
+        if (indexMask & SG_IDX_TEXCOORDS_1) {
+            write_indice(fp, static_cast<T>(texCoords[1][i]));
+        }
+        if (indexMask & SG_IDX_TEXCOORDS_2) {
+            write_indice(fp, static_cast<T>(texCoords[2][i]));
+        }
+        if (indexMask & SG_IDX_TEXCOORDS_3) {
+            write_indice(fp, static_cast<T>(texCoords[3][i]));
+        }
+        
+        if (vaMask) {
+            if (vaMask & SG_VA_INTEGER_0) {
+                write_indice(fp, static_cast<T>(vas[0][i]));
+            }
+            if (vaMask & SG_VA_INTEGER_1) {
+                write_indice(fp, static_cast<T>(vas[1][i]));
+            }
+            if (vaMask & SG_VA_INTEGER_2) {
+                write_indice(fp, static_cast<T>(vas[2][i]));
+            }
+            if (vaMask & SG_VA_INTEGER_3) {
+                write_indice(fp, static_cast<T>(vas[3][i]));
+            }
+
+            if (vaMask & SG_VA_FLOAT_0) {
+                write_indice(fp, static_cast<T>(vas[4][i]));
+            }
+            if (vaMask & SG_VA_FLOAT_1) {
+                write_indice(fp, static_cast<T>(vas[5][i]));
+            }
+            if (vaMask & SG_VA_FLOAT_2) {
+                write_indice(fp, static_cast<T>(vas[6][i]));
+            }
+            if (vaMask & SG_VA_FLOAT_3) {
+                write_indice(fp, static_cast<T>(vas[7][i]));
+            }
         }
     }
 }
@@ -281,13 +370,15 @@ void SGBinObject::read_object( gzFile fp,
                          int nproperties,
                          int nelements,
                          group_list& vertices, 
-                          group_list& normals,
-                          group_list& colors,
-                          group_list& texCoords,
-                          string_list& materials)
+                         group_list& normals,
+                         group_list& colors,
+                         group_tci_list& texCoords,
+                         group_vai_list& vertexAttribs,
+                         string_list& materials)
 {
-    unsigned int nbytes;
+    unsigned int  nbytes;
     unsigned char idx_mask;
+    unsigned int  vertex_attrib_mask;
     int j;
     sgSimpleBuffer buf( 32768 );  // 32 Kb
     char material[256];
@@ -296,26 +387,49 @@ void SGBinObject::read_object( gzFile fp,
     if ( obj_type == SG_POINTS ) {
         idx_mask = SG_IDX_VERTICES;
     } else {
-        idx_mask = (char)(SG_IDX_VERTICES | SG_IDX_TEXCOORDS);
+        idx_mask = (char)(SG_IDX_VERTICES | SG_IDX_TEXCOORDS_0);
     }
-
+    vertex_attrib_mask = 0;
+    
     for ( j = 0; j < nproperties; ++j ) {
         char prop_type;
         sgReadChar( fp, &prop_type );
         sgReadUInt( fp, &nbytes );
+        
         buf.resize(nbytes);
         char *ptr = buf.get_ptr();
-        sgReadBytes( fp, nbytes, ptr );
-        if ( prop_type == SG_MATERIAL ) {
-            if (nbytes > 255) {
-                nbytes = 255;
-            }
-            strncpy( material, ptr, nbytes );
-            material[nbytes] = '\0';
-            // cout << "material type = " << material << endl;
-        } else if ( prop_type == SG_INDEX_TYPES ) {
-            idx_mask = ptr[0];
-            //cout << std::hex << "index mask:" << idx_mask << std::dec << endl;
+        
+        switch( prop_type )
+        {
+            case SG_MATERIAL:
+                sgReadBytes( fp, nbytes, ptr );
+                if (nbytes > 255) {
+                    nbytes = 255;
+                }
+                strncpy( material, ptr, nbytes );
+                material[nbytes] = '\0';
+                break;
+                
+            case SG_INDEX_TYPES:
+                if (nbytes == 1) {
+                    sgReadChar( fp, (char *)&idx_mask );                    
+                } else {
+                    sgReadBytes( fp, nbytes, ptr );                    
+                }
+                break;
+
+            case SG_VERT_ATTRIBS:
+                if (nbytes == 4) {
+                    sgReadUInt( fp, &vertex_attrib_mask );
+                } else {
+                    sgReadBytes( fp, nbytes, ptr );
+                }
+                break;
+                
+            default:
+                sgReadBytes( fp, nbytes, ptr );
+                SG_LOG(SG_IO, SG_ALERT, "Found UNKNOWN property type with nbytes == " << nbytes << " mask is " << (int)idx_mask );
+                break;
         }
     }
 
@@ -323,7 +437,7 @@ void SGBinObject::read_object( gzFile fp,
         throw sg_exception("Error reading object properties");
     }
     
-    size_t indexCount = std::bitset<32>(idx_mask).count();
+    size_t indexCount = std::bitset<32>((int)idx_mask).count();
     if (indexCount == 0) {
         throw sg_exception("object index mask has no bits set");
     }
@@ -345,17 +459,20 @@ void SGBinObject::read_object( gzFile fp,
         int_list vs;
         int_list ns;
         int_list cs;
-        int_list tcs;
+        tci_list tcs;
+        vai_list vas;
+
         if (version >= 10) {
-            read_indices<uint32_t>(ptr, nbytes, idx_mask, vs, ns, cs, tcs);
+            read_indices<uint32_t>(ptr, nbytes, idx_mask, vertex_attrib_mask, vs, ns, cs, tcs, vas );
         } else {
-            read_indices<uint16_t>(ptr, nbytes, idx_mask, vs, ns, cs, tcs);
+            read_indices<uint16_t>(ptr, nbytes, idx_mask, vertex_attrib_mask, vs, ns, cs, tcs, vas );
         }
 
         vertices.push_back( vs );
         normals.push_back( ns );
         colors.push_back( cs );
         texCoords.push_back( tcs );
+        vertexAttribs.push_back( vas );
         materials.push_back( material );
     } // of element iteration
 }
@@ -380,25 +497,29 @@ bool SGBinObject::read_bin( const string& file ) {
     pts_v.clear();
     pts_n.clear();
     pts_c.clear();
-    pts_tc.clear();
+    pts_tcs.clear();
+    pts_vas.clear();
     pt_materials.clear();
 
     tris_v.clear();
     tris_n.clear();
     tris_c.clear();
-    tris_tc.clear();
+    tris_tcs.clear();
+    tris_vas.clear();
     tri_materials.clear();
 
     strips_v.clear();
     strips_n.clear();
     strips_c.clear();
-    strips_tc.clear();
+    strips_tcs.clear();
+    strips_vas.clear();
     strip_materials.clear();
 
     fans_v.clear();
     fans_n.clear();
     fans_c.clear();
-    fans_tc.clear();
+    fans_tcs.clear();
+    fans_vas.clear();
     fan_materials.clear();
 
     gzFile fp;
@@ -419,10 +540,9 @@ bool SGBinObject::read_bin( const string& file ) {
     sgReadUInt( fp, &header );
     if ( ((header & 0xFF000000) >> 24) == 'S' &&
          ((header & 0x00FF0000) >> 16) == 'G' ) {
-        // cout << "Good header" << endl;
+    
         // read file version
         version = (header & 0x0000FFFF);
-        // cout << "File version = " << version << endl;
     } else {
         // close the file before we return
         gzclose(fp);
@@ -460,7 +580,7 @@ bool SGBinObject::read_bin( const string& file ) {
         nobjects = v;
     }
      
-     //cout << "Total objects to read = " << nobjects << endl;
+    SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin Total objects to read = " << nobjects);
 
     if ( sgReadError() ) {
         throw sg_io_exception("Error reading BTG file header", sg_location(file));
@@ -489,9 +609,10 @@ bool SGBinObject::read_bin( const string& file ) {
             nelements = v;
         }
 
-         //cout << "object " << i << " = " << (int)obj_type << " props = "
-         //     << nproperties << " elements = " << nelements << endl;
-            
+        SG_LOG(SG_IO, SG_DEBUG, "SGBinObject::read_bin object " << i << 
+                " = " << (int)obj_type << " props = " << nproperties << 
+                " elements = " << nelements);
+         
         if ( obj_type == SG_BOUNDING_SPHERE ) {
             // read bounding sphere properties
             read_properties( fp, nproperties );
@@ -521,7 +642,7 @@ bool SGBinObject::read_bin( const string& file ) {
                 wgs84_nodes.reserve( count );
                 for ( k = 0; k < count; ++k ) {
                     SGVec3f v = buf.readVec3f();
-                // extend from float to double, hmmm
+                    // extend from float to double, hmmm
                     wgs84_nodes.push_back( SGVec3d(v[0], v[1], v[2]) );
                 }
             }
@@ -581,23 +702,60 @@ bool SGBinObject::read_bin( const string& file ) {
                     texcoords.push_back( buf.readVec2f() );
                 }
             }
+        } else if ( obj_type == SG_VA_FLOAT_LIST ) {
+            // read vertex attribute (float) properties
+            read_properties( fp, nproperties );
+            
+            // read vertex attribute list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(float));
+                va_flt.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    va_flt.push_back( buf.readFloat() );
+                }
+            }
+        } else if ( obj_type == SG_VA_INTEGER_LIST ) {
+            // read vertex attribute (integer) properties
+            read_properties( fp, nproperties );
+            
+            // read vertex attribute list elements
+            for ( j = 0; j < nelements; ++j ) {
+                sgReadUInt( fp, &nbytes );
+                buf.resize( nbytes );
+                buf.reset();
+                char *ptr = buf.get_ptr();
+                sgReadBytes( fp, nbytes, ptr );
+                int count = nbytes / (sizeof(unsigned int));
+                va_int.reserve(count);
+                for ( k = 0; k < count; ++k ) {
+                    va_int.push_back( buf.readInt() );
+                }
+            }
         } else if ( obj_type == SG_POINTS ) {
             // read point elements
             read_object( fp, SG_POINTS, nproperties, nelements,
-                         pts_v, pts_n, pts_c, pts_tc, pt_materials );
+                         pts_v, pts_n, pts_c, pts_tcs,
+                         pts_vas, pt_materials );
         } else if ( obj_type == SG_TRIANGLE_FACES ) {
             // read triangle face properties
             read_object( fp, SG_TRIANGLE_FACES, nproperties, nelements,
-                         tris_v, tris_n, tris_c, tris_tc, tri_materials );
+                         tris_v, tris_n, tris_c, tris_tcs,
+                         tris_vas, tri_materials );
         } else if ( obj_type == SG_TRIANGLE_STRIPS ) {
             // read triangle strip properties
             read_object( fp, SG_TRIANGLE_STRIPS, nproperties, nelements,
-                         strips_v, strips_n, strips_c, strips_tc,
-                         strip_materials );
+                         strips_v, strips_n, strips_c, strips_tcs,
+                         strips_vas, strip_materials );
         } else if ( obj_type == SG_TRIANGLE_FANS ) {
             // read triangle fan properties
             read_object( fp, SG_TRIANGLE_FANS, nproperties, nelements,
-                         fans_v, fans_n, fans_c, fans_tc, fan_materials );
+                         fans_v, fans_n, fans_c, fans_tcs,
+                         fans_vas, fan_materials );
         } else {
             // unknown object type, just skip
             read_properties( fp, nproperties );
@@ -652,9 +810,13 @@ unsigned int SGBinObject::count_objects(const string_list& materials)
     return result;
 }
 
-void SGBinObject::write_objects(gzFile fp, int type, const group_list& verts,
-    const group_list& normals, const group_list& colors, 
-    const group_list& texCoords, const string_list& materials)
+void SGBinObject::write_objects(gzFile fp, int type, 
+                                const group_list& verts,
+                                const group_list& normals, 
+                                const group_list& colors, 
+                                const group_tci_list& texCoords,
+                                const group_vai_list& vertexAttribs, 
+                                const string_list& materials)
 {
     if (verts.empty()) {
         return;
@@ -666,45 +828,77 @@ void SGBinObject::write_objects(gzFile fp, int type, const group_list& verts,
     
     while (start < materials.size()) {
         m = materials[start];
-    // find range of objects with identical material, write out as a single object
+        // find range of objects with identical material, write out as a single object
         for (end = start+1; (end < materials.size()) && (m == materials[end]); ++end) {}
     
+        // calc the number of elements
         const int count = end - start;
-        write_header(fp, type, 2, count);
+
+        // calc the number of properties
+        unsigned int va_mask = 0;
+        unsigned int va_count = vertexAttribs.size();
+        for ( unsigned int va=0; va<va_count; va++ ) {
+            if ( !vertexAttribs[va].empty() && !vertexAttribs[va].front().empty() ) {
+                va_mask |= ( 1 << va );
+            }
+        }
+
+        if ( va_mask ) {
+            write_header(fp, type, 3, count);
+        } else {
+            write_header(fp, type, 2, count);
+        }
         
     // properties
+        // material property
         sgWriteChar( fp, (char)SG_MATERIAL );        // property
         sgWriteUInt( fp, m.length() );        // nbytes
         sgWriteBytes( fp, m.length(), m.c_str() );
     
+        // index mask property
         unsigned char idx_mask = 0;
-        if ( !verts.empty() && !verts.front().empty()) idx_mask |= SG_IDX_VERTICES;
-        if ( !normals.empty() && !normals.front().empty()) idx_mask |= SG_IDX_NORMALS;
-        if ( !colors.empty() && !colors.front().empty()) idx_mask |= SG_IDX_COLORS;
-        if ( !texCoords.empty() && !texCoords.front().empty()) idx_mask |= SG_IDX_TEXCOORDS;
+        if ( !verts.empty() && !verts[start].empty()) idx_mask |= SG_IDX_VERTICES;
+        if ( !normals.empty() && !normals[start].empty()) idx_mask |= SG_IDX_NORMALS;
+        if ( !colors.empty() && !colors[start].empty()) idx_mask |= SG_IDX_COLORS;
+        if ( !texCoords.empty() && !texCoords[start][0].empty()) idx_mask |= SG_IDX_TEXCOORDS_0;
+        if ( !texCoords.empty() && !texCoords[start][1].empty()) idx_mask |= SG_IDX_TEXCOORDS_1;
+        if ( !texCoords.empty() && !texCoords[start][2].empty()) idx_mask |= SG_IDX_TEXCOORDS_2;
+        if ( !texCoords.empty() && !texCoords[start][3].empty()) idx_mask |= SG_IDX_TEXCOORDS_3;
         
         if (idx_mask == 0) {
             SG_LOG(SG_IO, SG_ALERT, "SGBinObject::write_objects: object with material:"
                 << m << "has no indices set");
         }
-    
-    
+
         sgWriteChar( fp, (char)SG_INDEX_TYPES );     // property
         sgWriteUInt( fp, 1 );                        // nbytes
         sgWriteChar( fp, idx_mask );
-    
-//        cout << "material:" << m << ", count =" << count << endl;
+
+        // vertex attribute property
+        if (va_mask != 0) {
+            sgWriteChar( fp, (char)SG_VERT_ATTRIBS );    // property
+            sgWriteUInt( fp, 4 );                        // nbytes
+            sgWriteChar( fp, va_mask );
+        }
+        
     // elements
         for (unsigned int i=start; i < end; ++i) {
             const int_list& va(verts[i]);
             const int_list& na((idx_mask & SG_IDX_NORMALS) ? normals[i] : emptyList);
             const int_list& ca((idx_mask & SG_IDX_COLORS) ? colors[i] : emptyList);
-            const int_list& tca((idx_mask & SG_IDX_TEXCOORDS) ? texCoords[i] : emptyList);
+
+            // pass the whole texcoord array - we'll figure out which indicies to write 
+            // in write_indices
+            const tci_list& tca( texCoords[i] );
+
+            // pass the whole vertex array - we'll figure out which indicies to write 
+            // in write_indices
+            const vai_list& vaa( vertexAttribs[i] );
             
             if (version == 7) {
-                write_indices<uint16_t>(fp, idx_mask, va, na, ca, tca);
+                write_indices<uint16_t>(fp, idx_mask, va_mask, va, na, ca, tca, vaa);
             } else {
-                write_indices<uint32_t>(fp, idx_mask, va, na, ca, tca);
+                write_indices<uint32_t>(fp, idx_mask, va_mask, va, na, ca, tca, vaa);
             }
         }
     
@@ -749,7 +943,6 @@ bool SGBinObject::write_bin_file(const SGPath& file)
     
     SGPath file2(file);
     file2.create_dir( 0755 );
-    cout << "Output file = " << file.str() << endl;
 
     gzFile fp;
     if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
@@ -759,19 +952,19 @@ bool SGBinObject::write_bin_file(const SGPath& file)
 
     sgClearWriteError();
 
-    cout << "points size = " << pts_v.size() << "  pt_materials = " 
-         << pt_materials.size() << endl;
-    cout << "triangles size = " << tris_v.size() << "  tri_materials = " 
-         << tri_materials.size() << endl;
-    cout << "strips size = " << strips_v.size() << "  strip_materials = " 
-         << strip_materials.size() << endl;
-    cout << "fans size = " << fans_v.size() << "  fan_materials = " 
-         << fan_materials.size() << endl;
+    SG_LOG(SG_IO, SG_DEBUG, "points size = " << pts_v.size() 
+         << "  pt_materials = " << pt_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "triangles size = " << tris_v.size() 
+         << "  tri_materials = " << tri_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "strips size = " << strips_v.size() 
+         << "  strip_materials = " << strip_materials.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "fans size = " << fans_v.size() 
+         << "  fan_materials = " << fan_materials.size() );
 
-    cout << "nodes = " << wgs84_nodes.size() << endl;
-    cout << "colors = " << colors.size() << endl;
-    cout << "normals = " << normals.size() << endl;
-    cout << "tex coords = " << texcoords.size() << endl;
+    SG_LOG(SG_IO, SG_DEBUG, "nodes = " << wgs84_nodes.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "colors = " << colors.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "normals = " << normals.size() );
+    SG_LOG(SG_IO, SG_DEBUG, "tex coords = " << texcoords.size() );
 
     version = 10;
     bool shortMaterialsRanges = 
@@ -803,7 +996,8 @@ bool SGBinObject::write_bin_file(const SGPath& file)
     nobjects += count_objects(strip_materials);
     nobjects += count_objects(fan_materials);
 
-    cout << "total top level objects = " << nobjects << endl;
+    SG_LOG(SG_IO, SG_DEBUG, "total top level objects = " << nobjects);
+
     if (version == 7) {
         sgWriteUShort( fp, (uint16_t) nobjects );
     } else {
@@ -849,10 +1043,10 @@ bool SGBinObject::write_bin_file(const SGPath& file)
       sgWriteVec2( fp, texcoords[i]);
     }
 
-    write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tc, pt_materials);
-    write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tc, tri_materials);
-    write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tc, strip_materials);
-    write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tc, fan_materials);
+    write_objects(fp, SG_POINTS, pts_v, pts_n, pts_c, pts_tcs, pts_vas, pt_materials);
+    write_objects(fp, SG_TRIANGLE_FACES, tris_v, tris_n, tris_c, tris_tcs, tris_vas, tri_materials);
+    write_objects(fp, SG_TRIANGLE_STRIPS, strips_v, strips_n, strips_c, strips_tcs, strips_vas, strip_materials);
+    write_objects(fp, SG_TRIANGLE_FANS, fans_v, fans_n, fans_c, fans_tcs, fans_vas, fan_materials);
     
     // close the file
     gzclose(fp);
@@ -952,7 +1146,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
             }
             // cout << "group = " << start << " to " << end - 1 << endl;
 
-      SGSphered d;
+      SGSphered d( SGVec3d(0.0, 0.0, 0.0), -1.0 );
       for ( i = start; i < end; ++i ) {
         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
@@ -972,7 +1166,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
             for ( i = start; i < end; ++i ) {
                 fprintf(fp, "f");
                 for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
-                    fprintf(fp, " %d/%d", tris_v[i][j], tris_tc[i][j] );
+                    fprintf(fp, " %d/%d", tris_v[i][j], tris_tcs[i][0][j] );
                 }
                 fprintf(fp, "\n");
             }
@@ -1001,7 +1195,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
             // cout << "group = " << start << " to " << end - 1 << endl;
 
 
-      SGSphered d;
+      SGSphered d( SGVec3d(0.0, 0.0, 0.0), -1.0 );
       for ( i = start; i < end; ++i ) {
         for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
           d.expandBy(wgs84_nodes[ tris_v[i][j] ]);
@@ -1021,7 +1215,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
             for ( i = start; i < end; ++i ) {
                 fprintf(fp, "ts");
                 for ( j = 0; j < (int)strips_v[i].size(); ++j ) {
-                    fprintf(fp, " %d/%d", strips_v[i][j], strips_tc[i][j] );
+                    fprintf(fp, " %d/%d", strips_v[i][j], strips_tcs[i][0][j] );
                 }
                 fprintf(fp, "\n");
             }
@@ -1061,3 +1255,27 @@ void SGBinObject::read_properties(gzFile fp, int nproperties)
     }
 }
 
+bool SGBinObject::add_point( const SGBinObjectPoint& pt )
+{
+    // add the point info
+    pt_materials.push_back( pt.material );
+    
+    pts_v.push_back( pt.v_list );
+    pts_n.push_back( pt.n_list );    
+    pts_c.push_back( pt.c_list );
+    
+    return true;
+}
+
+bool SGBinObject::add_triangle( const SGBinObjectTriangle& tri )
+{
+    // add the triangle info and keep lists aligned
+    tri_materials.push_back( tri.material );
+    tris_v.push_back( tri.v_list );
+    tris_n.push_back( tri.n_list );
+    tris_c.push_back( tri.c_list );
+    tris_tcs.push_back( tri.tc_list );
+    tris_vas.push_back( tri.va_list );
+    
+    return true;
+}

simgear/io/sg_binobj.hxx

@@ -36,16 +36,79 @@
 
 #include <vector>
 #include <string>
+#include <boost/array.hpp>
 
-/** STL Structure used to store object information */
+#define MAX_TC_SETS     (4)
+#define MAX_VAS         (8)
+
+// I really want to pass around fixed length arrays, as the size 
+// has to be hardcoded
+// but it's a C++0x feature use boost in its absence
+typedef boost::array<int_list, MAX_TC_SETS> tci_list;
+typedef boost::array<int_list, MAX_VAS>     vai_list;
+
+/** STL Structure used to store (integer index) object information */
 typedef std::vector < int_list > group_list;
 typedef group_list::iterator group_list_iterator;
 typedef group_list::const_iterator const_group_list_iterator;
 
+/** STL Structure used to store (tc index) object information */
+typedef std::vector < tci_list > group_tci_list;
+typedef group_tci_list::iterator group_tci_list_iterator;
+typedef group_tci_list::const_iterator const_group_tci_list_iterator;
+
+/** STL Structure used to store (va index) object information */
+typedef std::vector < vai_list > group_vai_list;
+typedef group_vai_list::iterator group_vai_list_iterator;
+typedef group_vai_list::const_iterator const_group_vai_list_iterator;
+
+
 // forward decls
 class SGBucket;
 class SGPath;
 
+class SGBinObjectPoint {
+public:
+    std::string material;
+    int_list    v_list;
+    int_list    n_list;
+    int_list    c_list;
+    
+    void clear( void ) {
+        material = "";
+        v_list.clear();
+        n_list.clear();
+        c_list.clear();
+    };    
+};
+
+class SGBinObjectTriangle {
+public:
+    std::string material;
+    int_list    v_list;
+    int_list    n_list;
+    int_list    c_list;
+    
+    tci_list    tc_list;
+    vai_list    va_list;
+
+    void clear( void ) {
+        material = "";
+        v_list.clear();
+        n_list.clear();
+        c_list.clear();
+        for ( unsigned int i=0; i<MAX_TC_SETS; i++ ) {
+            tc_list[i].clear();
+        }
+        for ( unsigned int i=0; i<MAX_VAS; i++ ) {
+            va_list[i].clear();
+        }
+    };
+    
+};
+
+
+
 /**
  * A class to manipulate the simgear 3d object format.
  * This class provides functionality to both read and write the binary format.
@@ -86,34 +149,40 @@ private:
     SGVec3d gbs_center;
     float gbs_radius;
 
-    std::vector<SGVec3d> wgs84_nodes;	// vertex list
-    std::vector<SGVec4f> colors;	// color list
-    std::vector<SGVec3f> normals;	// normal list
-    std::vector<SGVec2f> texcoords;	// texture coordinate list
+    std::vector<SGVec3d> wgs84_nodes;   // vertex list
+    std::vector<SGVec4f> colors;        // color list
+    std::vector<SGVec3f> normals;       // normal list
+    std::vector<SGVec2f> texcoords;     // texture coordinate list
+    std::vector<float>   va_flt;        // vertex attribute list (floats)
+    std::vector<int>     va_int;        // vertex attribute list (ints) 
+    
+    group_list pts_v;               	// points vertex index
+    group_list pts_n;               	// points normal index
+    group_list pts_c;               	// points color index
+    group_tci_list pts_tcs;             // points texture coordinates ( up to 4 sets )
+    group_vai_list pts_vas;             // points vertex attributes ( up to 8 sets )
+    string_list pt_materials;           // points materials
 
-    group_list pts_v;		// points vertex index
-    group_list pts_n;		// points normal index
-    group_list pts_c;		// points color index
-    group_list pts_tc;		// points texture coordinate index
-    string_list pt_materials;	// points materials
+    group_list tris_v;              	// triangles vertex index
+    group_list tris_n;              	// triangles normal index
+    group_list tris_c;              	// triangles color index
+    group_tci_list tris_tcs;            // triangles texture coordinates ( up to 4 sets )
+    group_vai_list tris_vas;            // triangles vertex attributes ( up to 8 sets )
+    string_list tri_materials;          // triangles materials
 
-    group_list tris_v;		// triangles vertex index
-    group_list tris_n;		// triangles normal index
-    group_list tris_c;		// triangles color index
-    group_list tris_tc;		// triangles texture coordinate index
-    string_list tri_materials;	// triangles materials
+    group_list strips_v;            	// tristrips vertex index
+    group_list strips_n;            	// tristrips normal index
+    group_list strips_c;            	// tristrips color index
+    group_tci_list strips_tcs;          // tristrips texture coordinates ( up to 4 sets )
+    group_vai_list strips_vas;          // tristrips vertex attributes ( up to 8 sets )
+    string_list strip_materials;        // tristrips materials
 
-    group_list strips_v;	// tristrips vertex index
-    group_list strips_n;	// tristrips normal index
-    group_list strips_c;	// tristrips color index
-    group_list strips_tc;	// tristrips texture coordinate index
-    string_list strip_materials;// tristrips materials
-
-    group_list fans_v;		// fans vertex index
-    group_list fans_n;		// fans normal index
-    group_list fans_c;		// fans color index
-    group_list fans_tc;		// fans texture coordinate index
-    string_list fan_materials;	// fans materials
+    group_list fans_v;              	// fans vertex index
+    group_list fans_n;              	// fans normal index
+    group_list fans_c;              	// fans color index
+    group_tci_list fans_tcs;            // fanss texture coordinates ( up to 4 sets )
+    group_vai_list fans_vas;            // fans vertex attributes ( up to 8 sets )
+    string_list fan_materials;	        // fans materials
 
     void read_properties(gzFile fp, int nproperties);
     
@@ -124,17 +193,23 @@ private:
                              group_list& vertices, 
                              group_list& normals,
                              group_list& colors,
-                             group_list& texCoords,
+                             group_tci_list& texCoords,
+                             group_vai_list& vertexAttribs,
                              string_list& materials);
                              
     void write_header(gzFile fp, int type, int nProps, int nElements);
-    void write_objects(gzFile fp, int type, const group_list& verts,
-        const group_list& normals, const group_list& colors, 
-        const group_list& texCoords, const string_list& materials);
+    void write_objects(gzFile fp, 
+                       int type, 
+                       const group_list& verts,
+                       const group_list& normals, 
+                       const group_list& colors, 
+                       const group_tci_list& texCoords, 
+                       const group_vai_list& vertexAttribs,
+                       const string_list& materials);
         
     unsigned int count_objects(const string_list& materials);
-public:
-
+    
+public:    
     inline unsigned short get_version() const { return version; }
 
     inline const SGVec3d& get_gbs_center() const { return gbs_center; }
@@ -143,10 +218,8 @@ public:
     inline float get_gbs_radius() const { return gbs_radius; }
     inline void set_gbs_radius( float r ) { gbs_radius = r; }
 
-    inline const std::vector<SGVec3d>& get_wgs84_nodes() const
-    { return wgs84_nodes; }
-    inline void set_wgs84_nodes( const std::vector<SGVec3d>& n )
-    { wgs84_nodes = n; }
+    inline const std::vector<SGVec3d>& get_wgs84_nodes() const { return wgs84_nodes; }
+    inline void set_wgs84_nodes( const std::vector<SGVec3d>& n ) { wgs84_nodes = n; }
 
     inline const std::vector<SGVec4f>& get_colors() const { return colors; }
     inline void set_colors( const std::vector<SGVec4f>& c ) { colors = c; }
@@ -157,51 +230,38 @@ public:
     inline const std::vector<SGVec2f>& get_texcoords() const { return texcoords; }
     inline void set_texcoords( const std::vector<SGVec2f>& t ) { texcoords = t; }
     
+    // Points API
+    bool add_point( const SGBinObjectPoint& pt );
     inline const group_list& get_pts_v() const { return pts_v; }
-    inline void set_pts_v( const group_list& g ) { pts_v = g; }
-    inline const group_list& get_pts_n() const { return pts_n; }
-    inline void set_pts_n( const group_list& g ) { pts_n = g; }
-    inline const group_list& get_pts_c() const { return pts_c; }
-    inline void set_pts_c( const group_list& g ) { pts_c = g; }
-    inline const group_list& get_pts_tc() const { return pts_tc; }
-    inline void set_pts_tc( const group_list& g ) { pts_tc = g; }
+    inline const group_list& get_pts_n() const { return pts_n; }    
+    inline const group_tci_list& get_pts_tcs() const { return pts_tcs; }
+    inline const group_vai_list& get_pts_vas() const { return pts_vas; }
     inline const string_list& get_pt_materials() const { return pt_materials; }
-    inline void set_pt_materials( const string_list& s ) { pt_materials = s; }
 
+    // Triangles API
+    bool add_triangle( const SGBinObjectTriangle& tri );
     inline const group_list& get_tris_v() const { return tris_v; }
-    inline void set_tris_v( const group_list& g ) { tris_v = g; }
     inline const group_list& get_tris_n() const { return tris_n; }
-    inline void set_tris_n( const group_list& g ) { tris_n = g; }
     inline const group_list& get_tris_c() const { return tris_c; }
-    inline void set_tris_c( const group_list& g ) { tris_c = g; }
-    inline const group_list& get_tris_tc() const { return tris_tc; }
-    inline void set_tris_tc( const group_list& g ) { tris_tc = g; }
+    inline const group_tci_list& get_tris_tcs() const { return tris_tcs; }
+    inline const group_vai_list& get_tris_vas() const { return tris_vas; }
     inline const string_list& get_tri_materials() const { return tri_materials; }
-    inline void set_tri_materials( const string_list& s ) { tri_materials = s; }
     
+    // Strips API (deprecated - read only)
     inline const group_list& get_strips_v() const { return strips_v; }
-    inline void set_strips_v( const group_list& g ) { strips_v = g; }
     inline const group_list& get_strips_n() const { return strips_n; }
-    inline void set_strips_n( const group_list& g ) { strips_n = g; }
     inline const group_list& get_strips_c() const { return strips_c; }
-    inline void set_strips_c( const group_list& g ) { strips_c = g; }
-
-    inline const group_list& get_strips_tc() const { return strips_tc; }
-    inline void set_strips_tc( const group_list& g ) { strips_tc = g; }
+    inline const group_tci_list& get_strips_tcs() const { return strips_tcs; }
+    inline const group_vai_list& get_strips_vas() const { return strips_vas; }
     inline const string_list& get_strip_materials() const { return strip_materials; }
-    inline void set_strip_materials( const string_list& s ) { strip_materials = s; }
-    
-    inline const group_list& get_fans_v() const { return fans_v; }
-    inline void set_fans_v( const group_list& g ) { fans_v = g; }
-    inline const group_list& get_fans_n() const { return fans_n; }
-    inline void set_fans_n( const group_list& g ) { fans_n = g; }
-    inline const group_list& get_fans_c() const { return fans_c; }
-    inline void set_fans_c( const group_list& g ) { fans_c = g; }
 
-    inline const group_list& get_fans_tc() const { return fans_tc; }
-    inline void set_fans_tc( const group_list& g ) { fans_tc = g; }
+    // Fans API (deprecated - read only )
+    inline const group_list& get_fans_v() const { return fans_v; }
+    inline const group_list& get_fans_n() const { return fans_n; }
+    inline const group_list& get_fans_c() const { return fans_c; }
+    inline const group_tci_list& get_fans_tcs() const { return fans_tcs; }
+    inline const group_vai_list& get_fans_vas() const { return fans_vas; }
     inline const string_list& get_fan_materials() const { return fan_materials; }
-    inline void set_fan_materials( const string_list& s ) { fan_materials = s; }
 
     /**
      * Read a binary file object and populate the provided structures.

simgear/io/test_binobj.cxx

@@ -103,6 +103,15 @@ int_list make_tri(int maxIndex)
     return r;
 }
 
+tci_list make_tri_tcs(int maxIndex)
+{
+    tci_list tci;
+    tci[0].push_back(random() % maxIndex);
+    tci[0].push_back(random() % maxIndex);
+    tci[0].push_back(random() % maxIndex);
+    return tci;
+}
+
 void compareTris(const SGBinObject& a, const SGBinObject& b)
 {
     unsigned int count = a.get_tri_materials().size();
@@ -113,32 +122,31 @@ void compareTris(const SGBinObject& a, const SGBinObject& b)
 
         COMPARE(a.get_tri_materials()[i], b.get_tri_materials()[i]);
         
-        const int_list& tA(a.get_tris_tc()[i]);
-        const int_list& tB(b.get_tris_tc()[i]);
+        const int_list& tA(a.get_tris_tcs()[i][0]);
+        const int_list& tB(b.get_tris_tcs()[i][0]);
         VERIFY(tA == tB);
     }
 }
 
 void generate_tris(SGBinObject& b, int count)
 {
-    group_list v, n, tc;
+    group_list v, n;
+    group_tci_list tc;
     string_list materials;
 
     int maxVertices = b.get_wgs84_nodes().size();
     int maxNormals = b.get_normals().size();
     int maxTCs = b.get_texcoords().size();
     
+    SGBinObjectTriangle sgboTri;
     for (int t=0; t<count; ++t) {
-        v.push_back(make_tri(maxVertices));
-        n.push_back(make_tri(maxNormals));
-        tc.push_back(make_tri(maxTCs));
-        materials.push_back("material1");
+        sgboTri.material = "material1";    
+        sgboTri.v_list = make_tri(maxVertices);
+        sgboTri.n_list = make_tri(maxNormals);
+        sgboTri.tc_list[0] = make_tri(maxTCs);
+
+        b.add_triangle( sgboTri );
     }
-    
-    b.set_tris_v(v);
-    b.set_tris_n(n);
-    b.set_tris_tc(tc);
-    b.set_tri_materials(materials);
 }
  
 void test_basic()

simgear/math/SGMathTest.cxx

@@ -19,10 +19,13 @@
 #  include <simgear_config.h>
 #endif
 
+#include <simgear/misc/test_macros.hxx>
+
 #include <cstdlib>
 #include <iostream>
 
 #include "SGMath.hxx"
+#include "SGRect.hxx"
 #include "sg_random.h"
 
 template<typename T>
@@ -268,6 +271,33 @@ MatrixTest(void)
   return true;
 }
 
+template<typename T>
+void doRectTest()
+{
+  SGRect<T> rect(10, 15, 20, 25);
+
+  COMPARE(rect.x(), 10)
+  COMPARE(rect.y(), 15)
+  COMPARE(rect.width(), 20)
+  COMPARE(rect.height(), 25)
+
+  COMPARE(rect.pos(), SGVec2<T>(10, 15))
+  COMPARE(rect.size(), SGVec2<T>(20, 25))
+
+  COMPARE(rect.l(), 10)
+  COMPARE(rect.t(), 15)
+  COMPARE(rect.r(), 30)
+  COMPARE(rect.b(), 40)
+
+  VERIFY(rect == rect)
+  VERIFY(rect == SGRect<T>(10, 15, 20, 25))
+  VERIFY(rect != SGRect<T>(11, 15, 20, 25))
+
+  VERIFY(rect.contains(10, 15))
+  VERIFY(!rect.contains(9, 15))
+  VERIFY(rect.contains(9, 15, 1))
+}
+
 bool
 GeodesyTest(void)
 {
@@ -351,6 +381,10 @@ main(void)
   if (!MatrixTest<double>())
     return EXIT_FAILURE;
 
+  // Do rect tests
+  doRectTest<int>();
+  doRectTest<double>();
+
   // Check geodetic/geocentric/cartesian conversions
   if (!GeodesyTest())
     return EXIT_FAILURE;

simgear/math/SGRect.hxx

@@ -34,7 +34,7 @@ class SGRect
 
     }
 
-    SGRect(const SGVec2<T>& pt):
+    explicit SGRect(const SGVec2<T>& pt):
       _min(pt),
       _max(pt)
     {
@@ -88,11 +88,15 @@ class SGRect
     T y() const { return _min.y(); }
     T width() const { return _max.x() - _min.x(); }
     T height() const { return _max.y() - _min.y(); }
+    SGVec2<T> const& pos() const { return _min; }
+    SGVec2<T> size() const { return SGVec2<T>(width(), height()); }
 
     void setX(T x) { T w = width(); _min.x() = x; _max.x() = x + w; }
     void setY(T y) { T h = height(); _min.y() = y; _max.y() = y + h; }
     void setWidth(T w) { _max.x() = _min.x() + w; }
     void setHeight(T h) { _max.y() = _min.y() + h; }
+    void setPos(const SGVec2<T>& p) { setX(p.x()); setY(p.y()); }
+    void setSize(const SGVec2<T>& s) { setWidth(s.x()); setHeight(s.y()); }
 
     T l() const { return _min.x(); }
     T r() const { return _max.x(); }
@@ -109,6 +113,18 @@ class SGRect
     void setTop(T t) { _min.y() = t; }
     void setBottom(T b) { _max.y() = b; }
 
+    /**
+     * Expand rectangle to include the given position
+     */
+    void expandBy(T x, T y)
+    {
+      if( x < _min.x() ) _min.x() = x;
+      if( x > _max.x() ) _max.x() = x;
+
+      if( y < _min.y() ) _min.y() = y;
+      if( y > _max.y() ) _max.y() = y;
+    }
+
     /**
      * Move rect by vector
      */
@@ -129,6 +145,17 @@ class SGRect
       return *this;
     }
 
+    bool operator==(const SGRect<T>& rhs) const
+    {
+      return _min == rhs._min
+          && _max == rhs._max;
+    }
+
+    bool operator!=(const SGRect<T>& rhs) const
+    {
+      return !(*this == rhs);
+    }
+
     bool contains(T x, T y) const
     {
       return _min.x() <= x && x <= _max.x()
@@ -176,4 +203,8 @@ std::basic_ostream<char_type, traits_type>&
 operator<<(std::basic_ostream<char_type, traits_type>& s, const SGRect<T>& rect)
 { return s << "min = " << rect.getMin() << ", max = " << rect.getMax(); }
 
+typedef SGRect<int> SGRecti;
+typedef SGRect<float> SGRectf;
+typedef SGRect<double> SGRectd;
+
 #endif /* SG_RECT_HXX_ */

simgear/math/SGTriangle.hxx

@@ -16,7 +16,7 @@
 //
 
 #ifndef SGTriangle_H
-#define SGTrianlge_H
+#define SGTriangle_H
 
 template<typename T>
 class SGTriangle {

simgear/misc/CMakeLists.txt

@@ -5,6 +5,8 @@ set(HEADERS
     CSSBorder.hxx
     ListDiff.hxx
     ResourceManager.hxx
+    SimpleMarkdown.hxx
+    SVGpreserveAspectRatio.hxx
     interpolator.hxx
     make_new.hxx
     sg_dir.hxx
@@ -22,6 +24,8 @@ set(HEADERS
 set(SOURCES
     CSSBorder.cxx
     ResourceManager.cxx
+    SimpleMarkdown.cxx
+    SVGpreserveAspectRatio.cxx
     interpolator.cxx
     sg_dir.cxx
     sg_path.cxx
@@ -33,6 +37,10 @@ set(SOURCES
     gzcontainerfile.cxx
     )
 
+if (APPLE)
+    list(APPEND SOURCES CocoaHelpers.mm)
+endif()
+
 simgear_component(misc misc "${SOURCES}" "${HEADERS}")
 
 if(ENABLE_TESTS)
@@ -45,10 +53,6 @@ add_executable(test_tabbed_values tabbed_values_test.cxx)
 add_test(tabbed_values ${EXECUTABLE_OUTPUT_PATH}/test_tabbed_values)
 target_link_libraries(test_tabbed_values ${TEST_LIBS})
 
-add_executable(test_strings strutils_test.cxx )
-add_test(strings ${EXECUTABLE_OUTPUT_PATH}/test_strings)
-target_link_libraries(test_strings ${TEST_LIBS})
-
 add_executable(test_streams sgstream_test.cxx )
 add_test(streams ${EXECUTABLE_OUTPUT_PATH}/test_streams)
 target_link_libraries(test_streams ${TEST_LIBS})
@@ -58,3 +62,23 @@ add_test(path ${EXECUTABLE_OUTPUT_PATH}/test_path)
 target_link_libraries(test_path ${TEST_LIBS})
 
 endif(ENABLE_TESTS)
+
+add_boost_test(SimpleMarkdown
+  SOURCES SimpleMarkdown_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)
+
+add_boost_test(SVGpreserveAspectRatio
+  SOURCES SVGpreserveAspectRatio_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)
+
+add_boost_test(strutils
+  SOURCES strutils_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)
+
+add_boost_test(utf8tolatin1
+  SOURCES utf8tolatin1_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)

simgear/misc/CocoaHelpers.mm

@@ -0,0 +1,41 @@
+#include <Cocoa/Cocoa.h>
+#include <Foundation/NSAutoreleasePool.h>
+
+#include <simgear/misc/sg_path.hxx>
+
+namespace {
+    
+class CocoaAutoreleasePool
+{
+public:
+    CocoaAutoreleasePool()
+    {
+        pool = [[NSAutoreleasePool alloc] init];
+    }
+
+    ~CocoaAutoreleasePool()
+    {
+        [pool release];
+    }
+
+private:
+    NSAutoreleasePool* pool;
+};
+
+} // of anonyous namespace
+
+SGPath appleSpecialFolder(int dirType, int domainMask, const SGPath& def)
+{
+    CocoaAutoreleasePool ap;
+    NSFileManager* fm = [NSFileManager defaultManager];
+    NSURL* pathUrl = [fm URLForDirectory:dirType
+                                     inDomain:domainMask
+                             appropriateForURL:Nil
+                                       create:YES
+                                         error:nil];
+    if (!pathUrl) {
+        return def;;
+    }
+    
+    return SGPath([[pathUrl path] UTF8String], def.getPermissionChecker());
+}

simgear/misc/SVGpreserveAspectRatio.cxx

@@ -0,0 +1,192 @@
+// Parse and represent SVG preserveAspectRatio attribute
+//
+// 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 "SVGpreserveAspectRatio.hxx"
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/misc/strutils.hxx>
+
+#include <boost/tokenizer.hpp>
+
+namespace simgear
+{
+
+  //----------------------------------------------------------------------------
+  SVGpreserveAspectRatio::SVGpreserveAspectRatio():
+    _align_x(ALIGN_NONE),
+    _align_y(ALIGN_NONE),
+    _meet(true)
+  {
+
+  }
+
+  //----------------------------------------------------------------------------
+  SVGpreserveAspectRatio::Align SVGpreserveAspectRatio::alignX() const
+  {
+    return _align_x;
+  }
+
+  //----------------------------------------------------------------------------
+  SVGpreserveAspectRatio::Align SVGpreserveAspectRatio::alignY() const
+  {
+    return _align_y;
+  }
+
+  //----------------------------------------------------------------------------
+  bool SVGpreserveAspectRatio::scaleToFill() const
+  {
+    return (_align_x == ALIGN_NONE) && (_align_y == ALIGN_NONE);
+  }
+
+  //----------------------------------------------------------------------------
+  bool SVGpreserveAspectRatio::scaleToFit() const
+  {
+    return !scaleToFill() && _meet;
+  }
+
+  //----------------------------------------------------------------------------
+  bool SVGpreserveAspectRatio::scaleToCrop() const
+  {
+    return !scaleToFill() && !_meet;
+  }
+
+  //----------------------------------------------------------------------------
+  bool SVGpreserveAspectRatio::meet() const
+  {
+    return _meet;
+  }
+
+  //----------------------------------------------------------------------------
+  bool
+  SVGpreserveAspectRatio::operator==(const SVGpreserveAspectRatio& rhs) const
+  {
+    return (_align_x == rhs._align_x)
+        && (_align_y == rhs._align_y)
+        && (_meet == rhs._meet || scaleToFill());
+  }
+
+  //----------------------------------------------------------------------------
+  SVGpreserveAspectRatio SVGpreserveAspectRatio::parse(const std::string& str)
+  {
+    SVGpreserveAspectRatio ret;
+    enum
+    {
+      PARSE_defer,
+      PARSE_align,
+      PARSE_meetOrSlice,
+      PARSE_done,
+      PARSE_error
+    } parse_state = PARSE_defer;
+
+    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+    const boost::char_separator<char> del(" \t\n");
+
+    tokenizer tokens(str.begin(), str.end(), del);
+    for( tokenizer::const_iterator tok = tokens.begin();
+                                   tok != tokens.end()
+                                && parse_state != PARSE_error;
+                                 ++tok )
+    {
+      const std::string& cur_tok = tok.current_token();
+
+      switch( parse_state )
+      {
+        case PARSE_defer:
+          if( cur_tok == "defer" )
+          {
+            SG_LOG( SG_GENERAL,
+                    SG_INFO,
+                    "SVGpreserveAspectRatio: 'defer' is ignored." );
+            parse_state = PARSE_align;
+            break;
+          }
+          // fall through
+        case PARSE_align:
+          if( cur_tok == "none" )
+          {
+            ret._align_x = ALIGN_NONE;
+            ret._align_y = ALIGN_NONE;
+          }
+          else if( cur_tok.length() == 8 )
+          {
+            if(      strutils::starts_with(cur_tok, "xMin") )
+              ret._align_x = ALIGN_MIN;
+            else if( strutils::starts_with(cur_tok, "xMid") )
+              ret._align_x = ALIGN_MID;
+            else if( strutils::starts_with(cur_tok, "xMax") )
+              ret._align_x = ALIGN_MAX;
+            else
+            {
+              parse_state = PARSE_error;
+              break;
+            }
+
+            if(      strutils::ends_with(cur_tok, "YMin") )
+              ret._align_y = ALIGN_MIN;
+            else if( strutils::ends_with(cur_tok, "YMid") )
+              ret._align_y = ALIGN_MID;
+            else if( strutils::ends_with(cur_tok, "YMax") )
+              ret._align_y = ALIGN_MAX;
+            else
+            {
+              parse_state = PARSE_error;
+              break;
+            }
+          }
+          else
+          {
+            parse_state = PARSE_error;
+            break;
+          }
+          parse_state = PARSE_meetOrSlice;
+          break;
+        case PARSE_meetOrSlice:
+          if( cur_tok == "meet" )
+            ret._meet = true;
+          else if( cur_tok == "slice" )
+            ret._meet = false;
+          else
+          {
+            parse_state = PARSE_error;
+            break;
+          }
+          parse_state = PARSE_done;
+          break;
+        case PARSE_done:
+          SG_LOG( SG_GENERAL,
+                  SG_WARN,
+                  "SVGpreserveAspectRatio: Ignoring superfluous token"
+                  " '" << cur_tok << "'" );
+          break;
+        default:
+          break;
+      }
+    }
+
+    if( parse_state == PARSE_error )
+    {
+      SG_LOG( SG_GENERAL,
+              SG_WARN,
+              "SVGpreserveAspectRatio: Failed to parse: '" << str << "'" );
+      return SVGpreserveAspectRatio();
+    }
+
+    return ret;
+  }
+
+} // namespace simgear

simgear/misc/SVGpreserveAspectRatio.hxx

@@ -0,0 +1,67 @@
+///@file Parse and represent SVG preserveAspectRatio attribute
+//
+// 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_SVG_PRESERVE_ASPECT_RATIO_HXX_
+#define SG_SVG_PRESERVE_ASPECT_RATIO_HXX_
+
+#include <string>
+
+namespace simgear
+{
+
+  /**
+   * SVG preserveAspectRatio attribute
+   *
+   * @see http://www.w3.org/TR/SVG11/coords.html#PreserveAspectRatioAttribute
+   */
+  class SVGpreserveAspectRatio
+  {
+    public:
+      enum Align
+      {
+        ALIGN_NONE,
+        ALIGN_MIN,
+        ALIGN_MID,
+        ALIGN_MAX
+      };
+
+      SVGpreserveAspectRatio();
+
+      Align alignX() const;
+      Align alignY() const;
+
+      bool scaleToFill() const;
+      bool scaleToFit() const;
+      bool scaleToCrop() const;
+
+      bool meet() const;
+
+      bool operator==(const SVGpreserveAspectRatio& rhs) const;
+
+      static SVGpreserveAspectRatio parse(const std::string& str);
+
+    private:
+      Align _align_x,
+            _align_y;
+      bool  _meet; //!< uniform scale to fit, if true
+                   //   uniform scale to fill+crop, if false
+  };
+
+} // namespace simgear
+
+#endif /* SG_SVG_PRESERVE_ASPECT_RATIO_HXX_ */

simgear/misc/SVGpreserveAspectRatio_test.cxx

@@ -0,0 +1,60 @@
+/// Unit tests for SVGpreserveAspectRatio
+#define BOOST_TEST_MODULE misc
+#include <BoostTestTargetConfig.h>
+
+#include "SVGpreserveAspectRatio.hxx"
+
+namespace simgear
+{
+  std::ostream& operator<<( std::ostream& strm,
+                            const SVGpreserveAspectRatio& ar )
+  {
+    strm << "[ align_x=" << ar.alignX() <<
+            ", align_y=" << ar.alignY() <<
+            ", meet=" << ar.meet() <<
+            "]";
+    return strm;
+  }
+}
+
+BOOST_AUTO_TEST_CASE( parse_attribute )
+{
+  using simgear::SVGpreserveAspectRatio;
+
+  SVGpreserveAspectRatio ar = SVGpreserveAspectRatio::parse("none");
+  BOOST_CHECK( ar.scaleToFill() );
+  BOOST_CHECK( !ar.scaleToFit() );
+  BOOST_CHECK( !ar.scaleToCrop() );
+  BOOST_CHECK_EQUAL( ar.alignX(), SVGpreserveAspectRatio::ALIGN_NONE );
+  BOOST_CHECK_EQUAL( ar.alignY(), SVGpreserveAspectRatio::ALIGN_NONE );
+
+  SVGpreserveAspectRatio ar_meet = SVGpreserveAspectRatio::parse("none meet");
+  SVGpreserveAspectRatio ar_slice = SVGpreserveAspectRatio::parse("none slice");
+
+  BOOST_CHECK_EQUAL( ar, ar_meet );
+  BOOST_CHECK_EQUAL( ar, ar_slice );
+
+  ar_meet  = SVGpreserveAspectRatio::parse("xMidYMid meet");
+  BOOST_CHECK( !ar_meet.scaleToFill() );
+  BOOST_CHECK( ar_meet.scaleToFit() );
+  BOOST_CHECK( !ar_meet.scaleToCrop() );
+  BOOST_CHECK_EQUAL( ar_meet.alignX(), SVGpreserveAspectRatio::ALIGN_MID );
+  BOOST_CHECK_EQUAL( ar_meet.alignY(), SVGpreserveAspectRatio::ALIGN_MID );
+
+  ar_slice = SVGpreserveAspectRatio::parse("xMidYMid slice");
+  BOOST_CHECK( !ar_slice.scaleToFill() );
+  BOOST_CHECK( !ar_slice.scaleToFit() );
+  BOOST_CHECK( ar_slice.scaleToCrop() );
+  BOOST_CHECK_EQUAL( ar_slice.alignX(), SVGpreserveAspectRatio::ALIGN_MID );
+  BOOST_CHECK_EQUAL( ar_slice.alignY(), SVGpreserveAspectRatio::ALIGN_MID );
+
+  BOOST_CHECK_NE(ar_meet, ar_slice);
+
+  // defer is ignored, meet is default
+  ar_meet  = SVGpreserveAspectRatio::parse("defer xMinYMin");
+  BOOST_CHECK( !ar_meet.scaleToFill() );
+  BOOST_CHECK( ar_meet.scaleToFit() );
+  BOOST_CHECK( !ar_meet.scaleToCrop() );
+  BOOST_CHECK_EQUAL( ar_meet.alignX(), SVGpreserveAspectRatio::ALIGN_MIN );
+  BOOST_CHECK_EQUAL( ar_meet.alignY(), SVGpreserveAspectRatio::ALIGN_MIN );
+}

simgear/misc/SimpleMarkdown.cxx

@@ -0,0 +1,104 @@
+// Really simple markdown parser
+//
+// 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 "SimpleMarkdown.hxx"
+
+namespace simgear
+{
+
+  // White space
+  static bool isSpace(const char c)
+  {
+    return c == ' ' || c == '\t';
+  }
+  
+  // Unordered list item
+  static bool isULItem(const char c)
+  {
+    return c == '*' || c == '+' || c == '-';
+  }
+
+  //----------------------------------------------------------------------------
+  std::string SimpleMarkdown::parse(const std::string& src)
+  {
+    std::string out;
+
+    int num_space = 0,
+        num_newline = 0;
+    bool line_empty = true;
+
+    for( std::string::const_iterator it = src.begin();
+                                     it != src.end();
+                                   ++it )
+    {
+      if( isSpace(*it) )
+      {
+        ++num_space;
+      }
+      else if( *it == '\n' )
+      {
+        // Two or more whitespace at end of line -> line break
+        if( !line_empty && num_space >= 2 )
+        {
+          out.push_back('\n');
+          line_empty = true;
+        }
+
+        ++num_newline;
+        num_space = 0;
+      }
+      else
+      {
+        // Remove all new lines before first printable character
+        if( out.empty() )
+          num_newline = 0;
+
+        // Two or more new lines (aka. at least one empty line) -> new paragraph
+        if( num_newline >= 2 )
+        {
+          out.append("\n\n");
+
+          line_empty = true;
+          num_newline = 0;
+        }
+
+        // Replace unordered list item markup at begin of line with bullet
+        // (TODO multilevel lists, indent multiple lines, etc.)
+        if( (line_empty || num_newline) && isULItem(*it) )
+        {
+          if( num_newline < 2 )
+            out.push_back('\n');
+          out.append("\xE2\x80\xA2");
+        }
+        else
+        {
+          // Collapse multiple whitespace
+          if( !line_empty && (num_space || num_newline) )
+            out.push_back(' ');
+          out.push_back(*it);
+        }
+
+        line_empty = false;
+        num_space = 0;
+        num_newline = 0;
+      }
+    }
+    return out;
+  }
+
+} // namespace simgear

simgear/misc/SimpleMarkdown.hxx

@@ -0,0 +1,39 @@
+///@file Really simple markdown parser
+//
+// 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 SIMPLE_MARKDOWN_HXX_
+#define SIMPLE_MARKDOWN_HXX_
+
+#include <string>
+
+namespace simgear
+{
+  /**
+   * Really simple mardown parser. Currently just paragraphs, new lines and
+   * one level of unordered lists are supported.
+   *
+   * @see http://en.wikipedia.org/wiki/Markdown
+   */
+  class SimpleMarkdown
+  {
+    public:
+      static std::string parse(const std::string& src);
+  };
+} // namespace simgear
+
+#endif /* SIMPLE_MARKDOWN_HXX_ */

simgear/misc/SimpleMarkdown_test.cxx

@@ -0,0 +1,34 @@
+/// Unit tests for simple markdown parser
+#define BOOST_TEST_MODULE misc
+#include <BoostTestTargetConfig.h>
+
+#include "SimpleMarkdown.hxx"
+
+BOOST_AUTO_TEST_CASE( basic_markdown )
+{
+  std::string const src(
+    "  \n"
+    "\n"
+    "blub\n"
+    "* \tlist item\n"
+    "*  another\t item\n"
+    "\n"
+    "test blubt\n"
+    " aha  \n"
+    "asd\n"
+    "  * 2nd list, another   item\n"
+    "  * 2nd list, one more..."
+  );
+  std::string const out(
+    "blub\n"
+    "\xE2\x80\xA2 list item\n"
+    "\xE2\x80\xA2 another item\n"
+    "\n"
+    "test blubt aha\n"
+    "asd\n"
+    "\xE2\x80\xA2 2nd list, another item\n"
+    "\xE2\x80\xA2 2nd list, one more..."
+  );
+
+  BOOST_CHECK_EQUAL(simgear::SimpleMarkdown::parse(src), out);
+}

simgear/misc/path_test.cxx

@@ -41,6 +41,20 @@ void test_dir()
     }
     
     cout << temp.path().modTime() << endl;
+
+    std::cout << "Standard Locations:"
+              << "\n - Home:      " << SGPath::standardLocation(SGPath::HOME)
+              << "\n - Desktop:   " << SGPath::standardLocation(SGPath::DESKTOP)
+              << "\n - Downloads: " << SGPath::standardLocation(SGPath::DOWNLOADS)
+              << "\n - Documents: " << SGPath::standardLocation(SGPath::DOCUMENTS)
+              << "\n - Pictures:  " << SGPath::standardLocation(SGPath::PICTURES)
+              << std::endl;
+
+    VERIFY( !SGPath::standardLocation(SGPath::HOME     ).isNull() );
+    VERIFY( !SGPath::standardLocation(SGPath::DESKTOP  ).isNull() );
+    VERIFY( !SGPath::standardLocation(SGPath::DOWNLOADS).isNull() );
+    VERIFY( !SGPath::standardLocation(SGPath::DOCUMENTS).isNull() );
+    VERIFY( !SGPath::standardLocation(SGPath::PICTURES ).isNull() );
 }
 
 SGPath::Permissions validateNone(const SGPath&)
@@ -178,12 +192,12 @@ int main(int argc, char* argv[])
     pp.append("./test-dir/file.txt");
     COMPARE(pp.create_dir(0700), -3);
 
-    pp.setPermissonChecker(&validateRead);
+    pp.setPermissionChecker(&validateRead);
     COMPARE(pp.canRead(), true);
     COMPARE(pp.canWrite(), false);
     COMPARE(pp.create_dir(0700), -3);
 
-    pp.setPermissonChecker(&validateWrite);
+    pp.setPermissionChecker(&validateWrite);
     COMPARE(pp.canRead(), false);
     COMPARE(pp.canWrite(), true);
 

simgear/misc/sg_path.cxx

@@ -55,6 +55,79 @@ static const char sgSearchPathSep = ';';
 static const char sgSearchPathSep = ':';
 #endif
 
+#ifdef _WIN32
+#include <ShlObj.h> // for CSIDL
+
+static SGPath pathForCSIDL(int csidl, const SGPath& def)
+{
+	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPSTR, int, BOOL);
+	static GetSpecialFolderPath SHGetSpecialFolderPath = NULL;
+
+	// lazy open+resolve of shell32
+	if (!SHGetSpecialFolderPath) {
+		HINSTANCE shellDll = ::LoadLibrary("shell32");
+		SHGetSpecialFolderPath = (GetSpecialFolderPath) GetProcAddress(shellDll, "SHGetSpecialFolderPathA");
+	}
+
+	if (!SHGetSpecialFolderPath){
+		return def;
+	}
+
+	char path[MAX_PATH];
+	if (SHGetSpecialFolderPath(0, path, csidl, false)) {
+		return SGPath(path, def.getPermissionChecker());
+	}
+
+	return def;
+}
+#elif __APPLE__
+
+// defined in CocoaHelpers.mm
+SGPath appleSpecialFolder(int dirType, int domainMask, const SGPath& def);
+
+#else
+static SGPath getXDGDir( const std::string& name,
+                         const SGPath& def,
+                         const std::string& fallback )
+{
+  // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+  // $XDG_CONFIG_HOME defines the base directory relative to which user specific
+  // configuration files should be stored. If $XDG_CONFIG_HOME is either not set
+  // or empty, a default equal to $HOME/.config should be used.
+  const SGPath user_dirs = SGPath::fromEnv( "XDG_CONFIG_HOME",
+                                            SGPath::home() / ".config")
+                         / "user-dirs.dirs";
+
+  // Format is XDG_xxx_DIR="$HOME/yyy", where yyy is a shell-escaped
+  // homedir-relative path, or XDG_xxx_DIR="/yyy", where /yyy is an absolute
+  // path. No other format is supported.
+  const std::string XDG_ID = "XDG_" + name + "_DIR=\"";
+
+  std::ifstream user_dirs_file( user_dirs.c_str() );
+  std::string line;
+  while( std::getline(user_dirs_file, line).good() )
+  {
+    if( !starts_with(line, XDG_ID) || *line.rbegin() != '"' )
+      continue;
+
+    // Extract dir from XDG_<name>_DIR="<dir>"
+    line = line.substr(XDG_ID.length(), line.length() - XDG_ID.length() - 1 );
+
+    const std::string HOME = "$HOME";
+    if( starts_with(line, HOME) )
+      return SGPath::home(def)
+           / simgear::strutils::unescape(line.substr(HOME.length()));
+
+    return SGPath(line, def.getPermissionChecker());
+  }
+
+  if( def.isNull() )
+    return SGPath::home(def) / fallback;
+
+  return def;
+}
+#endif
 
 // For windows, replace "\" by "/".
 void
@@ -75,7 +148,7 @@ SGPath::fix()
 
 
 // default constructor
-SGPath::SGPath(PermissonChecker validator)
+SGPath::SGPath(PermissionChecker validator)
     : path(""),
     _permission_checker(validator),
     _cached(false),
@@ -86,7 +159,7 @@ SGPath::SGPath(PermissonChecker validator)
 
 
 // create a path based on "path"
-SGPath::SGPath( const std::string& p, PermissonChecker validator )
+SGPath::SGPath( const std::string& p, PermissionChecker validator )
     : path(p),
     _permission_checker(validator),
     _cached(false),
@@ -99,7 +172,7 @@ SGPath::SGPath( const std::string& p, PermissonChecker validator )
 // create a path based on "path" and a "subpath"
 SGPath::SGPath( const SGPath& p,
                 const std::string& r,
-                PermissonChecker validator )
+                PermissionChecker validator )
     : path(p.path),
     _permission_checker(validator),
     _cached(false),
@@ -155,14 +228,14 @@ void SGPath::set( const string& p ) {
 }
 
 //------------------------------------------------------------------------------
-void SGPath::setPermissonChecker(PermissonChecker validator)
+void SGPath::setPermissionChecker(PermissionChecker validator)
 {
   _permission_checker = validator;
   _rwCached = false;
 }
 
 //------------------------------------------------------------------------------
-SGPath::PermissonChecker SGPath::getPermissonChecker() const
+SGPath::PermissionChecker SGPath::getPermissionChecker() const
 {
   return _permission_checker;
 }
@@ -306,19 +379,27 @@ string SGPath::complete_lower_extension() const
     }
 }
 
+//------------------------------------------------------------------------------
 void SGPath::validate() const
 {
   if (_cached && _cacheEnabled) {
     return;
   }
 
+  if (path.empty()) {
+	  _exists = false;
+	  return;
+  }
+
 #ifdef _WIN32
   struct _stat buf ;
-
   bool remove_trailing = false;
-  if ( path.length() > 1 && path[path.length()-1] == '/' )
-      remove_trailing=true;
-  if (_stat (path.substr(0,remove_trailing?path.length()-1:path.length()).c_str(), &buf ) < 0) {
+  string statPath(path);
+  if ((path.length() > 1) && (path.back() == '/')) {
+	  statPath.pop_back();
+  }
+      
+  if (_stat(statPath.c_str(), &buf ) < 0) {
     _exists = false;
   } else {
     _exists = true;
@@ -343,6 +424,7 @@ void SGPath::validate() const
   _cached = true;
 }
 
+//------------------------------------------------------------------------------
 void SGPath::checkAccess() const
 {
   if( _rwCached && _cacheEnabled )
@@ -395,14 +477,23 @@ bool SGPath::isFile() const
   return _exists && _isFile;
 }
 
+//------------------------------------------------------------------------------
 #ifdef _WIN32
 #  define sgMkDir(d,m)       _mkdir(d)
 #else
 #  define sgMkDir(d,m)       mkdir(d,m)
 #endif
 
+int SGPath::create_dir(mode_t mode)
+{
+  if( !canWrite() )
+  {
+    SG_LOG( SG_IO,
+            SG_WARN, "Error creating directory for '" << str() << "'"
+                                                    " reason: access denied" );
+    return -3;
+  }
 
-int SGPath::create_dir( mode_t mode ) {
     string_list dirlist = sgPathSplit(dir());
     if ( dirlist.empty() )
         return -1;
@@ -419,37 +510,31 @@ int SGPath::create_dir( mode_t mode ) {
         i = 2;
     }
 #endif
-    struct stat info;
-    int r;
-    for(; ( r = stat( dir.c_str(), &info ) ) == 0 && i < path_elements.size(); i++) {
-        dir.append(path_elements[i]);
-    }
-    if ( r == 0 ) {
-        return 0; // Directory already exists
-    }
-    for(;;)
+  struct stat info;
+  int r;
+  for(; (r = stat(dir.c_str(), &info)) == 0 && i < path_elements.size(); ++i)
+    dir.append(path_elements[i]);
+  if( r == 0 )
+      return 0; // Directory already exists
+
+  for(;;)
+  {
+    if( sgMkDir(dir.c_str(), mode) )
     {
-      if( !dir.canWrite() )
-      {
-        SG_LOG( SG_IO,
-                SG_WARN, "Error creating directory: (" << dir.str() << ")" <<
-                                                  " reason: access denied" );
-        return -3;
-      }
-      else if( sgMkDir(dir.c_str(), mode) )
-      {
-        SG_LOG( SG_IO,
-                SG_ALERT, "Error creating directory: (" << dir.str() << ")" );
-        return -2;
-      }
-
-      if( i >= path_elements.size() )
-        return  0;
-
-      dir.append(path_elements[i++]);
+      SG_LOG( SG_IO,
+              SG_ALERT, "Error creating directory: (" << dir.str() << ")" );
+      return -2;
     }
+    else
+      SG_LOG(SG_IO, SG_DEBUG, "Directory created: " << dir.str());
 
-    return 0;
+    if( i >= path_elements.size() )
+      return 0;
+
+    dir.append(path_elements[i++]);
+  }
+
+  return 0;
 }
 
 string_list sgPathBranchSplit( const string &dirpath ) {
@@ -612,6 +697,56 @@ bool SGPath::rename(const SGPath& newName)
   return true;
 }
 
+//------------------------------------------------------------------------------
+SGPath SGPath::standardLocation(StandardLocation type, const SGPath& def)
+{
+  switch(type)
+  {
+    case HOME:
+      return home(def);
+#ifdef _WIN32
+    case DESKTOP:
+      return pathForCSIDL(CSIDL_DESKTOPDIRECTORY, def);
+    case DOWNLOADS:
+      // TODO use KnownFolders
+      // http://msdn.microsoft.com/en-us/library/bb776911%28v=vs.85%29.aspx
+      if( !def.isNull() )
+        return def;
+
+      return pathForCSIDL(CSIDL_DESKTOPDIRECTORY, def);
+    case DOCUMENTS:
+      return pathForCSIDL(CSIDL_MYDOCUMENTS, def);
+    case PICTURES:
+      return pathForCSIDL(CSIDL_MYPICTURES, def);
+#elif __APPLE__
+      // since this is C++, we can't include NSPathUtilities.h to access the enum
+      // values, so hard-coding them here (they are stable, don't worry)
+    case DOWNLOADS:
+      return appleSpecialFolder(15, 1, def);
+    case DESKTOP:
+      return appleSpecialFolder(12, 1, def);
+    case DOCUMENTS:
+      return appleSpecialFolder(9, 1, def);
+    case PICTURES:
+      return appleSpecialFolder(19, 1, def);
+#else
+    case DESKTOP:
+      return getXDGDir("DESKTOP", def, "Desktop");
+    case DOWNLOADS:
+      return getXDGDir("DOWNLOADS", def, "Downloads");
+    case DOCUMENTS:
+      return getXDGDir("DOCUMENTS", def, "Documents");
+    case PICTURES:
+      return getXDGDir("PICTURES", def, "Pictures");
+#endif
+    default:
+      SG_LOG( SG_GENERAL,
+              SG_WARN,
+              "SGPath::standardLocation() unhandled type: " << type );
+      return def;
+  }
+}
+
 //------------------------------------------------------------------------------
 SGPath SGPath::fromEnv(const char* name, const SGPath& def)
 {
@@ -636,89 +771,19 @@ SGPath SGPath::home(const SGPath& def)
 }
 #endif
 
-#ifdef _WIN32
-
-#include <ShlObj.h> // for CSIDL
-
 //------------------------------------------------------------------------------
 SGPath SGPath::desktop(const SGPath& def)
 {
-	typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPSTR, int, BOOL);
-	static GetSpecialFolderPath SHGetSpecialFolderPath = NULL;
-
-	// lazy open+resolve of shell32
-	if (!SHGetSpecialFolderPath) {
-		HINSTANCE shellDll = ::LoadLibrary("shell32");
-		SHGetSpecialFolderPath = (GetSpecialFolderPath) GetProcAddress(shellDll, "SHGetSpecialFolderPathA");
-	}
-
-	if (!SHGetSpecialFolderPath){
-		return def;
-	}
-
-	char path[MAX_PATH];
-	if (SHGetSpecialFolderPath(0, path, CSIDL_DESKTOPDIRECTORY, false)) {
-		return SGPath(path, def._permission_checker);
-	}
-
-	SG_LOG(SG_GENERAL, SG_ALERT, "SGPath::desktop() failed, bad" );
-	return def;
+  return standardLocation(DESKTOP, def);
 }
-#elif __APPLE__
-#include <CoreServices/CoreServices.h>
 
 //------------------------------------------------------------------------------
-SGPath SGPath::desktop(const SGPath& def)
+SGPath SGPath::documents(const SGPath& def)
 {
-  FSRef ref;
-  OSErr err = FSFindFolder(kUserDomain, kDesktopFolderType, false, &ref);
-  if (err)
-    return def;
-
-  unsigned char path[1024];
-  if (FSRefMakePath(&ref, path, 1024) != noErr)
-      return def;
-
-  return SGPath((const char*) path, def._permission_checker);
+  return standardLocation(DOCUMENTS, def);
 }
-#else
+
 //------------------------------------------------------------------------------
-SGPath SGPath::desktop(const SGPath& def)
-{
-  // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-
-  // $XDG_CONFIG_HOME defines the base directory relative to which user specific
-  // configuration files should be stored. If $XDG_CONFIG_HOME is either not set
-  // or empty, a default equal to $HOME/.config should be used.
-  const SGPath user_dirs = fromEnv("XDG_CONFIG_HOME", home() / ".config")
-                         / "user-dirs.dirs";
-
-  // Format is XDG_xxx_DIR="$HOME/yyy", where yyy is a shell-escaped
-  // homedir-relative path, or XDG_xxx_DIR="/yyy", where /yyy is an absolute
-  // path. No other format is supported.
-  const std::string DESKTOP = "XDG_DESKTOP_DIR=\"";
-
-  std::ifstream user_dirs_file( user_dirs.c_str() );
-  std::string line;
-  while( std::getline(user_dirs_file, line).good() )
-  {
-    if( !starts_with(line, DESKTOP) || *line.rbegin() != '"' )
-      continue;
-
-    // Extract dir from XDG_DESKTOP_DIR="<dir>"
-    line = line.substr(DESKTOP.length(), line.length() - DESKTOP.length() - 1 );
-
-    const std::string HOME = "$HOME";
-    if( starts_with(line, HOME) )
-      return home(def) / simgear::strutils::unescape(line.substr(HOME.length()));
-
-    return SGPath(line, def._permission_checker);
-  }
-
-  return home(def) / "Desktop";
-}
-#endif
-
 std::string SGPath::realpath() const
 {
 #if (defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= 1050)

simgear/misc/sg_path.hxx

@@ -57,10 +57,10 @@ public:
       bool read : 1;
       bool write : 1;
     };
-    typedef Permissions (*PermissonChecker)(const SGPath&);
+    typedef Permissions (*PermissionChecker)(const SGPath&);
 
     /** Default constructor */
-    explicit SGPath(PermissonChecker validator = NULL);
+    explicit SGPath(PermissionChecker validator = NULL);
 
     /** Copy contructor */
     SGPath(const SGPath& p);
@@ -71,7 +71,7 @@ public:
      * Construct a path based on the starting path provided.
      * @param p initial path
      */
-    SGPath( const std::string& p, PermissonChecker validator = NULL );
+    SGPath( const std::string& p, PermissionChecker validator = NULL );
 
     /**
      * Construct a path based on the starting path provided and a relative subpath
@@ -80,7 +80,7 @@ public:
      */
     SGPath( const SGPath& p,
             const std::string& r,
-            PermissonChecker validator = NULL );
+            PermissionChecker validator = NULL );
 
     /** Destructor */
     ~SGPath();
@@ -95,8 +95,8 @@ public:
     bool operator==(const SGPath& other) const;
     bool operator!=(const SGPath& other) const;
 
-    void setPermissonChecker(PermissonChecker validator);
-    PermissonChecker getPermissonChecker() const;
+    void setPermissionChecker(PermissionChecker validator);
+    PermissionChecker getPermissionChecker() const;
 
     /**
      * Set if file information (exists, type, mod-time) is cached or
@@ -206,9 +206,12 @@ public:
 
     /**
      * Create the designated directory.
+     *
+     * @param mode Permissions. See:
+     *    http://en.wikipedia.org/wiki/File_system_permissions#Numeric_notation
      * @return 0 on success, or <0 on failure.
      */
-    int create_dir(mode_t mode);
+    int create_dir(mode_t mode = 0755);
 
     /**
      * Check if reading file is allowed. Readabilty does not imply the existance
@@ -257,6 +260,18 @@ public:
      */
     bool rename(const SGPath& newName);
 
+    enum StandardLocation
+    {
+      HOME,
+      DESKTOP,
+      DOWNLOADS,
+      DOCUMENTS,
+      PICTURES
+    };
+
+    static SGPath standardLocation( StandardLocation type,
+                                    const SGPath& def = SGPath() );
+
     /**
      * Get a path stored in the environment variable with the given \a name.
      *
@@ -276,6 +291,11 @@ public:
      */
     static SGPath desktop(const SGPath& def = SGPath());
 
+	/**
+     * Get path to the user's documents directory
+     */
+    static SGPath documents(const SGPath& def = SGPath());
+
 private:
 
     void fix();
@@ -284,7 +304,7 @@ private:
     void checkAccess() const;
 
     std::string path;
-    PermissonChecker _permission_checker;
+    PermissionChecker _permission_checker;
 
     mutable bool _cached : 1;
     mutable bool _rwCached : 1;

simgear/misc/sgstream_test.cxx

@@ -20,7 +20,7 @@ int main()
            "third line ends with both\r\n"
            "fourth line as well\r\n"
            "fifth line is another CR/LF line\r\n"
-           "end of test\r\n", 1024);
+           "end of test\r\n", 158);
        f.close();
    }
 

simgear/misc/strutils.cxx

@@ -27,6 +27,7 @@
 #include "strutils.hxx"
 
 #include <simgear/debug/logstream.hxx>
+#include <simgear/package/md5.h>
 
 using std::string;
 using std::vector;
@@ -53,8 +54,11 @@ namespace simgear {
 		size_t len = get_length (p);
 		if (len == 1) return *p;
 		value_type res = static_cast<unsigned char> ( *p & (0xff >> (len + 1))) << ((len - 1) * 6 );
-		for (--len; len; --len)
-			res |= (static_cast<unsigned char> (*(++p)) - 0x80) << ((len - 1) * 6);
+		for (--len; len; --len) {
+		        value_type next_byte = static_cast<unsigned char> (*(++p)) - 0x80;
+		        if (next_byte & 0xC0) return 0x00ffffff; // invalid UTF-8
+			res |= next_byte << ((len - 1) * 6);
+			}
 		return res;
 	}
 
@@ -62,6 +66,7 @@ namespace simgear {
 		string s_latin1;
 		for (string::iterator p = s_utf8.begin(); p != s_utf8.end(); ++p) {
 			value_type value = get_value<string::iterator&>(p);
+			if (value > 0x10ffff) return s_utf8; // invalid UTF-8: guess that the input was already Latin-1
 			if (value > 0xff) SG_LOG(SG_IO, SG_WARN, "utf8ToLatin1: wrong char value: " << value);
 			s_latin1 += static_cast<char>(value);
 		}
@@ -397,8 +402,32 @@ std::string convertWindowsLocal8BitToUtf8(const std::string& a)
 #endif
 }
 
+//------------------------------------------------------------------------------
+std::string md5(const unsigned char* data, size_t num)
+{
+  SG_MD5_CTX md5_ctx;
+  SG_MD5Init(&md5_ctx);
+  SG_MD5Update(&md5_ctx, data, num);
 
+  unsigned char digest[MD5_DIGEST_LENGTH];
+  SG_MD5Final(digest, &md5_ctx);
 
+  return encodeHex(digest, MD5_DIGEST_LENGTH);
+}
+
+//------------------------------------------------------------------------------
+std::string md5(const char* data, size_t num)
+{
+  return md5(reinterpret_cast<const unsigned char*>(data), num);
+}
+
+//------------------------------------------------------------------------------
+std::string md5(const std::string& str)
+{
+  return md5(reinterpret_cast<const unsigned char*>(str.c_str()), str.size());
+}
+
+//------------------------------------------------------------------------------
 static const std::string base64_chars =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "abcdefghijklmnopqrstuvwxyz"
@@ -478,28 +507,24 @@ void decodeBase64(const std::string& encoded_string, std::vector<unsigned char>&
   }
 }  
 
+//------------------------------------------------------------------------------
 const char hexChar[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
 std::string encodeHex(const std::string& bytes)
 {
-  std::string hex;
-  size_t count = bytes.size();
-  for (unsigned int i=0; i<count;++i) {
-      unsigned char c = bytes[i];
-      hex.push_back(hexChar[c >> 4]);
-      hex.push_back(hexChar[c & 0x0f]);
-  }
-  
-  return hex;
+  return encodeHex(
+    reinterpret_cast<const unsigned char*>(bytes.c_str()),
+    bytes.size()
+  );
 }
 
 std::string encodeHex(const unsigned char* rawBytes, unsigned int length)
 {
-  std::string hex;
+  std::string hex(length * 2, '\0');
   for (unsigned int i=0; i<length;++i) {
       unsigned char c = *rawBytes++;
-      hex.push_back(hexChar[c >> 4]);
-      hex.push_back(hexChar[c & 0x0f]);
+      hex[i * 2] = hexChar[c >> 4];
+      hex[i * 2 + 1] = hexChar[c & 0x0f];
   }
   
   return hex;

simgear/misc/strutils.hxx

@@ -176,6 +176,13 @@ namespace simgear {
     WCharVec convertUtf8ToWString(const std::string& a);
 #endif
 
+    /**
+     * Get md5 hash of raw data.
+     */
+    std::string md5(const unsigned char* data, size_t num);
+    std::string md5(const char* data, size_t num);
+    std::string md5(const std::string& str);
+
     /**
      * convert base-64 encoded data to raw bytes (possibly with embedded
      * NULs). Throws an exception if input data is not base64, or is

simgear/misc/strutils_test.cxx

@@ -1,84 +1,80 @@
-////////////////////////////////////////////////////////////////////////
-// Test harness.
-////////////////////////////////////////////////////////////////////////
+/// Unit tests for function inside strutils package
+#define BOOST_TEST_MODULE misc
+#include <BoostTestTargetConfig.h>
 
 #include <simgear/compiler.h>
-
-#include <iostream>
 #include "strutils.hxx"
 
-using std::cout;
-using std::cerr;
-using std::endl;
+namespace strutils = simgear::strutils;
 
-using namespace simgear::strutils;
-
-#define COMPARE(a, b) \
-    if ((a) != (b))  { \
-        cerr << "failed:" << #a << " != " << #b << endl; \
-        exit(1); \
-    }
-
-#define VERIFY(a) \
-    if (!(a))  { \
-        cerr << "failed:" << #a << endl; \
-        exit(1); \
-    }
-    
-int main (int ac, char ** av)
+BOOST_AUTO_TEST_CASE( strutils_functions )
 {
-    std::string a("abcd");
-    COMPARE(strip(a), a);
-    COMPARE(strip(" a "), "a");
-    COMPARE(lstrip(" a  "), "a  ");
-    COMPARE(rstrip("\ta "), "\ta");
-    // check internal spacing is preserved
-    COMPARE(strip("\t \na \t b\r \n "), "a \t b");
-    
-    
-    VERIFY(starts_with("banana", "ban"));
-    VERIFY(!starts_with("abanana", "ban"));
-    VERIFY(starts_with("banana", "banana")); // pass - string starts with itself
-    VERIFY(!starts_with("ban", "banana")); // fail - original string is prefix of 
-    
-    VERIFY(ends_with("banana", "ana"));
-    VERIFY(ends_with("foo.text", ".text"));
-    VERIFY(!ends_with("foo.text", ".html"));
-    
-    COMPARE(simplify("\ta\t b  \nc\n\r \r\n"), "a b c");
-    COMPARE(simplify("The quick  - brown dog!"), "The quick - brown dog!");
-    COMPARE(simplify("\r\n  \r\n   \t  \r"), "");
-    
-    COMPARE(to_int("999"), 999);
-    COMPARE(to_int("0000000"), 0);
-    COMPARE(to_int("-10000"), -10000);
-    
-    VERIFY(compare_versions("1.0.12", "1.1") < 0);
-    VERIFY(compare_versions("1.1", "1.0.12") > 0);
-    VERIFY(compare_versions("10.6.7", "10.6.7") == 0);
-    VERIFY(compare_versions("2.0", "2.0.99") < 0);
-    VERIFY(compare_versions("99", "99") == 0);
-    VERIFY(compare_versions("99", "98") > 0);
-    
-// since we compare numerically, leasing zeros shouldn't matter
-    VERIFY(compare_versions("0.06.7", "0.6.07") == 0);
-    
-    string_list la = split("zero one two three four five");
-    COMPARE(la[2], "two");
-    COMPARE(la[5], "five");
-    COMPARE(la.size(), 6);
-    
-    string_list lb = split("alpha:beta:gamma:delta", ":", 2);
-    COMPARE(lb.size(), 3);
-    COMPARE(lb[0], "alpha");
-    COMPARE(lb[1], "beta");
-    COMPARE(lb[2], "gamma:delta");
-    
-    std::string j = join(la, "&");
-    COMPARE(j, "zero&one&two&three&four&five");
+  std::string a("abcd");
+  BOOST_CHECK_EQUAL(strutils::strip(a), a);
+  BOOST_CHECK_EQUAL(strutils::strip(" a "), "a");
+  BOOST_CHECK_EQUAL(strutils::lstrip(" a  "), "a  ");
+  BOOST_CHECK_EQUAL(strutils::rstrip("\ta "), "\ta");
 
-    COMPARE(unescape("\\ \\n\\t\\x41\\117a"), " \n\tAOa");
+  // check internal spacing is preserved
+  BOOST_CHECK_EQUAL(strutils::strip("\t \na \t b\r \n "), "a \t b");
 
-    cout << "all tests passed successfully!" << endl;
-    return 0;
+
+  BOOST_CHECK(strutils::starts_with("banana", "ban"));
+  BOOST_CHECK(!strutils::starts_with("abanana", "ban"));
+  BOOST_CHECK(strutils::starts_with("banana", "banana")); // pass - string starts with itself
+  BOOST_CHECK(!strutils::starts_with("ban", "banana")); // fail - original string is prefix of
+
+  BOOST_CHECK(strutils::ends_with("banana", "ana"));
+  BOOST_CHECK(strutils::ends_with("foo.text", ".text"));
+  BOOST_CHECK(!strutils::ends_with("foo.text", ".html"));
+
+  BOOST_CHECK_EQUAL(strutils::simplify("\ta\t b  \nc\n\r \r\n"), "a b c");
+  BOOST_CHECK_EQUAL(strutils::simplify("The quick  - brown dog!"), "The quick - brown dog!");
+  BOOST_CHECK_EQUAL(strutils::simplify("\r\n  \r\n   \t  \r"), "");
+
+  BOOST_CHECK_EQUAL(strutils::to_int("999"), 999);
+  BOOST_CHECK_EQUAL(strutils::to_int("0000000"), 0);
+  BOOST_CHECK_EQUAL(strutils::to_int("-10000"), -10000);
+
+  string_list la = strutils::split("zero one two three four five");
+  BOOST_CHECK_EQUAL(la[2], "two");
+  BOOST_CHECK_EQUAL(la[5], "five");
+  BOOST_CHECK_EQUAL(la.size(), 6);
+
+  string_list lb = strutils::split("alpha:beta:gamma:delta", ":", 2);
+  BOOST_CHECK_EQUAL(lb.size(), 3);
+  BOOST_CHECK_EQUAL(lb[0], "alpha");
+  BOOST_CHECK_EQUAL(lb[1], "beta");
+  BOOST_CHECK_EQUAL(lb[2], "gamma:delta");
+
+  std::string j = strutils::join(la, "&");
+  BOOST_CHECK_EQUAL(j, "zero&one&two&three&four&five");
+
+  BOOST_CHECK_EQUAL(strutils::unescape("\\ \\n\\t\\x41\\117a"), " \n\tAOa");
+}
+
+BOOST_AUTO_TEST_CASE( compare_versions )
+{
+  BOOST_CHECK_LT(strutils::compare_versions("1.0.12", "1.1"), 0);
+  BOOST_CHECK_GT(strutils::compare_versions("1.1", "1.0.12"), 0);
+  BOOST_CHECK_EQUAL(strutils::compare_versions("10.6.7", "10.6.7"), 0);
+  BOOST_CHECK_LT(strutils::compare_versions("2.0", "2.0.99"), 0);
+  BOOST_CHECK_EQUAL(strutils::compare_versions("99", "99"), 0);
+  BOOST_CHECK_GT(strutils::compare_versions("99", "98"), 0);
+
+  // since we compare numerically, leasing zeros shouldn't matter
+  BOOST_CHECK_EQUAL(strutils::compare_versions("0.06.7", "0.6.07"), 0);
+}
+
+BOOST_AUTO_TEST_CASE( md5_hex )
+{
+  // hex encoding
+  unsigned char raw_data[] = {0x0f, 0x1a, 0xbc, 0xd2, 0xe3, 0x45, 0x67, 0x89};
+  const std::string& hex_data =
+    strutils::encodeHex(raw_data, sizeof(raw_data)/sizeof(raw_data[0]));
+  BOOST_REQUIRE_EQUAL(hex_data, "0f1abcd2e3456789");
+  BOOST_REQUIRE_EQUAL(strutils::encodeHex("abcde"), "6162636465");
+
+  // md5
+  BOOST_CHECK_EQUAL(strutils::md5("test"), "098f6bcd4621d373cade4e832627b4f6");
 }

simgear/misc/test_macros.hxx

@@ -2,18 +2,37 @@
 #ifndef SG_MISC_TEST_MACROS_HXX
 #define SG_MISC_TEST_MACROS_HXX
 
+#include <cmath> // for fabs()
+
 #define COMPARE(a, b) \
     if ((a) != (b))  { \
         std::cerr << "failed:" << #a << " != " << #b << std::endl; \
         std::cerr << "\tgot:'" << a << "'" << std::endl; \
+        std::cerr << "\tat:" << __FILE__ << ":" << __LINE__ << std::endl; \
         exit(1); \
     }
 
 #define VERIFY(a) \
     if (!(a))  { \
         std::cerr << "failed:" << #a << std::endl; \
+        std::cerr << "\tat:" << __FILE__ << ":" << __LINE__ << std::endl; \
         exit(1); \
     }
-    
-    
+
+#define COMPARE_EP(a, b) \
+    if (fabs(a - b) > SG_EPSILON)  { \
+        std::cerr << "failed with epsilon:" << #a << " != " << #b << std::endl; \
+        std::cerr << "\tgot:'" << a << "'" << std::endl; \
+        std::cerr << "\tat:" << __FILE__ << ":" << __LINE__ << std::endl; \
+        exit(1); \
+    }
+
+#define COMPARE_EP2(a, b, ep) \
+    if (fabs(a - b) > ep)  { \
+        std::cerr << "failed with epsilon:" << #a << " != " << #b << std::endl; \
+        std::cerr << "\tgot:'" << a << "'" << std::endl; \
+        std::cerr << "\tat:" << __FILE__ << ":" << __LINE__ << std::endl; \
+        exit(1); \
+    }
+
 #endif // of SG_MISC_TEST_MACROS_HXX

simgear/misc/utf8tolatin1_test.cxx

@@ -0,0 +1,26 @@
+/// Unit tests for utf8ToLatin1 conversion function
+#define BOOST_TEST_MODULE misc
+#include <BoostTestTargetConfig.h>
+
+#include "strutils.hxx"
+#include <string>
+
+BOOST_AUTO_TEST_CASE( utf8_latin1_conversion )
+{
+  std::string utf8_string1 = "Zweibr\u00FCcken";
+  //valid UTF-8, convertible to Latin-1
+  std::string latin1_string1 = "Zweibr\374cken";
+  //Latin-1, not valid UTF-8
+  std::string utf8_string2 = "\u600f\U00010143";
+  //valid UTF-8, out of range for Latin-1
+
+  std::string output_string1u = simgear::strutils::utf8ToLatin1(utf8_string1);
+  BOOST_CHECK_EQUAL(output_string1u, latin1_string1);
+
+  std::string output_string1l = simgear::strutils::utf8ToLatin1(latin1_string1);
+  BOOST_CHECK_EQUAL(output_string1l, latin1_string1);
+
+  std::string output_string3 = simgear::strutils::utf8ToLatin1(utf8_string2);
+  //we don't check the result of this one as there is no right answer,
+  //just make sure it doesn't crash/hang
+}

simgear/nasal/code.c

@@ -71,7 +71,9 @@ static double numify(naContext ctx, naRef o)
     else if(IS_NIL(o)) ERR(ctx, "nil used in numeric context");
     else if(!IS_STR(o)) ERR(ctx, "non-scalar in numeric context");
     else if(naStr_tonum(o, &n)) return n;
-    else ERR(ctx, "non-numeric string in numeric context");
+    else naRuntimeError( ctx,
+                         "non-numeric string in numeric context: '%s'",
+                         naStr_data(o) );
     return 0;
 }
 
@@ -592,6 +594,9 @@ static naRef run(naContext ctx)
         case OP_LTE:   BINOP(l <= r ? 1 : 0); break;
         case OP_GT:    BINOP(l >  r ? 1 : 0); break;
         case OP_GTE:   BINOP(l >= r ? 1 : 0); break;
+        case OP_BIT_AND: BINOP((int)l & (int)r); break;
+        case OP_BIT_OR:  BINOP((int)l | (int)r); break;
+        case OP_BIT_XOR: BINOP((int)l ^ (int)r); break;
 #undef BINOP
 
         case OP_EQ: case OP_NEQ:
@@ -605,6 +610,9 @@ static naRef run(naContext ctx)
         case OP_NEG:
             STK(1) = naNum(-numify(ctx, STK(1)));
             break;
+        case OP_BIT_NEG:
+            STK(1) = naNum(~(int)numify(ctx, STK(1)));
+            break;
         case OP_NOT:
             STK(1) = naNum(boolify(ctx, STK(1)) ? 0 : 1);
             break;

simgear/nasal/code.h

@@ -26,7 +26,8 @@ enum {
     OP_MEMBER, OP_SETMEMBER, OP_LOCAL, OP_SETLOCAL, OP_NEWVEC, OP_VAPPEND,
     OP_NEWHASH, OP_HAPPEND, OP_MARK, OP_UNMARK, OP_BREAK, OP_SETSYM, OP_DUP2,
     OP_INDEX, OP_BREAK2, OP_PUSHEND, OP_JIFTRUE, OP_JIFNOT, OP_FCALLH,
-    OP_MCALLH, OP_XCHG2, OP_UNPACK, OP_SLICE, OP_SLICE2
+    OP_MCALLH, OP_XCHG2, OP_UNPACK, OP_SLICE, OP_SLICE2, OP_BIT_AND, OP_BIT_OR,
+    OP_BIT_XOR, OP_BIT_NEG
 };
 
 struct Frame {

simgear/nasal/codegen.c

@@ -7,6 +7,7 @@
 // These are more sensical predicate names in most contexts in this file
 #define LEFT(tok)   ((tok)->children)
 #define RIGHT(tok)  ((tok)->lastChild)
+#define UNARY(tok)  (LEFT(tok) && LEFT(tok) == RIGHT(tok))
 #define BINARY(tok) (LEFT(tok) && RIGHT(tok) && LEFT(tok)->next == RIGHT(tok))
 
 // Forward references for recursion
@@ -165,6 +166,15 @@ static int defArg(struct Parser* p, struct Token* t)
         RIGHT(t)->num *= -1;
         return defArg(p, RIGHT(t));
     }
+    if(t->type == TOK_CAT && RIGHT(t) &&
+       RIGHT(t)->type == TOK_LITERAL && !RIGHT(t)->str)
+    {
+        /* default arguments are constants, but "~1" parses as two
+         * tokens, so we have to subset the expression generator for that
+         * case */
+        RIGHT(t)->num = ~(int)RIGHT(t)->num;
+        return defArg(p, RIGHT(t));
+    }
     return findConstantIndex(p, t);
 }
 
@@ -634,12 +644,16 @@ static void genExpr(struct Parser* p, struct Token* t)
         else genExpr(p, LEFT(t));
         break;
     case TOK_LBRA:
-        if(BINARY(t)) {
-            genExtract(p, t);
-        } else {
+        if(UNARY(t)) {
             emit(p, OP_NEWVEC);
             genList(p, LEFT(t), 1);
         }
+        else if(BINARY(t)) {
+            genExtract(p, t);
+        } else {
+            // forbid usage as 'vec[]'
+            naParseError(p, "missing index or slice expression(s)", t->line);
+        }
         break;
     case TOK_LCURL:
         emit(p, OP_NEWHASH);
@@ -673,6 +687,21 @@ static void genExpr(struct Parser* p, struct Token* t)
         genExpr(p, RIGHT(t)); // unary negation (see also TOK_MINUS!)
         emit(p, OP_NEG);
         break;
+    case TOK_CAT:
+        if(BINARY(t)) {
+            genBinOp(OP_CAT,    p, t); // string concatenation
+        } else if(RIGHT(t) && RIGHT(t)->type == TOK_LITERAL && !RIGHT(t)->str) {
+            RIGHT(t)->num = ~(int)RIGHT(t)->num; // Pre-negate constants
+            genScalarConstant(p, RIGHT(t));
+        } else {
+            genExpr(p, RIGHT(t));       // unary, bitwise negation
+            emit(p, OP_BIT_NEG);
+        }
+        break;
+    case TOK_BIT_NEG:
+        genExpr(p, RIGHT(t)); // unary, bitwise negation (see also TOK_CAT!)
+        emit(p, OP_BIT_NEG);
+        break;
     case TOK_DOT:
         genExpr(p, LEFT(t));
         if(!RIGHT(t) || RIGHT(t)->type != TOK_SYMBOL)
@@ -685,10 +714,12 @@ static void genExpr(struct Parser* p, struct Token* t)
     case TOK_AND: case TOK_OR:
         genShortCircuit(p, t);
         break;
+    case TOK_BIT_AND:genBinOp(OP_BIT_AND, p, t); break;
+    case TOK_BIT_OR: genBinOp(OP_BIT_OR,  p, t); break;
+    case TOK_BIT_XOR:genBinOp(OP_BIT_XOR, p, t); break;
     case TOK_MUL:   genBinOp(OP_MUL,    p, t); break;
     case TOK_PLUS:  genBinOp(OP_PLUS,   p, t); break;
     case TOK_DIV:   genBinOp(OP_DIV,    p, t); break;
-    case TOK_CAT:   genBinOp(OP_CAT,    p, t); break;
     case TOK_LT:    genBinOp(OP_LT,     p, t); break;
     case TOK_LTE:   genBinOp(OP_LTE,    p, t); break;
     case TOK_EQ:    genBinOp(OP_EQ,     p, t); break;
@@ -700,6 +731,9 @@ static void genExpr(struct Parser* p, struct Token* t)
     case TOK_MULEQ:   genEqOp(OP_MUL, p, t);   break;
     case TOK_DIVEQ:   genEqOp(OP_DIV, p, t);   break;
     case TOK_CATEQ:   genEqOp(OP_CAT, p, t);   break;
+    case TOK_BIT_ANDEQ: genEqOp(OP_BIT_AND, p, t); break;
+    case TOK_BIT_OREQ:  genEqOp(OP_BIT_OR,  p, t); break;
+    case TOK_BIT_XOREQ: genEqOp(OP_BIT_XOR, p, t); break;
     default:
         naParseError(p, "parse error", t->line);
     };