From a17ca8260aa4a1e414b6a19d3faeb18f914c3f31 Mon Sep 17 00:00:00 2001 From: brad kittenbrink Date: Mon, 26 Oct 2009 16:08:43 -0400 Subject: Beginning work for DEV-41722 normalizing shared lib staging on all 3 platforms. Renamed CopyWinLibs.cmake to Copy3rdPartyLibs.cmake. --- indra/llcommon/CMakeLists.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index e7aaf3c984..7a7281a4a7 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -8,9 +8,7 @@ include(Linking) include(Boost) include (Pth) -if (WINDOWS) - include(CopyWinLibs) -endif (WINDOWS) +include(Copy3rdPartyLibs) include_directories( ${EXPAT_INCLUDE_DIRS} -- cgit v1.3 From 4bff7b085381a514afb7e8546beaac5ad6117f9b Mon Sep 17 00:00:00 2001 From: brad kittenbrink Date: Wed, 4 Nov 2009 18:50:35 -0500 Subject: Wrap-up work for DEV-41724/DEV-41725 - normalizing shared library staging on all 3 platforms. Should now work out of the box on all 3 platforms and in the debugger. --- indra/cmake/Linking.cmake | 2 +- indra/llcommon/CMakeLists.txt | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/cmake/Linking.cmake b/indra/cmake/Linking.cmake index cce73ba08b..bca99caf2a 100644 --- a/indra/cmake/Linking.cmake +++ b/indra/cmake/Linking.cmake @@ -22,7 +22,7 @@ if (NOT STANDALONE) set(ARCH_PREBUILT_DIRS ${ARCH_PREBUILT_DIRS_RELEASE}) set(ARCH_PREBUILT_DIRS_DEBUG ${ARCH_PREBUILT_DIRS_RELEASE}) set(SHARED_LIB_STAGING_DIR ${CMAKE_BINARY_DIR}/sharedlibs CACHE FILEPATH "Location of staged DLLs") - set(EXE_STAGING_DIR ${CMAKE_BINARY_DIR}/sharedlibs CACHE FILEPATH "Location of staged executables") + set(EXE_STAGING_DIR "${CMAKE_BINARY_DIR}/sharedlibs/\$(CONFIGURATION)" CACHE FILEPATH "Location of staged executables") endif (WINDOWS) endif (NOT STANDALONE) diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index 7a7281a4a7..1e39a4474f 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -248,6 +248,13 @@ if(LLCOMMON_LINK_SHARED) if(NOT WINDOWS) get_target_property(LLCOMMON_PATH llcommon LOCATION) get_filename_component(LLCOMMON_FILE ${LLCOMMON_PATH} NAME) + if(DARWIN) + set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources) + else(DARWIN) + set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}) + endif(DARWIN) + + # *TODO - maybe make this a symbolic link? -brad add_custom_command( TARGET llcommon POST_BUILD COMMAND ${CMAKE_COMMAND} @@ -255,7 +262,7 @@ if(LLCOMMON_LINK_SHARED) -E copy_if_different ${LLCOMMON_PATH} - ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/${LLCOMMON_FILE} + ${SHARED_LIB_STAGING_DIR_CONFIG}/${LLCOMMON_FILE} COMMENT "Copying llcommon to the staging folder." ) endif(NOT WINDOWS) -- cgit v1.3 From ec32310c8602bf4dc69ed27e8c177cbd32c24411 Mon Sep 17 00:00:00 2001 From: palange Date: Thu, 5 Nov 2009 17:51:50 -0800 Subject: Removed search_dirs and dst_path arguments from ll_deploy_sharedlibs_command() Fixed mac breakage. --- indra/cmake/LLSharedLibs.cmake | 87 +++++++++++++++++++---------- indra/llcommon/CMakeLists.txt | 42 ++------------ indra/mac_crash_logger/CMakeLists.txt | 6 +- indra/mac_updater/CMakeLists.txt | 5 +- indra/test_apps/llplugintest/CMakeLists.txt | 6 +- indra/win_crash_logger/CMakeLists.txt | 5 +- indra/win_updater/CMakeLists.txt | 7 +-- 7 files changed, 67 insertions(+), 91 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/cmake/LLSharedLibs.cmake b/indra/cmake/LLSharedLibs.cmake index 28f0e7ad12..6f602680f4 100644 --- a/indra/cmake/LLSharedLibs.cmake +++ b/indra/cmake/LLSharedLibs.cmake @@ -1,49 +1,74 @@ - -if(DARWIN) - set(TMP_PATH "../Resource") -elseif(LINUX) - set(TMP_PATH "../lib") -else(DARWIN) - set(TMP_PATH ".") -endif(DARWIN) - - set(SHARED_LIB_REL_PATH ${TMP_PATH} CACHE STRING "Relative path from executable to shared libs") - # ll_deploy_sharedlibs_command # target_exe: the cmake target of the executable for which the shared libs will be deployed. -# search_dirs: a list of dirs to search for the dependencies -# dst_path: path to copy deps to, relative to the output location of the target_exe -macro(ll_deploy_sharedlibs_command target_exe search_dirs dst_path) - get_target_property(OUTPUT_LOCATION ${target_exe} LOCATION) - get_filename_component(OUTPUT_PATH ${OUTPUT_LOCATION} PATH) - +macro(ll_deploy_sharedlibs_command target_exe) + get_target_property(TARGET_LOCATION ${target_exe} LOCATION) + get_filename_component(OUTPUT_PATH ${TARGET_LOCATION} PATH) + if(DARWIN) + set(SEARCH_DIRS "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources") get_target_property(IS_BUNDLE ${target_exe} MACOSX_BUNDLE) if(IS_BUNDLE) - get_filename_component(TARGET_FILE ${OUTPUT_LOCATION} NAME) - set(OUTPUT_PATH ${OUTPUT_LOCATION}.app/Contents/MacOS) - set(OUTPUT_LOCATION ${OUTPUT_PATH}/${TARGET_FILE}) + # If its a bundle the exe is not in the target location, this should find it. + get_filename_component(TARGET_FILE ${TARGET_LOCATION} NAME) + set(OUTPUT_PATH ${TARGET_LOCATION}.app/Contents/MacOS) + set(TARGET_LOCATION ${OUTPUT_PATH}/${TARGET_FILE}) + set(OUTPUT_PATH ${OUTPUT_PATH}/../Resources) endif(IS_BUNDLE) + elseif(WINDOWS) + set(SEARCH_DIRS "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}" "$ENV{SystemRoot}/system32") + elseif(LINUX) + set(SEARCH_DIRS "${SHARED_LIB_STAGING_DIR}") + set(OUTPUT_PATH ${OUTPUT_PATH}/lib) endif(DARWIN) - if(WINDOWS) - set(REAL_SEARCH_DIRS ${search_dirs} "$ENV{SystemRoot}/system32") - endif(WINDOWS) - - if(LINUX) - message(FATAL_ERROR "LINUX Unsupported!?!") - endif(LINUX) - add_custom_command( TARGET ${target_exe} POST_BUILD COMMAND ${CMAKE_COMMAND} ARGS - "-DBIN_NAME=\"${OUTPUT_LOCATION}\"" - "-DSEARCH_DIRS=\"${REAL_SEARCH_DIRS}\"" - "-DDST_PATH=\"${OUTPUT_PATH}/${dst_path}\"" + "-DBIN_NAME=\"${TARGET_LOCATION}\"" + "-DSEARCH_DIRS=\"${SEARCH_DIRS}\"" + "-DDST_PATH=\"${OUTPUT_PATH}\"" "-P" "${CMAKE_SOURCE_DIR}/cmake/DeploySharedLibs.cmake" ) endmacro(ll_deploy_sharedlibs_command) +# ll_stage_sharedlib +# Performs config and adds a copy command for a sharedlib target. +macro(ll_stage_sharedlib DSO_TARGET) + if(SHARED_LIB_STAGING_DIR) + # target gets written to the DLL staging directory. + # Also this directory is shared with RunBuildTest.cmake, y'know, for the tests. + set_target_properties(${DSO_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${SHARED_LIB_STAGING_DIR}) + if(NOT WINDOWS) + get_target_property(DSO_PATH ${DSO_TARGET} LOCATION) + get_filename_component(DSO_FILE ${DSO_PATH} NAME) + if(DARWIN) + set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources) + else(DARWIN) + set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}) + endif(DARWIN) + + # *TODO - maybe make this a symbolic link? -brad + add_custom_command( + TARGET ${DSO_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} + ARGS + -E + copy_if_different + ${DSO_PATH} + ${SHARED_LIB_STAGING_DIR_CONFIG}/${DSO_FILE} + COMMENT "Copying llcommon to the staging folder." + ) + endif(NOT WINDOWS) + endif(SHARED_LIB_STAGING_DIR) + + if (DARWIN) + set_target_properties(${DSO_TARGET} PROPERTIES + BUILD_WITH_INSTALL_RPATH 1 + INSTALL_NAME_DIR "@executable_path/../Resources" + ) + endif(DARWIN) + +endmacro(ll_stage_sharedlib) \ No newline at end of file diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index ea36e65729..f40359790a 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -1,3 +1,4 @@ + # -*- cmake -*- project(llcommon) @@ -6,8 +7,8 @@ include(00-Common) include(LLCommon) include(Linking) include(Boost) -include (Pth) - +include(Pth) +include(LLSharedLibs) include(Copy3rdPartyLibs) include_directories( @@ -241,42 +242,7 @@ list(APPEND llcommon_SOURCE_FILES ${llcommon_HEADER_FILES}) if(LLCOMMON_LINK_SHARED) add_library (llcommon SHARED ${llcommon_SOURCE_FILES}) - - if(SHARED_LIB_STAGING_DIR) - # *FIX:Mani --- - # llcommon.dll get written to the DLL staging directory. - # Also this directory is shared with RunBuildTest.cmake, y'know, for the tests. - set_target_properties(llcommon PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${SHARED_LIB_STAGING_DIR}) - if(NOT WINDOWS) - get_target_property(LLCOMMON_PATH llcommon LOCATION) - get_filename_component(LLCOMMON_FILE ${LLCOMMON_PATH} NAME) - if(DARWIN) - set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources) - else(DARWIN) - set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}) - endif(DARWIN) - - # *TODO - maybe make this a symbolic link? -brad - add_custom_command( - TARGET llcommon POST_BUILD - COMMAND ${CMAKE_COMMAND} - ARGS - -E - copy_if_different - ${LLCOMMON_PATH} - ${SHARED_LIB_STAGING_DIR_CONFIG}/${LLCOMMON_FILE} - COMMENT "Copying llcommon to the staging folder." - ) - endif(NOT WINDOWS) - endif(SHARED_LIB_STAGING_DIR) - - if (DARWIN) - set_target_properties(llcommon PROPERTIES - BUILD_WITH_INSTALL_RPATH 1 - INSTALL_NAME_DIR "@executable_path/../Resources" - ) - endif(DARWIN) - + ll_stage_sharedlib(llcommon) else(LLCOMMON_LINK_SHARED) add_library (llcommon ${llcommon_SOURCE_FILES}) endif(LLCOMMON_LINK_SHARED) diff --git a/indra/mac_crash_logger/CMakeLists.txt b/indra/mac_crash_logger/CMakeLists.txt index 1c5a37c4c5..420e836e36 100644 --- a/indra/mac_crash_logger/CMakeLists.txt +++ b/indra/mac_crash_logger/CMakeLists.txt @@ -75,8 +75,6 @@ add_custom_command( ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mac-crash-logger.app/Contents/Resources/CrashReporter.nib ) -ll_deploy_sharedlibs_command( - mac-crash-logger - "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR};${ARCH_PREBUILT_DIRS}" - "../Resources") +ll_deploy_sharedlibs_command(mac-crash-logger) + diff --git a/indra/mac_updater/CMakeLists.txt b/indra/mac_updater/CMakeLists.txt index d7bd6f993c..57d426aa24 100644 --- a/indra/mac_updater/CMakeLists.txt +++ b/indra/mac_updater/CMakeLists.txt @@ -77,7 +77,4 @@ add_custom_command( ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mac-updater.app/Contents/Resources/AutoUpdater.nib ) -ll_deploy_sharedlibs_command( - mac-updater - "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR};${ARCH_PREBUILT_DIRS}" - "../Resources") +ll_deploy_sharedlibs_command(mac-updater) diff --git a/indra/test_apps/llplugintest/CMakeLists.txt b/indra/test_apps/llplugintest/CMakeLists.txt index 400f63cef0..0011daaec6 100644 --- a/indra/test_apps/llplugintest/CMakeLists.txt +++ b/indra/test_apps/llplugintest/CMakeLists.txt @@ -488,8 +488,4 @@ if(WINDOWS) endif(WINDOWS) -ll_deploy_sharedlibs_command( - llmediaplugintest - "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR};${ARCH_PREBUILT_DIRS}" - ${SHARED_LIB_REL_PATH} - ) +ll_deploy_sharedlibs_command(llmediaplugintest) diff --git a/indra/win_crash_logger/CMakeLists.txt b/indra/win_crash_logger/CMakeLists.txt index e141d7aa52..990dc6783e 100644 --- a/indra/win_crash_logger/CMakeLists.txt +++ b/indra/win_crash_logger/CMakeLists.txt @@ -89,7 +89,4 @@ if (WINDOWS) ) endif (WINDOWS) -ll_deploy_sharedlibs_command( - windows-crash-logger - "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}" - ".") +ll_deploy_sharedlibs_command(windows-crash-logger) \ No newline at end of file diff --git a/indra/win_updater/CMakeLists.txt b/indra/win_updater/CMakeLists.txt index 9e18555ea9..82347adf20 100644 --- a/indra/win_updater/CMakeLists.txt +++ b/indra/win_updater/CMakeLists.txt @@ -34,8 +34,5 @@ set_target_properties(windows-updater LINK_FLAGS_DEBUG "/NODEFAULTLIB:\"LIBCMT;LIBCMTD;MSVCRT\"" ) -# The windows-updater -#ll_deploy_sharedlibs_command( -# windows-updater -# "${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}" -# ".") +# The windows-updater doesn't link against anything non-system, apparently +#ll_deploy_sharedlibs_command(windows-updater) \ No newline at end of file -- cgit v1.3 From fc849873abb839b013efbae5e44b150d4be1f236 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Tue, 10 Nov 2009 13:16:33 -0500 Subject: Remove dangling LLEVENTS_LISTENER_ARITY control --- indra/llcommon/llevents.h | 2 ++ 1 file changed, 2 insertions(+) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llevents.h b/indra/llcommon/llevents.h index 192d79b27d..f52cf33fd8 100644 --- a/indra/llcommon/llevents.h +++ b/indra/llcommon/llevents.h @@ -45,10 +45,12 @@ #include "llsingleton.h" #include "lldependencies.h" +/*==========================================================================*| // override this to allow binding free functions with more parameters #ifndef LLEVENTS_LISTENER_ARITY #define LLEVENTS_LISTENER_ARITY 10 #endif +|*==========================================================================*/ // hack for testing #ifndef testable -- cgit v1.3 From a97aebb84a8b5b43de01fd3823d1b38e711e6ab7 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Tue, 10 Nov 2009 13:30:29 -0500 Subject: Enhance LLInstanceTracker variants to be more uniform. For both the (so far unused) generic KEY form and the KEY = T* form, provide key_iter, beginKeys(), endKeys(). Change instance_iter so that when dereferenced, it gives you a T& rather than a T*, to be more harmonious with a typical STL container. (You parameterize LLInstanceTracker with T, not with T*.) Fix existing usage in llfasttimer.cpp and lltimer.cpp to agree. For the KEY = T* specialization, add T* getInstance(T*) so client isn't forced to know which variant was used. Add unit tests for uniformity of public operations on both variants. --- indra/llcommon/CMakeLists.txt | 1 + indra/llcommon/llinstancetracker.h | 90 +++++++++---- indra/llcommon/lltimer.cpp | 12 +- indra/llcommon/tests/llinstancetracker_test.cpp | 160 ++++++++++++++++++++++++ 4 files changed, 231 insertions(+), 32 deletions(-) create mode 100644 indra/llcommon/tests/llinstancetracker_test.cpp (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index f785698612..3a36b8430c 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -305,6 +305,7 @@ LL_ADD_INTEGRATION_TEST(lldate "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lldependencies "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llerror "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llframetimer "" "${test_libs}") +LL_ADD_INTEGRATION_TEST(llinstancetracker "" "${test_libs}") LL_ADD_INTEGRATION_TEST(lllazy "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llrand "" "${test_libs}") LL_ADD_INTEGRATION_TEST(llsdserialize "" "${test_libs}") diff --git a/indra/llcommon/llinstancetracker.h b/indra/llcommon/llinstancetracker.h index ea50acbbc5..039d68faef 100644 --- a/indra/llcommon/llinstancetracker.h +++ b/indra/llcommon/llinstancetracker.h @@ -38,22 +38,53 @@ #include "string_table.h" #include - -// This mix-in class adds support for tracking all instances of the specified class parameter T -// The (optional) key associates a value of type KEY with a given instance of T, for quick lookup -// If KEY is not provided, then instances are stored in a simple set -// *NOTE: see explicit specialization below for default KEY==T* case +#include +#include +#include +#include + +/// This mix-in class adds support for tracking all instances of the specified class parameter T +/// The (optional) key associates a value of type KEY with a given instance of T, for quick lookup +/// If KEY is not provided, then instances are stored in a simple set +/// @NOTE: see explicit specialization below for default KEY==T* case template class LLInstanceTracker : boost::noncopyable { + typedef typename std::map InstanceMap; + typedef boost::function KeyGetter; + typedef boost::function InstancePtrGetter; public: - typedef typename std::map::iterator instance_iter; - typedef typename std::map::const_iterator instance_const_iter; - - static T* getInstance(const KEY& k) { instance_iter found = getMap().find(k); return (found == getMap().end()) ? NULL : found->second; } + /// Dereferencing key_iter gives you a const KEY& + typedef boost::transform_iterator key_iter; + /// Dereferencing instance_iter gives you a T& + typedef boost::indirect_iterator< boost::transform_iterator > instance_iter; + + static T* getInstance(const KEY& k) + { + typename InstanceMap::const_iterator found = getMap().find(k); + return (found == getMap().end()) ? NULL : found->second; + } - static instance_iter beginInstances() { return getMap().begin(); } - static instance_iter endInstances() { return getMap().end(); } + static key_iter beginKeys() + { + return boost::make_transform_iterator(getMap().begin(), + boost::bind(&InstanceMap::value_type::first, _1)); + } + static key_iter endKeys() + { + return boost::make_transform_iterator(getMap().end(), + boost::bind(&InstanceMap::value_type::first, _1)); + } + static instance_iter beginInstances() + { + return instance_iter(boost::make_transform_iterator(getMap().begin(), + boost::bind(&InstanceMap::value_type::second, _1))); + } + static instance_iter endInstances() + { + return instance_iter(boost::make_transform_iterator(getMap().end(), + boost::bind(&InstanceMap::value_type::second, _1))); + } static S32 instanceCount() { return getMap().size(); } protected: LLInstanceTracker(KEY key) { add(key); } @@ -69,11 +100,11 @@ private: } void remove() { getMap().erase(mKey); } - static std::map& getMap() + static InstanceMap& getMap() { if (! sInstances) { - sInstances = new std::map; + sInstances = new InstanceMap; } return *sInstances; } @@ -81,20 +112,27 @@ private: private: KEY mKey; - static std::map* sInstances; + static InstanceMap* sInstances; }; -// explicit specialization for default case where KEY is T* -// use a simple std::set +/// explicit specialization for default case where KEY is T* +/// use a simple std::set template class LLInstanceTracker { + typedef typename std::set InstanceSet; public: - typedef typename std::set::iterator instance_iter; - typedef typename std::set::const_iterator instance_const_iter; - - static instance_iter beginInstances() { return getSet().begin(); } - static instance_iter endInstances() { return getSet().end(); } + /// Dereferencing key_iter gives you a T* (since T* is the key) + typedef typename InstanceSet::iterator key_iter; + /// Dereferencing instance_iter gives you a T& + typedef boost::indirect_iterator instance_iter; + + /// for completeness of analogy with the generic implementation + static T* getInstance(T* k) { return k; } + static key_iter beginKeys() { return getSet().begin(); } + static key_iter endKeys() { return getSet().end(); } + static instance_iter beginInstances() { return instance_iter(getSet().begin()); } + static instance_iter endInstances() { return instance_iter(getSet().end()); } static S32 instanceCount() { return getSet().size(); } protected: @@ -103,19 +141,19 @@ protected: LLInstanceTracker(const LLInstanceTracker& other) { getSet().insert(static_cast(this)); } - static std::set& getSet() // called after getReady() but before go() + static InstanceSet& getSet() // called after getReady() but before go() { if (! sInstances) { - sInstances = new std::set; + sInstances = new InstanceSet; } return *sInstances; } - static std::set* sInstances; + static InstanceSet* sInstances; }; -template std::map* LLInstanceTracker::sInstances = NULL; -template std::set* LLInstanceTracker::sInstances = NULL; +template typename LLInstanceTracker::InstanceMap* LLInstanceTracker::sInstances = NULL; +template typename LLInstanceTracker::InstanceSet* LLInstanceTracker::sInstances = NULL; #endif diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp index ea5b0c03ef..ef3e8dbc94 100644 --- a/indra/llcommon/lltimer.cpp +++ b/indra/llcommon/lltimer.cpp @@ -583,13 +583,13 @@ void LLEventTimer::updateClass() std::list completed_timers; for (instance_iter iter = beginInstances(); iter != endInstances(); ) { - LLEventTimer* timer = *iter++; - F32 et = timer->mEventTimer.getElapsedTimeF32(); - if (timer->mEventTimer.getStarted() && et > timer->mPeriod) { - timer->mEventTimer.reset(); - if ( timer->tick() ) + LLEventTimer& timer = *iter++; + F32 et = timer.mEventTimer.getElapsedTimeF32(); + if (timer.mEventTimer.getStarted() && et > timer.mPeriod) { + timer.mEventTimer.reset(); + if ( timer.tick() ) { - completed_timers.push_back( timer ); + completed_timers.push_back( &timer ); } } } diff --git a/indra/llcommon/tests/llinstancetracker_test.cpp b/indra/llcommon/tests/llinstancetracker_test.cpp new file mode 100644 index 0000000000..7415f2d33b --- /dev/null +++ b/indra/llcommon/tests/llinstancetracker_test.cpp @@ -0,0 +1,160 @@ +/** + * @file llinstancetracker_test.cpp + * @author Nat Goodspeed + * @date 2009-11-10 + * @brief Test for llinstancetracker. + * + * $LicenseInfo:firstyear=2009&license=viewergpl$ + * Copyright (c) 2009, Linden Research, Inc. + * $/LicenseInfo$ + */ + +// Precompiled header +#include "linden_common.h" +// associated header +#include "llinstancetracker.h" +// STL headers +#include +#include +#include +#include // std::sort() +// std headers +// external library headers +#include +// other Linden headers +#include "../test/lltut.h" + +struct Keyed: public LLInstanceTracker +{ + Keyed(const std::string& name): + LLInstanceTracker(name), + mName(name) + {} + std::string mName; +}; + +struct Unkeyed: public LLInstanceTracker +{ +}; + +/***************************************************************************** +* TUT +*****************************************************************************/ +namespace tut +{ + struct llinstancetracker_data + { + }; + typedef test_group llinstancetracker_group; + typedef llinstancetracker_group::object object; + llinstancetracker_group llinstancetrackergrp("llinstancetracker"); + + template<> template<> + void object::test<1>() + { + ensure_equals(Keyed::instanceCount(), 0); + { + Keyed one("one"); + ensure_equals(Keyed::instanceCount(), 1); + Keyed* found = Keyed::getInstance("one"); + ensure("couldn't find stack Keyed", found); + ensure_equals("found wrong Keyed instance", found, &one); + { + boost::scoped_ptr two(new Keyed("two")); + ensure_equals(Keyed::instanceCount(), 2); + Keyed* found = Keyed::getInstance("two"); + ensure("couldn't find heap Keyed", found); + ensure_equals("found wrong Keyed instance", found, two.get()); + } + ensure_equals(Keyed::instanceCount(), 1); + } + Keyed* found = Keyed::getInstance("one"); + ensure("Keyed key lives too long", ! found); + ensure_equals(Keyed::instanceCount(), 0); + } + + template<> template<> + void object::test<2>() + { + ensure_equals(Unkeyed::instanceCount(), 0); + { + Unkeyed one; + ensure_equals(Unkeyed::instanceCount(), 1); + Unkeyed* found = Unkeyed::getInstance(&one); + ensure_equals(found, &one); + { + boost::scoped_ptr two(new Unkeyed); + ensure_equals(Unkeyed::instanceCount(), 2); + Unkeyed* found = Unkeyed::getInstance(two.get()); + ensure_equals(found, two.get()); + } + ensure_equals(Unkeyed::instanceCount(), 1); + } + ensure_equals(Unkeyed::instanceCount(), 0); + } + + template<> template<> + void object::test<3>() + { + Keyed one("one"), two("two"), three("three"); + // We don't want to rely on the underlying container delivering keys + // in any particular order. That allows us the flexibility to + // reimplement LLInstanceTracker using, say, a hash map instead of a + // std::map. We DO insist that every key appear exactly once. + typedef std::vector StringVector; + StringVector keys(Keyed::beginKeys(), Keyed::endKeys()); + std::sort(keys.begin(), keys.end()); + StringVector::const_iterator ki(keys.begin()); + ensure_equals(*ki++, "one"); + ensure_equals(*ki++, "three"); + ensure_equals(*ki++, "two"); + // Use ensure() here because ensure_equals would want to display + // mismatched values, and frankly that wouldn't help much. + ensure("didn't reach end", ki == keys.end()); + + // Use a somewhat different approach to order independence with + // beginInstances(): explicitly capture the instances we know in a + // set, and delete them as we iterate through. + typedef std::set InstanceSet; + InstanceSet instances; + instances.insert(&one); + instances.insert(&two); + instances.insert(&three); + for (Keyed::instance_iter ii(Keyed::beginInstances()), iend(Keyed::endInstances()); + ii != iend; ++ii) + { + Keyed& ref = *ii; + ensure_equals("spurious instance", instances.erase(&ref), 1); + } + ensure_equals("unreported instance", instances.size(), 0); + } + + template<> template<> + void object::test<4>() + { + Unkeyed one, two, three; + typedef std::set KeySet; + KeySet keys; + keys.insert(&one); + keys.insert(&two); + keys.insert(&three); + for (Unkeyed::key_iter ki(Unkeyed::beginKeys()), kend(Unkeyed::endKeys()); + ki != kend; ++ki) + { + ensure_equals("spurious key", keys.erase(*ki), 1); + } + ensure_equals("unreported key", keys.size(), 0); + + KeySet instances; + instances.insert(&one); + instances.insert(&two); + instances.insert(&three); + for (Unkeyed::instance_iter ii(Unkeyed::beginInstances()), iend(Unkeyed::endInstances()); + ii != iend; ++ii) + { + Unkeyed& ref = *ii; + ensure_equals("spurious instance", instances.erase(&ref), 1); + } + ensure_equals("unreported instance", instances.size(), 0); + } +} // namespace tut -- cgit v1.3 From 2fd31363f747aaf0ec3d3d6b5711e0ecc99b2cf3 Mon Sep 17 00:00:00 2001 From: Monroe Linden Date: Tue, 10 Nov 2009 15:57:26 -0800 Subject: Added PluginAttachDebuggerToPlugins debug setting. Added accessors to get platform-specific process ID from LLProcessLauncher. Added an optional "debug" argument to LLPluginClassMedia::init() and LLPluginProcessParent::init() (defaults to false). Mac only: made the state machine in LLPluginProcessParent::idle() open a new window in Terminal.app with a gdb session attached to the plugin process upon successful launch. --- indra/llcommon/llprocesslauncher.h | 8 ++++++++ indra/llplugin/llpluginclassmedia.cpp | 4 ++-- indra/llplugin/llpluginclassmedia.h | 2 +- indra/llplugin/llpluginprocessparent.cpp | 31 +++++++++++++++++++++++++++++-- indra/llplugin/llpluginprocessparent.h | 5 ++++- indra/newview/app_settings/settings.xml | 11 +++++++++++ indra/newview/llviewermedia.cpp | 2 +- 7 files changed, 56 insertions(+), 7 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llprocesslauncher.h b/indra/llcommon/llprocesslauncher.h index 880562157f..929d547f6e 100644 --- a/indra/llcommon/llprocesslauncher.h +++ b/indra/llcommon/llprocesslauncher.h @@ -70,6 +70,14 @@ public: // This needs to be called periodically on Mac/Linux to clean up zombie processes. static void reap(void); + + // Accessors for platform-specific process ID +#if LL_WINDOWS + HANDLE getProcessHandle() { return mProcessHandle; }; +#else + pid_t getProcessID() { return mProcessID; }; +#endif + private: std::string mExecutable; std::string mWorkingDir; diff --git a/indra/llplugin/llpluginclassmedia.cpp b/indra/llplugin/llpluginclassmedia.cpp index 457c074ef1..42d5ec49cd 100644 --- a/indra/llplugin/llpluginclassmedia.cpp +++ b/indra/llplugin/llpluginclassmedia.cpp @@ -61,14 +61,14 @@ LLPluginClassMedia::~LLPluginClassMedia() reset(); } -bool LLPluginClassMedia::init(const std::string &launcher_filename, const std::string &plugin_filename) +bool LLPluginClassMedia::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug) { LL_DEBUGS("Plugin") << "launcher: " << launcher_filename << LL_ENDL; LL_DEBUGS("Plugin") << "plugin: " << plugin_filename << LL_ENDL; mPlugin = new LLPluginProcessParent(this); mPlugin->setSleepTime(mSleepTime); - mPlugin->init(launcher_filename, plugin_filename); + mPlugin->init(launcher_filename, plugin_filename, debug); return true; } diff --git a/indra/llplugin/llpluginclassmedia.h b/indra/llplugin/llpluginclassmedia.h index 90ecd1e073..dcc4a3bd6a 100644 --- a/indra/llplugin/llpluginclassmedia.h +++ b/indra/llplugin/llpluginclassmedia.h @@ -47,7 +47,7 @@ public: virtual ~LLPluginClassMedia(); // local initialization, called by the media manager when creating a source - virtual bool init(const std::string &launcher_filename, const std::string &plugin_filename); + virtual bool init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug = false); // undoes everything init() didm called by the media manager when destroying a source virtual void reset(); diff --git a/indra/llplugin/llpluginprocessparent.cpp b/indra/llplugin/llpluginprocessparent.cpp index 39f9438fb3..b7ce800c3a 100644 --- a/indra/llplugin/llpluginprocessparent.cpp +++ b/indra/llplugin/llpluginprocessparent.cpp @@ -55,6 +55,7 @@ LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner) mBoundPort = 0; mState = STATE_UNINITIALIZED; mDisableTimeout = false; + mDebug = false; // initialize timer - heartbeat test (mHeartbeat.hasExpired()) // can sometimes return true immediately otherwise and plugins @@ -96,11 +97,12 @@ void LLPluginProcessParent::errorState(void) setState(STATE_ERROR); } -void LLPluginProcessParent::init(const std::string &launcher_filename, const std::string &plugin_filename) +void LLPluginProcessParent::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug) { mProcess.setExecutable(launcher_filename); mPluginFile = plugin_filename; mCPUUsage = 0.0f; + mDebug = debug; setState(STATE_INITIALIZED); } @@ -291,6 +293,31 @@ void LLPluginProcessParent::idle(void) } else { + if(mDebug) + { + #if LL_DARWIN + // If we're set to debug, start up a gdb instance in a new terminal window and have it attach to the plugin process and continue. + + // The command we're constructing would look like this on the command line: + // osascript -e 'tell application "Terminal"' -e 'set win to do script "gdb -pid 12345"' -e 'do script "continue" in win' -e 'end tell' + + std::stringstream cmd; + + mDebugger.setExecutable("/usr/bin/osascript"); + mDebugger.addArgument("-e"); + mDebugger.addArgument("tell application \"Terminal\""); + mDebugger.addArgument("-e"); + cmd << "set win to do script \"gdb -pid " << mProcess.getProcessID() << "\""; + mDebugger.addArgument(cmd.str()); + mDebugger.addArgument("-e"); + mDebugger.addArgument("do script \"continue\" in win"); + mDebugger.addArgument("-e"); + mDebugger.addArgument("end tell"); + mDebugger.launch(); + + #endif + } + // This will allow us to time out if the process never starts. mHeartbeat.start(); mHeartbeat.setTimerExpirySec(PLUGIN_LAUNCH_SECONDS); @@ -661,7 +688,7 @@ bool LLPluginProcessParent::pluginLockedUpOrQuit() { bool result = false; - if(!mDisableTimeout) + if(!mDisableTimeout && !mDebug) { if(!mProcess.isRunning()) { diff --git a/indra/llplugin/llpluginprocessparent.h b/indra/llplugin/llpluginprocessparent.h index 754ebeb946..1289e86c13 100644 --- a/indra/llplugin/llpluginprocessparent.h +++ b/indra/llplugin/llpluginprocessparent.h @@ -56,7 +56,7 @@ public: LLPluginProcessParent(LLPluginProcessParentOwner *owner); ~LLPluginProcessParent(); - void init(const std::string &launcher_filename, const std::string &plugin_filename); + void init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug = false); void idle(void); // returns true if the plugin is on its way to steady state @@ -150,6 +150,9 @@ private: F64 mCPUUsage; bool mDisableTimeout; + bool mDebug; + + LLProcessLauncher mDebugger; }; #endif // LL_LLPLUGINPROCESSPARENT_H diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index 55ff255c38..15c9499bbc 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -5327,6 +5327,17 @@ Value 1 + PluginAttachDebuggerToPlugins + + Comment + If true, attach a debugger session to each plugin process as it's launched. + Persist + 1 + Type + Boolean + Value + 0 + PluginInstancesCPULimit Comment diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp index 69650425cb..66d48fadd1 100644 --- a/indra/newview/llviewermedia.cpp +++ b/indra/newview/llviewermedia.cpp @@ -847,7 +847,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ { LLPluginClassMedia* media_source = new LLPluginClassMedia(owner); media_source->setSize(default_width, default_height); - if (media_source->init(launcher_name, plugin_name)) + if (media_source->init(launcher_name, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))) { return media_source; } -- cgit v1.3 From 43ae94ab0f35dafaa0e1787a155290e371e317a1 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 11 Nov 2009 07:32:59 -0500 Subject: Rename private methods to avoid ambiguity with subclasses --- indra/llcommon/llinstancetracker.h | 46 +++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 23 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llinstancetracker.h b/indra/llcommon/llinstancetracker.h index 039d68faef..11fe523651 100644 --- a/indra/llcommon/llinstancetracker.h +++ b/indra/llcommon/llinstancetracker.h @@ -61,46 +61,46 @@ public: static T* getInstance(const KEY& k) { - typename InstanceMap::const_iterator found = getMap().find(k); - return (found == getMap().end()) ? NULL : found->second; + typename InstanceMap::const_iterator found = getMap_().find(k); + return (found == getMap_().end()) ? NULL : found->second; } static key_iter beginKeys() { - return boost::make_transform_iterator(getMap().begin(), + return boost::make_transform_iterator(getMap_().begin(), boost::bind(&InstanceMap::value_type::first, _1)); } static key_iter endKeys() { - return boost::make_transform_iterator(getMap().end(), + return boost::make_transform_iterator(getMap_().end(), boost::bind(&InstanceMap::value_type::first, _1)); } static instance_iter beginInstances() { - return instance_iter(boost::make_transform_iterator(getMap().begin(), + return instance_iter(boost::make_transform_iterator(getMap_().begin(), boost::bind(&InstanceMap::value_type::second, _1))); } static instance_iter endInstances() { - return instance_iter(boost::make_transform_iterator(getMap().end(), + return instance_iter(boost::make_transform_iterator(getMap_().end(), boost::bind(&InstanceMap::value_type::second, _1))); } - static S32 instanceCount() { return getMap().size(); } + static S32 instanceCount() { return getMap_().size(); } protected: - LLInstanceTracker(KEY key) { add(key); } - virtual ~LLInstanceTracker() { remove(); } - virtual void setKey(KEY key) { remove(); add(key); } + LLInstanceTracker(KEY key) { add_(key); } + virtual ~LLInstanceTracker() { remove_(); } + virtual void setKey(KEY key) { remove_(); add_(key); } virtual const KEY& getKey() const { return mKey; } private: - void add(KEY key) + void add_(KEY key) { mKey = key; - getMap()[key] = static_cast(this); + getMap_()[key] = static_cast(this); } - void remove() { getMap().erase(mKey); } + void remove_() { getMap_().erase(mKey); } - static InstanceMap& getMap() + static InstanceMap& getMap_() { if (! sInstances) { @@ -129,19 +129,19 @@ public: /// for completeness of analogy with the generic implementation static T* getInstance(T* k) { return k; } - static key_iter beginKeys() { return getSet().begin(); } - static key_iter endKeys() { return getSet().end(); } - static instance_iter beginInstances() { return instance_iter(getSet().begin()); } - static instance_iter endInstances() { return instance_iter(getSet().end()); } - static S32 instanceCount() { return getSet().size(); } + static key_iter beginKeys() { return getSet_().begin(); } + static key_iter endKeys() { return getSet_().end(); } + static instance_iter beginInstances() { return instance_iter(getSet_().begin()); } + static instance_iter endInstances() { return instance_iter(getSet_().end()); } + static S32 instanceCount() { return getSet_().size(); } protected: - LLInstanceTracker() { getSet().insert(static_cast(this)); } - virtual ~LLInstanceTracker() { getSet().erase(static_cast(this)); } + LLInstanceTracker() { getSet_().insert(static_cast(this)); } + virtual ~LLInstanceTracker() { getSet_().erase(static_cast(this)); } - LLInstanceTracker(const LLInstanceTracker& other) { getSet().insert(static_cast(this)); } + LLInstanceTracker(const LLInstanceTracker& other) { getSet_().insert(static_cast(this)); } - static InstanceSet& getSet() // called after getReady() but before go() + static InstanceSet& getSet_() // called after getReady() but before go() { if (! sInstances) { -- cgit v1.3 From 062d0a13db505636b186084d42c527a49637f380 Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 11 Nov 2009 07:41:50 -0500 Subject: Add LLEventAPI class, formalizing the mechanism by which we wrap a C++ API with an event API. In addition to the LLEventPump name on which to listen, LLEventAPI accepts a documentation string for event API introspection. Give every LLEventDispatcher::add() overload a new documentation string parameter for event API introspection. Convert every existing event API to new conventions, introducing suitable documentation strings for the API and each of its operations. --- indra/llcommon/CMakeLists.txt | 2 ++ indra/llcommon/lleventapi.cpp | 30 +++++++++++++++++ indra/llcommon/lleventapi.h | 53 +++++++++++++++++++++++++++++++ indra/llcommon/lleventdispatcher.cpp | 12 ++++--- indra/llcommon/lleventdispatcher.h | 35 +++++++++++++++----- indra/llmessage/llares.cpp | 2 +- indra/llmessage/llareslistener.cpp | 13 +++++--- indra/llmessage/llareslistener.h | 9 +++--- indra/llui/llfloaterreg.cpp | 2 +- indra/llui/llfloaterreglistener.cpp | 30 +++++++++++++---- indra/llui/llfloaterreglistener.h | 6 ++-- indra/llui/llnotificationslistener.cpp | 8 +++-- indra/llui/llnotificationslistener.h | 4 +-- indra/newview/llagentlistener.cpp | 16 +++++++--- indra/newview/llagentlistener.h | 4 +-- indra/newview/llappviewer.cpp | 2 +- indra/newview/llappviewerlistener.cpp | 14 +++++--- indra/newview/llappviewerlistener.h | 9 +++--- indra/newview/llfloaterabout.cpp | 12 ++++--- indra/newview/lllogininstance.cpp | 6 ++-- indra/newview/lluilistener.cpp | 12 +++++-- indra/newview/lluilistener.h | 6 ++-- indra/newview/llviewercontrollistener.cpp | 20 +++++++++--- indra/newview/llviewercontrollistener.h | 4 +-- indra/newview/llviewermenu.cpp | 2 +- indra/newview/llviewerwindow.cpp | 2 +- indra/newview/llviewerwindowlistener.cpp | 16 +++++++--- indra/newview/llviewerwindowlistener.h | 9 +++--- 28 files changed, 254 insertions(+), 86 deletions(-) create mode 100644 indra/llcommon/lleventapi.cpp create mode 100644 indra/llcommon/lleventapi.h (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index 2d0363d188..e41c75846b 100644 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -41,6 +41,7 @@ set(llcommon_SOURCE_FILES llerror.cpp llerrorthread.cpp llevent.cpp + lleventapi.cpp lleventcoro.cpp lleventdispatcher.cpp lleventfilter.cpp @@ -140,6 +141,7 @@ set(llcommon_HEADER_FILES llerrorlegacy.h llerrorthread.h llevent.h + lleventapi.h lleventcoro.h lleventdispatcher.h lleventfilter.h diff --git a/indra/llcommon/lleventapi.cpp b/indra/llcommon/lleventapi.cpp new file mode 100644 index 0000000000..1dd104da8f --- /dev/null +++ b/indra/llcommon/lleventapi.cpp @@ -0,0 +1,30 @@ +/** + * @file lleventapi.cpp + * @author Nat Goodspeed + * @date 2009-11-10 + * @brief Implementation for lleventapi. + * + * $LicenseInfo:firstyear=2009&license=viewergpl$ + * Copyright (c) 2009, Linden Research, Inc. + * $/LicenseInfo$ + */ + +// Precompiled header +#include "linden_common.h" +// associated header +#include "lleventapi.h" +// STL headers +// std headers +// external library headers +// other Linden headers + +LLEventAPI::LLEventAPI(const std::string& name, const std::string& desc, const std::string& field): + lbase(name, field), + ibase(name), + mDesc(desc) +{ +} + +LLEventAPI::~LLEventAPI() +{ +} diff --git a/indra/llcommon/lleventapi.h b/indra/llcommon/lleventapi.h new file mode 100644 index 0000000000..fef12988cb --- /dev/null +++ b/indra/llcommon/lleventapi.h @@ -0,0 +1,53 @@ +/** + * @file lleventapi.h + * @author Nat Goodspeed + * @date 2009-10-28 + * @brief LLEventAPI is the base class for every class that wraps a C++ API + * in an event API + * (see https://wiki.lindenlab.com/wiki/Incremental_Viewer_Automation/Event_API). + * + * $LicenseInfo:firstyear=2009&license=viewergpl$ + * Copyright (c) 2009, Linden Research, Inc. + * $/LicenseInfo$ + */ + +#if ! defined(LL_LLEVENTAPI_H) +#define LL_LLEVENTAPI_H + +#include "lleventdispatcher.h" +#include "llinstancetracker.h" +#include + +/** + * LLEventAPI not only provides operation dispatch functionality, inherited + * from LLDispatchListener -- it also gives us event API introspection. + * Deriving from LLInstanceTracker lets us enumerate instances. + */ +class LLEventAPI: public LLDispatchListener, + public LLInstanceTracker +{ + typedef LLDispatchListener lbase; + typedef LLInstanceTracker ibase; + +public: + /** + * @param name LLEventPump name on which this LLEventAPI will listen. This + * also serves as the LLInstanceTracker instance key. + * @param desc Documentation string shown to a client trying to discover + * available event APIs. + * @param field LLSD::Map key used by LLDispatchListener to look up the + * subclass method to invoke [default "op"]. + */ + LLEventAPI(const std::string& name, const std::string& desc, const std::string& field="op"); + virtual ~LLEventAPI(); + + /// Get the string name of this LLEventAPI + std::string getName() const { return ibase::getKey(); } + /// Get the documentation string + std::string getDesc() const { return mDesc; } + +private: + std::string mDesc; +}; + +#endif /* ! defined(LL_LLEVENTAPI_H) */ diff --git a/indra/llcommon/lleventdispatcher.cpp b/indra/llcommon/lleventdispatcher.cpp index 6b1413d054..017bf3a521 100644 --- a/indra/llcommon/lleventdispatcher.cpp +++ b/indra/llcommon/lleventdispatcher.cpp @@ -36,9 +36,11 @@ LLEventDispatcher::~LLEventDispatcher() } /// Register a callable by name -void LLEventDispatcher::add(const std::string& name, const Callable& callable, const LLSD& required) +void LLEventDispatcher::add(const std::string& name, const std::string& desc, + const Callable& callable, const LLSD& required) { - mDispatch[name] = DispatchMap::mapped_type(callable, required); + mDispatch.insert(DispatchMap::value_type(name, + DispatchMap::mapped_type(callable, desc, required))); } void LLEventDispatcher::addFail(const std::string& name, const std::string& classname) const @@ -98,14 +100,14 @@ bool LLEventDispatcher::attemptCall(const std::string& name, const LLSD& event) } // Found the name, so it's plausible to even attempt the call. But first, // validate the syntax of the event itself. - std::string mismatch(llsd_matches(found->second.second, event)); + std::string mismatch(llsd_matches(found->second.mRequired, event)); if (! mismatch.empty()) { LL_ERRS("LLEventDispatcher") << "LLEventDispatcher(" << mDesc << ") calling '" << name << "': bad request: " << mismatch << LL_ENDL; } // Event syntax looks good, go for it! - (found->second.first)(event); + (found->second.mFunc)(event); return true; // tell caller we were able to call } @@ -116,7 +118,7 @@ LLEventDispatcher::Callable LLEventDispatcher::get(const std::string& name) cons { return Callable(); } - return found->second.first; + return found->second.mFunc; } LLDispatchListener::LLDispatchListener(const std::string& pumpname, const std::string& key): diff --git a/indra/llcommon/lleventdispatcher.h b/indra/llcommon/lleventdispatcher.h index 5a86b90bff..eba7b607f1 100644 --- a/indra/llcommon/lleventdispatcher.h +++ b/indra/llcommon/lleventdispatcher.h @@ -44,7 +44,10 @@ public: * is used to validate the structure of each incoming event (see * llsd_matches()). */ - void add(const std::string& name, const Callable& callable, const LLSD& required=LLSD()); + void add(const std::string& name, + const std::string& desc, + const Callable& callable, + const LLSD& required=LLSD()); /** * Special case: a subclass of this class can pass an unbound member @@ -52,18 +55,22 @@ public: * boost::bind() expression. */ template - void add(const std::string& name, void (CLASS::*method)(const LLSD&), + void add(const std::string& name, + const std::string& desc, + void (CLASS::*method)(const LLSD&), const LLSD& required=LLSD()) { - addMethod(name, method, required); + addMethod(name, desc, method, required); } /// Overload for both const and non-const methods template - void add(const std::string& name, void (CLASS::*method)(const LLSD&) const, + void add(const std::string& name, + const std::string& desc, + void (CLASS::*method)(const LLSD&) const, const LLSD& required=LLSD()) { - addMethod(name, method, required); + addMethod(name, desc, method, required); } /// Unregister a callable @@ -86,7 +93,8 @@ public: private: template - void addMethod(const std::string& name, const METHOD& method, const LLSD& required) + void addMethod(const std::string& name, const std::string& desc, + const METHOD& method, const LLSD& required) { CLASS* downcast = dynamic_cast(this); if (! downcast) @@ -95,7 +103,7 @@ private: } else { - add(name, boost::bind(method, downcast, _1), required); + add(name, desc, boost::bind(method, downcast, _1), required); } } void addFail(const std::string& name, const std::string& classname) const; @@ -103,7 +111,18 @@ private: bool attemptCall(const std::string& name, const LLSD& event) const; std::string mDesc, mKey; - typedef std::map > DispatchMap; + struct DispatchEntry + { + DispatchEntry(const Callable& func, const std::string& desc, const LLSD& required): + mFunc(func), + mDesc(desc), + mRequired(required) + {} + Callable mFunc; + std::string mDesc; + LLSD mRequired; + }; + typedef std::map DispatchMap; DispatchMap mDispatch; }; diff --git a/indra/llmessage/llares.cpp b/indra/llmessage/llares.cpp index acbf51d75c..104629c157 100644 --- a/indra/llmessage/llares.cpp +++ b/indra/llmessage/llares.cpp @@ -106,7 +106,7 @@ void LLAres::QueryResponder::queryError(int code) LLAres::LLAres() : chan_(NULL), mInitSuccess(false), - mListener(new LLAresListener("LLAres", this)) + mListener(new LLAresListener(this)) { if (ares_init(&chan_) != ARES_SUCCESS) { diff --git a/indra/llmessage/llareslistener.cpp b/indra/llmessage/llareslistener.cpp index a8beb8cbde..7db3675b77 100644 --- a/indra/llmessage/llareslistener.cpp +++ b/indra/llmessage/llareslistener.cpp @@ -22,13 +22,18 @@ #include "llevents.h" #include "llsdutil.h" -LLAresListener::LLAresListener(const std::string& pumpname, LLAres* llares): - LLDispatchListener(pumpname, "op"), +LLAresListener::LLAresListener(LLAres* llares): + LLEventAPI("LLAres", + "LLAres listener to request DNS operations"), mAres(llares) { // add() every method we want to be able to invoke via this event API. - // Optional third parameter validates expected LLSD request structure. - add("rewriteURI", &LLAresListener::rewriteURI, + // Optional last parameter validates expected LLSD request structure. + add("rewriteURI", + "Given [\"uri\"], return on [\"reply\"] an array of alternative URIs.\n" + "On failure, returns an array containing only the original URI, so\n" + "failure case can be processed like success case.", + &LLAresListener::rewriteURI, LLSD().insert("uri", LLSD()).insert("reply", LLSD())); } diff --git a/indra/llmessage/llareslistener.h b/indra/llmessage/llareslistener.h index bf093b3d3d..33cef79c09 100644 --- a/indra/llmessage/llareslistener.h +++ b/indra/llmessage/llareslistener.h @@ -14,18 +14,17 @@ #if ! defined(LL_LLARESLISTENER_H) #define LL_LLARESLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" class LLAres; class LLSD; /// Listen on an LLEventPump with specified name for LLAres request events. -class LLAresListener: public LLDispatchListener +class LLAresListener: public LLEventAPI { public: - /// Specify the pump name on which to listen, and bind the LLAres instance - /// to use (e.g. gAres) - LLAresListener(const std::string& pumpname, LLAres* llares); + /// Bind the LLAres instance to use (e.g. gAres) + LLAresListener(LLAres* llares); private: /// command["op"] == "rewriteURI" diff --git a/indra/llui/llfloaterreg.cpp b/indra/llui/llfloaterreg.cpp index 03925f922c..eb67e3a561 100644 --- a/indra/llui/llfloaterreg.cpp +++ b/indra/llui/llfloaterreg.cpp @@ -46,7 +46,7 @@ LLFloaterReg::instance_map_t LLFloaterReg::sInstanceMap; LLFloaterReg::build_map_t LLFloaterReg::sBuildMap; std::map LLFloaterReg::sGroupMap; -static LLFloaterRegListener sFloaterRegListener("LLFloaterReg"); +static LLFloaterRegListener sFloaterRegListener; //******************************************************* diff --git a/indra/llui/llfloaterreglistener.cpp b/indra/llui/llfloaterreglistener.cpp index 57d148b5af..029d3b6810 100644 --- a/indra/llui/llfloaterreglistener.cpp +++ b/indra/llui/llfloaterreglistener.cpp @@ -21,19 +21,35 @@ #include "llfloater.h" #include "llbutton.h" -LLFloaterRegListener::LLFloaterRegListener(const std::string& pumpName): - LLDispatchListener(pumpName, "op") +LLFloaterRegListener::LLFloaterRegListener(): + LLEventAPI("LLFloaterReg", + "LLFloaterReg listener to (e.g.) show/hide LLFloater instances") { - add("getBuildMap", &LLFloaterRegListener::getBuildMap, LLSD().insert("reply", LLSD())); + add("getBuildMap", + "Return on [\"reply\"] data about all registered LLFloaterReg floater names", + &LLFloaterRegListener::getBuildMap, + LLSD().insert("reply", LLSD())); LLSD requiredName; requiredName["name"] = LLSD(); - add("showInstance", &LLFloaterRegListener::showInstance, requiredName); - add("hideInstance", &LLFloaterRegListener::hideInstance, requiredName); - add("toggleInstance", &LLFloaterRegListener::toggleInstance, requiredName); + add("showInstance", + "Ask to display the floater specified in [\"name\"]", + &LLFloaterRegListener::showInstance, + requiredName); + add("hideInstance", + "Ask to hide the floater specified in [\"name\"]", + &LLFloaterRegListener::hideInstance, + requiredName); + add("toggleInstance", + "Ask to toggle the state of the floater specified in [\"name\"]", + &LLFloaterRegListener::toggleInstance, + requiredName); LLSD requiredNameButton; requiredNameButton["name"] = LLSD(); requiredNameButton["button"] = LLSD(); - add("clickButton", &LLFloaterRegListener::clickButton, requiredNameButton); + add("clickButton", + "Simulate clicking the named [\"button\"] in the visible floater named in [\"name\"]", + &LLFloaterRegListener::clickButton, + requiredNameButton); } void LLFloaterRegListener::getBuildMap(const LLSD& event) const diff --git a/indra/llui/llfloaterreglistener.h b/indra/llui/llfloaterreglistener.h index 304ecd1090..a38117f6b0 100644 --- a/indra/llui/llfloaterreglistener.h +++ b/indra/llui/llfloaterreglistener.h @@ -12,18 +12,18 @@ #if ! defined(LL_LLFLOATERREGLISTENER_H) #define LL_LLFLOATERREGLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" #include class LLSD; /// Event API wrapper for LLFloaterReg -class LLFloaterRegListener: public LLDispatchListener +class LLFloaterRegListener: public LLEventAPI { public: /// As all public LLFloaterReg methods are static, there's no point in /// binding an LLFloaterReg instance. - LLFloaterRegListener(const std::string& pumpName); + LLFloaterRegListener(); private: void getBuildMap(const LLSD& event) const; diff --git a/indra/llui/llnotificationslistener.cpp b/indra/llui/llnotificationslistener.cpp index 75f4d6177d..fe4fbe7510 100644 --- a/indra/llui/llnotificationslistener.cpp +++ b/indra/llui/llnotificationslistener.cpp @@ -16,10 +16,14 @@ #include "llnotifications.h" LLNotificationsListener::LLNotificationsListener(LLNotifications & notifications) : - LLDispatchListener("LLNotifications", "op"), + LLEventAPI("LLNotifications", + "LLNotifications listener to (e.g.) pop up a notification"), mNotifications(notifications) { - add("requestAdd", &LLNotificationsListener::requestAdd); + add("requestAdd", + "Add a notification with specified [\"name\"], [\"substitutions\"] and [\"payload\"].\n" + "If optional [\"reply\"] specified, arrange to send user response on that LLEventPump.", + &LLNotificationsListener::requestAdd); } void LLNotificationsListener::requestAdd(const LLSD& event_data) const diff --git a/indra/llui/llnotificationslistener.h b/indra/llui/llnotificationslistener.h index 6f71a7c781..9b405d7b4b 100644 --- a/indra/llui/llnotificationslistener.h +++ b/indra/llui/llnotificationslistener.h @@ -12,12 +12,12 @@ #ifndef LL_LLNOTIFICATIONSLISTENER_H #define LL_LLNOTIFICATIONSLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" class LLNotifications; class LLSD; -class LLNotificationsListener : public LLDispatchListener +class LLNotificationsListener : public LLEventAPI { public: LLNotificationsListener(LLNotifications & notifications); diff --git a/indra/newview/llagentlistener.cpp b/indra/newview/llagentlistener.cpp index 0f00078b33..3da6a4e3f4 100644 --- a/indra/newview/llagentlistener.cpp +++ b/indra/newview/llagentlistener.cpp @@ -22,12 +22,20 @@ #include "llviewerregion.h" LLAgentListener::LLAgentListener(LLAgent &agent) - : LLDispatchListener("LLAgent", "op"), + : LLEventAPI("LLAgent", + "LLAgent listener to (e.g.) teleport, sit, stand, etc."), mAgent(agent) { - add("requestTeleport", &LLAgentListener::requestTeleport); - add("requestSit", &LLAgentListener::requestSit); - add("requestStand", &LLAgentListener::requestStand); + add("requestTeleport", + "Teleport: [\"regionname\"], [\"x\"], [\"y\"], [\"z\"]\n" + "If [\"skip_confirmation\"] is true, use LLURLDispatcher rather than LLCommandDispatcher.", + &LLAgentListener::requestTeleport); + add("requestSit", + "Ask to sit on the object specified in [\"obj_uuid\"]", + &LLAgentListener::requestSit); + add("requestStand", + "Ask to stand up", + &LLAgentListener::requestStand); } void LLAgentListener::requestTeleport(LLSD const & event_data) const diff --git a/indra/newview/llagentlistener.h b/indra/newview/llagentlistener.h index 6f0b5a54c5..eed6922b3e 100644 --- a/indra/newview/llagentlistener.h +++ b/indra/newview/llagentlistener.h @@ -13,12 +13,12 @@ #ifndef LL_LLAGENTLISTENER_H #define LL_LLAGENTLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" class LLAgent; class LLSD; -class LLAgentListener : public LLDispatchListener +class LLAgentListener : public LLEventAPI { public: LLAgentListener(LLAgent &agent); diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp index ddb6589b49..845a264327 100644 --- a/indra/newview/llappviewer.cpp +++ b/indra/newview/llappviewer.cpp @@ -207,7 +207,7 @@ #pragma warning (disable:4702) #endif -static LLAppViewerListener sAppViewerListener("LLAppViewer", LLAppViewer::instance); +static LLAppViewerListener sAppViewerListener(LLAppViewer::instance); ////// Windows-specific includes to the bottom - nasty defines in these pollute the preprocessor // diff --git a/indra/newview/llappviewerlistener.cpp b/indra/newview/llappviewerlistener.cpp index 3259309eee..adb5f43c1a 100644 --- a/indra/newview/llappviewerlistener.cpp +++ b/indra/newview/llappviewerlistener.cpp @@ -19,14 +19,18 @@ // other Linden headers #include "llappviewer.h" -LLAppViewerListener::LLAppViewerListener(const std::string& pumpname, - const LLAppViewerGetter& getter): - LLDispatchListener(pumpname, "op"), +LLAppViewerListener::LLAppViewerListener(const LLAppViewerGetter& getter): + LLEventAPI("LLAppViewer", + "LLAppViewer listener to (e.g.) request shutdown"), mAppViewerGetter(getter) { // add() every method we want to be able to invoke via this event API. - add("requestQuit", &LLAppViewerListener::requestQuit); - add("forceQuit", &LLAppViewerListener::forceQuit); + add("requestQuit", + "Ask to quit nicely", + &LLAppViewerListener::requestQuit); + add("forceQuit", + "Quit abruptly", + &LLAppViewerListener::forceQuit); } void LLAppViewerListener::requestQuit(const LLSD& event) diff --git a/indra/newview/llappviewerlistener.h b/indra/newview/llappviewerlistener.h index 73227cb95a..deedcbc179 100644 --- a/indra/newview/llappviewerlistener.h +++ b/indra/newview/llappviewerlistener.h @@ -12,20 +12,19 @@ #if ! defined(LL_LLAPPVIEWERLISTENER_H) #define LL_LLAPPVIEWERLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" #include class LLAppViewer; class LLSD; /// Listen on an LLEventPump with specified name for LLAppViewer request events. -class LLAppViewerListener: public LLDispatchListener +class LLAppViewerListener: public LLEventAPI { public: typedef boost::function LLAppViewerGetter; - /// Specify the pump name on which to listen, and bind the LLAppViewer - /// instance to use (e.g. LLAppViewer::instance()). - LLAppViewerListener(const std::string& pumpname, const LLAppViewerGetter& getter); + /// Bind the LLAppViewer instance to use (e.g. LLAppViewer::instance()). + LLAppViewerListener(const LLAppViewerGetter& getter); private: void requestQuit(const LLSD& event); diff --git a/indra/newview/llfloaterabout.cpp b/indra/newview/llfloaterabout.cpp index b01293d17c..80b0a430e0 100644 --- a/indra/newview/llfloaterabout.cpp +++ b/indra/newview/llfloaterabout.cpp @@ -64,7 +64,7 @@ #include "llwindow.h" #include "stringize.h" #include "llsdutil_math.h" -#include "lleventdispatcher.h" +#include "lleventapi.h" #if LL_WINDOWS #include "lldxhardware.h" @@ -302,13 +302,17 @@ static std::string get_viewer_release_notes_url() return LLWeb::escapeURL(url.str()); } -class LLFloaterAboutListener: public LLDispatchListener +class LLFloaterAboutListener: public LLEventAPI { public: LLFloaterAboutListener(): - LLDispatchListener("LLFloaterAbout", "op") + LLEventAPI("LLFloaterAbout", + "LLFloaterAbout listener to retrieve About box info") { - add("getInfo", &LLFloaterAboutListener::getInfo, LLSD().insert("reply", LLSD())); + add("getInfo", + "Request an LLSD::Map containing information used to populate About box", + &LLFloaterAboutListener::getInfo, + LLSD().insert("reply", LLSD())); } private: diff --git a/indra/newview/lllogininstance.cpp b/indra/newview/lllogininstance.cpp index e5f347ddc4..945294f3f2 100644 --- a/indra/newview/lllogininstance.cpp +++ b/indra/newview/lllogininstance.cpp @@ -73,9 +73,9 @@ LLLoginInstance::LLLoginInstance() : { mLoginModule->getEventPump().listen("lllogininstance", boost::bind(&LLLoginInstance::handleLoginEvent, this, _1)); - mDispatcher.add("fail.login", boost::bind(&LLLoginInstance::handleLoginFailure, this, _1)); - mDispatcher.add("connect", boost::bind(&LLLoginInstance::handleLoginSuccess, this, _1)); - mDispatcher.add("disconnect", boost::bind(&LLLoginInstance::handleDisconnect, this, _1)); + mDispatcher.add("fail.login", "", boost::bind(&LLLoginInstance::handleLoginFailure, this, _1)); + mDispatcher.add("connect", "", boost::bind(&LLLoginInstance::handleLoginSuccess, this, _1)); + mDispatcher.add("disconnect", "", boost::bind(&LLLoginInstance::handleDisconnect, this, _1)); } LLLoginInstance::~LLLoginInstance() diff --git a/indra/newview/lluilistener.cpp b/indra/newview/lluilistener.cpp index 9c643e78de..8b4cfa7248 100644 --- a/indra/newview/lluilistener.cpp +++ b/indra/newview/lluilistener.cpp @@ -20,10 +20,16 @@ #include "lluictrl.h" #include "llerror.h" -LLUIListener::LLUIListener(const std::string& name): - LLDispatchListener(name, "op") +LLUIListener::LLUIListener(): + LLEventAPI("UI", + "LLUICtrl::CommitCallbackRegistry listener.\n" + "Capable of invoking any function (with parameter) you can specify in XUI.") { - add("call", &LLUIListener::call, LLSD().insert("function", LLSD())); + add("call", + "Invoke the operation named by [\"function\"], passing [\"parameter\"],\n" + "as if from a user gesture on a menu -- or a button click.", + &LLUIListener::call, + LLSD().insert("function", LLSD())); } void LLUIListener::call(const LLSD& event) const diff --git a/indra/newview/lluilistener.h b/indra/newview/lluilistener.h index ea904a99ff..8605d60bd3 100644 --- a/indra/newview/lluilistener.h +++ b/indra/newview/lluilistener.h @@ -12,15 +12,15 @@ #if ! defined(LL_LLUILISTENER_H) #define LL_LLUILISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" #include class LLSD; -class LLUIListener: public LLDispatchListener +class LLUIListener: public LLEventAPI { public: - LLUIListener(const std::string& name); + LLUIListener(); private: void call(const LLSD& event) const; diff --git a/indra/newview/llviewercontrollistener.cpp b/indra/newview/llviewercontrollistener.cpp index ecba1b8eb0..0b9db1b906 100644 --- a/indra/newview/llviewercontrollistener.cpp +++ b/indra/newview/llviewercontrollistener.cpp @@ -18,12 +18,22 @@ LLViewerControlListener gSavedSettingsListener; LLViewerControlListener::LLViewerControlListener() - : LLDispatchListener("LLViewerControl", "group") + : LLEventAPI("LLViewerControl", + "LLViewerControl listener: set, toggle or set default for various controls", + "group") { - add("Global", boost::bind(&LLViewerControlListener::set, &gSavedSettings, _1)); - add("PerAccount", boost::bind(&LLViewerControlListener::set, &gSavedPerAccountSettings, _1)); - add("Warning", boost::bind(&LLViewerControlListener::set, &gWarningSettings, _1)); - add("Crash", boost::bind(&LLViewerControlListener::set, &gCrashSettings, _1)); + add("Global", + "Set gSavedSettings control [\"key\"] to value [\"value\"]", + boost::bind(&LLViewerControlListener::set, &gSavedSettings, _1)); + add("PerAccount", + "Set gSavedPerAccountSettings control [\"key\"] to value [\"value\"]", + boost::bind(&LLViewerControlListener::set, &gSavedPerAccountSettings, _1)); + add("Warning", + "Set gWarningSettings control [\"key\"] to value [\"value\"]", + boost::bind(&LLViewerControlListener::set, &gWarningSettings, _1)); + add("Crash", + "Set gCrashSettings control [\"key\"] to value [\"value\"]", + boost::bind(&LLViewerControlListener::set, &gCrashSettings, _1)); #if 0 add(/*"toggleControl",*/ "Global", boost::bind(&LLViewerControlListener::toggleControl, &gSavedSettings, _1)); diff --git a/indra/newview/llviewercontrollistener.h b/indra/newview/llviewercontrollistener.h index cacf97e908..88afbb871d 100644 --- a/indra/newview/llviewercontrollistener.h +++ b/indra/newview/llviewercontrollistener.h @@ -12,12 +12,12 @@ #ifndef LL_LLVIEWERCONTROLLISTENER_H #define LL_LLVIEWERCONTROLLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" class LLControlGroup; class LLSD; -class LLViewerControlListener : public LLDispatchListener +class LLViewerControlListener : public LLEventAPI { public: LLViewerControlListener(); diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp index 820f709ba5..976d89a5b7 100644 --- a/indra/newview/llviewermenu.cpp +++ b/indra/newview/llviewermenu.cpp @@ -415,7 +415,7 @@ public: static LLMenuParcelObserver* gMenuParcelObserver = NULL; -static LLUIListener sUIListener("UI"); +static LLUIListener sUIListener; LLMenuParcelObserver::LLMenuParcelObserver() { diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index 6b0f8814b9..d69cc5999c 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -1212,7 +1212,7 @@ LLViewerWindow::LLViewerWindow( mStatesDirty(false), mIsFullscreenChecked(false), mCurrResolutionIndex(0), - mViewerWindowListener(new LLViewerWindowListener("LLViewerWindow", this)) + mViewerWindowListener(new LLViewerWindowListener(this)) { LLNotificationChannel::buildChannel("VW_alerts", "Visible", LLNotificationFilters::filterBy(&LLNotification::getType, "alert")); LLNotificationChannel::buildChannel("VW_alertmodal", "Visible", LLNotificationFilters::filterBy(&LLNotification::getType, "alertmodal")); diff --git a/indra/newview/llviewerwindowlistener.cpp b/indra/newview/llviewerwindowlistener.cpp index a890b042ae..de57788271 100644 --- a/indra/newview/llviewerwindowlistener.cpp +++ b/indra/newview/llviewerwindowlistener.cpp @@ -20,8 +20,9 @@ // other Linden headers #include "llviewerwindow.h" -LLViewerWindowListener::LLViewerWindowListener(const std::string& pumpname, LLViewerWindow* llviewerwindow): - LLDispatchListener(pumpname, "op"), +LLViewerWindowListener::LLViewerWindowListener(LLViewerWindow* llviewerwindow): + LLEventAPI("LLViewerWindow", + "LLViewerWindow listener to (e.g.) save a screenshot"), mViewerWindow(llviewerwindow) { // add() every method we want to be able to invoke via this event API. @@ -34,8 +35,15 @@ LLViewerWindowListener::LLViewerWindowListener(const std::string& pumpname, LLVi // saveSnapshotArgs["showui"] = LLSD::Boolean(); // saveSnapshotArgs["rebuild"] = LLSD::Boolean(); // saveSnapshotArgs["type"] = LLSD::String(); - add("saveSnapshot", &LLViewerWindowListener::saveSnapshot, saveSnapshotArgs); - add("requestReshape", &LLViewerWindowListener::requestReshape); + add("saveSnapshot", + "Save screenshot: [\"filename\"], [\"width\"], [\"height\"], [\"showui\"], [\"rebuild\"], [\"type\"]\n" + "type: \"COLOR\", \"DEPTH\", \"OBJECT_ID\"\n" + "Post on [\"reply\"] an event containing [\"ok\"]", + &LLViewerWindowListener::saveSnapshot, + saveSnapshotArgs); + add("requestReshape", + "Resize the window: [\"w\"], [\"h\"]", + &LLViewerWindowListener::requestReshape); } void LLViewerWindowListener::saveSnapshot(const LLSD& event) const diff --git a/indra/newview/llviewerwindowlistener.h b/indra/newview/llviewerwindowlistener.h index 59c636ecec..699f7907af 100644 --- a/indra/newview/llviewerwindowlistener.h +++ b/indra/newview/llviewerwindowlistener.h @@ -12,18 +12,17 @@ #if ! defined(LL_LLVIEWERWINDOWLISTENER_H) #define LL_LLVIEWERWINDOWLISTENER_H -#include "lleventdispatcher.h" +#include "lleventapi.h" class LLViewerWindow; class LLSD; /// Listen on an LLEventPump with specified name for LLViewerWindow request events. -class LLViewerWindowListener: public LLDispatchListener +class LLViewerWindowListener: public LLEventAPI { public: - /// Specify the pump name on which to listen, and bind the LLViewerWindow - /// instance to use (e.g. gViewerWindow). - LLViewerWindowListener(const std::string& pumpname, LLViewerWindow* llviewerwindow); + /// Bind the LLViewerWindow instance to use (e.g. gViewerWindow). + LLViewerWindowListener(LLViewerWindow* llviewerwindow); private: void saveSnapshot(const LLSD& event) const; -- cgit v1.3 From d4846af9fbd4a8b78071724d6e04cef70a982a81 Mon Sep 17 00:00:00 2001 From: brad kittenbrink Date: Wed, 11 Nov 2009 12:30:23 -0500 Subject: Fix for DLL linkage error in new LLEventAPI class. --- indra/llcommon/lleventapi.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/lleventapi.h b/indra/llcommon/lleventapi.h index fef12988cb..2cd3b5bf89 100644 --- a/indra/llcommon/lleventapi.h +++ b/indra/llcommon/lleventapi.h @@ -23,7 +23,7 @@ * from LLDispatchListener -- it also gives us event API introspection. * Deriving from LLInstanceTracker lets us enumerate instances. */ -class LLEventAPI: public LLDispatchListener, +class LL_COMMON_API LLEventAPI: public LLDispatchListener, public LLInstanceTracker { typedef LLDispatchListener lbase; -- cgit v1.3