teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

removed mygui from source tree and use system install instead

Browse source
This commit is contained in:
scrawl 2012-03-18 15:11:37 +01:00
parent 655f9fe920
commit 3a00fbb950
263 changed files with 131 additions and 48809 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
CMakeLists.txt
View file

@ -177,7 +177,6 @@ include_directories(${UUID_INCLUDE_DIR})
endif (WIN32)
if (MSVC10)
set(PLATFORM_INCLUDE_DIR "")
add_definitions(-DMYGUI_DONT_REPLACE_NULLPTR)
endif()
if (APPLE)
@ -187,6 +186,7 @@ endif (APPLE)
# Dependencies
find_package(OGRE REQUIRED)
find_package(MyGUI REQUIRED)
find_package(Boost REQUIRED COMPONENTS system filesystem program_options thread)
find_package(OIS REQUIRED)
find_package(OpenAL REQUIRED)
@ -203,14 +203,14 @@ include_directories("."
${OGRE_INCLUDE_DIR} ${OGRE_INCLUDE_DIR}/Ogre ${OGRE_INCLUDE_DIR}/OGRE ${OGRE_PLUGIN_INCLUDE_DIRS}
${OIS_INCLUDE_DIRS} ${Boost_INCLUDE_DIR}
${PLATFORM_INCLUDE_DIR}
${CMAKE_HOME_DIRECTORY}/extern/mygui_3.0.1/MyGUIEngine/include
${CMAKE_HOME_DIRECTORY}/extern/mygui_3.0.1/OgrePlatform/include
${MYGUI_INCLUDE_DIRS}
${MYGUI_PLATFORM_INCLUDE_DIRS}
${OPENAL_INCLUDE_DIR}
${UUID_INCLUDE_DIR}
${LIBDIR}
)
link_directories(${Boost_LIBRARY_DIRS} ${OGRE_LIB_DIR})
link_directories(${Boost_LIBRARY_DIRS} ${OGRE_LIB_DIR} ${MYGUI_LIB_DIR})
if(APPLE)
# List used Ogre plugins
@ -222,13 +222,6 @@ endif(APPLE)
add_subdirectory( extern/mygui_3.0.1 )
# Make sure that certain libraries are used as static libraries
# This is in effect turns off __declspec (dllexport) for windows
# Each library will also need to be configured to build as a static lib
# MyGUI: extern/mygui_3.0.0/
add_definitions(-DMYGUI_STATIC)
# Specify build paths
if (APPLE)

4
apps/openmw/CMakeLists.txt
View file

@ -87,9 +87,9 @@ target_link_libraries(openmw
${OPENAL_LIBRARY}
${SOUND_INPUT_LIBRARY}
${BULLET_LIBRARIES}
${MYGUI_LIBRARIES}
MyGUI.OgrePlatform #TODO MyGUI ogre platform is not added by the find script
components
MyGUIEngine
MyGUIOgrePlatform
)
if(APPLE)

125
cmake/FindMyGUI.cmake Normal file
View file

@ -0,0 +1,125 @@
# - Find MyGUI includes and library
#
# This module defines
# MYGUI_INCLUDE_DIRS
# MYGUI_LIBRARIES, the libraries to link against to use MYGUI.
# MYGUI_LIB_DIR, the location of the libraries
# MYGUI_FOUND, If false, do not try to use MYGUI
#
# Copyright © 2007, Matt Williams
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
CMAKE_POLICY(PUSH)
include(FindPkgMacros)
# IF (MYGUI_LIBRARIES AND MYGUI_INCLUDE_DIRS)
# SET(MYGUI_FIND_QUIETLY TRUE)
# ENDIF (MYGUI_LIBRARIES AND MYGUI_INCLUDE_DIRS)
IF (WIN32) #Windows
MESSAGE(STATUS "Looking for MyGUI")
SET(MYGUISDK $ENV{MYGUI_HOME})
IF (MYGUISDK)
findpkg_begin ( "MYGUI" )
MESSAGE(STATUS "Using MyGUI in OGRE SDK")
STRING(REGEX REPLACE "[\\]" "/" MYGUISDK "${MYGUISDK}" )
find_path ( MYGUI_INCLUDE_DIRS
MyGUI.h
"${MYGUISDK}/MyGUIEngine/include"
NO_DEFAULT_PATH )
find_path ( MYGUI_PLATFORM_INCLUDE_DIRS
MyGUI_OgrePlatform.h
"${MYGUISDK}/Platforms/Ogre/OgrePlatform/include"
NO_DEFAULT_PATH )
SET ( MYGUI_LIB_DIR ${MYGUISDK}/*/lib )
find_library ( MYGUI_LIBRARIES_REL NAMES
MyGUIEngine.lib
MyGUI.OgrePlatform.lib
HINTS
${MYGUI_LIB_DIR}
PATH_SUFFIXES "" release relwithdebinfo minsizerel )
find_library ( MYGUI_LIBRARIES_DBG NAMES
MyGUIEngine_d.lib
MyGUI.OgrePlatform_d.lib
HINTS
${MYGUI_LIB_DIR}
PATH_SUFFIXES "" debug )
find_library ( MYGUI_PLATFORM_LIBRARIES_REL NAMES
MyGUI.OgrePlatform.lib
HINTS
${MYGUI_LIB_DIR}
PATH_SUFFIXES "" release relwithdebinfo minsizerel )
find_library ( MYGUI_PLATFORM_LIBRARIES_DBG NAMES
MyGUI.OgrePlatform_d.lib
HINTS
${MYGUI_LIB_DIR}
PATH_SUFFIXES "" debug )
make_library_set ( MYGUI_LIBRARIES )
make_library_set ( MYGUI_PLATFORM_LIBRARIES )
MESSAGE ("${MYGUI_LIBRARIES}")
MESSAGE ("${MYGUI_PLATFORM_LIBRARIES}")
findpkg_finish ( "MYGUI" )
ENDIF (MYGUISDK)
IF (OGRESOURCE)
MESSAGE(STATUS "Using MyGUI in OGRE dependencies")
STRING(REGEX REPLACE "[\\]" "/" OGRESDK "${OGRESOURCE}" )
SET(MYGUI_INCLUDE_DIRS ${OGRESOURCE}/OgreMain/include/MYGUI)
SET(MYGUI_LIB_DIR ${OGRESOURCE}/lib)
SET(MYGUI_LIBRARIES debug Debug/MyGUIEngine_d optimized Release/MyGUIEngine)
ENDIF (OGRESOURCE)
ELSE (WIN32) #Unix
CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
FIND_PACKAGE(PkgConfig)
PKG_SEARCH_MODULE(MYGUI MYGUI MyGUI)
IF (MYGUI_INCLUDE_DIRS)
SET(MYGUI_INCLUDE_DIRS ${MYGUI_INCLUDE_DIRS})
SET(MYGUI_LIB_DIR ${MYGUI_LIBDIR})
SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} CACHE STRING "")
ELSE (MYGUI_INCLUDE_DIRS)
FIND_PATH(MYGUI_INCLUDE_DIRS MyGUI.h PATHS /usr/local/include /usr/include PATH_SUFFIXES MyGUI MYGUI)
FIND_LIBRARY(MYGUI_LIBRARIES mygui PATHS /usr/lib /usr/local/lib)
SET(MYGUI_LIB_DIR ${MYGUI_LIBRARIES})
STRING(REGEX REPLACE "(.*)/.*" "\\1" MYGUI_LIB_DIR "${MYGUI_LIB_DIR}")
STRING(REGEX REPLACE ".*/" "" MYGUI_LIBRARIES "${MYGUI_LIBRARIES}")
ENDIF (MYGUI_INCLUDE_DIRS)
ENDIF (WIN32)
#Do some preparation
SEPARATE_ARGUMENTS(MYGUI_INCLUDE_DIRS)
SEPARATE_ARGUMENTS(MYGUI_LIBRARIES)
SEPARATE_ARGUMENTS(MYGUI_PLATFORM_LIBRARIES)
SET(MYGUI_INCLUDE_DIRS ${MYGUI_INCLUDE_DIRS} CACHE PATH "")
SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} CACHE STRING "")
SET(MYGUI_LIBRARIES ${MYGUI_PLATFORM_LIBRARIES} CACHE STRING "")
SET(MYGUI_LIB_DIR ${MYGUI_LIB_DIR} CACHE PATH "")
IF (MYGUI_INCLUDE_DIRS AND MYGUI_LIBRARIES)
SET(MYGUI_FOUND TRUE)
ENDIF (MYGUI_INCLUDE_DIRS AND MYGUI_LIBRARIES)
IF (MYGUI_FOUND)
MARK_AS_ADVANCED(MYGUI_LIB_DIR)
IF (NOT MYGUI_FIND_QUIETLY)
MESSAGE(STATUS " libraries : ${MYGUI_LIBRARIES} from ${MYGUI_LIB_DIR}")
MESSAGE(STATUS " includes : ${MYGUI_INCLUDE_DIRS}")
ENDIF (NOT MYGUI_FIND_QUIETLY)
ELSE (MYGUI_FOUND)
IF (MYGUI_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could not find MYGUI")
ENDIF (MYGUI_FIND_REQUIRED)
ENDIF (MYGUI_FOUND)
CMAKE_POLICY(POP)

20
extern/mygui_3.0.1/CMakeLists.txt vendored
View file

@ -1,25 +1,5 @@
# Minimal MyGUI build system for OpenMW
cmake_minimum_required(VERSION 2.6)
project(MYGUI)
# Use Freetype
find_package(Freetype REQUIRED)
set(MYGUI_USE_FREETYPE TRUE)
# Use Ogre
add_definitions("-DMYGUI_OGRE_PLATFORM")
# Static linking
set(MYGUI_LIB_TYPE STATIC)
add_definitions(-DMYGUI_STATIC)
# Setup MyGUIEngine project
add_subdirectory(MyGUIEngine)
# Setup OgrePlatform
add_subdirectory(OgrePlatform)
# Copy resource files into the build directory
set(SDIR ${CMAKE_CURRENT_SOURCE_DIR}/openmw_resources)
set(DDIR ${OpenMW_BINARY_DIR}/resources/mygui)

35
extern/mygui_3.0.1/MyGUIEngine/CMakeLists.txt vendored
View file

@ -1,35 +0,0 @@
set (PROJECT_NAME MyGUIEngine)
project( ${PROJECT_NAME} )
include(${PROJECT_NAME}.list)
include_directories(include)
if (MYGUI_USE_FREETYPE)
include_directories(
${FREETYPE_INCLUDE_DIRS}
)
add_definitions(-DMYGUI_USE_FREETYPE)
endif ()
add_definitions(-DMYGUI_BUILD)
if (WIN32)
add_definitions(-DNOMINMAX)
endif ()
add_library(${PROJECT_NAME} ${MYGUI_LIB_TYPE} ${HEADER_FILES} ${SOURCE_FILES})
if (MYGUI_USE_FREETYPE)
target_link_libraries(${PROJECT_NAME}
${FREETYPE_LIBRARIES}
)
endif()
# We don't need this lib in OS X. uuid functions is in libc here.
if (NOT APPLE)
target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS} uuid)
endif(NOT APPLE)
if (MINGW)
target_link_libraries(${PROJECT_NAME} libwinmm.a)
endif (MINGW)

561
extern/mygui_3.0.1/MyGUIEngine/MyGUIEngine.list vendored
View file

@ -1,561 +0,0 @@
set (HEADER_FILES
include/MyGUI_Allocator.h
include/MyGUI_CustomAllocator.h
include/MyGUI_DDItemInfo.h
include/MyGUI_IBItemInfo.h
include/MyGUI_MenuItemType.h
include/MyGUI_MessageStyle.h
include/MyGUI_WidgetToolTip.h
include/MyGUI_Button.h
include/MyGUI_Canvas.h
include/MyGUI_ComboBox.h
include/MyGUI_DDContainer.h
include/MyGUI_Edit.h
include/MyGUI_HScroll.h
include/MyGUI_ItemBox.h
include/MyGUI_List.h
include/MyGUI_ListBox.h
include/MyGUI_ListCtrl.h
include/MyGUI_MenuBar.h
include/MyGUI_MenuCtrl.h
include/MyGUI_MenuItem.h
include/MyGUI_Message.h
include/MyGUI_MultiList.h
include/MyGUI_PopupMenu.h
include/MyGUI_Progress.h
include/MyGUI_ScrollView.h
include/MyGUI_StaticImage.h
include/MyGUI_StaticText.h
include/MyGUI_Tab.h
include/MyGUI_TabItem.h
include/MyGUI_VScroll.h
include/MyGUI_Widget.h
include/MyGUI_Window.h
include/MyGUI_IWidgetFactory.h
include/MyGUI_Bitwise.h
include/MyGUI_CoordConverter.h
include/MyGUI_DataFileStream.h
include/MyGUI_DataStream.h
include/MyGUI_Delegate.h
include/MyGUI_DelegateImplement.h
include/MyGUI_DynLib.h
include/MyGUI_Enumerator.h
include/MyGUI_EventPair.h
include/MyGUI_Guid.h
include/MyGUI_RenderOut.h
include/MyGUI_TextChangeHistory.h
include/MyGUI_TextIterator.h
include/MyGUI_TextureUtility.h
include/MyGUI_TextView.h
include/MyGUI_Timer.h
include/MyGUI_UString.h
include/MyGUI_Utility.h
include/MyGUI_WidgetTranslate.h
include/MyGUI_XmlDocument.h
include/MyGUI_LogManager.h
include/MyGUI_LogStream.h
include/MyGUI.h
include/MyGUI_CastWidget.h
include/MyGUI_Common.h
include/MyGUI_Diagnostic.h
include/MyGUI_Exception.h
include/MyGUI_GenericFactory.h
include/MyGUI_Macros.h
include/MyGUI_Platform.h
include/MyGUI_Precompiled.h
include/MyGUI_Prerequest.h
include/MyGUI_RenderFormat.h
include/MyGUI_ResourceHolder.h
include/MyGUI_WidgetDefines.h
include/MyGUI_ICroppedRectangle.h
include/MyGUI_IDataStream.h
include/MyGUI_Instance.h
include/MyGUI_IObject.h
include/MyGUI_ISerializable.h
include/MyGUI_ITexture.h
include/MyGUI_IUnlinkWidget.h
include/MyGUI_IVertexBuffer.h
include/MyGUI_IWidgetCreator.h
include/MyGUI_Plugin.h
include/MyGUI_RTTI.h
include/MyGUI_BiIndexBase.h
include/MyGUI_ScrollViewBase.h
include/MyGUI_WidgetEvent.h
include/MyGUI_WidgetUserData.h
include/MyGUI_EditText.h
include/MyGUI_MainSkin.h
include/MyGUI_RawRect.h
include/MyGUI_RotatingSkin.h
include/MyGUI_SimpleText.h
include/MyGUI_SubSkin.h
include/MyGUI_TileRect.h
include/MyGUI_IStateInfo.h
include/MyGUI_ISubWidget.h
include/MyGUI_ISubWidgetRect.h
include/MyGUI_ISubWidgetText.h
include/MyGUI_LayerItem.h
include/MyGUI_LayerNode.h
include/MyGUI_OverlappedLayer.h
include/MyGUI_RenderItem.h
include/MyGUI_SharedLayer.h
include/MyGUI_SharedLayerNode.h
include/MyGUI_ILayer.h
include/MyGUI_ILayerItem.h
include/MyGUI_ILayerNode.h
include/MyGUI_IRenderTarget.h
include/MyGUI_ActionController.h
include/MyGUI_ControllerEdgeHide.h
include/MyGUI_ControllerFadeAlpha.h
include/MyGUI_ControllerItem.h
include/MyGUI_ControllerPosition.h
include/MyGUI_ResourceImageSet.h
include/MyGUI_ResourceImageSetPointer.h
include/MyGUI_ResourceManualFont.h
include/MyGUI_ResourceManualPointer.h
include/MyGUI_ResourceSkin.h
include/MyGUI_ResourceTrueTypeFont.h
include/MyGUI_IFont.h
include/MyGUI_IPointer.h
include/MyGUI_IResource.h
include/MyGUI_ChildSkinInfo.h
include/MyGUI_FontData.h
include/MyGUI_MaskPickInfo.h
include/MyGUI_SubWidgetBinding.h
include/MyGUI_SubWidgetInfo.h
include/MyGUI_Align.h
include/MyGUI_Any.h
include/MyGUI_Colour.h
include/MyGUI_CommonStateInfo.h
include/MyGUI_ImageInfo.h
include/MyGUI_InputDefine.h
include/MyGUI_RenderTargetInfo.h
include/MyGUI_TCoord.h
include/MyGUI_TPoint.h
include/MyGUI_TRect.h
include/MyGUI_TSize.h
include/MyGUI_Types.h
include/MyGUI_Version.h
include/MyGUI_VertexData.h
include/MyGUI_WidgetStyle.h
include/MyGUI_ClipboardManager.h
include/MyGUI_ControllerManager.h
include/MyGUI_DataManager.h
include/MyGUI_DynLibManager.h
include/MyGUI_FactoryManager.h
include/MyGUI_FontManager.h
include/MyGUI_Gui.h
include/MyGUI_InputManager.h
include/MyGUI_LanguageManager.h
include/MyGUI_LayerManager.h
include/MyGUI_LayoutManager.h
include/MyGUI_PluginManager.h
include/MyGUI_PointerManager.h
include/MyGUI_RenderManager.h
include/MyGUI_ResourceManager.h
include/MyGUI_SkinManager.h
include/MyGUI_SubWidgetManager.h
include/MyGUI_WidgetManager.h
)
set (SOURCE_FILES
src/MyGUI_Button.cpp
src/MyGUI_Canvas.cpp
src/MyGUI_ComboBox.cpp
src/MyGUI_DDContainer.cpp
src/MyGUI_Edit.cpp
src/MyGUI_HScroll.cpp
src/MyGUI_ItemBox.cpp
src/MyGUI_List.cpp
src/MyGUI_ListBox.cpp
src/MyGUI_ListCtrl.cpp
src/MyGUI_MenuBar.cpp
src/MyGUI_MenuCtrl.cpp
src/MyGUI_MenuItem.cpp
src/MyGUI_Message.cpp
src/MyGUI_MultiList.cpp
src/MyGUI_PopupMenu.cpp
src/MyGUI_Progress.cpp
src/MyGUI_ScrollView.cpp
src/MyGUI_StaticImage.cpp
src/MyGUI_StaticText.cpp
src/MyGUI_Tab.cpp
src/MyGUI_TabItem.cpp
src/MyGUI_VScroll.cpp
src/MyGUI_Widget.cpp
src/MyGUI_Window.cpp
src/MyGUI_EditText.cpp
src/MyGUI_MainSkin.cpp
src/MyGUI_RawRect.cpp
src/MyGUI_RotatingSkin.cpp
src/MyGUI_SimpleText.cpp
src/MyGUI_SubSkin.cpp
src/MyGUI_TileRect.cpp
src/MyGUI_LayerItem.cpp
src/MyGUI_LayerNode.cpp
src/MyGUI_OverlappedLayer.cpp
src/MyGUI_RenderItem.cpp
src/MyGUI_SharedLayer.cpp
src/MyGUI_SharedLayerNode.cpp
src/MyGUI_ActionController.cpp
src/MyGUI_ControllerEdgeHide.cpp
src/MyGUI_ControllerFadeAlpha.cpp
src/MyGUI_ControllerPosition.cpp
src/MyGUI_Exception.cpp
src/MyGUI_Precompiled.cpp
src/MyGUI_IWidgetCreator.cpp
src/MyGUI_ScrollViewBase.cpp
src/MyGUI_ResourceImageSet.cpp
src/MyGUI_ResourceImageSetPointer.cpp
src/MyGUI_ResourceManualFont.cpp
src/MyGUI_ResourceManualPointer.cpp
src/MyGUI_ResourceSkin.cpp
src/MyGUI_ResourceTrueTypeFont.cpp
src/MyGUI_MaskPickInfo.cpp
src/MyGUI_Any.cpp
src/MyGUI_Colour.cpp
src/MyGUI_ClipboardManager.cpp
src/MyGUI_ControllerManager.cpp
src/MyGUI_DataManager.cpp
src/MyGUI_DynLibManager.cpp
src/MyGUI_FactoryManager.cpp
src/MyGUI_FontManager.cpp
src/MyGUI_Gui.cpp
src/MyGUI_InputManager.cpp
src/MyGUI_LanguageManager.cpp
src/MyGUI_LayerManager.cpp
src/MyGUI_LayoutManager.cpp
src/MyGUI_PluginManager.cpp
src/MyGUI_PointerManager.cpp
src/MyGUI_RenderManager.cpp
src/MyGUI_ResourceManager.cpp
src/MyGUI_SkinManager.cpp
src/MyGUI_SubWidgetManager.cpp
src/MyGUI_WidgetManager.cpp
src/MyGUI_DataFileStream.cpp
src/MyGUI_DataStream.cpp
src/MyGUI_DynLib.cpp
src/MyGUI_Guid.cpp
src/MyGUI_RenderOut.cpp
src/MyGUI_TextIterator.cpp
src/MyGUI_TextureUtility.cpp
src/MyGUI_Timer.cpp
src/MyGUI_XmlDocument.cpp
src/MyGUI_LogManager.cpp
src/MyGUI_LogStream.cpp
)
SOURCE_GROUP("Source Files\\Widget\\Widget" FILES
src/MyGUI_Button.cpp
src/MyGUI_Canvas.cpp
src/MyGUI_ComboBox.cpp
src/MyGUI_DDContainer.cpp
src/MyGUI_Edit.cpp
src/MyGUI_HScroll.cpp
src/MyGUI_ItemBox.cpp
src/MyGUI_List.cpp
src/MyGUI_ListBox.cpp
src/MyGUI_ListCtrl.cpp
src/MyGUI_MenuBar.cpp
src/MyGUI_MenuCtrl.cpp
src/MyGUI_MenuItem.cpp
src/MyGUI_Message.cpp
src/MyGUI_MultiList.cpp
src/MyGUI_PopupMenu.cpp
src/MyGUI_Progress.cpp
src/MyGUI_ScrollView.cpp
src/MyGUI_StaticImage.cpp
src/MyGUI_StaticText.cpp
src/MyGUI_Tab.cpp
src/MyGUI_TabItem.cpp
src/MyGUI_VScroll.cpp
src/MyGUI_Widget.cpp
src/MyGUI_Window.cpp
)
SOURCE_GROUP("Source Files\\Widget" FILES
)
SOURCE_GROUP("Source Files\\Core\\SubWidget" FILES
src/MyGUI_EditText.cpp
src/MyGUI_MainSkin.cpp
src/MyGUI_RawRect.cpp
src/MyGUI_RotatingSkin.cpp
src/MyGUI_SimpleText.cpp
src/MyGUI_SubSkin.cpp
src/MyGUI_TileRect.cpp
)
SOURCE_GROUP("Source Files\\Core\\LayerItem" FILES
src/MyGUI_LayerItem.cpp
src/MyGUI_LayerNode.cpp
src/MyGUI_OverlappedLayer.cpp
src/MyGUI_RenderItem.cpp
src/MyGUI_SharedLayer.cpp
src/MyGUI_SharedLayerNode.cpp
)
SOURCE_GROUP("Source Files\\Core\\Controller" FILES
src/MyGUI_ActionController.cpp
src/MyGUI_ControllerEdgeHide.cpp
src/MyGUI_ControllerFadeAlpha.cpp
src/MyGUI_ControllerPosition.cpp
)
SOURCE_GROUP("Source Files\\Core\\Common\\Interfaces" FILES
src/MyGUI_IWidgetCreator.cpp
)
SOURCE_GROUP("Source Files\\Core\\Common\\Base" FILES
src/MyGUI_ScrollViewBase.cpp
)
SOURCE_GROUP("Source Files\\Core\\Common" FILES
src/MyGUI_Exception.cpp
src/MyGUI_Precompiled.cpp
)
SOURCE_GROUP("Source Files\\Core\\Resource\\Data" FILES
src/MyGUI_MaskPickInfo.cpp
)
SOURCE_GROUP("Source Files\\Core\\Resource" FILES
src/MyGUI_ResourceImageSet.cpp
src/MyGUI_ResourceImageSetPointer.cpp
src/MyGUI_ResourceManualFont.cpp
src/MyGUI_ResourceManualPointer.cpp
src/MyGUI_ResourceSkin.cpp
src/MyGUI_ResourceTrueTypeFont.cpp
)
SOURCE_GROUP("Source Files\\Core\\Types" FILES
src/MyGUI_Any.cpp
src/MyGUI_Colour.cpp
)
SOURCE_GROUP("Source Files\\Core\\Manager" FILES
src/MyGUI_ClipboardManager.cpp
src/MyGUI_ControllerManager.cpp
src/MyGUI_DataManager.cpp
src/MyGUI_DynLibManager.cpp
src/MyGUI_FactoryManager.cpp
src/MyGUI_FontManager.cpp
src/MyGUI_Gui.cpp
src/MyGUI_InputManager.cpp
src/MyGUI_LanguageManager.cpp
src/MyGUI_LayerManager.cpp
src/MyGUI_LayoutManager.cpp
src/MyGUI_PluginManager.cpp
src/MyGUI_PointerManager.cpp
src/MyGUI_RenderManager.cpp
src/MyGUI_ResourceManager.cpp
src/MyGUI_SkinManager.cpp
src/MyGUI_SubWidgetManager.cpp
src/MyGUI_WidgetManager.cpp
)
SOURCE_GROUP("Source Files\\Core" FILES
)
SOURCE_GROUP("Source Files\\Utility\\Logging" FILES
src/MyGUI_LogManager.cpp
src/MyGUI_LogStream.cpp
)
SOURCE_GROUP("Source Files\\Utility" FILES
src/MyGUI_DataFileStream.cpp
src/MyGUI_DataStream.cpp
src/MyGUI_DynLib.cpp
src/MyGUI_Guid.cpp
src/MyGUI_RenderOut.cpp
src/MyGUI_TextIterator.cpp
src/MyGUI_TextureUtility.cpp
src/MyGUI_Timer.cpp
src/MyGUI_XmlDocument.cpp
)
SOURCE_GROUP("Source Files" FILES
)
SOURCE_GROUP("Header Files\\Widget\\Types" FILES
include/MyGUI_DDItemInfo.h
include/MyGUI_IBItemInfo.h
include/MyGUI_MenuItemType.h
include/MyGUI_MessageStyle.h
include/MyGUI_WidgetToolTip.h
)
SOURCE_GROUP("Header Files\\Widget\\Widget" FILES
include/MyGUI_Button.h
include/MyGUI_Canvas.h
include/MyGUI_ComboBox.h
include/MyGUI_DDContainer.h
include/MyGUI_Edit.h
include/MyGUI_HScroll.h
include/MyGUI_ItemBox.h
include/MyGUI_List.h
include/MyGUI_ListBox.h
include/MyGUI_ListCtrl.h
include/MyGUI_MenuBar.h
include/MyGUI_MenuCtrl.h
include/MyGUI_MenuItem.h
include/MyGUI_Message.h
include/MyGUI_MultiList.h
include/MyGUI_PopupMenu.h
include/MyGUI_Progress.h
include/MyGUI_ScrollView.h
include/MyGUI_StaticImage.h
include/MyGUI_StaticText.h
include/MyGUI_Tab.h
include/MyGUI_TabItem.h
include/MyGUI_VScroll.h
include/MyGUI_Widget.h
include/MyGUI_Window.h
)
SOURCE_GROUP("Header Files\\Widget\\Interfaces" FILES
include/MyGUI_IWidgetFactory.h
)
SOURCE_GROUP("Header Files\\Widget" FILES
)
SOURCE_GROUP("Header Files\\Utility\\Logging" FILES
include/MyGUI_LogManager.h
include/MyGUI_LogStream.h
)
SOURCE_GROUP("Header Files\\Utility" FILES
include/MyGUI_Bitwise.h
include/MyGUI_CoordConverter.h
include/MyGUI_DataFileStream.h
include/MyGUI_DataStream.h
include/MyGUI_Delegate.h
include/MyGUI_DelegateImplement.h
include/MyGUI_DynLib.h
include/MyGUI_Enumerator.h
include/MyGUI_EventPair.h
include/MyGUI_Guid.h
include/MyGUI_RenderOut.h
include/MyGUI_TextChangeHistory.h
include/MyGUI_TextIterator.h
include/MyGUI_TextureUtility.h
include/MyGUI_TextView.h
include/MyGUI_Timer.h
include/MyGUI_UString.h
include/MyGUI_Utility.h
include/MyGUI_WidgetTranslate.h
include/MyGUI_XmlDocument.h
)
SOURCE_GROUP("Header Files\\Core\\Common\\Interfaces" FILES
include/MyGUI_ICroppedRectangle.h
include/MyGUI_IDataStream.h
include/MyGUI_Instance.h
include/MyGUI_IObject.h
include/MyGUI_ISerializable.h
include/MyGUI_ITexture.h
include/MyGUI_IUnlinkWidget.h
include/MyGUI_IVertexBuffer.h
include/MyGUI_IWidgetCreator.h
include/MyGUI_Plugin.h
include/MyGUI_RTTI.h
)
SOURCE_GROUP("Header Files\\Core\\Common\\Base" FILES
include/MyGUI_BiIndexBase.h
include/MyGUI_ScrollViewBase.h
include/MyGUI_WidgetEvent.h
include/MyGUI_WidgetUserData.h
)
SOURCE_GROUP("Header Files\\Core\\Common" FILES
include/MyGUI.h
include/MyGUI_CastWidget.h
include/MyGUI_Common.h
include/MyGUI_Diagnostic.h
include/MyGUI_Exception.h
include/MyGUI_GenericFactory.h
include/MyGUI_Macros.h
include/MyGUI_Platform.h
include/MyGUI_Precompiled.h
include/MyGUI_Prerequest.h
include/MyGUI_RenderFormat.h
include/MyGUI_ResourceHolder.h
include/MyGUI_WidgetDefines.h
)
SOURCE_GROUP("Header Files\\Core\\SubWidget\\Interfaces" FILES
include/MyGUI_IStateInfo.h
include/MyGUI_ISubWidget.h
include/MyGUI_ISubWidgetRect.h
include/MyGUI_ISubWidgetText.h
)
SOURCE_GROUP("Header Files\\Core\\SubWidget" FILES
include/MyGUI_EditText.h
include/MyGUI_MainSkin.h
include/MyGUI_RawRect.h
include/MyGUI_RotatingSkin.h
include/MyGUI_SimpleText.h
include/MyGUI_SubSkin.h
include/MyGUI_TileRect.h
)
SOURCE_GROUP("Header Files\\Core\\LayerItem\\Interfaces" FILES
include/MyGUI_ILayer.h
include/MyGUI_ILayerItem.h
include/MyGUI_ILayerNode.h
include/MyGUI_IRenderTarget.h
)
SOURCE_GROUP("Header Files\\Core\\LayerItem" FILES
include/MyGUI_LayerItem.h
include/MyGUI_LayerNode.h
include/MyGUI_OverlappedLayer.h
include/MyGUI_RenderItem.h
include/MyGUI_SharedLayer.h
include/MyGUI_SharedLayerNode.h
)
SOURCE_GROUP("Header Files\\Core\\Controller" FILES
include/MyGUI_ActionController.h
include/MyGUI_ControllerEdgeHide.h
include/MyGUI_ControllerFadeAlpha.h
include/MyGUI_ControllerItem.h
include/MyGUI_ControllerPosition.h
)
SOURCE_GROUP("Header Files\\Core\\Resource\\Interface" FILES
include/MyGUI_IFont.h
include/MyGUI_IPointer.h
include/MyGUI_IResource.h
)
SOURCE_GROUP("Header Files\\Core\\Resource\\Data" FILES
include/MyGUI_ChildSkinInfo.h
include/MyGUI_FontData.h
include/MyGUI_MaskPickInfo.h
include/MyGUI_SubWidgetBinding.h
include/MyGUI_SubWidgetInfo.h
)
SOURCE_GROUP("Header Files\\Core\\Resource" FILES
include/MyGUI_ResourceImageSet.h
include/MyGUI_ResourceImageSetPointer.h
include/MyGUI_ResourceManualFont.h
include/MyGUI_ResourceManualPointer.h
include/MyGUI_ResourceSkin.h
include/MyGUI_ResourceTrueTypeFont.h
)
SOURCE_GROUP("Header Files\\Core\\Types" FILES
include/MyGUI_Align.h
include/MyGUI_Any.h
include/MyGUI_Colour.h
include/MyGUI_CommonStateInfo.h
include/MyGUI_ImageInfo.h
include/MyGUI_InputDefine.h
include/MyGUI_RenderTargetInfo.h
include/MyGUI_TCoord.h
include/MyGUI_TPoint.h
include/MyGUI_TRect.h
include/MyGUI_TSize.h
include/MyGUI_Types.h
include/MyGUI_Version.h
include/MyGUI_VertexData.h
include/MyGUI_WidgetStyle.h
)
SOURCE_GROUP("Header Files\\Core\\Manager" FILES
include/MyGUI_ClipboardManager.h
include/MyGUI_ControllerManager.h
include/MyGUI_DataManager.h
include/MyGUI_DynLibManager.h
include/MyGUI_FactoryManager.h
include/MyGUI_FontManager.h
include/MyGUI_Gui.h
include/MyGUI_InputManager.h
include/MyGUI_LanguageManager.h
include/MyGUI_LayerManager.h
include/MyGUI_LayoutManager.h
include/MyGUI_PluginManager.h
include/MyGUI_PointerManager.h
include/MyGUI_RenderManager.h
include/MyGUI_ResourceManager.h
include/MyGUI_SkinManager.h
include/MyGUI_SubWidgetManager.h
include/MyGUI_WidgetManager.h
)
SOURCE_GROUP("Header Files\\Core" FILES
)
SOURCE_GROUP("Header Files" FILES
include/MyGUI_Allocator.h
include/MyGUI_CustomAllocator.h
)
SOURCE_GROUP("" FILES
CMakeLists.txt
)

92
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI.h vendored
View file

@ -1,92 +0,0 @@
/*!
@file
@author Georgiy Evmenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_H__
#define __MYGUI_H__
#include "MyGUI_Gui.h"
#include "MyGUI_Button.h"
#include "MyGUI_ComboBox.h"
#include "MyGUI_Edit.h"
#include "MyGUI_HScroll.h"
#include "MyGUI_List.h"
#include "MyGUI_StaticText.h"
#include "MyGUI_StaticImage.h"
#include "MyGUI_Tab.h"
#include "MyGUI_TabItem.h"
#include "MyGUI_VScroll.h"
#include "MyGUI_Window.h"
#include "MyGUI_Progress.h"
#include "MyGUI_Message.h"
#include "MyGUI_ItemBox.h"
#include "MyGUI_MultiList.h"
#include "MyGUI_MenuCtrl.h"
#include "MyGUI_MenuItem.h"
#include "MyGUI_PopupMenu.h"
#include "MyGUI_MenuBar.h"
#include "MyGUI_ScrollView.h"
#include "MyGUI_DDContainer.h"
#include "MyGUI_Canvas.h"
#include "MyGUI_ListCtrl.h"
#include "MyGUI_ListBox.h"
#include "MyGUI_InputManager.h"
#include "MyGUI_SubWidgetManager.h"
#include "MyGUI_ClipboardManager.h"
#include "MyGUI_LayerManager.h"
#include "MyGUI_LogManager.h"
#include "MyGUI_SkinManager.h"
#include "MyGUI_WidgetManager.h"
#include "MyGUI_LayoutManager.h"
#include "MyGUI_FontManager.h"
#include "MyGUI_PointerManager.h"
#include "MyGUI_PluginManager.h"
#include "MyGUI_DynLibManager.h"
#include "MyGUI_ControllerManager.h"
#include "MyGUI_LanguageManager.h"
#include "MyGUI_ResourceManager.h"
#include "MyGUI_RenderManager.h"
#include "MyGUI_DataManager.h"
#include "MyGUI_FactoryManager.h"
#include "MyGUI_ActionController.h"
#include "MyGUI_ControllerEdgeHide.h"
#include "MyGUI_ControllerFadeAlpha.h"
#include "MyGUI_ControllerPosition.h"
#include "MyGUI_CoordConverter.h"
#include "MyGUI_IResource.h"
#include "MyGUI_CastWidget.h"
#include "MyGUI_Any.h"
#include "MyGUI_MenuItemType.h"
#include "MyGUI_Version.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_WidgetStyle.h"
#include "MyGUI_IObject.h"
#include "MyGUI_ISerializable.h"
#include "MyGUI_RenderOut.h"
#include "MyGUI_RawRect.h"
#include "MyGUI_RotatingSkin.h"
#include "MyGUI_TextureUtility.h"
#endif // __MYGUI_H__

75
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ActionController.h vendored
View file

@ -1,75 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ACTION_CONTROLLER_H__
#define __MYGUI_ACTION_CONTROLLER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include <math.h>
namespace MyGUI
{
namespace action
{
/** Function used for hiding widget with one of controller event */
void MYGUI_EXPORT actionWidgetHide(Widget* _widget);
/** Function used for showing widget with one of controller event */
void MYGUI_EXPORT actionWidgetShow(Widget* _widget);
/** Function used for destroying widget with one of controller event */
void MYGUI_EXPORT actionWidgetDestroy(Widget* _widget);
/** Function for ControllerPosition per frame action : Move with constant speed */
void MYGUI_EXPORT linearMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _k);
/** Function for ControllerPosition per frame action : Move with accelerated speed
if N == 10 then this function is same as linearMoveFunction
if N > 10 speed will be increasing
if N < 10 speed will be decreasing
*/
template <int N>
inline void acceleratedMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time)
{
float k = (float)pow (_current_time, N/10.f /*3 by default as Accelerated and 0.4 by default as Slowed*/);
linearMoveFunction(_startRect, _destRect, _result, k);
}
/** Function for ControllerPosition per frame action : Move with accelerated speed a bit farther than necessary and then return it back */
template <int N>
inline void jumpMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time)
{
float k = pow (_current_time, 2) * (-2 - N/10.f) + _current_time * (3 + N/10.f);
linearMoveFunction(_startRect, _destRect, _result, k);
}
/** Function for ControllerPosition per frame action : Start with zero speed increasing half time and then decreasing to zero */
void MYGUI_EXPORT inertionalMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time);
} // namespace action
} // namespace MyGUI
#endif // __MYGUI_ACTION_CONTROLLER_H__

202
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Align.h vendored
View file

@ -1,202 +0,0 @@
/*!
@file
@author Albert Semenov
@date 08/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ALIGN_H__
#define __MYGUI_ALIGN_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Macros.h"
#include "MyGUI_Diagnostic.h"
#include <map>
namespace MyGUI
{
struct MYGUI_EXPORT Align
{
enum Enum
{
HCenter = MYGUI_FLAG_NONE, /**< center horizontally */
VCenter = MYGUI_FLAG_NONE, /**< center vertically */
Center = HCenter | VCenter, /**< center in the dead center */
Left = MYGUI_FLAG(1), /**< value from the left (and center vertically) */
Right = MYGUI_FLAG(2), /**< value from the right (and center vertically) */
HStretch = Left | Right, /**< stretch horizontally proportionate to parent window (and center vertically) */
Top = MYGUI_FLAG(3), /**< value from the top (and center horizontally) */
Bottom = MYGUI_FLAG(4), /**< value from the bottom (and center horizontally) */
VStretch = Top | Bottom, /**< stretch vertically proportionate to parent window (and center horizontally) */
Stretch = HStretch | VStretch, /**< stretch proportionate to parent window */
Default = Left | Top, /**< default value (value from left and top) */
HRelative = MYGUI_FLAG(5),
VRelative = MYGUI_FLAG(6),
Relative = HRelative | VRelative
};
Align(Enum _value = Default) : value(_value) { }
bool isHCenter() const { return HCenter == (value & ((int)HStretch | (int)HRelative)); }
bool isVCenter() const { return VCenter == (value & ((int)VStretch | (int)VRelative)); }
bool isCenter() const { return Center == (value & ((int)Stretch | (int)Relative)); }
bool isLeft() const { return Left == (value & ((int)HStretch | (int)HRelative)); }
bool isRight() const { return Right == (value & ((int)HStretch | (int)HRelative)); }
bool isHStretch() const { return HStretch == (value & ((int)HStretch | (int)HRelative)); }
bool isTop() const { return Top == (value & ((int)VStretch | (int)VRelative)); }
bool isBottom() const { return (Bottom == (value & ((int)VStretch | (int)VRelative))); }
bool isVStretch() const { return (VStretch == (value & ((int)VStretch | (int)VRelative))); }
bool isStretch() const { return (Stretch == (value & ((int)Stretch | (int)Relative))); }
bool isDefault() const { return (Default == (value & ((int)Stretch | (int)Relative))); }
bool isHRelative() const { return HRelative == (value & (int)HRelative); }
bool isVRelative() const { return VRelative == (value & (int)VRelative); }
bool isRelative() const { return Relative == (value & (int)Relative); }
Align& operator |= (Align const& _other) { value = Enum(int(value) | int(_other.value)); return *this; }
friend Align operator | (Enum const& a, Enum const& b) { return Align(Enum(int(a) | int(b))); }
friend Align operator | (Align const& a, Align const& b) { return Align(Enum(int(a.value) | int(b.value))); }
friend bool operator == (Align const& a, Align const& b) { return a.value == b.value; }
friend bool operator != (Align const& a, Align const& b) { return a.value != b.value; }
typedef std::map<std::string, int> MapAlign;
static Align parse(const std::string& _value)
{
Align result(Enum(0));
const MapAlign& map_names = result.getValueNames();
const std::vector<std::string>& vec = utility::split(_value);
for (size_t pos=0; pos<vec.size(); pos++)
{
MapAlign::const_iterator iter = map_names.find(vec[pos]);
if (iter != map_names.end())
{
result.value = Enum(int(result.value) | int(iter->second));
}
}
return result;
}
std::string print() const
{
std::string result;
if (value & Left)
{
if (value & Right) result = "HStretch";
else result = "Left";
}
else if (value & Right) result = "Right";
else result = "HCenter";
if (value & Top)
{
if (value & Bottom) result += " VStretch";
else result += " Top";
}
else if (value & Bottom) result += " Bottom";
else result += " VCenter";
return result;
}
friend std::ostream& operator << ( std::ostream& _stream, const Align& _value )
{
_stream << _value.print();
return _stream;
}
friend std::istream& operator >> ( std::istream& _stream, Align& _value )
{
_value.value = Enum(0);
std::string value;
_stream >> value;
const MapAlign& map_names = _value.getValueNames();
MapAlign::const_iterator iter = map_names.find(value);
if (iter != map_names.end())
_value.value = Enum(int(_value.value) | int(iter->second));
if (!_stream.eof())
{
std::string value2;
_stream >> value2;
iter = map_names.find(value2);
if (iter != map_names.end())
_value.value = Enum(int(_value.value) | int(iter->second));
}
return _stream;
}
private:
const MapAlign& getValueNames() const
{
static MapAlign map_names;
if (map_names.empty())
{
// OBSOLETE
map_names["ALIGN_HCENTER"] = HCenter;
map_names["ALIGN_VCENTER"] = VCenter;
map_names["ALIGN_CENTER"] = Center;
map_names["ALIGN_LEFT"] = Left;
map_names["ALIGN_RIGHT"] = Right;
map_names["ALIGN_HSTRETCH"] = HStretch;
map_names["ALIGN_TOP"] = Top;
map_names["ALIGN_BOTTOM"] = Bottom;
map_names["ALIGN_VSTRETCH"] = VStretch;
map_names["ALIGN_STRETCH"] = Stretch;
map_names["ALIGN_DEFAULT"] = Default;
MYGUI_REGISTER_VALUE(map_names, HCenter);
MYGUI_REGISTER_VALUE(map_names, VCenter);
MYGUI_REGISTER_VALUE(map_names, Center);
MYGUI_REGISTER_VALUE(map_names, Left);
MYGUI_REGISTER_VALUE(map_names, Right);
MYGUI_REGISTER_VALUE(map_names, HStretch);
MYGUI_REGISTER_VALUE(map_names, Top);
MYGUI_REGISTER_VALUE(map_names, Bottom);
MYGUI_REGISTER_VALUE(map_names, VStretch);
MYGUI_REGISTER_VALUE(map_names, Stretch);
MYGUI_REGISTER_VALUE(map_names, Default);
MYGUI_REGISTER_VALUE(map_names, HRelative);
MYGUI_REGISTER_VALUE(map_names, VRelative);
MYGUI_REGISTER_VALUE(map_names, Relative);
}
return map_names;
}
private:
Enum value;
};
} // namespace MyGUI
#endif // __MYGUI_ALIGN_H__

89
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Allocator.h vendored
View file

@ -1,89 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ALLOCATOR_H__
#define __MYGUI_ALLOCATOR_H__
#include <memory>
#include <limits>
namespace MyGUI
{
template<typename T>
class Allocator
{
public:
// typedefs
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
public:
// convert an allocator<T> to allocator<U>
template<typename U>
struct rebind
{
typedef Allocator<U> other;
};
public:
inline explicit Allocator() { }
inline ~Allocator() { }
template<typename U>
inline explicit Allocator(Allocator<U> const&) { }
// address
inline pointer address(reference r) { return &r; }
inline const_pointer address(const_reference r) { return &r; }
// memory allocation
inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0)
{
return reinterpret_cast<pointer>(::operator new (cnt * sizeof (T)));
}
inline void deallocate(pointer p, size_type)
{
::operator delete (p);
}
// size
inline size_type max_size() const
{
return std::numeric_limits<size_type>::max() / sizeof(T);
}
// construction/destruction
inline void construct(pointer p, const T& t) { new (p) T(t); }
inline void destroy(pointer p) { p->~T(); }
inline bool operator==(Allocator const&) { return true; }
inline bool operator!=(Allocator const& a) { return !operator==(a); }
};
} // namespace MyGUI
#endif // __MYGUI_ALLOCATOR_H__

213
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Any.h vendored
View file

@ -1,213 +0,0 @@
/*!
@file
@author Albert Semenov
@date 10/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
// -- Based on boost::any, original copyright information follows --
// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
//
// Distributed under the Boost Software License, Version 1.0.
// (See at http://www.boost.org/LICENSE_1_0.txt)
// -- End original copyright --
#ifndef __MYGUI_ANY_H__
#define __MYGUI_ANY_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Diagnostic.h"
#include <algorithm>
#include <typeinfo>
namespace MyGUI
{
/** @example "Class Any usage"
@code
void f()
{
// RU: тестовый класс, с простыми типами все аналогично
// EN: test class, with simple types all is similar
struct Data { int value; };
// RU: экземпляр и инициализация
// EN: instance and initialization
Data data;
data.value = 0xDEAD;
// RU: создастся копия класса Data
// EN: copy of class Data will be created
MyGUI::Any any = data;
// RU: копия класса Data
// EN: copy of class Data
Data copy_data = *any.castType<Data>();
// RU: теперь value == 0xDEAD
// EN: now value == 0xDEAD
int value = copy_data.value;
// RU: создастся копия указателя на класс Data
// EN: copy of pointer on class Data will be created
any = &data;
// RU: копия указателя на класс Data и конкретно на объект data
// EN: copy of pointer on class Data and on object data
Data * copy_ptr = *any.castType<Data*>();
// RU: теперь data.value == 0
// EN: now value == 0
copy_ptr->value = 0;
}
@endcode
*/
class MYGUI_EXPORT Any
{
private:
struct AnyEmpty { };
public:
static AnyEmpty Null;
public:
Any() :
mContent(nullptr)
{
}
template<typename ValueType> Any(const ValueType& value) :
mContent(new Holder<ValueType>(value))
{
}
Any(const Any::AnyEmpty& value) :
mContent(nullptr)
{
}
Any(const Any& other) :
mContent(other.mContent ? other.mContent->clone() : nullptr)
{
}
~Any()
{
delete mContent;
}
Any& swap(Any& rhs)
{
std::swap(mContent, rhs.mContent);
return *this;
}
template<typename ValueType> Any& operator = (const ValueType& rhs)
{
Any(rhs).swap(*this);
return *this;
}
Any& operator = (const Any::AnyEmpty& rhs)
{
delete mContent;
mContent = nullptr;
return *this;
}
Any& operator = (const Any& rhs)
{
Any(rhs).swap(*this);
return *this;
}
bool empty() const
{
return !mContent;
}
const std::type_info& getType() const
{
return mContent ? mContent->getType() : typeid(void);
}
template<typename ValueType>
ValueType * castType(bool _throw = true) const
{
if (this->getType() == typeid(ValueType))
{
return &static_cast<Any::Holder<ValueType> *>(this->mContent)->held;
}
MYGUI_ASSERT(!_throw, "Bad cast from type '" << getType().name() << "' to '" << typeid(ValueType).name() << "'");
return nullptr;
}
void * castUnsafe() const
{
return mContent ? static_cast<Any::Holder<void *> *>(this->mContent)->held : nullptr;
}
private:
class Placeholder
{
public:
virtual ~Placeholder() { }
public:
virtual const std::type_info& getType() const = 0;
virtual Placeholder * clone() const = 0;
};
template<typename ValueType> class Holder : public Placeholder
{
public:
Holder(const ValueType& value) :
held(value)
{
}
public:
virtual const std::type_info& getType() const
{
return typeid(ValueType);
}
virtual Placeholder * clone() const
{
return new Holder(held);
}
public:
ValueType held;
private:
Holder& operator=(const Holder &);
};
private: // representation
Placeholder * mContent;
};
} // namespace MyGUI
#endif // __MYGUI_ANY_H__

216
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_BiIndexBase.h vendored
View file

@ -1,216 +0,0 @@
/*!
@file
@author Albert Semenov
@date 10/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_BIINDEX_BASE_H__
#define __MYGUI_BIINDEX_BASE_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
class BiIndexBase
{
public:
virtual ~BiIndexBase() { }
protected:
size_t getIndexCount() { return mIndexFace.size(); }
size_t insertItemAt(size_t _index)
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE_INSERT(_index, mIndexFace.size(), "BiIndexBase::insertItemAt");
checkIndexes();
#endif
if (_index == MyGUI::ITEM_NONE) _index = mIndexFace.size();
size_t index;
if (_index == mIndexFace.size())
{
// для вставки айтема
index = mIndexFace.size();
mIndexFace.push_back(_index);
mIndexBack.push_back(_index);
}
else
{
// для вставки айтема
index = mIndexFace[_index];
size_t count = mIndexFace.size();
for (size_t pos=0; pos<count; ++pos)
{
if (mIndexFace[pos] >= index) mIndexFace[pos]++;
}
mIndexFace.insert(mIndexFace.begin() + _index, index);
count ++;
mIndexBack.push_back(0);
for (size_t pos=0; pos<count; ++pos)
{
mIndexBack[mIndexFace[pos]] = pos;
}
}
#if MYGUI_DEBUG_MODE == 1
checkIndexes();
#endif
return index;
}
size_t removeItemAt(size_t _index)
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE(_index, mIndexFace.size(), "BiIndexBase::removeItemAt");
checkIndexes();
#endif
// для удаления айтема
size_t index = mIndexFace[_index];
mIndexFace.erase(mIndexFace.begin() + _index);
mIndexBack.pop_back();
size_t count = mIndexFace.size();
for (size_t pos=0; pos<count; ++pos)
{
if (mIndexFace[pos] > index) mIndexFace[pos]--;
mIndexBack[mIndexFace[pos]] = pos;
}
#if MYGUI_DEBUG_MODE == 1
checkIndexes();
#endif
return index;
}
void removeAllItems()
{
mIndexFace.clear();
mIndexBack.clear();
}
// на входе индексы пользователя, на выходе реальные индексы
size_t convertToBack(size_t _index) const
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE_AND_NONE(_index, mIndexFace.size(), "BiIndexBase::convertToBack");
#endif
return _index == ITEM_NONE ? ITEM_NONE : mIndexFace[_index];
}
// на входе индексы реальные, на выходе, то что видит пользователь
size_t convertToFace(size_t _index) const
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE_AND_NONE(_index, mIndexFace.size(), "BiIndexBase::convertToFace");
#endif
return _index == ITEM_NONE ? ITEM_NONE : mIndexBack[_index];
}
// меняет местами два индекса, индексы со стороны пользователя
void swapItemsFaceAt(size_t _index1, size_t _index2)
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE(_index1, mIndexFace.size(), "BiIndexBase::swapItemsFaceAt");
MYGUI_ASSERT_RANGE(_index2, mIndexFace.size(), "BiIndexBase::swapItemsFaceAt");
#endif
std::swap(mIndexFace[_index1], mIndexFace[_index2]);
std::swap(mIndexBack[mIndexFace[_index1]], mIndexBack[mIndexFace[_index2]]);
}
// меняет местами два индекса, индексы со сторонны данных
void swapItemsBackAt(size_t _index1, size_t _index2)
{
#if MYGUI_DEBUG_MODE == 1
MYGUI_ASSERT_RANGE(_index1, mIndexFace.size(), "BiIndexBase::swapItemsBackAt");
MYGUI_ASSERT_RANGE(_index2, mIndexFace.size(), "BiIndexBase::swapItemsBackAt");
#endif
std::swap(mIndexBack[_index1], mIndexBack[_index2]);
std::swap(mIndexFace[mIndexBack[_index1]], mIndexFace[mIndexBack[_index2]]);
}
#if MYGUI_DEBUG_MODE == 1
void checkIndexes()
{
assert(mIndexFace.size() == mIndexBack.size());
// проверяем на уникальность каждого индекса в маппинге
std::vector<bool> vec;
size_t count = mIndexFace.size();
vec.reserve(count);
for (size_t pos=0; pos<count; ++pos) vec.push_back(false);
for (size_t pos=0; pos<count; ++pos)
{
// максимум
size_t index = mIndexBack[pos];
if (index >= count) throw new std::exception();
// максимум
index = mIndexFace[pos];
if (index >= count) throw new std::exception();
if (vec[index]) throw new std::exception();
vec[index] = true;
}
for (size_t pos=0; pos<count; ++pos)
{
if (!vec[pos]) throw new std::exception();
}
// проверяем на взаимоссылаемость индексов
for (size_t pos=0; pos<count; ++pos)
{
size_t index = mIndexFace[pos];
if (mIndexBack[index] != pos) throw new std::exception();
}
}
#endif
private:
typedef std::vector<size_t> VectorSizeT;
// маппинг с индексов, которые видны наружу
// на индексы которые реально используются данными
VectorSizeT mIndexFace;
// маппинг с индексов, которые используют данные
// на индексы которые виндны наружу
VectorSizeT mIndexBack;
};
} // namespace MyGUI
#endif // __MYGUI_BIINDEX_BASE_H__

78
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Bitwise.h vendored
View file

@ -1,78 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_BITWISE_H__
#define __MYGUI_BITWISE_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
class Bitwise
{
public:
/** Returns the closest power-of-two number greater or equal to value.
*/
template<typename Type>
static MYGUI_FORCEINLINE Type firstPO2From(Type _value)
{
--_value;
_value |= _value >> 16;
_value |= _value >> 8;
_value |= _value >> 4;
_value |= _value >> 2;
_value |= _value >> 1;
++_value;
return _value;
}
/** Determines whether the number is power-of-two or not. */
template<typename Type>
static MYGUI_FORCEINLINE bool isPO2(Type _value)
{
return (_value & (_value-1)) == 0;
}
/** Returns the number of bits a pattern must be shifted right by to
remove right-hand zeros.
*/
template<typename Type>
static MYGUI_FORCEINLINE size_t getBitShift(Type _mask)
{
if (_mask == 0)
return 0;
size_t result = 0;
while ((_mask & 1) == 0)
{
++result;
_mask >>= 1;
}
return result;
}
};
} // namespace MyGUI
#endif // __MYGUI_BITWISE_H__

111
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Button.h vendored
View file

@ -1,111 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_BUTTON_H__
#define __MYGUI_BUTTON_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_StaticText.h"
namespace MyGUI
{
class MYGUI_EXPORT Button :
public StaticText
{
MYGUI_RTTI_DERIVED( Button )
public:
Button();
//! OLD Set button check state
void setButtonPressed(bool _value) { setStateCheck(_value); }
//! OLD Get buton check
bool getButtonPressed() { return getStateCheck(); }
//! Set button check state
void setStateCheck(bool _value);
//! Get buton check
bool getStateCheck() { return mIsStateCheck; }
//! Set image index (image should be defined in skin)
void setImageIndex(size_t _value);
//! Get image index
size_t getImageIndex();
/** Enable or disable Image mode\n
Image mode: when button state changed Image on button also change it's picture.\n
Disabled (false) by default.
*/
void setModeImage(bool _value);
/** Get Image mode flag */
bool getModeImage() { return mModeImage; }
/** Get pointer to glyph image for this button (if it exist in button skin) */
StaticImage* getStaticImage() { return mImage; }
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
void _setMouseFocus(bool _focus);
protected:
virtual ~Button();
virtual void baseChangeWidgetSkin(ResourceSkin* _info);
virtual void onMouseLostFocus(Widget* _new);
virtual void onMouseSetFocus(Widget* _old);
virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
virtual void baseUpdateEnable();
bool _setState(const std::string& _value);
void setImageResource(const std::string& _name);
private:
void updateButtonState();
void shutdownWidgetSkin();
void initialiseWidgetSkin(ResourceSkin* _info);
private:
// нажата ли кнопка
bool mIsMousePressed;
// в фокусе ли кнопка
bool mIsMouseFocus;
// статус кнопки нажата или нет
bool mIsStateCheck;
StaticImage* mImage;
bool mModeImage;
};
} // namespace MyGUI
#endif // __MYGUI_BUTTON_H__

246
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Canvas.h vendored
View file

@ -1,246 +0,0 @@
/*!
@file
@author Alexander Ptakhin
@date 01/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CANVAS_H__
#define __MYGUI_CANVAS_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
#include "MyGUI_ITexture.h"
namespace MyGUI
{
/**
* Widget wrapper over Texture - shows the texture.
* Implemented: resizing of texture (see TextureResizeMode); recovery after lossing device;
*/
class MYGUI_EXPORT Canvas :
public Widget,
public ITextureInvalidateListener
{
MYGUI_RTTI_DERIVED( Canvas )
public:
Canvas();
struct Event
{
Event( bool _textureChanged, bool _widgetResized, bool _requested ) :
textureChanged( _textureChanged ),
widgetResized( _widgetResized ),
requested( _requested )
{
}
bool textureChanged;
bool widgetResized;
/// This update was caused by calling updateTexture();
bool requested;
};
typedef delegates::CDelegate1<Canvas*> EventInfo_Canvas;
typedef delegates::CDelegate2<Canvas*, Event> EventInfo_CanvasEvent;
//FIXME
/**
Available resize and view modes of texture
@remarks PT - Power of Two (size)
*/
enum TextureResizeMode
{
//
TRM_PT_CONST_SIZE, /// Texture doesn't resizes and fills all widget space
TRM_PT_VIEW_REQUESTED, /// You can view all pixels of texture, texture cropped by sizes of widget
TRM_PT_VIEW_ALL /// Texture resizes and fills all widget space
};
public:
/// Creates texture
void createTexture( TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
/// Creates texture
void createTexture( int _width, int _height, TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
/// Creates texture
void createTexture( const IntSize& _size, TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
/// Destroys texture
void destroyTexture();
/// Call user delegate update and removes old texture if it isn't original.
void updateTexture();
/// Locks hardware pixel buffer.
void* lock(TextureUsage _usage = TextureUsage::Write);
/// Unlocks hardware pixel buffer.
void unlock();
/// Checks lockness of hardware _pixel buffer.
bool isLocked() const { return mTexture->isLocked(); }
/// Returns real width of texture.
int getTextureRealWidth() const { return (int) mTexture->getWidth(); }
/// Returns real height of texture.
int getTextureRealHeight() const { return (int) mTexture->getHeight(); }
/// Returns real _size of texture.
IntSize getTextureRealSize() const { return IntSize( getTextureRealWidth(), getTextureRealHeight() ); }
/// Returns needed width while creating texture.
int getTextureSrcWidth() const { return mReqTexSize.width; }
/// Returns needed height while creating texture.
int getTextureSrcHeight() const { return mReqTexSize.height; }
/// Returns needed sizes while creating texture.
IntSize getTextureSrcSize() const { return mReqTexSize; }
/// Returns needed sizes while creating texture.
PixelFormat getTextureFormat() const { return mTexture->getFormat(); }
/// Returns name of the current texture.
const std::string& getTextureName() const { return mTexture->getName(); }
//! @copydoc Widget::setSize(const IntSize& _value)
virtual void setSize(const IntSize& _value);
//! @copydoc Widget::setCoord(const IntCoord& _value)
virtual void setCoord(const IntCoord& _value);
/** @copydoc Widget::setSize(int _width, int _height) */
void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
/// Returns resize mode
TextureResizeMode getResizeMode() const { return mTexResizeMode; }
/// Sets resize mode of texture \sa TextureResizeMode
void setResizeMode( TextureResizeMode _set ) { mTexResizeMode = _set; }
/// Checks if the texture has the source (required by user) size, otherwise real texture size are bigger.
bool isTextureSrcSize() const;
/// Returns true if the texture was created (and exists), otherwise false
bool isTextureCreated() const { return mTexture != nullptr; }
/// Returns true if we own the texture, otherwise false. \sa mManaged
bool isTextureManaged() const { return mTexManaged; }
/// Reurns interface texture.
ITexture* getTexture() { return mTexture; }
/// Sets the texture managed @remarks Be careful with assigning managed status to texture, which wasn't created in Canvas! \sa mManaged
void setTextureManaged( bool _value ) { mTexManaged = _value; }
/// Returns default GUI texture usage
static TextureUsage getDefaultTextureUsage() { return TextureUsage::Stream | TextureUsage::Write; }
/// Returns default GUI texture format
static PixelFormat getDefaultTextureFormat() { return PixelFormat::R8G8B8A8; }
/*event:*/
/** Event : Notify user texture instance will be changed \sa requestUpdateCanvas\n
signature : void method(MyGUI::Canvas* _canvas)\n
@param _canvas, which will be updated
*/
EventInfo_Canvas eventPreTextureChanges;
/** Event : Texture instance was changed (May be caused by resizing texture or lossing device). User have to update all references to new instance of texture.\n
signature : void method(MyGUI::Canvas* _canvas, MyGUI::Canvas::Event _event)\n
@param _canvas, which needs to update
@param _event
*/
EventInfo_CanvasEvent requestUpdateCanvas;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~Canvas();
/// Destroys texture
void _destroyTexture( bool _sendEvent );
/// Update entered parameters according to current texture resize mode(size) and restore (if can) parameters of usage and format from texture
void validate( int& _width, int& _height, TextureUsage& _usage, PixelFormat& _format ) const;
/// Creates the texture itself
void createExactTexture( int _width, int _height, TextureUsage _usage, PixelFormat _format );
/// Checks if we need to create a texture with such sizes.
bool checkCreate( int _width, int _height ) const;
/// Calls when resize widget
void resize( const IntSize& _size );
/// Correct texture uv-coordinates
void correctUV();
//! @copydoc Widget::baseChangeWidgetSkin(ResourceSkin* _info)
void baseChangeWidgetSkin( ResourceSkin* _info );
//! @copydoc Widget::initialiseWidgetSkin(ResourceSkin* _info)
void initialiseWidgetSkin( ResourceSkin* _info );
//! @copydoc Widget::shutdownWidgetSkin()
void shutdownWidgetSkin();
/// For updating once per frame.
void frameAdvise( bool _advise );
/// For updating once per frame.
void frameEntered( float _time );
virtual void textureInvalidate(ITexture* _texture);
protected:
/// Current texture
ITexture* mTexture;
/// Requested bu user sizes
IntSize mReqTexSize;
/// Generated texture name
std::string mGenTexName;
/// Texture resize mode \sa TextureResizeMode
TextureResizeMode mTexResizeMode;
/// Saved pointer from last calling lock. \sa lock
uint8* mTexData;
/// true if we own the texture (can delete it or replace by another instance), otherwise false
bool mTexManaged;
/// For updating once per frame. True state means updating before next frame starts.
bool mFrameAdvise;
};
} // namespace MyGUI
#endif // __MYGUI_CANVAS_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CastWidget.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CAST_WIDGET_H__
#define __MYGUI_CAST_WIDGET_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
namespace MyGUI
{
#ifndef MYGUI_DONT_USE_OBSOLETE
// шаблонный класс для проверки типа виджета
template <typename T>
MYGUI_OBSOLETE("use : template<typename Type> Type* Widget::castType(bool _throw)")
T* castWidget(Widget * _widget)
{
MYGUI_DEBUG_ASSERT(nullptr != _widget, "Error static cast, widget == nullptr");
return _widget->castType<T>();
}
#endif // MYGUI_DONT_USE_OBSOLETE
} // namespace MyGUI
#endif // __MYGUI_CAST_WIDGET_H__

73
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ChildSkinInfo.h vendored
View file

@ -1,73 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CHILD_SKIN_INFO_H__
#define __MYGUI_CHILD_SKIN_INFO_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_WidgetStyle.h"
namespace MyGUI
{
struct MYGUI_EXPORT ChildSkinInfo
{
ChildSkinInfo() : style(WidgetStyle::Child), align(Align::Default) { }
ChildSkinInfo(const std::string& _type, const WidgetStyle& _style, const std::string& _skin, const IntCoord& _coord, const Align& _align, const std::string& _layer, const std::string& _name) :
type(_type),
skin(_skin),
name(_name),
layer(_layer),
style(_style),
coord(_coord),
align(_align)
{
// set Child style by default
if (style == WidgetStyle::MAX) style = WidgetStyle::Child;
}
void addParam(const std::string& _key, const std::string& _value)
{
params[_key] = _value;
}
std::string findValue(const std::string& _key) const
{
MapString::const_iterator iter = params.find(_key);
if (iter != params.end()) return iter->second;
return "";
}
std::string type, skin, name, layer;
WidgetStyle style;
IntCoord coord;
Align align;
MapString params;
};
typedef std::vector<ChildSkinInfo> VectorChildSkinInfo;
} // namespace MyGUI
#endif // __MYGUI_CHILD_SKIN_INFO_H__

70
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ClipboardManager.h vendored
View file

@ -1,70 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CLIPBOARD_MANAGER_H__
#define __MYGUI_CLIPBOARD_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_Types.h"
#include "MyGUI_UString.h"
namespace MyGUI
{
class MYGUI_EXPORT ClipboardManager
{
MYGUI_INSTANCE_HEADER( ClipboardManager )
public:
void initialise();
void shutdown();
/** Set current data in clipboard
@param _type of data (for example "Text")
@param _data
*/
void setClipboardData(const std::string& _type, const std::string& _data);
/** Clear specific type data
@param _type of data to delete (for example "Text")
*/
void clearClipboardData(const std::string& _type);
/** Get specific type data
@param _type of data to get (for example "Text")
*/
std::string getClipboardData(const std::string& _type);
private:
MapString mClipboardData;
#if MYGUI_PLATFORM == MYGUI_PLATFORM_WIN32
// дискриптор нашего главного окна
size_t mHwnd;
// строка, которую мы положили в буфер обмена винды
UString mPutTextInClipboard;
#endif
};
}
#endif // __MYGUI_CLIPBOARD_MANAGER_H__

163
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Colour.h vendored
View file

@ -1,163 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_COLOUR_H__
#define __MYGUI_COLOUR_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
struct MYGUI_EXPORT Colour
{
float red, green, blue, alpha;
static const Colour Zero;
static const Colour Black;
static const Colour White;
static const Colour Red;
static const Colour Green;
static const Colour Blue;
Colour() : red( 1 ), green( 1 ), blue( 1 ), alpha( 1 ) { }
Colour( float _red, float _green, float _blue, float _alpha = 1 ) : red( _red ), green( _green ), blue( _blue ), alpha( _alpha ) { }
explicit Colour(const std::string& _value) { *this = parse(_value); }
Colour& operator=( Colour const& _value )
{
red = _value.red;
green = _value.green;
blue = _value.blue;
alpha = _value.alpha;
return *this;
}
bool operator==( Colour const& _value ) const
{
return ((red == _value.red) && (green == _value.green) && (blue == _value.blue) && (alpha == _value.alpha));
}
bool operator!=( Colour const& _value ) const
{
return ! (*this == _value);
}
void set( float _red, float _green, float _blue, float _alpha = 1 )
{
red = _red;
green = _green;
blue = _blue;
alpha = _alpha;
}
void clear()
{
red = green = blue = alpha = 0;
}
std::string print() const
{
std::ostringstream stream;
stream << *this;
return stream.str();
}
static Colour parse(const std::string& _value)
{
if (!_value.empty())
{
if (_value[0] == '#')
{
std::istringstream stream(_value.substr(1));
int result = 0;
stream >> std::hex >> result;
if (!stream.fail())
{
return Colour( (unsigned char)( result >> 16 ) / 256.0f, (unsigned char)( result >> 8 ) / 256.0f, (unsigned char)( result ) / 256.0f );
}
}
else
{
float red, green, blue, alpha = 1;
std::istringstream stream(_value);
stream >> red >> green >> blue;
if (!stream.fail())
{
if (!stream.eof())
stream >> alpha;
return Colour(red, green, blue, alpha);
}
}
}
return Colour::Zero;
}
friend std::ostream& operator << ( std::ostream& _stream, const Colour& _value )
{
_stream << _value.red << " " << _value.green << " " << _value.blue << " " << _value.alpha;
return _stream;
}
friend std::istream& operator >> ( std::istream& _stream, Colour& _value )
{
_value.clear();
std::string value;
_stream >> value;
if (value.empty())
return _stream;
if (value[0] == '#')
{
_value = Colour::parse(value);
}
else
{
std::istringstream stream(value);
stream >> _value.red;
if (stream.fail())
_value.clear();
else
{
_stream >> _value.green >> _value.blue;
if (!_stream.eof())
_stream >> _value.alpha;
else
_value.alpha = 1;
if (_stream.fail())
_value.clear();
}
}
return _stream;
}
};
} // namespace MyGUI
#endif // __MYGUI_COLOUR_H__

237
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ComboBox.h vendored
View file

@ -1,237 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_COMBO_BOX_H__
#define __MYGUI_COMBO_BOX_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Edit.h"
#include "MyGUI_List.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_ControllerFadeAlpha.h"
namespace MyGUI
{
typedef delegates::CDelegate2<ComboBox*, size_t> EventHandle_ComboBoxPtrSizeT;
class MYGUI_EXPORT ComboBox :
public Edit
{
MYGUI_RTTI_DERIVED( ComboBox )
public:
ComboBox();
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of items
size_t getItemCount() const { return mList->getItemCount(); }
//! Insert an item into a array at a specified position
void insertItemAt(size_t _index, const UString& _name, Any _data = Any::Null);
//! Add an item to the end of a array
void addItem(const UString& _name, Any _data = Any::Null) { return insertItemAt(ITEM_NONE, _name, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove all items
void removeAllItems();
//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
size_t findItemIndexWith(const UString& _name);
//------------------------------------------------------------------------------//
// манипуляции выделениями
//! Get index of selected item (ITEM_NONE if none selected)
size_t getIndexSelected() { return mItemIndex; }
//! Select specified _index
void setIndexSelected(size_t _index);
//! Clear item selection
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data);
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
return mList->getItemDataAt<ValueType>(_index, _throw);
}
//------------------------------------------------------------------------------//
// манипуляции отображением
//! Replace an item name at a specified position
void setItemNameAt(size_t _index, const UString& _name);
//! Get item name from specified position
const UString& getItemNameAt(size_t _index) { return mList->getItemNameAt(_index); }
//------------------------------------------------------------------------------//
// манипуляции выдимостью
//! Move all elements so specified becomes visible
void beginToItemAt(size_t _index) { mList->beginToItemAt(_index); }
//! Move all elements so first becomes visible
void beginToItemFirst() { if (getItemCount()) beginToItemAt(0); }
//! Move all elements so last becomes visible
void beginToItemLast() { if (getItemCount()) beginToItemAt(getItemCount() - 1); }
//! Move all elements so selected becomes visible
void beginToItemSelected() { if (getIndexSelected() != ITEM_NONE) beginToItemAt(getIndexSelected()); }
//------------------------------------------------------------------------------------//
// методы для управления отображением
//! Set drop list mode (text can not be edited)
void setComboModeDrop(bool _value);
//! Get drop list mode flag
bool getComboModeDrop() { return mModeDrop; }
//! Set smooth show of list
void setSmoothShow(bool _value) { mShowSmooth = _value; }
//! Get smooth show of list flag
bool getSmoothShow() { return mShowSmooth; }
//! Get max list height
void setMaxListHeight(int _value) { mMaxHeight = _value; }
//! Set max list height
int getMaxListHeight() { return mMaxHeight; }
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*event:*/
/** Event : Enter pressed in combo mode or item selected in drop.\n
signature : void method(MyGUI::ComboBox* _sender, size_t _index)
@param _sender widget that called this event
@param _index item
*/
EventPair<EventHandle_WidgetVoid, EventHandle_ComboBoxPtrSizeT> eventComboAccept;
/** Event : Position changed.\n
signature : void method(MyGUI::ComboBox* _sender, size_t _index)
@param _sender widget that called this event
@param _index of new position
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ComboBoxPtrSizeT> eventComboChangePosition;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : size_t ComboBox::getIndexSelected()")
size_t getItemIndexSelected() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void ComboBox::setIndexSelected(size_t _index)")
void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void ComboBox::clearIndexSelected()")
void clearItemSelected() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void ComboBox::insertItemAt(size_t _index, const UString& _name)")
void insertItem(size_t _index, const UString& _name) { insertItemAt(_index, _name); }
MYGUI_OBSOLETE("use : void ComboBox::setItemNameAt(size_t _index, const UString& _name)")
void setItem(size_t _index, const UString& _item) { setItemNameAt(_index, _item); }
MYGUI_OBSOLETE("use : const UString& ComboBox::getItemNameAt(size_t _index)")
const UString& getItem(size_t _index) { return getItemNameAt(_index); }
MYGUI_OBSOLETE("use : void ComboBox::removeItemAt(size_t _index)")
void deleteItem(size_t _index) { removeItemAt(_index); }
MYGUI_OBSOLETE("use : void ComboBox::removeAllItems()")
void deleteAllItems() { removeAllItems(); }
MYGUI_OBSOLETE("use : size_t ComboBox::getIndexSelected()")
size_t getItemSelect() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void void ComboBox::clearIndexSelected()")
void resetItemSelect() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void ComboBox::setIndexSelected(size_t _index)")
void setItemSelect(size_t _index) { setIndexSelected(_index); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~ComboBox();
virtual void onKeyButtonPressed(KeyCode _key, Char _char);
virtual void baseChangeWidgetSkin(ResourceSkin* _info);
private:
void notifyButtonPressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyListLostFocus(Widget* _sender, MyGUI::Widget* _new);
void notifyListSelectAccept(List* _widget, size_t _position);
void notifyListMouseItemActivate(List* _widget, size_t _position);
void notifyListChangePosition(List* _widget, size_t _position);
void notifyMouseWheel(Widget* _sender, int _rel);
void notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyEditTextChange(Edit* _sender);
void showList();
void hideList();
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void actionWidgetHide(Widget* _widget);
ControllerFadeAlpha* createControllerFadeAlpha(float _alpha, float _coef, bool _enable);
private:
Button* mButton;
List* mList;
bool mListShow;
int mMaxHeight;
size_t mItemIndex;
bool mModeDrop;
bool mDropMouse;
bool mShowSmooth;
bool mManualList;
};
} // namespace MyGUI
#endif // __MYGUI_COMBO_BOX_H__

57
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Common.h vendored
View file

@ -1,57 +0,0 @@
/*!
@file
@author Albert Semenov
@author baho_is
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_COMMON_H__
#define __MYGUI_COMMON_H__
#include "MyGUI_Prerequest.h"
#include <string>
#include <list>
#include <set>
#include <map>
#include <vector>
#include <deque>
#include <exception>
#include <math.h>
#ifdef MYGUI_CUSTOM_ALLOCATOR
# include "MyGUI_CustomAllocator.h"
#else // MYGUI_CUSTOM_ALLOCATOR
# include "MyGUI_Allocator.h"
#endif // MYGUI_CUSTOM_ALLOCATOR
#include "MyGUI_Macros.h"
#include "MyGUI_Diagnostic.h"
#include "MyGUI_LogManager.h"
#include "MyGUI_Instance.h"
#include "MyGUI_Types.h"
#include "MyGUI_RenderOut.h"
#include "MyGUI_Utility.h"
#include "MyGUI_InputDefine.h"
#include "MyGUI_Version.h"
#include "MyGUI_WidgetStyle.h"
#include "MyGUI_UString.h"
#include "MyGUI_Delegate.h"
#endif // __MYGUI_COMMON_H__

145
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CommonStateInfo.h vendored
View file

@ -1,145 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_COMMON_STATE_INFO_H__
#define __MYGUI_COMMON_STATE_INFO_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IStateInfo.h"
#include "MyGUI_CoordConverter.h"
#include "MyGUI_LanguageManager.h"
#include "MyGUI_TextureUtility.h"
namespace MyGUI
{
class MYGUI_EXPORT SubSkinStateInfo :
public IStateInfo
{
MYGUI_RTTI_DERIVED( SubSkinStateInfo )
public:
virtual ~SubSkinStateInfo() { }
const FloatRect& getRect() { return mRect; }
private:
virtual void deserialization(xml::ElementPtr _node, Version _version)
{
std::string texture = _node->getParent()->getParent()->findAttribute("texture");
// ïîääåðæêà çàìåíû òåãîâ â ñêèíàõ
if (_version >= Version(1, 1))
{
texture = LanguageManager::getInstance().replaceTags(texture);
}
const IntSize& size = texture_utility::getTextureSize(texture);
const IntCoord& coord = IntCoord::parse(_node->findAttribute("offset"));
mRect = CoordConverter::convertTextureCoord(coord, size);
}
private:
FloatRect mRect;
};
class MYGUI_EXPORT TileRectStateInfo :
public IStateInfo
{
MYGUI_RTTI_DERIVED( TileRectStateInfo )
public:
TileRectStateInfo() : mTileH(true), mTileV(true) { }
virtual ~TileRectStateInfo() { }
const FloatRect& getRect() { return mRect; }
const IntSize& getTileSize() { return mTileSize; }
bool getTileH() { return mTileH; }
bool getTileV() { return mTileV; }
private:
virtual void deserialization(xml::ElementPtr _node, Version _version)
{
std::string texture = _node->getParent()->getParent()->findAttribute("texture");
// ïîääåðæêà çàìåíû òåãîâ â ñêèíàõ
if (_version >= Version(1, 1))
{
texture = LanguageManager::getInstance().replaceTags(texture);
}
const IntSize& size = texture_utility::getTextureSize(texture);
const IntCoord& coord = IntCoord::parse(_node->findAttribute("offset"));
mRect = CoordConverter::convertTextureCoord(coord, size);
xml::ElementEnumerator prop = _node->getElementEnumerator();
while (prop.next("Property"))
{
const std::string& key = prop->findAttribute("key");
const std::string& value = prop->findAttribute("value");
if (key == "TileH") mTileH = utility::parseBool(value);
else if (key == "TileV") mTileV = utility::parseBool(value);
else if (key == "TileSize") mTileSize = IntSize::parse(value);
}
}
private:
FloatRect mRect;
IntSize mTileSize;
bool mTileH;
bool mTileV;
};
class MYGUI_EXPORT EditTextStateInfo :
public IStateInfo
{
MYGUI_RTTI_DERIVED( EditTextStateInfo )
public:
EditTextStateInfo() : mColour(Colour::White), mShift(false) { }
virtual ~EditTextStateInfo() { }
const Colour& getColour() { return mColour; }
bool getShift() { return mShift; }
private:
virtual void deserialization(xml::ElementPtr _node, Version _version)
{
mShift = utility::parseBool(_node->findAttribute("shift"));
std::string colour = _node->findAttribute("colour");
if (_version >= Version(1, 1))
{
colour = LanguageManager::getInstance().replaceTags(colour);
}
mColour = Colour::parse(colour);
}
private:
Colour mColour;
bool mShift;
};
} // namespace MyGUI
#endif // __MYGUI_COMMON_STATE_INFO_H__

84
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerEdgeHide.h vendored
View file

@ -1,84 +0,0 @@
/*!
@file
@author Evmenov Georgiy
@date 04/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CONTROLLER_EDGE_HIDE_H__
#define __MYGUI_CONTROLLER_EDGE_HIDE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_ControllerItem.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
/** This controller used for hiding widgets near screen edges.
Widget will start hiding(move out of screen) if it's near
border and it and it's childrens don't have any focus. Hiding
till only small part of widget be visible. Widget will move
inside screen if it have any focus.
*/
class MYGUI_EXPORT ControllerEdgeHide :
public ControllerItem
{
MYGUI_RTTI_DERIVED( ControllerEdgeHide )
public:
ControllerEdgeHide();
virtual ~ControllerEdgeHide() { }
/**
@param _value in which widget will be hidden or shown
*/
void setTime(float _value) { mTime = _value; }
/**
@param _remainPixels how many pixels you will see afterr full hide
*/
void setRemainPixels(int _value) { mRemainPixels = _value; }
/**
@param _shadowSize adds to _remainPixels when hiding left or top (for example used for windows with shadows)
*/
void setShadowSize(int _value) { mShadowSize = _value; }
virtual void setProperty(const std::string& _key, const std::string& _value);
private:
bool addTime(Widget* _widget, float _time);
void prepareItem(Widget* _widget);
void recalculateTime(Widget* _widget);
delegates::CDelegate1<Widget*> eventPostAction;
float mTime;
int mRemainPixels;
int mShadowSize;
float mElapsedTime;
// for checking if widget was moved
MyGUI::IntCoord mLastCoord;
};
}
#endif // __MYGUI_CONTROLLER_EDGE_HIDE_H__

78
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerFadeAlpha.h vendored
View file

@ -1,78 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CONTROLLER_FADE_ALPHA_H__
#define __MYGUI_CONTROLLER_FADE_ALPHA_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_ControllerItem.h"
namespace MyGUI
{
/** This controller used for smooth changing alpha of widget in time */
class MYGUI_EXPORT ControllerFadeAlpha :
public ControllerItem
{
MYGUI_RTTI_DERIVED( ControllerFadeAlpha )
public:
ControllerFadeAlpha();
virtual ~ControllerFadeAlpha() { }
/**
@param _alpha that will be as result of changing
*/
void setAlpha(float _value) { mAlpha = _value; }
/**
@param _coef of alpha changing speed (1. mean that alpha will change from 0 to 1 at 1 second)
*/
void setCoef(float _value) { mCoef = _value; }
/**
@param _enabled if true then widget will be inactive after start of alpha changing
*/
void setEnabled(bool _value) { mEnabled = _value; }
virtual void setProperty(const std::string& _key, const std::string& _value);
private:
bool addTime(Widget* _widget, float _time);
void prepareItem(Widget* _widget);
bool getEnabled() { return mEnabled; }
float getAlpha() { return mAlpha; }
float getCoef() { return mCoef; }
private:
float mAlpha;
float mCoef;
bool mEnabled;
};
}
#endif // __MYGUI_CONTROLLER_FADE_ALPHA_H__

73
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerItem.h vendored
View file

@ -1,73 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CONTROLLER_ITEM_H__
#define __MYGUI_CONTROLLER_ITEM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_IObject.h"
#include "MyGUI_Delegate.h"
namespace MyGUI
{
/** Base interface for controllers */
class MYGUI_EXPORT ControllerItem :
public IObject
{
MYGUI_RTTI_DERIVED( ControllerItem )
public:
virtual ~ControllerItem() { }
virtual void prepareItem(Widget* _widget) = 0;
virtual bool addTime(Widget* _widget, float _time) = 0;
virtual void setProperty(const std::string& _key, const std::string& _value) { }
/** Event : Before controller started working.\n
signature : void method(MyGUI::Widget* _sender)\n
@param _sender widget under control
*/
delegates::CDelegate1<Widget*>
eventPreAction;
/** Event : Controller updated (called every frame).\n
signature : void method(MyGUI::Widget* _sender)\n
@param _sender widget under control
*/
delegates::CDelegate1<Widget*>
eventUpdateAction;
/** Event : After controller finished working.\n
signature : void method(MyGUI::Widget* _sender)\n
@param _sender widget under control
*/
delegates::CDelegate1<Widget*>
eventPostAction;
};
} // namespace MyGUI
#endif // __MYGUI_CONTROLLER_ITEM_H__

74
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerManager.h vendored
View file

@ -1,74 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CONTROLLER_MANAGER_H__
#define __MYGUI_CONTROLLER_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_ControllerItem.h"
#include "MyGUI_IUnlinkWidget.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_ActionController.h"
namespace MyGUI
{
class MYGUI_EXPORT ControllerManager : public IUnlinkWidget
{
MYGUI_INSTANCE_HEADER( ControllerManager )
public:
void initialise();
void shutdown();
// ñîçäàåò êîíòðîëëåð
ControllerItem* createItem(const std::string& _type);
/** Add controlled widget
@param _widget to be controlled
@param _item controller with some actions (for example ControllerFadeAlpha or your own)
@note _item will be deleted automatically at end of controller lifetime
(if not removed by removeItem(Widget* _widget) before)
*/
void addItem(Widget* _widget, ControllerItem * _item);
/** Stop the control over a widget
@param _widget to be removed
*/
void removeItem(Widget* _widget);
private:
void _unlinkWidget(Widget* _widget);
void frameEntered(float _time);
void clear();
private:
typedef std::pair<Widget*, ControllerItem *> PairControllerItem;
typedef std::list<PairControllerItem> ListControllerItem;
ListControllerItem mListItem;
};
} // namespace MyGUI
#endif // __MYGUI_CONTROLLER_MANAGER_H__

95
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerPosition.h vendored
View file

@ -1,95 +0,0 @@
/*!
@file
@author Evmenov Georgiy
@date 03/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CONTROLLER_POSITION_H__
#define __MYGUI_CONTROLLER_POSITION_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Delegate.h"
#include "MyGUI_Types.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_ControllerItem.h"
namespace MyGUI
{
/** This controller used for smooth changing position of widget in time */
class MYGUI_EXPORT ControllerPosition :
public ControllerItem
{
MYGUI_RTTI_DERIVED( ControllerPosition )
public:
typedef delegates::CDelegate4<const IntCoord&, const IntCoord&, IntCoord&, float> FrameAction;
ControllerPosition();
virtual ~ControllerPosition() { }
void setCoord(const IntCoord& _value);
void setSize(const IntSize& _value);
void setPosition(const IntPoint& _value);
void setFunction(const std::string& _value);
/**
@param _value seconds in which widget planned to reach destination coordinate
*/
void setTime(float _value) { mTime = _value; }
/**
@param _action applied to widget every frame (see ControllerPosition::eventFrameAction)
*/
void setAction(FrameAction::IDelegate* _value) { eventFrameAction = _value; }
virtual void setProperty(const std::string& _key, const std::string& _value);
private:
bool addTime(Widget* _widget, float _time);
void prepareItem(Widget* _widget);
float getElapsedTime() { return mElapsedTime; }
IntCoord mStartCoord;
IntCoord mDestCoord;
float mTime;
float mElapsedTime;
// controller changing position
bool mCalcPosition;
// controller changing size
bool mCalcSize;
/** Event : Every frame action while controller exist.\n
signature : void method(const IntRect& _startRect, const IntRect& _destRect, IntRect& _result, float _current_time)\n
@param _startRect start coordinate of widget
@param _destRect destination coordinate
@param _result resultRect
@param _current_time elapsed time (_current_time is real elapsed time divided by _time(see constructor) so _current_time == 1 mean that _time seconds elapsed)
*/
FrameAction eventFrameAction;
};
}
#endif // __MYGUI_CONTROLLER_POSITION_H__

92
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CoordConverter.h vendored
View file

@ -1,92 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_COORD_CONVERTER_H__
#define __MYGUI_COORD_CONVERTER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
class MYGUI_EXPORT CoordConverter
{
public:
/** Convert pixel coordinates to texture UV coordinates */
static FloatRect convertTextureCoord(const IntCoord& _coord, const IntSize& _textureSize)
{
if (!_textureSize.width || !_textureSize.height) return FloatRect();
return FloatRect(
(float)_coord.left / (float)_textureSize.width,
(float)_coord.top / (float)_textureSize.height,
(float)_coord.right() / (float)_textureSize.width,
(float)_coord.bottom() / (float)_textureSize.height);
}
/* Convert from relative to pixel coordinates.
@param _coord relative coordinates.
*/
static IntCoord convertFromRelative(const FloatCoord& _coord, const IntSize& _view)
{
return IntCoord(int(_coord.left * _view.width), int(_coord.top * _view.height), int(_coord.width * _view.width), int(_coord.height * _view.height));
}
/* Convert from relative to pixel coordinates.
@param _coord relative coordinates.
*/
static IntSize convertFromRelative(const FloatSize& _size, const IntSize& _view)
{
return IntSize(int(_size.width * _view.width), int(_size.height * _view.height));
}
/* Convert from relative to pixel coordinates.
@param _coord relative coordinates.
*/
static IntPoint convertFromRelative(const FloatPoint& _point, const IntSize& _view)
{
return IntPoint(int(_point.left * _view.width), int(_point.top * _view.height));
}
/* Convert from pixel to relative coordinates.
@param _coord pixel coordinates.
*/
static FloatCoord convertToRelative(const IntCoord& _coord, const IntSize& _view)
{
return FloatCoord(_coord.left / (float)_view.width, _coord.top / (float)_view.height, _coord.width / (float)_view.width, _coord.height / (float)_view.height);
}
static FloatSize convertToRelative(const IntSize& _size, const IntSize& _view)
{
return FloatSize(_size.width / (float)_view.width, _size.height / (float)_view.height);
}
static FloatPoint convertToRelative(const IntPoint& _point, const IntSize& _view)
{
return FloatPoint(_point.left / (float)_view.width, _point.top / (float)_view.height);
}
};
} // namespace MyGUI
#endif // __MYGUI_COORD_CONVERTER_H__

101
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CustomAllocator.h vendored
View file

@ -1,101 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_CUSTOM_ALLOCATOR_H__
#define __MYGUI_CUSTOM_ALLOCATOR_H__
#include <memory>
#include <limits>
// for Ogre version
#include <OgrePrerequisites.h>
#if OGRE_VERSION < MYGUI_DEFINE_VERSION(1, 6, 0)
#include <OgreMemoryManager.h>
#include <OgreNoMemoryMacros.h>
#endif
namespace MyGUI
{
template<typename T>
class Allocator
{
public:
// typedefs
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
public:
// convert an allocator<T> to allocator<U>
template<typename U>
struct rebind
{
typedef Allocator<U> other;
};
public:
inline explicit Allocator() { }
inline ~Allocator() { }
template<typename U>
inline explicit Allocator(Allocator<U> const&) { }
// address
inline pointer address(reference r) { return &r; }
inline const_pointer address(const_reference r) { return &r; }
// memory allocation
inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0)
{
return reinterpret_cast<pointer>(::operator new (cnt * sizeof (T)));
}
inline void deallocate(pointer p, size_type)
{
::operator delete (p);
}
// size
inline size_type max_size() const
{
return std::numeric_limits<size_type>::max() / sizeof(T);
}
// construction/destruction
inline void construct(pointer p, const T& t) { new (p) T(t); }
inline void destroy(pointer p) { p->~T(); }
inline bool operator==(Allocator const&) { return true; }
inline bool operator!=(Allocator const& a) { return !operator==(a); }
};
} // namespace MyGUI
#if OGRE_VERSION < MYGUI_DEFINE_VERSION(1, 6, 0)
#include <OgreMemoryMacros.h>
#endif
#endif // __MYGUI_CUSTOM_ALLOCATOR_H__

175
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DDContainer.h vendored
View file

@ -1,175 +0,0 @@
/*!
@file
@author Albert Semenov
@date 10/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DDCONTAINER_H__
#define __MYGUI_DDCONTAINER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
#include "MyGUI_DDItemInfo.h"
#include "MyGUI_EventPair.h"
namespace MyGUI
{
typedef delegates::CDelegate3<DDContainer*, const DDItemInfo&, bool&> EventHandle_DDContainerPtrCDDItemInfoRefBoolRef;
typedef delegates::CDelegate3<DDContainer*, const DDItemInfo&, bool> EventHandle_DDContainerPtrCDDItemInfoRefBool;
typedef delegates::CDelegate2<DDContainer*, DDItemState> EventHandle_EventHandle_DDContainerPtrDDItemState;
typedef delegates::CDelegate3<DDContainer*, WidgetPtr&, IntCoord&> EventHandle_EventHandle_DDContainerPtrWidgetPtrRefIntCoordRef;
class MYGUI_EXPORT DDContainer :
public Widget
{
MYGUI_RTTI_DERIVED( DDContainer )
public:
DDContainer();
/** Set drag'n'drop mode flag.
Disabled (false) by default.
*/
void setNeedDragDrop(bool _value) { mNeedDragDrop = _value; }
/** Get drag'n'drop mode flag */
bool getNeedDragDrop() { return mNeedDragDrop; }
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*event:*/
/** Event : request for start drag
signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool& _result)
@param _sender widget that called this event
@param _info information about DDContainers
@param _result write here true if container can be draggedor false if it can't
*/
EventHandle_DDContainerPtrCDDItemInfoRefBoolRef eventStartDrag;
/** Event : request for start drag (moving mouse over container, but not dropped yet)
signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool& _result)
@param _sender widget that called this event
@param _info information about DDContainers
@param _result write here true if container accept dragged widget or false if it isn't
*/
EventHandle_DDContainerPtrCDDItemInfoRefBoolRef eventRequestDrop;
/** Event : end drag (drop)
signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool _result)
@param _sender widget that called this event
@param _info information about DDContainers
@param _result if true then drop was successfull
*/
EventHandle_DDContainerPtrCDDItemInfoRefBool eventDropResult;
/** Event : drag'n'drop state changed
signature : void method(MyGUI::DDContainer* _sender, MyGUI::DDItemState _state)
@param _sender widget that called this event
@param _state new state
*/
EventHandle_EventHandle_DDContainerPtrDDItemState eventChangeDDState;
/** Event : [not used] request widget for dragging
signature : void method(MyGUI::DDContainer* _sender, MyGUI::Widget*& _item, MyGUI::IntCoord& _dimension)
@param _sender widget that called this event
@param _item write widget pointer here
@param _dimension write widget coordinate here
*/
EventHandle_EventHandle_DDContainerPtrWidgetPtrRefIntCoordRef requestDragWidgetInfo;
/*internal:*/
// метод для установления стейта айтема
virtual void _setContainerItemInfo(size_t _index, bool _set, bool _accept) { }
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/** Event : внутреннее событие, невалидна информация для контейнера
signature : void method(MyGUI::DDContainer* _sender)
@param _sender widget that called this event
*/
EventPair<EventHandle_WidgetVoid, delegates::CDelegate1<DDContainer*> >
_eventInvalideContainer;
/** Event : !!обновить виджеты дропа DD_FIXME наверное internal
signature : void method(MyGUI::DDContainer* _sender, MyGUI::Widget* _item, const MyGUI::DDWidgetState& _state)
@param _sender widget that called this event
@param _items
@param _state
*/
delegates::CDelegate3<DDContainer*, Widget*, const DDWidgetState&>
eventUpdateDropState;
protected:
virtual ~DDContainer();
void baseChangeWidgetSkin(ResourceSkin* _info);
virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
virtual void onMouseDrag(int _left, int _top);
virtual void notifyInvalideDrop(DDContainer* _sender);
virtual void _getContainer(Widget*& _container, size_t& _index);
virtual void removeDropItems();
virtual void updateDropItems();
virtual void updateDropItemsState(const DDWidgetState& _state);
void mouseDrag();
void mouseButtonReleased(MouseButton _id);
void mouseButtonPressed(MouseButton _id);
void endDrop(bool _reset);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
protected:
bool mDropResult;
bool mNeedDrop;
bool mStartDrop;
Widget* mOldDrop;
Widget* mCurrentSender;
DDItemInfo mDropInfo;
size_t mDropSenderIndex;
// список виджетов для дропа
Widget* mDropItem;
IntCoord mDropDimension;
IntPoint mClickInWidget;
// нужно и виджету поддержка драг энд дропа
bool mNeedDragDrop;
DDContainer* mReseiverContainer;
};
} // namespace MyGUI
#endif // __MYGUI_DDCONTAINER_H__

120
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DDItemInfo.h vendored
View file

@ -1,120 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ITEM_DROP_INFO_H__
#define __MYGUI_ITEM_DROP_INFO_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct MYGUI_EXPORT DDItemState
{
enum Enum
{
None,
Start, /**< start drag */
End, /**< end drag (drop) */
Miss, /**< drag DDContainer over empty space or widgets that don't have drag'n'drop */
Accept, /**< drag DDContainer over another DDContainer that accept dropping on it */
Refuse /**< drag DDContainer over another DDContainer that refuse dropping on it */
};
DDItemState(Enum _value = None) : value(_value) { }
friend bool operator == (DDItemState const& a, DDItemState const& b) { return a.value == b.value; }
friend bool operator != (DDItemState const& a, DDItemState const& b) { return a.value != b.value; }
private:
Enum value;
};
// структура информации об индексах дропа
/** Inormation about drag'n'drop indexes */
struct MYGUI_EXPORT DDItemInfo
{
DDItemInfo() :
sender(nullptr),
sender_index(ITEM_NONE),
receiver(nullptr),
receiver_index(ITEM_NONE)
{
}
DDItemInfo(DDContainer* _sender, size_t _sender_index, DDContainer* _receiver, size_t _receiver_index) :
sender(_sender),
sender_index(_sender_index),
receiver(_receiver),
receiver_index(_receiver_index)
{
}
void set(DDContainer* _sender, size_t _sender_index, DDContainer* _receiver, size_t _receiver_index)
{
sender = _sender;
sender_index = _sender_index;
receiver = _receiver;
receiver_index = _receiver_index;
}
void reset()
{
sender = nullptr;
sender_index = ITEM_NONE;
receiver = nullptr;
receiver_index = ITEM_NONE;
}
/** DDContainer that send this event (container from which we started drag) */
DDContainer* sender;
/** Index of sender container */
size_t sender_index;
/** DDContainer that receive dragged widget (container to which we want to drop) */
DDContainer* receiver;
/** Index of receiver container */
size_t receiver_index;
};
struct MYGUI_EXPORT DDWidgetState
{
DDWidgetState(size_t _index) :
index(_index),
update(true),
accept(false),
refuse(false)
{ }
/** Index of element */
size_t index;
/** State and internal data changed */
bool update;
/** Is widget accept drop */
bool accept;
/** Is widget refuse drop */
bool refuse;
};
} // namespace MyGUI
#endif // __MYGUI_ITEM_DROP_INFO_H__

45
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataFileStream.h vendored
View file

@ -1,45 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DATA_FILE_STREAM_H__
#define __MYGUI_DATA_FILE_STREAM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_DataStream.h"
namespace MyGUI
{
class MYGUI_EXPORT DataFileStream : public DataStream
{
public:
DataFileStream();
DataFileStream(std::ifstream* _stream);
~DataFileStream();
private:
std::ifstream* mFileStream;
};
} // namespace MyGUI
#endif // __MYGUI_DATA_STREAM_H__

56
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataManager.h vendored
View file

@ -1,56 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DATA_MANAGER_H__
#define __MYGUI_DATA_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IDataStream.h"
namespace MyGUI
{
class MYGUI_EXPORT DataManager
{
public:
DataManager();
virtual ~DataManager() = 0;
static DataManager& getInstance();
static DataManager* getInstancePtr();
virtual IDataStream* getData(const std::string& _name) = 0;
virtual bool isDataExist(const std::string& _name) = 0;
virtual const VectorString& getDataListNames(const std::string& _pattern) = 0;
virtual const std::string& getDataPath(const std::string& _name) = 0;
private:
static DataManager* msInstance;
bool mIsInitialise;
};
} // namespace MyGUI
#endif // __MYGUI_DATA_MANAGER_H__

51
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataStream.h vendored
View file

@ -1,51 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DATA_STREAM_H__
#define __MYGUI_DATA_STREAM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IDataStream.h"
namespace MyGUI
{
class MYGUI_EXPORT DataStream : public IDataStream
{
public:
DataStream();
DataStream(std::istream* _stream);
virtual ~DataStream();
virtual bool eof();
virtual size_t size();
virtual void readline(std::string& _source, Char _delim);
virtual size_t read(void* _buf, size_t _count);
protected:
std::istream* mStream;
size_t mSize;
};
} // namespace MyGUI
#endif // __MYGUI_DATA_STREAM_H__

137
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Delegate.h vendored
View file

@ -1,137 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DELEGATE_H__
#define __MYGUI_DELEGATE_H__
#include "MyGUI_Diagnostic.h"
#include <typeinfo>
#include <list>
// source
// http://rsdn.ru/article/cpp/delegates.xml
// генерация делегатов для различного колличества параметров
namespace MyGUI
{
namespace delegates
{
// базовый класс для тех классов, что хотят себя отвязывать от мульти делегатов
class MYGUI_EXPORT IDelegateUnlink
{
public:
virtual ~IDelegateUnlink() { }
IDelegateUnlink() { m_baseDelegateUnlink = this; }
bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; }
private:
IDelegateUnlink * m_baseDelegateUnlink;
};
inline IDelegateUnlink * GetDelegateUnlink(void * _base) { return 0; }
inline IDelegateUnlink * GetDelegateUnlink(IDelegateUnlink * _base) { return _base; }
}
// без параметров
#define MYGUI_SUFFIX 0
#define MYGUI_TEMPLATE
#define MYGUI_TEMPLATE_PARAMS
#define MYGUI_TEMPLATE_ARGS
#define MYGUI_T_TEMPLATE_PARAMS <typename T>
#define MYGUI_T_TEMPLATE_ARGS <T>
#define MYGUI_PARAMS
#define MYGUI_ARGS
#define MYGUI_TYPENAME
#include "MyGUI_DelegateImplement.h"
// один параметр
#define MYGUI_SUFFIX 1
#define MYGUI_TEMPLATE template
#define MYGUI_TEMPLATE_PARAMS <typename TP1>
#define MYGUI_TEMPLATE_ARGS <TP1>
#define MYGUI_T_TEMPLATE_PARAMS <typename T, typename TP1>
#define MYGUI_T_TEMPLATE_ARGS <T, TP1>
#define MYGUI_PARAMS TP1 p1
#define MYGUI_ARGS p1
#define MYGUI_TYPENAME typename
#include "MyGUI_DelegateImplement.h"
// два параметра
#define MYGUI_SUFFIX 2
#define MYGUI_TEMPLATE template
#define MYGUI_TEMPLATE_PARAMS <typename TP1, typename TP2>
#define MYGUI_TEMPLATE_ARGS <TP1, TP2>
#define MYGUI_T_TEMPLATE_PARAMS <typename T, typename TP1, typename TP2>
#define MYGUI_T_TEMPLATE_ARGS <T, TP1, TP2>
#define MYGUI_PARAMS TP1 p1, TP2 p2
#define MYGUI_ARGS p1, p2
#define MYGUI_TYPENAME typename
#include "MyGUI_DelegateImplement.h"
// три параметра
#define MYGUI_SUFFIX 3
#define MYGUI_TEMPLATE template
#define MYGUI_TEMPLATE_PARAMS <typename TP1, typename TP2, typename TP3>
#define MYGUI_TEMPLATE_ARGS <TP1, TP2, TP3>
#define MYGUI_T_TEMPLATE_PARAMS <typename T, typename TP1, typename TP2, typename TP3>
#define MYGUI_T_TEMPLATE_ARGS <T, TP1, TP2, TP3>
#define MYGUI_PARAMS TP1 p1, TP2 p2, TP3 p3
#define MYGUI_ARGS p1, p2, p3
#define MYGUI_TYPENAME typename
#include "MyGUI_DelegateImplement.h"
// четыре параметра
#define MYGUI_SUFFIX 4
#define MYGUI_TEMPLATE template
#define MYGUI_TEMPLATE_PARAMS <typename TP1, typename TP2, typename TP3, typename TP4>
#define MYGUI_TEMPLATE_ARGS <TP1, TP2, TP3, TP4>
#define MYGUI_T_TEMPLATE_PARAMS <typename T, typename TP1, typename TP2, typename TP3, typename TP4>
#define MYGUI_T_TEMPLATE_ARGS <T, TP1, TP2, TP3, TP4>
#define MYGUI_PARAMS TP1 p1, TP2 p2, TP3 p3, TP4 p4
#define MYGUI_ARGS p1, p2, p3, p4
#define MYGUI_TYPENAME typename
#include "MyGUI_DelegateImplement.h"
// пять параметров
#define MYGUI_SUFFIX 5
#define MYGUI_TEMPLATE template
#define MYGUI_TEMPLATE_PARAMS <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
#define MYGUI_TEMPLATE_ARGS <TP1, TP2, TP3, TP4, TP5>
#define MYGUI_T_TEMPLATE_PARAMS <typename T, typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
#define MYGUI_T_TEMPLATE_ARGS <T, TP1, TP2, TP3, TP4, TP5>
#define MYGUI_PARAMS TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5
#define MYGUI_ARGS p1, p2, p3, p4, p5
#define MYGUI_TYPENAME typename
#include "MyGUI_DelegateImplement.h"
} // namespace MyGUI
#endif // __MYGUI_DELEGATE_H__

319
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DelegateImplement.h vendored
View file

@ -1,319 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
namespace delegates
{
#define MYGUI_COMBINE(a, b) MYGUI_COMBINE1(a, b)
#define MYGUI_COMBINE1(a, b) a##b
#define MYGUI_I_DELEGATE MYGUI_COMBINE(IDelegate, MYGUI_SUFFIX)
#define MYGUI_C_STATIC_DELEGATE MYGUI_COMBINE(CStaticDelegate, MYGUI_SUFFIX)
#define MYGUI_C_METHOD_DELEGATE MYGUI_COMBINE(CMethodDelegate, MYGUI_SUFFIX)
#define MYGUI_C_DELEGATE MYGUI_COMBINE(CDelegate, MYGUI_SUFFIX)
#define MYGUI_C_MULTI_DELEGATE MYGUI_COMBINE(CMultiDelegate, MYGUI_SUFFIX)
// базовый класс всех делегатов
MYGUI_TEMPLATE MYGUI_TEMPLATE_PARAMS
class MYGUI_I_DELEGATE
{
public:
virtual ~MYGUI_I_DELEGATE() { }
virtual bool isType( const std::type_info& _type) = 0;
virtual void invoke( MYGUI_PARAMS ) = 0;
virtual bool compare( MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS * _delegate) const = 0;
virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
};
// делегат для статической функции
MYGUI_TEMPLATE MYGUI_TEMPLATE_PARAMS
class MYGUI_C_STATIC_DELEGATE : public MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS
{
public:
typedef void (*Func)( MYGUI_PARAMS );
MYGUI_C_STATIC_DELEGATE (Func _func) : mFunc(_func) { }
virtual bool isType( const std::type_info& _type) { return typeid( MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS ) == _type; }
virtual void invoke( MYGUI_PARAMS )
{
mFunc( MYGUI_ARGS );
}
virtual bool compare( MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS * _delegate) const
{
if (nullptr == _delegate || !_delegate->isType(typeid(MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS)) ) return false;
MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS * cast = static_cast<MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS *>(_delegate);
return cast->mFunc == mFunc;
}
virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
private:
Func mFunc;
};
// делегат для метода класса
template MYGUI_T_TEMPLATE_PARAMS
class MYGUI_C_METHOD_DELEGATE : public MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS
{
public:
typedef void (T::*Method)( MYGUI_PARAMS );
MYGUI_C_METHOD_DELEGATE(IDelegateUnlink * _unlink, T * _object, Method _method) : mUnlink(_unlink), mObject(_object), mMethod(_method) { }
virtual bool isType( const std::type_info& _type) { return typeid( MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS ) == _type; }
virtual void invoke( MYGUI_PARAMS )
{
(mObject->*mMethod)( MYGUI_ARGS );
}
virtual bool compare( MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS * _delegate) const
{
if (nullptr == _delegate || !_delegate->isType(typeid(MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS)) ) return false;
MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS * cast = static_cast< MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS * >(_delegate);
return cast->mObject == mObject && cast->mMethod == mMethod;
}
virtual bool compare(IDelegateUnlink * _unlink) const
{
return mUnlink == _unlink;
}
private:
IDelegateUnlink *mUnlink;
T * mObject;
Method mMethod;
};
} // namespace delegates
// шаблон для создания делегата статической функции
// параметры : указатель на функцию
// пример : newDelegate(funk_name);
// пример : newDelegate(class_name::static_method_name);
MYGUI_TEMPLATE MYGUI_TEMPLATE_PARAMS
inline delegates::MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS * newDelegate( void (*_func)( MYGUI_PARAMS ) )
{
return new delegates::MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS (_func);
}
// шаблон для создания делегата метода класса
// параметры : указатель на объект класса и указатель на метод класса
// пример : newDelegate(&object_name, &class_name::method_name);
template MYGUI_T_TEMPLATE_PARAMS
inline delegates::MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS * newDelegate( T * _object, void (T::*_method)( MYGUI_PARAMS ) )
{
return new delegates::MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS (delegates::GetDelegateUnlink(_object), _object, _method);
}
namespace delegates
{
// шаблон класса делегата
MYGUI_TEMPLATE MYGUI_TEMPLATE_PARAMS
class MYGUI_C_DELEGATE
{
public:
typedef MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS IDelegate;
MYGUI_C_DELEGATE () : mDelegate(nullptr) { }
MYGUI_C_DELEGATE (const MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS& _event)
{
// забираем себе владение
mDelegate = _event.mDelegate;
const_cast< MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS& >(_event).mDelegate = nullptr;
}
~MYGUI_C_DELEGATE () { clear(); }
bool empty() const { return mDelegate == nullptr; }
void clear()
{
if (mDelegate)
{
delete mDelegate;
mDelegate = nullptr;
}
}
MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS & operator=(IDelegate* _delegate)
{
delete mDelegate;
mDelegate = _delegate;
return *this;
}
MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS & operator=(const MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS& _event)
{
// забираем себе владение
delete mDelegate;
mDelegate = _event.mDelegate;
const_cast< MYGUI_C_DELEGATE MYGUI_TEMPLATE_ARGS& >(_event).mDelegate = nullptr;
return *this;
}
void operator()( MYGUI_PARAMS )
{
if (mDelegate == nullptr) return;
mDelegate->invoke( MYGUI_ARGS );
}
private:
IDelegate * mDelegate;
};
// шаблон класса мульти делегата
MYGUI_TEMPLATE MYGUI_TEMPLATE_PARAMS
class MYGUI_C_MULTI_DELEGATE
{
public:
typedef MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS IDelegate;
typedef MYGUI_TYPENAME std::list<IDelegate* /*, Allocator<IDelegate*>*/ > ListDelegate;
typedef MYGUI_TYPENAME ListDelegate::iterator ListDelegateIterator;
typedef MYGUI_TYPENAME ListDelegate::const_iterator ConstListDelegateIterator;
MYGUI_C_MULTI_DELEGATE () { }
~MYGUI_C_MULTI_DELEGATE () { clear(); }
bool empty() const
{
for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter) return false;
}
return true;
}
void clear()
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter)
{
delete (*iter);
(*iter) = nullptr;
}
}
}
void clear(IDelegateUnlink * _unlink)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_unlink))
{
delete (*iter);
(*iter) = nullptr;
}
}
}
MYGUI_C_MULTI_DELEGATE MYGUI_TEMPLATE_ARGS & operator+=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
MYGUI_ASSERT(false, "dublicate delegate");
}
}
mListDelegates.push_back(_delegate);
return *this;
}
MYGUI_C_MULTI_DELEGATE MYGUI_TEMPLATE_ARGS & operator-=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
// проверяем на идентичность делегатов
if ((*iter) != _delegate) delete (*iter);
(*iter) = nullptr;
break;
}
}
delete _delegate;
return *this;
}
void operator()( MYGUI_PARAMS )
{
ListDelegateIterator iter = mListDelegates.begin();
while (iter != mListDelegates.end())
{
if (nullptr == (*iter))
{
iter = mListDelegates.erase(iter);
}
else
{
(*iter)->invoke( MYGUI_ARGS );
++iter;
}
}
}
private:
// constructor and operator =, without implementation, just for private
MYGUI_C_MULTI_DELEGATE (const MYGUI_C_MULTI_DELEGATE MYGUI_TEMPLATE_ARGS & _event);
MYGUI_C_MULTI_DELEGATE MYGUI_TEMPLATE_ARGS & operator=(const MYGUI_C_MULTI_DELEGATE MYGUI_TEMPLATE_ARGS & _event);
private:
ListDelegate mListDelegates;
};
#undef MYGUI_COMBINE
#undef MYGUI_COMBINE1
#undef MYGUI_I_DELEGATE
#undef MYGUI_C_STATIC_DELEGATE
#undef MYGUI_C_METHOD_DELEGATE
#undef MYGUI_C_DELEGATE
#undef MYGUI_C_MULTI_DELEGATE
#undef MYGUI_SUFFIX
#undef MYGUI_TEMPLATE
#undef MYGUI_TEMPLATE_PARAMS
#undef MYGUI_TEMPLATE_ARGS
#undef MYGUI_T_TEMPLATE_PARAMS
#undef MYGUI_T_TEMPLATE_ARGS
#undef MYGUI_PARAMS
#undef MYGUI_ARGS
#undef MYGUI_TYPENAME
} // namespace delegates

115
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Diagnostic.h vendored
View file

@ -1,115 +0,0 @@
/*!
@file
@author Albert Semenov
@author baho_is
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DIAGNOSTIC_H__
#define __MYGUI_DIAGNOSTIC_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Exception.h"
#include "MyGUI_LogManager.h"
#include <sstream>
// for debugging
#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
#include <crtdbg.h>
#endif
#define MYGUI_LOG_SECTION "Core"
#define MYGUI_LOG_FILENAME "MyGUI.log"
#define MYGUI_LOG(level, text) MYGUI_LOGGING(MYGUI_LOG_SECTION, level, text)
#define MYGUI_BASE_EXCEPT(desc, src) throw MyGUI::Exception(desc, src, __FILE__, __LINE__);
// MSVC specific: sets the breakpoint
#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
#define MYGUI_DBG_BREAK _CrtDbgBreak();
#else
#define MYGUI_DBG_BREAK
#endif
#define MYGUI_EXCEPT(dest) \
{ \
MYGUI_LOG(Critical, dest); \
MYGUI_DBG_BREAK;\
std::ostringstream stream; \
stream << dest << "\n"; \
MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
}
#define MYGUI_ASSERT(exp, dest) \
{ \
if ( ! (exp) ) \
{ \
MYGUI_LOG(Critical, dest); \
MYGUI_DBG_BREAK;\
std::ostringstream stream; \
stream << dest << "\n"; \
MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
} \
}
#define MYGUI_ASSERT_RANGE(index, size, owner) MYGUI_ASSERT(index < size, owner << " : index number " << index << " out of range [" << size << "]");
#define MYGUI_ASSERT_RANGE_AND_NONE(index, size, owner) MYGUI_ASSERT(index < size || index == ITEM_NONE, owner << " : index number " << index << " out of range [" << size << "]");
#define MYGUI_ASSERT_RANGE_INSERT(index, size, owner) MYGUI_ASSERT((index <= size) || (index == MyGUI::ITEM_NONE), owner << " : insert index number " << index << " out of range [" << size << "] or not ITEM_NONE");
#if MYGUI_DEBUG_MODE == 1
#define MYGUI_REGISTER_VALUE(map, value) \
{ \
MYGUI_LOG(Info, "Register value : '" << #value << "' = " << (int)value); \
map[#value] = value; \
}
#define MYGUI_DEBUG_ASSERT(exp, dest) MYGUI_ASSERT(exp, dest)
#else
#define MYGUI_REGISTER_VALUE(map, value) map[#value] = value;
#define MYGUI_DEBUG_ASSERT(exp, dest) ((void)0)
#endif
// for more info see: http://mdf-i.blogspot.com/2008/09/deprecated-gcc-vs-vs-vs-vs.html
#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
#if MYGUI_COMP_VER == 1310 // VC++ 7.1
#define MYGUI_OBSOLETE_START(text)
#define MYGUI_OBSOLETE_END
#else
#define MYGUI_OBSOLETE_START(text) __declspec(deprecated(text))
#define MYGUI_OBSOLETE_END
#endif
#elif MYGUI_COMPILER == MYGUI_COMPILER_GNUC
#if MYGUI_PLATFORM == MYGUI_PLATFORM_LINUX && MYGUI_COMP_VER == 412
#define MYGUI_OBSOLETE_START(text)
#define MYGUI_OBSOLETE_END
#else
#define MYGUI_OBSOLETE_START(text)
#define MYGUI_OBSOLETE_END __attribute__((deprecated))
#endif
#else
#define MYGUI_OBSOLETE_START(text)
#define MYGUI_OBSOLETE_END
#endif
#define MYGUI_OBSOLETE(text) /*! \deprecated text */ MYGUI_OBSOLETE_START(text)MYGUI_OBSOLETE_END
#endif // __MYGUI_DIAGNOSTIC_H__

111
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DynLib.h vendored
View file

@ -1,111 +0,0 @@
/*!
@file
@author Denis Koronchik
@author Georgiy Evmenov
@date 09/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DYNLIB_H__
#define __MYGUI_DYNLIB_H__
#include "MyGUI_Prerequest.h"
#include <string>
#if MYGUI_PLATFORM == MYGUI_PLATFORM_WIN32
# define MYGUI_DYNLIB_HANDLE hInstance
# define MYGUI_DYNLIB_LOAD( a ) LoadLibrary( a )
# define MYGUI_DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )
# define MYGUI_DYNLIB_UNLOAD( a ) !FreeLibrary( a )
struct HINSTANCE__;
typedef struct HINSTANCE__* hInstance;
#elif MYGUI_PLATFORM == MYGUI_PLATFORM_LINUX
# define MYGUI_DYNLIB_HANDLE void*
# define MYGUI_DYNLIB_LOAD( a ) dlopen( a, RTLD_LAZY | RTLD_GLOBAL)
# define MYGUI_DYNLIB_GETSYM( a, b ) dlsym( a, b )
# define MYGUI_DYNLIB_UNLOAD( a ) dlclose( a )
#elif MYGUI_PLATFORM == MYGUI_PLATFORM_APPLE
# include <CoreFoundation/CFBundle.h>
# define MYGUI_DYNLIB_HANDLE CFBundleRef
# define MYGUI_DYNLIB_LOAD( a ) mac_loadExeBundle( a )
# define MYGUI_DYNLIB_GETSYM( a, b ) mac_getBundleSym( a, b )
# define MYGUI_DYNLIB_UNLOAD( a ) mac_unloadExeBundle( a )
#endif
namespace MyGUI
{
/*! @brief Resource holding data about a dynamic library.
@remarks
This class holds the data required to get symbols from
libraries loaded at run-time (i.e. from DLL's for so's)
*/
class MYGUI_EXPORT DynLib
{
friend class DynLibManager;
protected:
DynLib(const std::string &name);
~DynLib();
public:
/*! Load the library
*/
bool load();
/*! Unload the library
*/
void unload();
//! Get the name of the library
std::string getName(void) const { return mName; }
/**
Returns the address of the given symbol from the loaded library.
@param
strName The name of the symbol to search for
@returns
If the function succeeds, the returned value is a handle to the symbol.
If the function fails, the returned value is <b>nullptr</b>.
*/
void* getSymbol( const std::string& strName ) const throw();
protected:
//! Gets the last loading error
std::string dynlibError(void);
protected:
//! Name of library
std::string mName;
//! Handle to the loaded library.
MYGUI_DYNLIB_HANDLE mInstance;
};
}
#endif // __MYGUI_DYNLIB_H__

58
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DynLibManager.h vendored
View file

@ -1,58 +0,0 @@
/*!
@file
@author Denis Koronchik
@date 08/2007
@module libEngine
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_DYN_LIB_MANAGER_H__
#define __MYGUI_DYN_LIB_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_DynLib.h"
#include <map>
namespace MyGUI
{
/*! \brief Manager of dynamic libraries
*/
class MYGUI_EXPORT DynLibManager
{
MYGUI_INSTANCE_HEADER( DynLibManager )
public:
void initialise();
void shutdown();
//! Load library
DynLib* load(const std::string &fileName);
//! Unload library
void unload(DynLib *library);
private:
//! Dynamic libraries map
typedef std::map <std::string, DynLib*> StringDynLibMap;
//! Loaded libraries
StringDynLibMap mLibsMap;
};
}
#endif // __MYGUI_DYN_LIB_MANAGER_H__

443
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Edit.h vendored
View file

@ -1,443 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_EDIT_H__
#define __MYGUI_EDIT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_StaticText.h"
#include "MyGUI_TextChangeHistory.h"
#include "MyGUI_TextIterator.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_ScrollViewBase.h"
namespace MyGUI
{
typedef delegates::CDelegate1<Edit*> EventHandle_EditPtr;
class MYGUI_EXPORT Edit :
public StaticText,
public ScrollViewBase
{
MYGUI_RTTI_DERIVED( Edit )
public:
Edit();
/** Colour interval */
void setTextIntervalColour(size_t _start, size_t _count, const Colour& _colour);
/** Get index of first selected character or ITEM_NONE if nothing selected */
size_t getTextSelectionStart();
/** Get index of last selected character or ITEM_NONE if nothing selected */
size_t getTextSelectionEnd();
/** Get length of selected text */
size_t getTextSelectionLength();
// возвращает текст с тегами
/** Get _count characters with tags from _start position */
UString getTextInterval(size_t _start, size_t _count);
/** Set selected text interval
@param _start of interval
@param _end of interval
*/
void setTextSelection(size_t _start, size_t _end);
/** Delete selected text */
void deleteTextSelection();
/** Get selected text */
UString getTextSelection();
/** Is any text selected */
bool isTextSelection();
/** Colour selected text */
void setTextSelectionColour(const Colour& _value);
/** Set text cursor position */
void setTextCursor(size_t _index);
/** Get text cursor position */
size_t getTextCursor() { return mCursorPosition; }
/** Set edit text applying tags */
virtual void setCaption(const UString& _value);
/** Get edit text with tags */
virtual const UString& getCaption();
/** Set edit text without tags */
void setOnlyText(const UString& _value);
/** Get edit text without tags */
UString getOnlyText();
/** Get text length excluding tags
For example "#00FF00Hello" length is 5
*/
size_t getTextLength() const { return mTextLength; }
//! Sets if surplus characters should push characters off the left side rather than ignored
void setOverflowToTheLeft(bool _value) { mOverflowToTheLeft = _value; }
//! Returns true if surplus characters will be pushed off the left rather than ignored
bool getOverflowToTheLeft() { return mOverflowToTheLeft; }
//! Sets the max amount of text allowed in the edit field.
void setMaxTextLength(size_t _value) { mMaxTextLength = _value; }
//! Gets the max amount of text allowed in the edit field.
size_t getMaxTextLength() { return mMaxTextLength; }
/** Inser text at _index position (text end by default) */
void insertText(const UString& _text, size_t _index = ITEM_NONE);
/** Add text */
void addText(const UString& _text);
/** Erase _count characters from _start position */
void eraseText(size_t _start, size_t _count = 1);
/** Enable or disable edit read only mode\n
Read only mode: you can't edit text, but can select it.\n
Disabled (false) by default.
*/
void setEditReadOnly(bool _value);
/** Get edit read only mode flag */
bool getEditReadOnly() { return mModeReadOnly; }
/** Enable or disable edit password mode\n
Password mode: you see password chars (*** by default) instead text.\n
Disabled (false) by default.
*/
void setEditPassword(bool _value);
/** Get edit password mode flag */
bool getEditPassword() { return mModePassword; }
/** Enable or disable edit multiline mode\n
Multile mode: new line character moves text to new line.\n
Otherwise new lines replaced with space and all text is in single line.\n
Disabled (false) by default.
*/
void setEditMultiLine(bool _value);
/** Get edit multiline mode flag */
bool getEditMultiLine() { return mModeMultiline; }
/** Enable or disable edit static mode\n
Static mode is same as read only, but you also can't select text.\n
Disabled (false) by default.
*/
void setEditStatic(bool _value);
/** Get edit static mode flag */
bool getEditStatic() { return mModeStatic; }
/** Set edit password character ('*' by default) */
void setPasswordChar(Char _value);
/** Set edit password character ('*' by default). First character of string used. */
void setPasswordChar(const UString& _char);
/** Get edit password character */
Char getPasswordChar() { return mCharPassword; }
/** Enable or disable edit word wrap mode\n
Word Wrap mode: move words to new line if they goes out of width.
Also in this mode you can't edit or select text.\n
Disabled (false) by default.
*/
void setEditWordWrap(bool _value);
/** Get edit word wrap mode flag */
bool getEditWordWrap() { return mModeWordWrap; }
/** Enable or disable tab printing mode\n
Tab printing mode: when editing text and pressing Tab key it displayed.
If this mode disabled Tab key ignored.\n
Disabled (false) by default.
*/
void setTabPrinting(bool _value) { mTabPrinting = _value; }
/** Get edit tab printing wrap mode flag */
bool getTabPrinting() { return mTabPrinting; }
/** Get invert selected text color property */
bool getInvertSelected();
/** Enable or disable inverting color of selected text\n
Enabled (true) by default
*/
void setInvertSelected(bool _value);
//! @copydoc Widget::setPosition(const IntPoint& _value)
virtual void setPosition(const IntPoint& _value);
//! @copydoc Widget::setSize(const IntSize& _value)
virtual void setSize(const IntSize& _value);
//! @copydoc Widget::setCoord(const IntCoord& _value)
virtual void setCoord(const IntCoord& _value);
/** @copydoc Widget::setPosition(int _left, int _top) */
void setPosition(int _left, int _top) { setPosition(IntPoint(_left, _top)); }
/** @copydoc Widget::setSize(int _width, int _height) */
void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
/** Show VScroll when text size larger than Edit */
void setVisibleVScroll(bool _value);
/** Get Show VScroll flag */
bool isVisibleVScroll() { return mVisibleVScroll; }
/** Get range of vertical scroll (or 0 if no scroll).
Range measured in pixels (full text heiht minus Edit height).
For example if Edit is 200 pixels height and 40 lines of text
30 pixels height each (i.e. 600 pixels total), then return
value is 400 ( = 600 - 200 ).
*/
size_t getVScrollRange();
/** Get current position of vertical scroll (or 0 if no scroll) */
size_t getVScrollPosition();
/** Set current position of vertical scroll */
void setVScrollPosition(size_t _index);
/** Show HScroll when text size larger than Edit */
void setVisibleHScroll(bool _value);
/** Get Show HScroll flag */
bool isVisibleHScroll() { return mVisibleHScroll; }
/** Get range of horizontal scroll (or 0 if no scroll).
Range measured in pixels (full text width minus Edit width).
For example if Edit is 200 pixels width and the longest line
is 600 pixels width, then return value is 400 ( = 600 - 200 ).
*/
size_t getHScrollRange();
/** Get current position of horizontal scroll (or 0 if no scroll) */
size_t getHScrollPosition();
/** Set current position of horizontal scroll */
void setHScrollPosition(size_t _index);
//! @copydoc StaticText::setFontName
virtual void setFontName(const std::string& _value);
//! @copydoc StaticText::setFontHeight
virtual void setFontHeight(int _value);
//! @copydoc StaticText::setTextAlign
virtual void setTextAlign(Align _value);
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*event:*/
/** Event : Enter pressed (Ctrl+enter in multiline mode).\n
signature : void method(MyGUI::Edit* _sender)
@param _sender widget that called this event
*/
EventPair<EventHandle_WidgetVoid, EventHandle_EditPtr> eventEditSelectAccept;
/** Event : Text changed.\n
signature : void method(MyGUI::Edit* _sender)
@param _sender widget that called this event
*/
EventPair<EventHandle_WidgetVoid, EventHandle_EditPtr> eventEditTextChange;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void Edit::setVisibleVScroll(bool _visible)")
void showVScroll(bool _visible) { setVisibleVScroll(_visible); }
MYGUI_OBSOLETE("use : bool Edit::isVisibleVScroll()")
bool isShowVScroll() { return isVisibleVScroll(); }
MYGUI_OBSOLETE("use : void Edit::setVisibleHScroll(bool _visible)")
void showHScroll(bool _visible) { setVisibleHScroll(_visible); }
MYGUI_OBSOLETE("use : bool Edit::isVisibleHScroll()")
bool isShowHScroll() { return isVisibleHScroll(); }
MYGUI_OBSOLETE("use : void Widget::setCoord(const IntCoord& _coord)")
void setPosition(const IntCoord& _coord) { setCoord(_coord); }
MYGUI_OBSOLETE("use : void Widget::setCoord(int _left, int _top, int _width, int _height)")
void setPosition(int _left, int _top, int _width, int _height) { setCoord(_left, _top, _width, _height); }
// to avoid hiding base virtual function
virtual void setTextColour(const Colour& _colour) { Base::setTextColour(_colour); }
MYGUI_OBSOLETE("use : void Edit::setTextIntervalColour(size_t _start, size_t _count, const Colour& _colour)")
void setTextColour(size_t _start, size_t _count, const Colour& _colour) { setTextIntervalColour(_start, _count, _colour); }
MYGUI_OBSOLETE("use : size_t Edit::getTextSelectionStart() , size_t getTextSelectionEnd()")
void getTextSelect(size_t& _start, size_t& _end);
MYGUI_OBSOLETE("use : UString Edit::getTextInterval(size_t _start, size_t _count)")
UString getText(size_t _start, size_t _count) { return getTextInterval(_start, _count); }
MYGUI_OBSOLETE("use : void Edit::setTextSelection(size_t _start, size_t _end)")
void setTextSelect(size_t _start, size_t _end) { setTextSelection(_start, _end); }
MYGUI_OBSOLETE("use : void Edit::deleteTextSelection()")
void deleteTextSelect() { deleteTextSelection(); }
MYGUI_OBSOLETE("use : UString Edit::getTextSelection()")
UString getSelectedText() { return getTextSelection(); }
MYGUI_OBSOLETE("use : bool Edit::isTextSelection()")
bool isTextSelect() { return isTextSelection(); }
MYGUI_OBSOLETE("use : void Edit::setTextSelectionColour(const Colour& _colour)")
void setTextSelectColour(const Colour& _colour) { setTextSelectionColour(_colour); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~Edit();
virtual void onMouseDrag(int _left, int _top);
virtual void onKeyLostFocus(Widget* _new);
virtual void onKeySetFocus(Widget* _old);
virtual void onKeyButtonPressed(KeyCode _key, Char _char);
// потом убрать все нотифи в сраку
void notifyMouseSetFocus(Widget* _sender, Widget* _old);
void notifyMouseLostFocus(Widget* _sender, Widget* _new);
void notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyMouseReleased(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyMouseDrag(Widget* _sender, int _left, int _top);
void notifyMouseButtonDoubleClick(Widget* _sender);
void notifyScrollChangePosition(VScroll* _sender, size_t _position);
void notifyMouseWheel(Widget* _sender, int _rel);
// обновление представления
void updateView();
void updateViewWithCursor();
void baseChangeWidgetSkin(ResourceSkin* _info);
void eraseView();
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
private:
// устанавливает текст
void setText(const UString& _text, bool _history);
// удаляет все что выделенно
bool deleteTextSelect(bool _history);
// вставляет текст в указанную позицию
void insertText(const UString& _text, size_t _index, bool _history);
// удаляет текст
void eraseText(size_t _start, size_t _count, bool _history);
// выделяет цветом выделение
void setTextSelectColour(const Colour& _colour, bool _history);
// выделяет цветом диапазон
void _setTextColour(size_t _start, size_t _count, const Colour& _colour, bool _history);
void frameEntered(float _frame);
void updateEditState();
// обновляет курсор по координате
void updateSelectText();
void resetSelect();
// запись в историю данных о позиции
void commandPosition(size_t _undo, size_t _redo, size_t _length, VectorChangeInfo * _info = nullptr);
// команнды отмена и повтор
bool commandRedo();
bool commandUndo();
// объединяет последние две комманды
void commandMerge();
// очистка
void commandResetRedo() { mVectorRedoChangeInfo.clear(); }
void commandResetHistory() { mVectorRedoChangeInfo.clear();mVectorUndoChangeInfo.clear(); }
void saveInHistory(VectorChangeInfo * _info = nullptr);
// работа с буфером обмена
void commandCut();
void commandCopy();
void commandPast();
const UString& getRealString();
void setRealString(const UString& _caption);
void updateCursorPosition();
// размер данных
virtual IntSize getContentSize();
// смещение данных
virtual IntPoint getContentPosition();
virtual void setContentPosition(const IntPoint& _point);
// размер окна, через которые видно данные
virtual IntSize getViewSize() const;
// размер на который прокручиваются данные при щелчке по скролу
virtual size_t getVScrollPage();
virtual size_t getHScrollPage();
virtual Align getContentAlign();
protected:
// нажата ли кнопка
bool mIsPressed;
// в фокусе ли кнопка
bool mIsFocus;
bool mCursorActive;
float mCursorTimer;
float mActionMouseTimer;
// позиция курсора
size_t mCursorPosition;
// максимальное колличество
size_t mTextLength;
// выделение
size_t mStartSelect;
size_t mEndSelect;
// списоки изменений для отмены и повтора
DequeUndoRedoInfo mVectorUndoChangeInfo;
DequeUndoRedoInfo mVectorRedoChangeInfo;
bool mMouseLeftPressed;
bool mModeReadOnly;
bool mModePassword;
bool mModeMultiline;
bool mModeStatic;
bool mModeWordWrap;
bool mTabPrinting;
// настоящий текст, закрытый за звездочками
UString mPasswordText;
// для поддержки режима статик, где курсор не нужен
std::string mOriginalPointer;
Char mCharPassword;
bool mOverflowToTheLeft;
size_t mMaxTextLength;
};
} // namespace MyGUI
#endif // __MYGUI_EDIT_H__

164
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_EditText.h vendored
View file

@ -1,164 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_EDIT_TEXT_H__
#define __MYGUI_EDIT_TEXT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_Types.h"
#include "MyGUI_ISubWidgetText.h"
#include "MyGUI_IFont.h"
#include "MyGUI_ResourceSkin.h"
#include "MyGUI_RenderFormat.h"
#include "MyGUI_TextView.h"
namespace MyGUI
{
class RenderItem;
class MYGUI_EXPORT EditText : public ISubWidgetText
{
MYGUI_RTTI_DERIVED( EditText )
public:
EditText();
virtual ~EditText();
virtual void setVisible(bool _value);
// обновляет все данные связанные с тектом
virtual void updateRawData();
// метод для отрисовки себя
virtual void doRender();
void setCaption(const UString& _value);
const UString& getCaption();
void setTextColour(const Colour& _value);
const Colour& getTextColour();
void setAlpha(float _value);
float getAlpha();
virtual void setFontName(const std::string& _value);
virtual const std::string& getFontName();
virtual void setFontHeight(int _value);
virtual int getFontHeight();
virtual void createDrawItem(ITexture* _texture, ILayerNode * _node);
virtual void destroyDrawItem();
virtual void setTextAlign(Align _value);
virtual Align getTextAlign();
virtual size_t getTextSelectionStart();
virtual size_t getTextSelectionEnd();
virtual void setTextSelection(size_t _start, size_t _end);
virtual bool getSelectBackground();
virtual void setSelectBackground(bool _normal);
virtual bool isVisibleCursor();
virtual void setVisibleCursor(bool _value);
/** Get invert selected text color property */
virtual bool getInvertSelected() { return mInvertSelect; }
/** Enable or disable inverting color of selected text\n
Enabled (true) by default
*/
virtual void setInvertSelected(bool _value);
virtual size_t getCursorPosition();
virtual void setCursorPosition(size_t _index);
virtual IntSize getTextSize();
// устанавливает смещение текста в пикселях
virtual void setViewOffset(const IntPoint& _point);
virtual IntPoint getViewOffset();
// возвращает положение курсора по произвольному положению
virtual size_t getCursorPosition(const IntPoint& _point);
// возвращает положение курсора в обсолютных координатах
virtual IntCoord getCursorCoord(size_t _position);
void setShiftText(bool _shift);
void setWordWrap(bool _value);
virtual void setStateData(IStateInfo * _data);
void _updateView();
void _correctView();
/*internal:*/
void _setAlign(const IntSize& _oldsize, bool _update);
void _setAlign(const IntCoord& _oldcoord, bool _update);
protected:
bool mEmptyView;
uint32 mCurrentColour;
uint32 mInverseColour;
uint32 mCurrentAlpha;
IntCoord mCurrentCoord;
UString mCaption;
bool mTextOutDate;
Align mTextAlign;
Colour mColour;
float mAlpha;
VertexColourType mVertexFormat;
IFont* mFont;
ITexture* mTexture;
int mFontHeight;
bool mBackgroundNormal;
size_t mStartSelect;
size_t mEndSelect;
size_t mCursorPosition;
bool mVisibleCursor;
bool mInvertSelect;
IntPoint mViewOffset; // смещение текста
ILayerNode* mNode;
RenderItem* mRenderItem;
size_t mCountVertex;
bool mIsAddCursorWidth;
bool mShiftText;
bool mWordWrap;
int mOldWidth;
TextView mTextView;
};
} // namespace MyGUI
#endif // __MYGUI_EDIT_TEXT_H__

108
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Enumerator.h vendored
View file

@ -1,108 +0,0 @@
/*!
@file
@author Albert Semenov
@date 08/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ENUMERATOR_H__
#define __MYGUI_ENUMERATOR_H__
#include <assert.h>
namespace MyGUI
{
/** Class for comfortable using of vectors with small while loop
instead iterators. Performance is same as with iterators.
Enumerator usage
@example Enumerator
@code
typedef std::vector<std::string> VectorString;
typedef Enumerator<VectorString> EnumeratorVectorString;
VectorString vec;
vec.push_back("value");
//EnumeratorVectorString enum_vec(vec.begin(), vec.end());
EnumeratorVectorString enum_vec(vec);
while (enum_vec.next())
{
std::string value = enum_vec.current();
}
typedef std::pair<std::string, std::string> PairString;
typedef std::map<PairString> MapString;
MapString map;
map["key"] = "value";
//EnumeratorMapString enum_map(map.begin(), map.end());
EnumeratorMapString enum_map(map);
while (enum_map.next())
{
std::string key = enum_map.current().first;
std::string value = enum_map.current().second;
}
@endcode
*/
template<typename T>
class Enumerator
{
private:
Enumerator() { }
public:
explicit Enumerator(const T& _container) :
m_first(true),
m_current(_container.begin()),
m_end(_container.end())
{
}
Enumerator(typename T::const_iterator _first, typename T::const_iterator _end) :
m_first(true),
m_current(_first),
m_end(_end)
{
}
bool next()
{
if (m_current == m_end) return false;
else if (m_first)
{
m_first = false;
return true;
}
++ m_current;
if (m_current == m_end) return false;
return true;
}
typename T::const_reference operator->() const { assert(m_current != m_end); return (*m_current); }
typename T::const_reference current() { assert(m_current != m_end); return (*m_current); }
private:
bool m_first;
typename T::const_iterator m_current;
typename T::const_iterator m_end;
};
} // namespace MyGUI
#endif // __MYGUI_ENUMERATOR_H__

118
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_EventPair.h vendored
View file

@ -1,118 +0,0 @@
/*!
@file
@author Albert Semenov
@date 10/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_EVENT_PAIR_H__
#define __MYGUI_EVENT_PAIR_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
template <typename EventObsolete, typename Event>
class EventPair
{
public:
template <typename T>
MYGUI_OBSOLETE("use : signature : Event::IDelegate * _delegate")
void operator = (T * _delegate)
{
m_eventObsolete = _delegate;
m_event = nullptr;
}
void operator = (typename Event::IDelegate * _delegate)
{
m_eventObsolete = nullptr;
m_event = _delegate;
}
template <typename TP1>
void operator()( TP1 p1 )
{
m_eventObsolete(p1);
m_event(p1);
}
template <typename TP1, typename TP2>
void operator()( TP1 p1, TP2 p2 )
{
m_eventObsolete(p1, p2);
m_event(p1, p2);
}
template <typename TP1, typename TP2, typename TP3>
void operator()( TP1 p1, TP2 p2, TP3 p3 )
{
m_eventObsolete(p1, p2, p3);
m_event(p1, p2, p3);
}
template <typename TP1, typename TP2, typename TP3, typename TP4>
void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4 )
{
m_eventObsolete(p1, p2, p3, p4);
m_event(p1, p2, p3, p4);
}
template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5 )
{
m_eventObsolete(p1, p2, p3, p4, p5);
m_event(p1, p2, p3, p4, p5);
}
template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6>
void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6 )
{
m_eventObsolete(p1, p2, p3, p4, p5, p6);
m_event(p1, p2, p3, p4, p5, p6);
}
template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6, typename TP7>
void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6, TP7 p7 )
{
m_eventObsolete(p1, p2, p3, p4, p5, p6, p7);
m_event(p1, p2, p3, p4, p5, p6, p7);
}
template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6, typename TP7, typename TP8>
void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6, TP7 p7, TP8 p8 )
{
m_eventObsolete(p1, p2, p3, p4, p5, p6, p7, p8);
m_event(p1, p2, p3, p4, p5, p6, p7, p8);
}
bool empty() const
{
return m_eventObsolete.empty() && m_event.empty();
}
public:
EventObsolete m_eventObsolete;
Event m_event;
};
} // namespace MyGUI
#endif // __MYGUI_EVENT_PAIR_H__

69
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Exception.h vendored
View file

@ -1,69 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_EXCEPTION_H__
#define __MYGUI_EXCEPTION_H__
#include "MyGUI_Prerequest.h"
#include <exception>
#include <string>
namespace MyGUI
{
class MYGUI_EXPORT Exception : public std::exception
{
protected:
std::string mDescription;
std::string mSource;
std::string mFile;
long mLine;
mutable std::string mFullDesc;
public:
Exception(const std::string& _description, const std::string& _source, const char* _file, long _line );
Exception(const Exception& _rhs);
// Needed for compatibility with std::exception
~Exception() throw() { }
Exception& operator = (const Exception& _rhs);
virtual const std::string& getFullDescription() const;
virtual const std::string &getSource() const { return mSource; }
virtual const std::string &getFile() const { return mFile; }
virtual long getLine() const { return mLine; }
virtual const std::string& getDescription() const { return mDescription; }
// Override std::exception::what
const char* what() const throw() { return getFullDescription().c_str(); }
};
} // namespace MyGUI
#endif // __MYGUI_EXCEPTION_H__

79
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FactoryManager.h vendored
View file

@ -1,79 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_FACTORY_MANAGER_H__
#define __MYGUI_FACTORY_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_IObject.h"
#include "MyGUI_GenericFactory.h"
namespace MyGUI
{
class MYGUI_EXPORT FactoryManager
{
MYGUI_INSTANCE_HEADER( FactoryManager )
public:
typedef delegates::CDelegate1<IObject*&> Delegate;
void initialise();
void shutdown();
void registerFactory(const std::string& _category, const std::string& _type, Delegate::IDelegate* _delegate);
void unregisterFactory(const std::string& _category, const std::string& _type);
void unregisterFactory(const std::string& _category);
bool isFactoryExist(const std::string& _category, const std::string& _type);
template<typename Type>
void registerFactory(const std::string& _category)
{
registerFactory(_category, Type::getClassTypeName(), GenericFactory<Type>::getFactory());
}
template<typename Type>
void registerFactory(const std::string& _category, const std::string& _type)
{
registerFactory(_category, _type, GenericFactory<Type>::getFactory());
}
template<typename Type>
void unregisterFactory(const std::string& _category)
{
unregisterFactory(_category, Type::getClassTypeName());
}
IObject* createObject(const std::string& _category, const std::string& _type);
void destroyObject(IObject* _object);
private:
typedef std::map<std::string, Delegate> MapFactoryItem;
typedef std::map<std::string, MapFactoryItem> MapRegisterFactoryItem;
MapRegisterFactoryItem mRegisterFactoryItems;
};
} // namespace MyGUI
#endif // __MYGUI_FACTORY_MANAGER_H__

129
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FontData.h vendored
View file

@ -1,129 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_FONT_DATA_H__
#define __MYGUI_FONT_DATA_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct MYGUI_EXPORT FontCodeType
{
enum Enum
{
Selected = 6,
SelectedBack = 7,
Cursor = 8,
Tab = 9,
LF = 0x000A,
CR = 0x000D,
Space = 0x0020,
LatinStart = 0x0021,
NEL = 0x0085,
LatinEnd = 0x00A6,
MAX
};
FontCodeType(Enum _value = MAX) : value(_value) { }
friend bool operator == (FontCodeType const& a, FontCodeType const& b) { return a.value == b.value; }
friend bool operator != (FontCodeType const& a, FontCodeType const& b) { return a.value != b.value; }
private:
Enum value;
};
// èíôîðìàöèÿ îá îäíîì ñèìâîëå
struct GlyphInfo
{
FloatRect uvRect;
Char codePoint;
int width;
GlyphInfo() : codePoint(0), width(0) { }
};
typedef std::vector<GlyphInfo> VectorGlyphInfo;
// èíôîðìàöèÿ îá äèàïàçîíå
//FIXME move to std::pair
class PairCodePoint
{
public:
PairCodePoint() : first(0), last(0) { }
PairCodePoint(Char _first, Char _last) : first(_first), last(_last) { }
// ïðîâåðÿåò âõîäèò ëè ñèìâîë â äèàïàçîí
bool isExist(Char _code) const { return _code >= first && _code <= last; }
public:
Char first;
Char last;
};
// èíôîìàöèÿ î äèàïàçîíå ñèìâîëîâ
class RangeInfo
{
public:
RangeInfo() : first(0), last(0) { }
RangeInfo(Char _first, Char _last) :
first(_first),
last(_last)
{
range.resize(last - first + 1);
}
// ïðîâåðÿåò âõîäèò ëè ñèìâîë â äèàïàçîí
bool isExist(Char _code) const { return _code >= first && _code <= last; }
// âîçâðàùàåò óêàçàòåëü íà ãëèô, èëè 0, åñëè êîä íå âõîäèò â äèàïàçîí
GlyphInfo* getInfo(Char _code) { return isExist(_code) ? &range[_code - first] : nullptr; }
void setInfo(Char _code, GlyphInfo* _value) { if (isExist(_code)) range[_code - first] = *_value; }
public:
Char first;
Char last;
VectorGlyphInfo range;
};
// FIXME move to resource font
class PairCodeCoord
{
public:
PairCodeCoord() : code(0) { }
PairCodeCoord(Char _code, const IntCoord& _coord) :
code(_code),
coord(_coord)
{
}
bool operator < (const PairCodeCoord& _value) const { return code < _value.code; }
Char code;
IntCoord coord;
};
} // namespace MyGUI
#endif // __MYGUI_FONT_DATA_H__

60
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FontManager.h vendored
View file

@ -1,60 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_FONT_MANAGER_H__
#define __MYGUI_FONT_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Enumerator.h"
#include "MyGUI_IFont.h"
#include "MyGUI_Instance.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_ResourceManager.h"
namespace MyGUI
{
class MYGUI_EXPORT FontManager
{
MYGUI_INSTANCE_HEADER( FontManager )
public:
void initialise();
void shutdown();
/** Load additional MyGUI *_font.xml file */
bool load(const std::string& _file);
void _load(xml::ElementPtr _node, const std::string& _file, Version _version);
const std::string& getDefaultFont() const { return mDefaultName; }
void setDefaultFont(const std::string& _value);
/** Get font resource */
IFont* getByName(const std::string& _name) const;
private:
std::string mDefaultName;
};
} // namespace MyGUI
#endif // __MYGUI_FONT_MANAGER_H__

36
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_GenericFactory.h vendored
View file

@ -1,36 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
#ifndef __MYGUI_GENERIC_FACTORY_H__
#define __MYGUI_GENERIC_FACTORY_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_Delegate.h"
namespace MyGUI
{
template <typename Type>
class GenericFactory
{
public:
typedef delegates::CDelegate1<IObject*&> Delegate;
static typename Delegate::IDelegate* getFactory()
{
return newDelegate(createFromFactory);
}
private:
static void createFromFactory(IObject*& _instance)
{
_instance = new Type();
}
};
}
#endif // __MYGUI_GENERIC_FACTORY_H__

287
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Gui.h vendored
View file

@ -1,287 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_GUI_H__
#define __MYGUI_GUI_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_Instance.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_IWidgetCreator.h"
#include "MyGUI_IUnlinkWidget.h"
#include "MyGUI_Widget.h"
namespace MyGUI
{
typedef delegates::CMultiDelegate1<float> FrameEventDelegate;
class MYGUI_EXPORT Gui : public IWidgetCreator, public IUnlinkWidget
{
friend class WidgetManager;
MYGUI_INSTANCE_HEADER( Gui )
public:
/** Initialise GUI and all GUI Managers
@param
_core name of core config file for MyGUI (contain main config files with skins, layers, fonts, etc.)
@param
_logFileName Log file name
*/
void initialise(const std::string& _core = "core.xml", const std::string& _logFileName = MYGUI_LOG_FILENAME);
/** Shutdown GUI and all GUI Managers*/
void shutdown();
// methods for creating widgets
/** Create widget
@param _type widget type
@param _skin widget skin
@param _coord int coordinates of widget (_left, _top, _width, _height)
@param _align widget align (possible values can be found in enum Align)
@param _layer layer where widget will be created (all layers usually defined in core.layer file).
If your widget will overlap with any other you shoud select _layer with "overlapped" property enabled.
@param _name if needed (you can use it for finding widget by name later)
*/
Widget* createWidgetT(const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
{
return baseCreateWidget(WidgetStyle::Overlapped, _type, _skin, _coord, _align, _layer, _name);
}
/** See Gui::createWidgetT */
Widget* createWidgetT(const std::string& _type, const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _layer, const std::string& _name = "")
{
return createWidgetT(_type, _skin, IntCoord(_left, _top, _width, _height), _align, _layer, _name);
}
/** Create widget using coordinates relative to parent. see Gui::createWidgetT */
Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
{
return createWidgetT(_type, _skin, IntCoord((int)(_coord.left*mViewSize.width), (int)(_coord.top*mViewSize.height), (int)(_coord.width*mViewSize.width), (int)(_coord.height*mViewSize.height)), _align, _layer, _name);
}
/** Create widget using coordinates relative to parent. see Gui::createWidgetT */
Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _layer, const std::string& _name = "")
{
return createWidgetT(_type, _skin, IntCoord((int)(_left*mViewSize.width), (int)(_top*mViewSize.height), (int)(_width*mViewSize.width), (int)(_height*mViewSize.height)), _align, _layer, _name);
}
// templates for creating widgets by type
/** Same as Gui::createWidgetT but return T* instead of Widget* */
template <typename T>
T* createWidget(const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
{
return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, _coord, _align, _layer, _name));
}
/** Same as Gui::createWidgetT but return T* instead of Widget* */
template <typename T>
T* createWidget(const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _layer, const std::string& _name = "")
{
return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, IntCoord(_left, _top, _width, _height), _align, _layer, _name));
}
/** Same as Gui::createWidgetRealT but return T* instead of Widget* */
template <typename T>
T* createWidgetReal(const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
{
return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _coord, _align, _layer, _name));
}
/** Same as Gui::createWidgetRealT but return T* instead of Widget* */
template <typename T>
T* createWidgetReal(const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _layer, const std::string& _name = "")
{
return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _left, _top, _width, _height, _align, _layer, _name));
}
/** Get view size of GUI area */
const IntSize& getViewSize() const { return mViewSize; }
int getViewWidth() { return mViewSize.width; }
int getViewHeight() { return mViewSize.height; }
// mirror of InputManager methods
/** Inject MouseMove event
@return true if event has been processed by GUI
*/
bool injectMouseMove(int _absx, int _absy, int _absz);
/** Inject MousePress event
@return true if event has been processed by GUI
*/
bool injectMousePress(int _absx, int _absy, MouseButton _id);
/** Inject MouseRelease event
@return true if event has been processed by GUI
*/
bool injectMouseRelease(int _absx, int _absy, MouseButton _id);
/** Inject KeyPress event
@return true if event has been processed by GUI
*/
bool injectKeyPress(KeyCode _key, Char _text = 0);
/** Inject KeyReleas event
@return true if event has been processed by GUI
*/
bool injectKeyRelease(KeyCode _key);
/** Destroy any created widget */
void destroyWidget(Widget* _widget);
/** Destroy vector of widgets */
void destroyWidgets(VectorWidgetPtr& _widgets);
/** Destroy Enumerator of widgets */
void destroyWidgets(EnumeratorWidgetPtr& _widgets);
/** Find widget by name
If widget is not found the exception will be thrown, or if the second parameter is false the nullptr pointer will be returned
*/
Widget* findWidgetT(const std::string& _name, bool _throw = true);
/** Find widget by name and prefix
If widget is not found the exception will be thrown, or if the second parameter is false the nullptr pointer will be returned
*/
Widget* findWidgetT(const std::string& _name, const std::string& _prefix, bool _throw = true)
{
return findWidgetT(_prefix + _name, _throw);
}
// mirror WidgetManager
/** Find widget by name and cast it to T type.
If widget not found or T and found widget have different types cause exception, or if the second parameter is false the nullptr pointer will be returned
*/
template <typename T>
T* findWidget(const std::string& _name, bool _throw = true)
{
Widget* widget = findWidgetT(_name, _throw);
if (nullptr == widget) return nullptr;
return widget->castType<T>(_throw);
}
/** Find widget by name and prefix and cast it to T type
If widget not found or T and found widget have different types cause exception, or if the second parameter is false the nullptr pointer will be returned
*/
template <typename T>
T* findWidget(const std::string& _name, const std::string& _prefix, bool _throw = true)
{
return findWidget<T>(_prefix + _name, _throw);
}
/** Show or hide mouse pointer */
void setVisiblePointer(bool _visible);
/** Is mouse pointer visible */
bool isVisiblePointer();
// mirror ResourceManager
/** Load config with any info (file can have different data such other config files that will be loaded, skins, layers, pointers, etc) */
bool load(const std::string& _file);
void resizeWindow(const IntSize& _size);
/** Destroy child widget or throw exception if this child widget not found */
void destroyChildWidget(Widget* _widget) { _destroyChildWidget(_widget); }
/** Destroy all child widgets */
void destroyAllChildWidget() { _destroyAllChildWidget(); }
/** Get name of Gui ResourceGroup*/
//static const std::string& getResourceGroup();
/** Get root widgets Enumerator */
EnumeratorWidgetPtr getEnumerator() { return EnumeratorWidgetPtr(mWidgetChild); }
/*internal:*/
/** Inject frame entered event (called be renderer, do not call it manually).
This function is called every frame by renderer.
*/
void _injectFrameEntered(float _time);
/*event:*/
/** Multidelegate for GUI per frame call.\n
signature : void method(float _time)\n
@param _time Time elapsed since last frame
*/
FrameEventDelegate eventFrameStart;
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void Gui::destroyWidgets(VectorWidgetPtr &_widgets)")
void destroyWidgetsVector(VectorWidgetPtr& _widgets) { destroyWidgets(_widgets); }
MYGUI_OBSOLETE("use : void Gui::setVisiblePointer(bool _value)")
void hidePointer() { setVisiblePointer(false); }
MYGUI_OBSOLETE("use : void Gui::setVisiblePointer(bool _value)")
void showPointer() { setVisiblePointer(true); }
MYGUI_OBSOLETE("use : bool Gui::isVisiblePointer()")
bool isShowPointer() { return isVisiblePointer(); }
MYGUI_OBSOLETE("called be renderer, do not call it manually")
void injectFrameEntered(float _time) { }
#endif // MYGUI_DONT_USE_OBSOLETE
private:
// создает виджет
virtual Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name);
// удяляет неудачника
void _destroyChildWidget(Widget* _widget);
// удаляет всех детей
void _destroyAllChildWidget();
virtual void _unlinkWidget(Widget* _widget);
// добавляет в список виджет
virtual void _linkChildWidget(Widget* _widget);
// удаляет из списка
virtual void _unlinkChildWidget(Widget* _widget);
private:
// вектор всех детей виджетов
VectorWidgetPtr mWidgetChild;
// размеры экрана
IntSize mViewSize;
// синглтоны гуя
InputManager * mInputManager;
SubWidgetManager * mSubWidgetManager;
LayerManager* mLayerManager;
SkinManager* mSkinManager;
WidgetManager* mWidgetManager;
FontManager* mFontManager;
ControllerManager* mControllerManager;
PointerManager* mPointerManager;
ClipboardManager* mClipboardManager;
LayoutManager* mLayoutManager;
DynLibManager* mDynLibManager;
PluginManager* mPluginManager;
LanguageManager* mLanguageManager;
ResourceManager* mResourceManager;
FactoryManager* mFactoryManager;
};
} // namespace MyGUI
#endif // __MYGUI_GUI_H__

137
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Guid.h vendored
View file

@ -1,137 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_GUID_H__
#define __MYGUI_GUID_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include <memory.h>
namespace MyGUI
{
class MYGUI_EXPORT Guid
{
public:
Guid() { fast._data1 = fast._data2 = fast._data3 = fast._data4 = 0; }
Guid( Guid const& _value ) { *this = _value; }
explicit Guid(const std::string& _value) { *this = parse(_value); }
explicit Guid(unsigned char(&_id)[16]) { ::memcpy((void*)&vec._data1[0], (void*)&_id[0], 16); }
bool operator == (Guid const& _comp) const
{
return _comp.fast._data1 == fast._data1
&& _comp.fast._data2 == fast._data2
&& _comp.fast._data3 == fast._data3
&& _comp.fast._data4 == fast._data4;
}
bool operator != ( Guid const& _comp ) const
{
return ! (*this == _comp);
}
bool operator < ( Guid const& _comp ) const
{
if (_comp.fast._data1 < fast._data1) return true;
else if (_comp.fast._data1 > fast._data1) return false;
if (_comp.fast._data2 < fast._data2) return true;
else if (_comp.fast._data2 > fast._data2) return false;
if (_comp.fast._data3 < fast._data3) return true;
else if (_comp.fast._data3 > fast._data3) return false;
if (_comp.fast._data4 < fast._data4) return true;
return false;
}
Guid& operator = (Guid const& _rvalue)
{
fast._data1 = _rvalue.fast._data1;
fast._data2 = _rvalue.fast._data2;
fast._data3 = _rvalue.fast._data3;
fast._data4 = _rvalue.fast._data4;
return *this;
}
bool empty() const
{
return fast._data1 == 0
&& fast._data2 == 0
&& fast._data3 == 0
&& fast._data4 == 0;
}
void clear()
{
fast._data1 = fast._data2 = fast._data3 = fast._data4 = 0;
}
std::string print() const;
static Guid parse(const std::string& _value);
static Guid generate();
friend std::ostream& operator << ( std::ostream& _stream, const Guid& _value )
{
_stream << _value.print();
return _stream;
}
friend std::istream& operator >> ( std::istream& _stream, Guid& _value )
{
std::string value;
_stream >> value;
if (_stream.fail()) _value.clear();
else _value = Guid::parse(value);
return _stream;
}
private:
// массив для быстрой конвертации
static const char convert_hex[64];
struct _original
{
uint32 data1;
uint16 data2, data3;
uint8 data4[8];
};
struct _fast
{
uint32 _data1, _data2, _data3, _data4;
};
struct _vec
{
unsigned char _data1[16];
};
union
{
_original original;
_fast fast;
_vec vec;
};
};
} // namespace MyGUI
#endif // __MYGUI_GUID_H__

67
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_HScroll.h vendored
View file

@ -1,67 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_HSCROLL_H__
#define __MYGUI_HSCROLL_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_VScroll.h"
namespace MyGUI
{
class MYGUI_EXPORT HScroll :
public VScroll
{
MYGUI_RTTI_DERIVED( HScroll )
public:
HScroll();
//! @copydoc VScroll::getLineSize()
virtual int getLineSize();
//! @copydoc VScroll::setTrackSize(int _value)
virtual void setTrackSize(int _value);
//! @copydoc VScroll::getTrackSize()
virtual int getTrackSize();
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~HScroll();
void baseChangeWidgetSkin(ResourceSkin* _info);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void TrackMove(int _left, int _top);
void updateTrack();
};
} // namespace MyGUI
#endif // __MYGUI_HSCROLL_H__

111
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IBItemInfo.h vendored
View file

@ -1,111 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ITEM_INFO_H__
#define __MYGUI_ITEM_INFO_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
// структура информации об отображении элемента
/** Info about ItemBox item*/
struct MYGUI_EXPORT IBDrawItemInfo
{
IBDrawItemInfo() :
index(ITEM_NONE),
update(false),
select(false),
active(false),
drag(false),
drop_accept(false),
drop_refuse(false)
{
}
IBDrawItemInfo(size_t _index, size_t _select, size_t _active, size_t _accept, size_t _refuse, bool _update, bool _drag) :
index(_index),
update(_update),
select(_index == _select),
active(_index == _active),
drag(_drag),
drop_accept(_index == _accept),
drop_refuse(_index == _refuse)
{
}
/** Index of element */
size_t index;
/** State and interdan data changed */
bool update;
/** Is widget selected */
bool select;
/** Is widget active */
bool active;
/** Is widget able to be dragged */
bool drag;
/** Is widget accepting drop */
bool drop_accept;
/** Is widget refuseing drop */
bool drop_refuse;
};
struct MYGUI_EXPORT IBNotifyItemData
{
enum NotifyItem
{
MousePressed,
MouseReleased,
KeyPressed,
KeyReleased
};
IBNotifyItemData(size_t _index, NotifyItem _notify, int _x, int _y, MouseButton _id) :
index(_index), notify(_notify), x(_x), y(_y), id(_id), code(KeyCode::None), key(0) { }
IBNotifyItemData(size_t _index, NotifyItem _notify, KeyCode _code, Char _key) :
index(_index), notify(_notify), x(0), y(0), id(MouseButton::None), code(_code), key(_key) { }
IBNotifyItemData(size_t _index, NotifyItem _notify, KeyCode _code) :
index(_index), notify(_notify), x(0), y(0), id(MouseButton::None), code(_code), key(KeyCode::None) { }
/** Item index */
size_t index;
/** Notify type */
NotifyItem notify;
/** If Mouse* notify type - mouse x position, else 0 */
int x;
/** If Mouse* notify type - mouse y position, else 0 */
int y;
/** If Mouse* notify type - mouse button id position, else 0 */
MouseButton id;
/** If Key* notify type - key code, else 0 */
KeyCode code;
/** If Key* notify type - mouse button id position, else 0 */
Char key;
};
} // namespace MyGUI
#endif // __MYGUI_ITEM_INFO_H__

213
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ICroppedRectangle.h vendored
View file

@ -1,213 +0,0 @@
/*!
@file
@author Georgiy Evmenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_CROPPED_RECTANGLE_H__
#define __MYGUI_I_CROPPED_RECTANGLE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
class MYGUI_EXPORT ICroppedRectangle
{
public:
ICroppedRectangle() :
mIsMargin(false),
mCroppedParent(nullptr),
mVisible(true),
mAlign(Align::Default)
{ }
virtual ~ICroppedRectangle() { }
/** Get parent ICroppedRectangle */
ICroppedRectangle * getCroppedParent() { return mCroppedParent; }
/** Set coordinates (position and size) */
virtual void setCoord(const IntCoord& _value) { mCoord = _value; }
/** Get coordinates (position and size) */
const IntCoord& getCoord() const { return mCoord; }
/** Set position */
virtual void setPosition(const IntPoint& _value) { mCoord.left = _value.left; mCoord.top = _value.top; }
/** Get position */
IntPoint getPosition() const { return mCoord.point(); }
/** Set size */
virtual void setSize(const IntSize& _value) { mCoord.width = _value.width; mCoord.height = _value.height; }
/** Get size */
IntSize getSize() const { return mCoord.size(); }
/** Hide or show */
virtual void setVisible(bool _value) { mVisible = _value; }
/** Return true if visible */
bool isVisible() const { return mVisible; }
/** Get position in screen coordinates */
const IntPoint& getAbsolutePosition() const { return mAbsolutePosition; }
/** Get rectangle in screen coordinates */
IntRect getAbsoluteRect() const { return IntRect(mAbsolutePosition.left, mAbsolutePosition.top, mAbsolutePosition.left+mCoord.width, mAbsolutePosition.top+mCoord.height); }
/** Get coordinate in screen coordinates */
IntCoord getAbsoluteCoord() const { return IntCoord(mAbsolutePosition.left, mAbsolutePosition.top, mCoord.width, mCoord.height); }
/** Get X in screen coordinates */
int getAbsoluteLeft() const { return mAbsolutePosition.left; }
/** Get Y in screen coordinates */
int getAbsoluteTop() const { return mAbsolutePosition.top; }
/** Set align */
virtual void setAlign(Align _value) { mAlign = _value; }
/** Get align */
Align getAlign() const { return mAlign; }
/** Get left x-coordinate */
int getLeft() const { return mCoord.left; }
/** Get right x-coordinate */
int getRight() const { return mCoord.right(); }
/** Get top y-coordinate */
int getTop() const { return mCoord.top; }
/** Get bottom y-coordinate */
int getBottom() const { return mCoord.bottom(); }
/** Get width */
int getWidth() const { return mCoord.width; }
/** Get height */
int getHeight() const { return mCoord.height; }
/*internal:*/
/** True if rectangle is cropped by parent rectangle */
bool _isMargin() const { return mIsMargin; }
// Get cropped by parent rectangle coordinates
int _getViewLeft() const { return mCoord.left + mMargin.left; }
int _getViewRight() const { return mCoord.right() - mMargin.right; }
int _getViewTop() const { return mCoord.top + mMargin.top; }
int _getViewBottom() const { return mCoord.bottom() - mMargin.bottom; }
int _getViewWidth() const { return mCoord.width - mMargin.left - mMargin.right; }
int _getViewHeight() const { return mCoord.height - mMargin.top - mMargin.bottom; }
virtual void _updateView() { }
virtual void _correctView() { }
virtual void _setAlign(const IntSize& _oldsize, bool _update) { }
virtual void _setAlign(const IntCoord& _oldcoord, bool _update) { }
void _setCroppedParent(ICroppedRectangle* _parent) { mCroppedParent = _parent; }
const IntRect& _getMargin() const { return mMargin; }
int _getMarginLeft() const { return mMargin.left; }
int _getMarginRight() const { return mMargin.right; }
int _getMarginTop() const { return mMargin.top; }
int _getMarginBottom() const { return mMargin.bottom; }
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void ICroppedRectangle::setVisible(bool _visible)")
void show() { setVisible(true); }
MYGUI_OBSOLETE("use : void ICroppedRectangle::setVisible(bool _visible)")
void hide() { setVisible(false); }
MYGUI_OBSOLETE("use : bool ICroppedRectangle::isVisible()")
bool isShow() { return isVisible(); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
bool _checkPoint(int _left, int _top)
{
return ! ((_getViewLeft() > _left) || (_getViewTop() > _top) || (_getViewRight() < _left) || (_getViewBottom() < _top));
}
bool _checkMargin()
{
bool margin = false;
//вылезли ли налево
if (getLeft() < mCroppedParent->mMargin.left)
{
mMargin.left = mCroppedParent->mMargin.left - getLeft();
margin = true;
}
else
{
mMargin.left = 0;
}
//вылезли ли направо
if (getRight() > mCroppedParent->getWidth() - mCroppedParent->mMargin.right)
{
mMargin.right = getRight() - (mCroppedParent->getWidth() - mCroppedParent->mMargin.right);
margin = true;
}
else
{
mMargin.right = 0;
}
//вылезли ли вверх
if (getTop() < mCroppedParent->mMargin.top)
{
mMargin.top = mCroppedParent->mMargin.top - getTop();
margin = true;
}
else
{
mMargin.top = 0;
}
//вылезли ли вниз
if (getBottom() > mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom)
{
mMargin.bottom = getBottom() - (mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom);
margin = true;
}
else
{
mMargin.bottom = 0;
}
return margin;
}
bool _checkOutside() // проверка на полный выход за границу
{
return ( (getRight() < mCroppedParent->mMargin.left ) || // совсем уехали налево
(getLeft() > mCroppedParent->getWidth() - mCroppedParent->mMargin.right ) || // совсем уехали направо
(getBottom() < mCroppedParent->mMargin.top ) || // совсем уехали вверх
(getTop() > mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom ) ); // совсем уехали вниз
}
protected:
bool mIsMargin;
IntRect mMargin; // перекрытие
IntCoord mCoord; // координаты
IntPoint mAbsolutePosition; // обсолютные координаты
ICroppedRectangle * mCroppedParent;
bool mVisible;
Align mAlign;
};
} // namespace MyGUI
#endif // __MYGUI_I_CROPPED_RECTANGLE_H__

46
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IDataStream.h vendored
View file

@ -1,46 +0,0 @@
/*!
@file
@author Albert Semenov
@date 08/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_DATA_STREAM_H__
#define __MYGUI_I_DATA_STREAM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
class MYGUI_EXPORT IDataStream
{
public:
virtual ~IDataStream() { }
virtual bool eof() = 0;
virtual size_t size() = 0;
virtual void readline(std::string& _source, Char _delim = '\n') = 0;
virtual size_t read(void* _buf, size_t _count) = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_DATA_STREAM_H__

54
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IFont.h vendored
View file

@ -1,54 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_FONT_H__
#define __MYGUI_I_FONT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ISerializable.h"
#include "MyGUI_IResource.h"
#include "MyGUI_FontData.h"
namespace MyGUI
{
class ITexture;
class MYGUI_EXPORT IFont : public IResource
{
MYGUI_RTTI_DERIVED( IFont )
public:
IFont() { }
virtual ~IFont() { }
virtual GlyphInfo* getGlyphInfo(Char _id) = 0;
virtual ITexture* getTextureFont() = 0;
virtual int getDefaultHeight() = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_FONT_H__

79
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ILayer.h vendored
View file

@ -1,79 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_LAYER_H__
#define __MYGUI_I_LAYER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_IRenderTarget.h"
#include "MyGUI_ILayerNode.h"
#include "MyGUI_ISerializable.h"
namespace MyGUI
{
class ILayerItem;
class MYGUI_EXPORT ILayer : public ISerializable
{
MYGUI_RTTI_DERIVED( ILayer )
public:
ILayer() { }
virtual ~ILayer() { }
// èìÿ ëååðà
const std::string& getName() const { return mName; }
// ñîçäàåì äî÷åðíèé íîä
virtual ILayerNode* createChildItemNode() = 0;
// óäàëÿåì äî÷åðíèé íîä
virtual void destroyChildItemNode(ILayerNode* _node) = 0;
// ïîäíèìàåì äî÷åðíèé íîä
virtual void upChildItemNode(ILayerNode* _node) = 0;
// ñïèñîê äåòåé
virtual EnumeratorILayerNode getEnumerator() = 0;
// âîçâðàùàåò âèäæåò ïî ïîçèöèè
virtual ILayerItem* getLayerItemByPoint(int _left, int _top) = 0;
// âîçâðàùàåò ïîçèöèþ â êîîðäèíàòàõ ëååðà
virtual IntPoint getPosition(int _left, int _top) const = 0;
// âîçâðàùàåò ðàçìåð ëååðà
virtual const IntSize& getSize() const = 0;
// ðèñóåò ëååð
virtual void renderToTarget(IRenderTarget* _target, bool _update) = 0;
virtual void dumpStatisticToLog() { }
protected:
std::string mName;
};
} // namespace MyGUI
#endif // __MYGUI_I_LAYER_H__

50
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ILayerItem.h vendored
View file

@ -1,50 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_LAYER_ITEM_H__
#define __MYGUI_I_LAYER_ITEM_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
class ILayer;
class ILayerNode;
class MYGUI_EXPORT ILayerItem
{
public:
virtual ~ILayerItem() { }
virtual ILayerItem * getLayerItemByPoint(int _left, int _top) = 0;
virtual const IntCoord& getLayerItemCoord() = 0;
virtual void attachItemToNode(ILayer* _layer, ILayerNode* _node) = 0;
virtual void detachFromLayer() = 0;
virtual void upLayerItem() = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_LAYER_ITEM_H__

91
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ILayerNode.h vendored
View file

@ -1,91 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_LAYER_NODE_H__
#define __MYGUI_I_LAYER_NODE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Enumerator.h"
#include "MyGUI_IObject.h"
#include "MyGUI_IRenderTarget.h"
namespace MyGUI
{
class ILayer;
class ILayerItem;
class ILayerNode;
class RenderItem;
class ISubWidget;
typedef std::vector<ILayerNode*> VectorILayerNode;
typedef Enumerator<VectorILayerNode> EnumeratorILayerNode;
class MYGUI_EXPORT ILayerNode : public IObject
{
MYGUI_RTTI_DERIVED( ILayerNode )
public:
virtual ~ILayerNode() { }
// ëååð, êîòîðîìó ìû ïðèíàäëåæèì
virtual ILayer* getLayer() = 0;
// âîçâðàùàåò îòöà èëè nullptr
virtual ILayerNode* getParent() = 0;
// ñîçäàåì äî÷åðíèé íîä
virtual ILayerNode* createChildItemNode() = 0;
// óäàëÿåì äî÷åðíèé íîä
virtual void destroyChildItemNode(ILayerNode* _node) = 0;
// ïîäíèìàåì äî÷åðíèé íîä
virtual void upChildItemNode(ILayerNode* _node) = 0;
// ñïèñîê äåòåé
virtual EnumeratorILayerNode getEnumerator() = 0;
// äîáàâëÿåì àéòåì ê íîäó
virtual void attachLayerItem(ILayerItem* _item) = 0;
// óäàëÿåì àéòåì èç íîäà
virtual void detachLayerItem(ILayerItem* _root) = 0;
// äîáàâëÿåò ñàá àéòåì è âîçâðàùàåò ðåíäåð àéòåì
virtual RenderItem* addToRenderItem(ITexture* _texture, ISubWidget* _item) = 0;
// íåîáõîäèìî îáíîâëåíèå íîäà
virtual void outOfDate(RenderItem* _item) = 0;
// âîçâðàùàåò âèäæåò ïî ïîçèöèè
virtual ILayerItem* getLayerItemByPoint(int _left, int _top) = 0;
// ðèñóåò ëååð
virtual void renderToTarget(IRenderTarget* _target, bool _update) = 0;
virtual void dumpStatisticToLog(size_t _level) { }
};
} // namespace MyGUI
#endif // __MYGUI_I_LAYER_NODE_H__

43
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IObject.h vendored
View file

@ -1,43 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_OBJECT_H__
#define __MYGUI_I_OBJECT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_RTTI.h"
namespace MyGUI
{
class MYGUI_EXPORT IObject
{
MYGUI_RTTI_BASE( IObject )
public:
virtual ~IObject() { }
};
} // namespace MyGUI
#endif // __MYGUI_I_OBJECT_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IPointer.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_POINTER_H__
#define __MYGUI_I_POINTER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IResource.h"
namespace MyGUI
{
class MYGUI_EXPORT IPointer : public IResource
{
MYGUI_RTTI_DERIVED( IPointer )
public:
IPointer() { }
virtual ~IPointer() { }
virtual void setImage(StaticImage* _image) = 0;
virtual void setPosition(StaticImage* _image, const IntPoint& _point) = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_POINTER_H__

52
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IRenderTarget.h vendored
View file

@ -1,52 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_RENDER_TARGET_H__
#define __MYGUI_I_RENDER_TARGET_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_RenderTargetInfo.h"
namespace MyGUI
{
class ITexture;
class IVertexBuffer;
class MYGUI_EXPORT IRenderTarget
{
public:
IRenderTarget() { }
virtual ~IRenderTarget() { }
virtual void begin() = 0;
virtual void end() = 0;
virtual void doRender(IVertexBuffer* _buffer, ITexture* _texture, size_t _count) = 0;
virtual const RenderTargetInfo& getInfo() = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_RENDER_TARGET_H__

77
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IResource.h vendored
View file

@ -1,77 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_RESOURCE_H__
#define __MYGUI_I_RESOURCE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_Guid.h"
#include "MyGUI_Version.h"
#include "MyGUI_ISerializable.h"
#include "MyGUI_ResourceHolder.h"
namespace MyGUI
{
class IResource;
typedef IResource * IResourcePtr;
class ResourceManager;
class MYGUI_EXPORT IResource : public ISerializable
{
// для серелизации
friend class ResourceManager;
// для удаления
friend class ResourceHolder<IResource>;
MYGUI_RTTI_DERIVED( IResource )
public:
const std::string& getResourceName() { return mResourceName; }
const Guid& getResourceID() { return mResourceID; }
protected:
IResource() { }
private:
// constructors and operator =, without implementation, just for private
IResource(IResource const &);
IResource& operator = (IResource const &);
protected:
virtual void deserialization(xml::ElementPtr _node, Version _version)
{
mResourceID = Guid::parse(_node->findAttribute("id"));
mResourceName = _node->findAttribute("name");
}
virtual ~IResource() { }
private:
std::string mResourceName;
Guid mResourceID;
};
} // namespace MyGUI
#endif // __MYGUI_I_RESOURCE_H__

49
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ISerializable.h vendored
View file

@ -1,49 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_SERIALIZABLE_H__
#define __MYGUI_I_SERIALIZABLE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IObject.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_Version.h"
namespace MyGUI
{
class MYGUI_EXPORT ISerializable : public IObject
{
MYGUI_RTTI_DERIVED( ISerializable )
public:
ISerializable() { }
virtual ~ISerializable() { }
virtual void serialization(xml::ElementPtr _node, Version _version) { }
virtual void deserialization(xml::ElementPtr _node, Version _version) { }
};
} // namespace MyGUI
#endif // __MYGUI_I_SERIALIZABLE_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IStateInfo.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 06/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_STATE_INFO_H__
#define __MYGUI_I_STATE_INFO_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ISerializable.h"
namespace MyGUI
{
class MYGUI_EXPORT IStateInfo : public ISerializable
{
MYGUI_RTTI_DERIVED( IStateInfo )
public:
virtual ~IStateInfo() { }
};
typedef std::vector<IStateInfo*> VectorStateInfo;
typedef std::map<std::string, IStateInfo*> MapStateInfo;
typedef std::map<std::string, VectorStateInfo> MapWidgetStateInfo;
} // namespace MyGUI
#endif // __MYGUI_I_STATE_INFO_H__

62
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ISubWidget.h vendored
View file

@ -1,62 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_SUB_WIDGET_H__
#define __MYGUI_I_SUB_WIDGET_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ICroppedRectangle.h"
#include "MyGUI_ILayerNode.h"
#include "MyGUI_Types.h"
#include "MyGUI_IRenderTarget.h"
#include "MyGUI_IStateInfo.h"
#include "MyGUI_IObject.h"
namespace MyGUI
{
class ISubWidget;
typedef std::vector<ISubWidget*> VectorSubWidget;
class MYGUI_EXPORT ISubWidget :
public ICroppedRectangle,
public IObject
{
MYGUI_RTTI_DERIVED( ISubWidget )
public:
virtual ~ISubWidget() { }
virtual void createDrawItem(ITexture* _texture, ILayerNode* _node) = 0;
virtual void destroyDrawItem() = 0;
virtual void setAlpha(float _alpha) { }
virtual void setStateData(IStateInfo* _data) { }
virtual void doRender() = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_SUB_WIDGET_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ISubWidgetRect.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_SUB_WIDGET_RECT_H__
#define __MYGUI_I_SUB_WIDGET_RECT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ISubWidget.h"
#include "MyGUI_Colour.h"
namespace MyGUI
{
class MYGUI_EXPORT ISubWidgetRect : public ISubWidget
{
MYGUI_RTTI_DERIVED( ISubWidgetRect )
public:
virtual ~ISubWidgetRect() { }
virtual void _setUVSet(const FloatRect& _rect) { }
virtual void _setColour(const Colour& _value) { }
};
} // namespace MyGUI
#endif // __MYGUI_I_SUB_WIDGET_RECT_H__

114
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ISubWidgetText.h vendored
View file

@ -1,114 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_SUB_WIDGET_TEXT_H__
#define __MYGUI_I_SUB_WIDGET_TEXT_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ISubWidget.h"
#include "MyGUI_Colour.h"
namespace MyGUI
{
class MYGUI_EXPORT ISubWidgetText : public ISubWidget
{
MYGUI_RTTI_DERIVED( ISubWidgetText )
public:
virtual ~ISubWidgetText() { }
/** Get index of start of selection */
virtual size_t getTextSelectionStart() { return 0; }
/** Get index of end of selection */
virtual size_t getTextSelectionEnd() { return 0; }
/** Set text selection */
virtual void setTextSelection(size_t _start, size_t _end) { }
// интенсивность выделенного текста
virtual bool getSelectBackground() { return true; }
virtual void setSelectBackground(bool _normal) { }
// нужно ли инвертировать выделение
virtual bool getInvertSelected() { return true; }
virtual void setInvertSelected(bool _value) { }
// управление видимостью курсора
virtual bool isVisibleCursor() { return false; }
virtual void setVisibleCursor(bool _value) { }
// управление положением курсора
virtual size_t getCursorPosition() { return 0; }
virtual void setCursorPosition(size_t _index) { }
virtual void setWordWrap(bool _value) { }
// возвращает положение курсора по произвольному положению
// позиция абсолютная, без учета смещений
virtual size_t getCursorPosition(const IntPoint& _point) { return 0; }
// возвращает положение курсора в обсолютных координатах
virtual IntCoord getCursorCoord(size_t _position) { return IntCoord(); }
// возвращает положение курсора в обсолютных координатах
IntPoint getCursorPoint(size_t _position)
{
const IntCoord& coord = getCursorCoord(_position);
return IntPoint(coord.left + coord.width / 2, coord.top + coord.height / 2);
}
// возвращает положение курсора в обсолютных координатах
IntRect getCursorRect(size_t _position)
{
const IntCoord& coord = getCursorCoord(_position);
return IntRect(coord.left, coord.top, coord.left + coord.width, coord.top + coord.height);
}
// возвращает размер текста в пикселях
virtual IntSize getTextSize() { return IntSize(); }
// устанавливает смещение текста в пикселях
virtual void setViewOffset(const IntPoint& _point) { }
virtual IntPoint getViewOffset() { return IntPoint(); }
virtual void setCaption(const UString& _value) { }
virtual const UString& getCaption() { static UString caption; return caption; }
virtual void setTextColour(const Colour& _value) { }
virtual const Colour& getTextColour() { return Colour::Zero; }
virtual void setFontName(const std::string& _value) { }
virtual const std::string& getFontName() { static std::string name; return name; }
virtual void setFontHeight(int _value) { }
virtual int getFontHeight() { return 0; }
virtual void setTextAlign(Align _value) { }
virtual Align getTextAlign() { return Align::Default; }
virtual void setShiftText(bool _value) { }
};
} // namespace MyGUI
#endif // __MYGUI_I_SUB_WIDGET_TEXT_H__

73
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ITexture.h vendored
View file

@ -1,73 +0,0 @@
/*!
@file
@author Albert Semenov
@date 04/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_TEXTURE_H__
#define __MYGUI_I_TEXTURE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_IRenderTarget.h"
#include "MyGUI_RenderFormat.h"
#include <string>
namespace MyGUI
{
class ITexture;
class MYGUI_EXPORT ITextureInvalidateListener
{
public:
virtual void textureInvalidate(ITexture* _texture) = 0;
};
class MYGUI_EXPORT ITexture
{
public:
virtual ~ITexture() { }
virtual const std::string& getName() const = 0;
virtual void createManual(int _width, int _height, TextureUsage _usage, PixelFormat _format) = 0;
virtual void loadFromFile(const std::string& _filename) = 0;
virtual void saveToFile(const std::string& _filename) = 0;
virtual void setInvalidateListener(ITextureInvalidateListener* _listener) { }
virtual void destroy() = 0;
virtual void* lock(TextureUsage _access) = 0;
virtual void unlock() = 0;
virtual bool isLocked() = 0;
virtual int getWidth() = 0;
virtual int getHeight() = 0;
virtual PixelFormat getFormat() = 0;
virtual TextureUsage getUsage() = 0;
virtual size_t getNumElemBytes() = 0;
virtual IRenderTarget* getRenderTarget() { return nullptr; }
};
} // namespace MyGUI
#endif // __MYGUI_I_TEXTURE_H__

43
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IUnlinkWidget.h vendored
View file

@ -1,43 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_UNLINK_WIDGET_H__
#define __MYGUI_UNLINK_WIDGET_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_WidgetDefines.h"
namespace MyGUI
{
class MYGUI_EXPORT IUnlinkWidget
{
public:
virtual ~IUnlinkWidget() { }
virtual void _unlinkWidget(Widget* _widget) = 0;
};
typedef std::vector<IUnlinkWidget*> VectorIUnlinkWidget;
} // namespace MyGUI
#endif // __MYGUI_UNLINK_WIDGET_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IVertexBuffer.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 04/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_VERTEX_BUFFER_H__
#define __MYGUI_I_VERTEX_BUFFER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_VertexData.h"
namespace MyGUI
{
class MYGUI_EXPORT IVertexBuffer
{
public:
virtual ~IVertexBuffer() { }
virtual void setVertextCount(size_t _value) = 0;
virtual size_t getVertextCount() = 0;
virtual Vertex* lock() = 0;
virtual void unlock() = 0;
};
} // namespace MyGUI
#endif // __MYGUI_I_VERTEX_BUFFER_H__

64
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IWidgetCreator.h vendored
View file

@ -1,64 +0,0 @@
/*!
@file
@author Albert Semenov
@date 03/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_WIDGET_CREATOR_H__
#define __MYGUI_WIDGET_CREATOR_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_WidgetStyle.h"
namespace MyGUI
{
class MYGUI_EXPORT IWidgetCreator
{
friend class WidgetManager;
public:
virtual ~IWidgetCreator() { }
protected:
virtual Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name) = 0;
// удяляет неудачника
virtual void _destroyChildWidget(Widget* _widget) = 0;
// удаляет всех детей
virtual void _destroyAllChildWidget() = 0;
// удаляет виджет с закрытым конструктором
void _deleteWidget(Widget* _widget);
public:
// добавляет в список виджет
// имплементировать только для рутовых креаторов
virtual void _linkChildWidget(Widget* _widget) { }
// удаляет из списка
// имплементировать только для рутовых креаторов
virtual void _unlinkChildWidget(Widget* _widget) { }
};
} // namespace MyGUI
#endif // __MYGUI_WIDGET_CREATOR_H__

95
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IWidgetFactory.h vendored
View file

@ -1,95 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_I_WIDGET_FACTORY_H__
#define __MYGUI_I_WIDGET_FACTORY_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_WidgetStyle.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_ICroppedRectangle.h"
#include "MyGUI_WidgetManager.h"
#include "MyGUI_SkinManager.h"
namespace MyGUI
{
//OBSOLETE
class MYGUI_EXPORT IWidgetFactory
{
public:
virtual ~IWidgetFactory() { }
virtual const std::string& getTypeName() = 0;
virtual Widget* createWidget(WidgetStyle _style, const std::string& _skin, const IntCoord& _coord, Align _align, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name) = 0;
};
namespace factory
{
//OBSOLETE
template <typename T>
class MYGUI_EXPORT BaseWidgetFactory : public IWidgetFactory
{
public:
BaseWidgetFactory()
{
// регестрируем себя
MyGUI::WidgetManager& manager = MyGUI::WidgetManager::getInstance();
manager.registerFactory(this);
}
~BaseWidgetFactory()
{
// удаляем себя
MyGUI::WidgetManager& manager = MyGUI::WidgetManager::getInstance();
manager.unregisterFactory(this);
}
const std::string& getTypeName()
{
return T::getClassTypeName();
}
Widget* createWidget(WidgetStyle _style, const std::string& _skin, const IntCoord& _coord, Align _align, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
{
T* instance = new T(_style, _coord, _align, SkinManager::getInstance().getByName(_skin), _parent, _croppedParent, _creator, _name);
return instance;
}
bool isFalseType(Widget* _ptr, const std::string &_key)
{
if (!_ptr->isType<T>())
{
MYGUI_LOG(Error, "Property '" << _key << "' is not supported by '" << _ptr->getTypeName() << "' widget");
return true;
}
return false;
}
};
} // namespace factory
} // namespace MyGUI
#endif // __MYGUI_I_WIDGET_FACTORY_H__

64
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ImageInfo.h vendored
View file

@ -1,64 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_IMAGE_INFO_H__
#define __MYGUI_IMAGE_INFO_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct ImageItem
{
ImageItem() : frame_rate(0) { }
float frame_rate;
std::vector<FloatRect> images;
};
typedef std::vector<ImageItem> VectorImages;
struct ImageIndexInfo
{
ImageIndexInfo(
const std::string& _texture,
const IntSize& _size,
const float _rate,
const std::vector<IntPoint>& _frames
) :
texture(_texture),
size(_size),
rate(_rate),
frames(_frames)
{
}
const std::string& texture;
const IntSize& size;
const float rate;
const std::vector<IntPoint>& frames;
};
} // namespace MyGUI
#endif // __MYGUI_IMAGE_INFO_H__

227
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_InputDefine.h vendored
View file

@ -1,227 +0,0 @@
/*!
@file
@author Albert Semenov
@date 03/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_INPUT_DEFINE_H__
#define __MYGUI_INPUT_DEFINE_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct MYGUI_EXPORT MouseButton
{
enum Enum
{
Left = 0,
Right,
Middle,
Button0 = 0,
Button1,
Button2,
Button3,
Button4,
Button5,
Button6,
Button7,
None = -1
};
MouseButton(Enum _value = None) : value(_value) { }
friend bool operator == (MouseButton const& a, MouseButton const& b) { return a.value == b.value; }
friend bool operator != (MouseButton const& a, MouseButton const& b) { return a.value != b.value; }
int toValue() const { return (int)value; }
private:
Enum value;
};
struct MYGUI_EXPORT KeyCode
{
enum Enum
{
None = 0x00,
Escape = 0x01,
One = 0x02,
Two = 0x03,
Three = 0x04,
Four = 0x05,
Five = 0x06,
Six = 0x07,
Seven = 0x08,
Eight = 0x09,
Nine = 0x0A,
Zero = 0x0B,
Minus = 0x0C, /* - on main keyboard */
Equals = 0x0D,
Backspace = 0x0E, /* Backspace */
Tab = 0x0F,
Q = 0x10,
W = 0x11,
E = 0x12,
R = 0x13,
T = 0x14,
Y = 0x15,
U = 0x16,
I = 0x17,
O = 0x18,
P = 0x19,
LeftBracket = 0x1A,
RightBracket = 0x1B,
Return = 0x1C, /* Enter on main keyboard */
LeftControl = 0x1D,
A = 0x1E,
S = 0x1F,
D = 0x20,
F = 0x21,
G = 0x22,
H = 0x23,
J = 0x24,
K = 0x25,
L = 0x26,
Semicolon = 0x27,
Apostrophe = 0x28,
Grave = 0x29, /* Accent grave ( ~ ) */
LeftShift = 0x2A,
Backslash = 0x2B,
Z = 0x2C,
X = 0x2D,
C = 0x2E,
V = 0x2F,
B = 0x30,
N = 0x31,
M = 0x32,
Comma = 0x33,
Period = 0x34, /* . on main keyboard */
Slash = 0x35, /* '/' on main keyboard */
RightShift = 0x36,
Multiply = 0x37, /* * on numeric keypad */
LeftAlt = 0x38, /* Left Alt */
Space = 0x39,
Capital = 0x3A,
F1 = 0x3B,
F2 = 0x3C,
F3 = 0x3D,
F4 = 0x3E,
F5 = 0x3F,
F6 = 0x40,
F7 = 0x41,
F8 = 0x42,
F9 = 0x43,
F10 = 0x44,
NumLock = 0x45,
ScrollLock = 0x46, /* Scroll Lock */
Numpad7 = 0x47,
Numpad8 = 0x48,
Numpad9 = 0x49,
Subtract = 0x4A, /* - on numeric keypad */
Numpad4 = 0x4B,
Numpad5 = 0x4C,
Numpad6 = 0x4D,
Add = 0x4E, /* + on numeric keypad */
Numpad1 = 0x4F,
Numpad2 = 0x50,
Numpad3 = 0x51,
Numpad0 = 0x52,
Decimal = 0x53, /* . on numeric keypad */
OEM_102 = 0x56, /* < > | on UK/Germany keyboards */
F11 = 0x57,
F12 = 0x58,
F13 = 0x64, /* (NEC PC98) */
F14 = 0x65, /* (NEC PC98) */
F15 = 0x66, /* (NEC PC98) */
Kana = 0x70, /* (Japanese keyboard) */
ABNT_C1 = 0x73, /* / ? on Portugese (Brazilian) keyboards */
Convert = 0x79, /* (Japanese keyboard) */
NoConvert = 0x7B, /* (Japanese keyboard) */
Yen = 0x7D, /* (Japanese keyboard) */
ABNT_C2 = 0x7E, /* Numpad . on Portugese (Brazilian) keyboards */
NumpadEquals = 0x8D, /* = on numeric keypad (NEC PC98) */
PrevTrack = 0x90, /* Previous Track (KC_CIRCUMFLEX on Japanese keyboard) */
At = 0x91, /* (NEC PC98) */
Colon = 0x92, /* (NEC PC98) */
Underline = 0x93, /* (NEC PC98) */
Kanji = 0x94, /* (Japanese keyboard) */
Stop = 0x95, /* (NEC PC98) */
AX = 0x96, /* (Japan AX) */
Unlabeled = 0x97, /* (J3100) */
NextTrack = 0x99, /* Next Track */
NumpadEnter = 0x9C, /* Enter on numeric keypad */
RightControl = 0x9D,
Mute = 0xA0,
Calculator = 0xA1,
PlayPause = 0xA2, /* Play / Pause */
MediaStop = 0xA4, /* Media Stop */
VolumeDown = 0xAE, /* Volume - */
VolumeUp = 0xB0, /* Volume + */
WebHome = 0xB2, /* Web home */
NumpadComma = 0xB3, /* , on numeric keypad (NEC PC98) */
Divide = 0xB5, /* / on numeric keypad */
SysRq = 0xB7,
RightAlt = 0xB8, /* Right Alt */
Pause = 0xC5,
Home = 0xC7, /* Home on arrow keypad */
ArrowUp = 0xC8, /* UpArrow on arrow keypad */
PageUp = 0xC9, /* PgUp on arrow keypad */
ArrowLeft = 0xCB, /* LeftArrow on arrow keypad */
ArrowRight = 0xCD, /* RightArrow on arrow keypad */
End = 0xCF, /* End on arrow keypad */
ArrowDown = 0xD0, /* DownArrow on arrow keypad */
PageDown = 0xD1, /* PgDn on arrow keypad */
Insert = 0xD2, /* Insert on arrow keypad */
Delete = 0xD3, /* Delete on arrow keypad */
LeftWindows = 0xDB, /* Left Windows key */
RightWindow = 0xDC, /* Right Windows key */
RightWindows = 0xDC, /* Right Windows key - Correct spelling :) */
AppMenu = 0xDD, /* AppMenu key */
Power = 0xDE, /* System Power */
Sleep = 0xDF, /* System Sleep */
Wake = 0xE3, /* System Wake */
WebSearch = 0xE5,
WebFavorites = 0xE6,
WebRefresh = 0xE7,
WebStop = 0xE8,
WebForward = 0xE9,
WebBack = 0xEA,
MyComputer = 0xEB,
Mail = 0xEC,
MediaSelect = 0xED
};
KeyCode(Enum _value = None) : value(_value) { }
friend bool operator == (KeyCode const& a, KeyCode const& b) { return a.value == b.value; }
friend bool operator != (KeyCode const& a, KeyCode const& b) { return a.value != b.value; }
int toValue() const { return (int)value; }
private:
Enum value;
};
} // namespace MyGUI
#endif // __MYGUI_INPUT_DEFINE_H__

180
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_InputManager.h vendored
View file

@ -1,180 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_INPUT_MANAGER_H__
#define __MYGUI_INPUT_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Macros.h"
#include "MyGUI_Instance.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_IUnlinkWidget.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_InputDefine.h"
#include "MyGUI_Timer.h"
#include "MyGUI_ILayer.h"
#include "MyGUI_Delegate.h"
namespace MyGUI
{
class MYGUI_EXPORT InputManager : public IUnlinkWidget
{
MYGUI_INSTANCE_HEADER( InputManager )
public:
void initialise();
void shutdown();
/** Inject MouseMove event
@return true if event has been processed by GUI
*/
bool injectMouseMove(int _absx, int _absy, int _absz);
/** Inject MousePress event
@return true if event has been processed by GUI
*/
bool injectMousePress(int _absx, int _absy, MouseButton _id);
/** Inject MouseRelease event
@return true if event has been processed by GUI
*/
bool injectMouseRelease(int _absx, int _absy, MouseButton _id);
/** Inject KeyPress event
@return true if event has been processed by GUI
*/
bool injectKeyPress(KeyCode _key, Char _text = 0);
/** Inject KeyRelease event
@return true if event has been processed by GUI
*/
bool injectKeyRelease(KeyCode _key);
/** Is any widget have mouse focus */
bool isFocusMouse() { return mWidgetMouseFocus != nullptr; }
/** Is any widget have key focus */
bool isFocusKey() { return mWidgetKeyFocus != nullptr; }
/** Is any widget captured mouse */
bool isCaptureMouse() { return mIsWidgetMouseCapture; }
/** Set key focus for _widget */
void setKeyFocusWidget(Widget* _widget);
/** Drop key focus for _widget */
void resetKeyFocusWidget(Widget* _widget);
/** Drop any key focus */
void resetKeyFocusWidget() { setKeyFocusWidget(nullptr); }
/** Get mouse focused widget */
Widget* getMouseFocusWidget() { return mWidgetMouseFocus; }
/** Get key focused widget */
Widget* getKeyFocusWidget() { return mWidgetKeyFocus; }
/** Get position of last left mouse button press */
const IntPoint& getLastLeftPressed() { return mLastLeftPressed; }
/** Get current mouse position */
const IntPoint& getMousePosition() { return mMousePosition; }
IntPoint getMousePositionByLayer();
// тестовый вариант, очистка фокуса мыши
/** Drop any mouse focus */
void resetMouseFocusWidget();
// работа с модальными окнами
/** Add modal widget - all other widgets inaccessible while modal widget exist */
void addWidgetModal(Widget* _widget);
/** Remove modal widget */
void removeWidgetModal(Widget* _widget);
/** Return true if any modal widget exist */
bool isModalAny() { return !mVectorModalRootWidget.empty(); }
/** Is control button pressed */
bool isControlPressed() { return mIsControlPressed; }
/** Is shift button pressed */
bool isShiftPressed() { return mIsShiftPressed; }
/** Reset mouse capture (for example when we dragging and application
lost focus you should call this)
*/
void resetMouseCaptureWidget() { mIsWidgetMouseCapture = false; }
void unlinkWidget(Widget* _widget) { _unlinkWidget(_widget); }
/** Event :\n
signature : void method(MyGUI::Widget* _widget)\n
@param _widget
*/
delegates::CMultiDelegate1<Widget*>
eventChangeMouseFocus;
/** Event :\n
signature : void method(MyGUI::Widget* _widget)\n
@param _widget
*/
delegates::CMultiDelegate1<Widget*>
eventChangeKeyFocus;
private:
// удаляем данный виджет из всех возможных мест
void _unlinkWidget(Widget* _widget);
void frameEntered(float _frame);
void firstEncoding(KeyCode _key, bool bIsKeyPressed);
// запоминает клавишу для поддержки повторения
void storeKey(KeyCode _key, Char _text);
// сбрасывает клавишу повторения
void resetKey();
private:
// виджеты которым принадлежит фокус
Widget* mWidgetMouseFocus;
Widget* mWidgetKeyFocus;
ILayer* mLayerMouseFocus;
// захватил ли мышь активный виджет
bool mIsWidgetMouseCapture;
// таймер для двойного клика
Timer mTimer; //used for double click timing
// нажат ли шифт
bool mIsShiftPressed;
// нажат ли контрол
bool mIsControlPressed;
// там где была последний раз нажата левая кнопка
IntPoint mLastLeftPressed;
IntPoint mMousePosition;
// клавиша для повтора
KeyCode mHoldKey;
Char mHoldChar;
bool mFirstPressKey;
float mTimerKey;
int mOldAbsZ;
// список виджетов с модальным режимом
VectorWidgetPtr mVectorModalRootWidget;
};
} // namespace MyGUI
#endif // __MYGUI_INPUT_MANAGER_H__

45
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Instance.h vendored
View file

@ -1,45 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_INSTANCE_H__
#define __MYGUI_INSTANCE_H__
#define MYGUI_INSTANCE_HEADER(type) \
private: \
static type* msInstance; \
bool mIsInitialise; \
public: \
type();\
~type();\
static type& getInstance(); \
static type* getInstancePtr();
#define MYGUI_INSTANCE_IMPLEMENT(type) \
const std::string INSTANCE_TYPE_NAME(#type); \
type* type::msInstance = nullptr; \
type* type::getInstancePtr() { return msInstance; } \
type& type::getInstance() { MYGUI_ASSERT(0 != msInstance, "instance " << INSTANCE_TYPE_NAME << " was not created"); return (*msInstance); } \
type::type() : mIsInitialise(false) { MYGUI_ASSERT(0 == msInstance, "instance " << INSTANCE_TYPE_NAME << " is exsist"); msInstance = this; } \
type::~type() { msInstance = nullptr; }
#endif // __MYGUI_INSTANCE_H__

368
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ItemBox.h vendored
View file

@ -1,368 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_ITEM_BOX_H__
#define __MYGUI_ITEM_BOX_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_DDContainer.h"
#include "MyGUI_IBItemInfo.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_ScrollViewBase.h"
namespace MyGUI
{
typedef delegates::CDelegate2<ItemBox*, Widget*> EventHandle_ItemBoxPtrWidgetPtr;
typedef delegates::CDelegate3<ItemBox*, IntCoord&, bool> EventHandle_ItemBoxPtrIntCoordRefBool;
typedef delegates::CDelegate3<ItemBox*, Widget*, const IBDrawItemInfo &> EventHandle_ItemBoxPtrWidgetPtrCIBCellDrawInfoRef;
typedef delegates::CDelegate2<ItemBox*, size_t> EventHandle_ItemBoxPtrSizeT;
typedef delegates::CDelegate2<ItemBox*, const IBNotifyItemData &> EventHandle_ItemBoxPtrCIBNotifyCellDataRef;
class MYGUI_EXPORT ItemBox :
public DDContainer,
protected ScrollViewBase
{
MYGUI_RTTI_DERIVED( ItemBox )
public:
ItemBox();
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of items
size_t getItemCount() const { return mItemsInfo.size(); }
//! Insert an item into a array at a specified position
void insertItemAt(size_t _index, Any _data = Any::Null);
//! Add an item to the end of a array
void addItem(Any _data = Any::Null) { insertItemAt(ITEM_NONE, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove all items
void removeAllItems();
//! Redraw at a specified position
void redrawItemAt(size_t _index);
//! Redraw all items
void redrawAllItems();
//------------------------------------------------------------------------------//
// манипуляции выделениями
//! Get index of selected item (ITEM_NONE if none selected)
size_t getIndexSelected() { return mIndexSelect; }
//! Select specified _index
void setIndexSelected(size_t _index);
//! Clear item selection
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data);
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ItemBox::getItemDataAt");
return mItemsInfo[_index].data.castType<ValueType>(_throw);
}
/** Set vertical alignment grid mode */
void setItemBoxAlignVert(bool _value);
/** Get vertical alignment grid mode flag */
bool getItemBoxAlignVert() { return mAlignVert; }
/** Get item index by item Widget pointer */
size_t getIndexByWidget(Widget* _widget);
/** Get widget created for drop */
Widget* getWidgetDrag() { return mItemDrag; }
/** Get item Widget pointer by item index if it is visible
@note returned widget can be deleted, so this pointer
is valid only at time when you got it and can be invalid
next frame
*/
Widget* getWidgetByIndex(size_t _index);
/** Interrupt drag as if widget was dropped into empty space */
void resetDrag();
//! @copydoc Widget::setPosition(const IntPoint& _value)
virtual void setPosition(const IntPoint& _value);
//! @copydoc Widget::setSize(const IntSize& _value)
virtual void setSize(const IntSize& _value);
//! @copydoc Widget::setCoord(const IntCoord& _value)
virtual void setCoord(const IntCoord& _value);
/** @copydoc Widget::setPosition(int _left, int _top) */
void setPosition(int _left, int _top) { setPosition(IntPoint(_left, _top)); }
/** @copydoc Widget::setSize(int _width, int _height) */
void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
/*event:*/
/** Event : request for creating new item
signature : void method(MyGUI::ItemBox* _sender, MyGUI::Widget* _item)
@param _sender widget that called this event
@param _item widget item pointer
*/
EventHandle_ItemBoxPtrWidgetPtr requestCreateWidgetItem;
/** Event : request for item coordinate
signature : void method(MyGUI::ItemBox* _sender, MyGUI::IntCoord& _coord, bool _drag)
@param _sender widget that called this event
@param _coord write heer item coordinate
@param _drag is this item dragging
*/
EventHandle_ItemBoxPtrIntCoordRefBool requestCoordItem;
/** Event : request for item redraw
signature : void method(MyGUI::ItemBox* _sender, MyGUI::Widget* _item, const MyGUI::IBDrawItemInfo& _info)
@param _sender widget that called this event
@param _item widget item pointer
@param _info item info
*/
EventHandle_ItemBoxPtrWidgetPtrCIBCellDrawInfoRef requestDrawItem;
/** Event : doubleclick or enter pressed on item
signature : void method(MyGUI::ItemBox* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ItemBoxPtrSizeT eventSelectItemAccept;
/** Event : position of selected item was changed
signature : void method(MyGUI::ItemBox* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ItemBoxPtrSizeT eventChangeItemPosition;
/** Event : click on item
signature : void method(MyGUI::ItemBox* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ItemBoxPtrSizeT eventMouseItemActivate;
/** Event : notify about event in item widget
signature : void method(MyGUI::ItemBox* _sender, const MyGUI::IBNotifyItemData& _info)
@param _sender widget that called this event
@param _info info about item notify
*/
EventHandle_ItemBoxPtrCIBNotifyCellDataRef eventNotifyItem;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void Widget::setCoord(const IntCoord& _coord)")
void setPosition(const IntCoord& _coord) { setCoord(_coord); }
MYGUI_OBSOLETE("use : void Widget::setCoord(int _left, int _top, int _width, int _height)")
void setPosition(int _left, int _top, int _width, int _height) { setCoord(_left, _top, _width, _height); }
MYGUI_OBSOLETE("use : size_t ItemBox::getItemIndexSelected()")
size_t getItemIndexSelected() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void ItemBox::setIndexSelected(size_t _index)")
void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void ItemBox::clearIndexSelected()")
void clearItemSelected() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void ItemBox::insertItemAt(size_t _index, Any _data)")
void insertItem(size_t _index, Any _data = Any::Null) { insertItemAt(_index, _data); }
MYGUI_OBSOLETE("use : void ItemBox::setItemDataAt(size_t _index, Any _data)")
void setItemData(size_t _index, Any _data) { setItemDataAt(_index, _data); }
MYGUI_OBSOLETE("use : void ItemBox::removeItemAt(size_t _index)")
void deleteItem(size_t _index) { removeItemAt(_index); }
MYGUI_OBSOLETE("use : void ItemBox::removeAllItems()")
void deleteAllItems() { removeAllItems(); }
MYGUI_OBSOLETE("use : size_t ItemBox::getIndexSelected()")
size_t getItemSelect() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void ItemBox::clearIndexSelected()")
void resetItemSelect() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void ItemBox::setIndexSelected(size_t _index)")
void setItemSelect(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : Widget* ItemBox::getWidgetDrag()")
Widget* getWidgetDrop() { return getWidgetDrag(); }
MYGUI_OBSOLETE("use : void ItemBox::resetDrag()")
void resetDrop() { resetDrag(); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~ItemBox();
struct ItemDataInfo
{
ItemDataInfo(Any _data) :
data(_data) { }
Any data;
};
typedef std::vector<ItemDataInfo> VectorItemInfo;
void baseChangeWidgetSkin(ResourceSkin* _info);
virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
virtual void onMouseDrag(int _left, int _top);
virtual void onMouseWheel(int _rel);
virtual void onKeyLostFocus(Widget* _new);
virtual void onKeySetFocus(Widget* _old);
void notifyKeyButtonPressed(Widget* _sender, KeyCode _key, Char _char);
void notifyKeyButtonReleased(Widget* _sender, KeyCode _key);
void notifyScrollChangePosition(VScroll* _sender, size_t _index);
void notifyMouseWheel(Widget* _sender, int _rel);
void notifyRootMouseChangeFocus(Widget* _sender, bool _focus);
void notifyMouseButtonDoubleClick(Widget* _sender);
void _requestGetContainer(Widget* _sender, Widget*& _container, size_t& _index);
void notifyMouseDrag(Widget* _sender, int _left, int _top);
void notifyMouseButtonPressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyMouseButtonReleased(Widget* _sender, int _left, int _top, MouseButton _id);
virtual void removeDropItems();
virtual void updateDropItems();
virtual void updateDropItemsState(const DDWidgetState& _state);
// Обновляет данные о айтемах, при изменении размеров
void updateMetrics();
// просто обновляет все виджеты что видны
void _updateAllVisible(bool _redraw);
void updateFromResize();
// возвращает следующий айтем, если нет его, то создается
// запросы только последовательно
Widget* getItemWidget(size_t _index);
void _setContainerItemInfo(size_t _index, bool _set, bool _accept);
// сбрасываем старую подсветку
void resetCurrentActiveItem();
// ищет и устанавливает подсвеченный айтем
void findCurrentActiveItem();
// запрашиваем у конейтера айтем по позиции мыши
virtual size_t _getContainerIndex(const IntPoint& _point);
// сбрасывает зависимости, при любом колличественном изменении
virtual void _resetContainer(bool _update);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
size_t calcIndexByWidget(Widget* _widget);
void requestItemSize();
virtual IntSize getContentSize();
virtual IntPoint getContentPosition();
virtual IntSize getViewSize() const;
virtual void eraseContent();
virtual size_t getHScrollPage();
virtual size_t getVScrollPage();
virtual Align getContentAlign();
virtual void setContentPosition(const IntPoint& _point);
IntRect _getClientAbsoluteRect();
Widget* _getClientWidget();
const Widget* _getClientWidget() const;
private:
// наши дети в строках
VectorWidgetPtr mVectorItems;
// размер одного айтема
IntSize mSizeItem;
// размерность скролла в пикселях
IntSize mContentSize;
// позиция скролла п пикселях
IntPoint mContentPosition;
// колличество айтемов в одной строке
int mCountItemInLine;
// колличество линий
int mCountLines;
// самая верхняя строка
int mFirstVisibleIndex;
// текущее смещение верхнего элемента в пикселях
// сколько его пикселей не видно сверху
int mFirstOffsetIndex;
// текущий выделенный элемент или ITEM_NONE
size_t mIndexSelect;
// подсвеченный элемент или ITEM_NONE
size_t mIndexActive;
// индекс со свойством приема или ITEM_NONE
size_t mIndexAccept;
// индекс со свойством отказа или ITEM_NONE
size_t mIndexRefuse;
// имеем ли мы фокус ввода
bool mIsFocus;
// структура данных об айтеме
VectorItemInfo mItemsInfo;
Widget* mItemDrag;
IntPoint mPointDragOffset;
bool mAlignVert;
std::string mDragLayer;
};
} // namespace MyGUI
#endif // __MYGUI_ITEM_BOX_H__

96
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LanguageManager.h vendored
View file

@ -1,96 +0,0 @@
/*!
@file
@author Albert Semenov
@date 09/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LANGUAGE_MANAGER_H__
#define __MYGUI_LANGUAGE_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_Delegate.h"
namespace MyGUI
{
class MYGUI_EXPORT LanguageManager
{
MYGUI_INSTANCE_HEADER( LanguageManager )
public:
void initialise();
void shutdown();
/** Load additional MyGUI *_language.xml file */
bool load(const std::string& _file);
void _load(xml::ElementPtr _node, const std::string& _file, Version _version);
/** Set current language for replacing #{} tags */
void setCurrentLanguage(const std::string& _name);
/** Get current language */
const std::string& getCurrentLanguage();
/** Replace all tags #{tagname} in _line with appropriate string dependent
on current language or keep #{tagname} if 'tagname' not found found */
UString replaceTags(const UString& _line);
/** Get tag value */
UString getTag(const UString& _tag);
/** Add user tag */
void addUserTag(const UString& _tag, const UString& _replace);
/** Delete all user tags */
void clearUserTags();
bool loadUserTags(const std::string& _file);
/** Event : Change current language.\n
signature : void method(const std::string& _language);
@param _language Current language.
*/
delegates::CMultiDelegate1<const std::string &> eventChangeLanguage;
private:
//bool loadResourceLanguage(const std::string& _name);
bool loadLanguage(const std::string& _file, bool _user = false);
void _loadLanguage(IDataStream* _stream, bool _user);
void _loadLanguageXML(IDataStream* _stream, bool _user);
//void _loadSource(xml::ElementPtr _node, const std::string& _file, Version _version);
private:
typedef std::map<UString, UString> MapLanguageString;
MapLanguageString mMapLanguage;
MapLanguageString mUserMapLanguage;
std::string mCurrentLanguageName;
typedef std::vector<std::string> VectorString;
typedef std::map<std::string, VectorString> MapListString;
MapListString mMapFile;
};
} // namespace MyGUI
#endif // __MYGUI_LANGUAGE_MANAGER_H__

88
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LayerItem.h vendored
View file

@ -1,88 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LAYER_ITEM_H__
#define __MYGUI_LAYER_ITEM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_LayerManager.h"
#include "MyGUI_ILayer.h"
#include "MyGUI_ILayerNode.h"
#include "MyGUI_ILayerItem.h"
#include "MyGUI_ISubWidget.h"
namespace MyGUI
{
class MYGUI_EXPORT LayerItem : public ILayerItem
{
public:
LayerItem();
virtual ~LayerItem() { }
public:
ILayer* getLayer() { return mLayer; }
virtual void attachItemToNode(ILayer* _layer, ILayerNode* _node);
virtual void detachFromLayer();
virtual void upLayerItem();
void setRenderItemTexture(ITexture* _texture);
void addChildItem(LayerItem* _item);
void removeChildItem(LayerItem* _item);
void addChildNode(LayerItem* _item);
void removeChildNode(LayerItem* _item);
void addRenderItem(ISubWidget* _item);
void removeAllRenderItems();
void saveLayerItem();
void restoreLayerItem();
protected:
void attachToLayerItemNode(ILayerNode* _node, bool _deep);
void detachFromLayerItemNode(bool _deep);
private:
// актуально для рутового виджета
ILayer* mLayer;
// конкретный айтем находящийся в слое
ILayerNode * mLayerNode;
ILayerNode * mSaveLayerNode;
typedef std::vector<LayerItem*> VectorLayerItem;
// список наших детей айтемов
VectorLayerItem mLayerItems;
// список наших узлов
VectorLayerItem mLayerNodes;
// вектор всех детей сабскинов
VectorSubWidget mDrawItems;
ITexture* mTexture;
};
} // namespace MyGUI
#endif // __MYGUI_LAYER_ITEM_H__

99
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LayerManager.h vendored
View file

@ -1,99 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LAYER_MANAGER_H__
#define __MYGUI_LAYER_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_Enumerator.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_IUnlinkWidget.h"
#include "MyGUI_ResourceManager.h"
#include "MyGUI_ILayer.h"
namespace MyGUI
{
class MYGUI_EXPORT LayerManager :
public IUnlinkWidget
{
MYGUI_INSTANCE_HEADER( LayerManager )
public:
typedef std::vector<ILayer*> VectorLayer;
typedef Enumerator<VectorLayer> EnumeratorLayer;
public:
void initialise();
void shutdown();
/** Attach widget to specific layer
@param _name Layer name
@param _item Widget pointer
*/
void attachToLayerNode(const std::string& _name, Widget* _item);
/** Detach widget from layer
@param _item Widget pointer
*/
void detachFromLayer(Widget* _item);
/** Up widget to be on top of its layer
@param _item Widget pointer
*/
void upLayerItem(Widget* _item);
/** Load additional MyGUI *_layer.xml file */
bool load(const std::string& _file);
void _load(xml::ElementPtr _node, const std::string& _file, Version _version);
/** Check is layer exist */
bool isExist(const std::string& _name) const;
/** Get layer nodes Enumerator */
EnumeratorLayer getEnumerator() { return EnumeratorLayer(mLayerNodes); }
ILayer* getByName(const std::string& _name, bool _throw = true) const;
/** Get top visible and enabled widget at specified position */
Widget* getWidgetFromPoint(int _left, int _top);
void renderToTarget(IRenderTarget* _target, bool _update);
virtual void dumpStatisticToLog();
private:
// удаляем данный виджет из всех возможных мест
void _unlinkWidget(Widget* _widget);
void clear();
void merge(VectorLayer& _layers);
void destroy(ILayer* _layer);
private:
VectorLayer mLayerNodes;
};
} // namespace MyGUI
#endif // __MYGUI_LAYER_MANAGER_H__

105
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LayerNode.h vendored
View file

@ -1,105 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LAYER_NODE_H__
#define __MYGUI_LAYER_NODE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ILayer.h"
#include "MyGUI_ILayerNode.h"
#include "MyGUI_RenderItem.h"
namespace MyGUI
{
class LayerItem;
typedef std::vector<RenderItem*> VectorRenderItem;
typedef std::vector<ILayerItem*> VectorLayerItem;
class MYGUI_EXPORT LayerNode : public ILayerNode
{
MYGUI_RTTI_DERIVED( LayerNode )
public:
explicit LayerNode(ILayer* _layer, ILayerNode * _parent = nullptr);
virtual ~LayerNode();
// леер, которому мы принадлежим
virtual ILayer* getLayer() { return mLayer; }
// возвращает отца или nullptr
virtual ILayerNode* getParent() { return mParent; }
// создаем дочерний нод
virtual ILayerNode* createChildItemNode();
// удаляем дочерний нод
virtual void destroyChildItemNode(ILayerNode* _node);
// поднимаем дочерний нод
virtual void upChildItemNode(ILayerNode* _node);
// список детей
virtual EnumeratorILayerNode getEnumerator();
// добавляем айтем к ноду
virtual void attachLayerItem(ILayerItem* _item);
// удаляем айтем из нода
virtual void detachLayerItem(ILayerItem* _item);
// добавляет саб айтем и возвращает рендер айтем
virtual RenderItem* addToRenderItem(ITexture* _texture, ISubWidget* _item);
// необходимо обновление нода
virtual void outOfDate(RenderItem* _item);
// возвращает виджет по позиции
virtual ILayerItem* getLayerItemByPoint(int _left, int _top);
// рисует леер
virtual void renderToTarget(IRenderTarget* _target, bool _update);
virtual void dumpStatisticToLog(size_t _level);
bool isOutOfDate() { return mOutOfDate; }
protected:
void updateCompression();
protected:
// список двух очередей отрисовки, для сабскинов и текста
VectorRenderItem mFirstRenderItems;
VectorRenderItem mSecondRenderItems;
// список всех рутовых виджетов
// у перекрывающегося слоя здесь только один
VectorLayerItem mLayerItems;
// список такиж как мы, для построения дерева
VectorILayerNode mChildItems;
ILayerNode * mParent;
ILayer* mLayer;
bool mOutOfDate;
};
} // namespace MyGUI
#endif // __MYGUI_LAYER_NODE_H__

78
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LayoutManager.h vendored
View file

@ -1,78 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LAYOUT_MANAGER_H__
#define __MYGUI_LAYOUT_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Instance.h"
#include "MyGUI_XmlDocument.h"
#include "MyGUI_WidgetDefines.h"
#include "MyGUI_Gui.h"
namespace MyGUI
{
class MYGUI_EXPORT LayoutManager
{
MYGUI_INSTANCE_HEADER( LayoutManager )
public:
void initialise();
void shutdown();
/** Load layout file
@param _file name of layout
@return Return vector of pointers of loaded root widgets (root == without parents)
*/
VectorWidgetPtr& load(const std::string& _file);
void _load(xml::ElementPtr _node, const std::string& _file, Version _version);
/** Load layout file
@param _file name of layout
@param _prefix will be added to all loaded widgets names
@param _parent widget to load on
@return Return vector of pointers of loaded root widgets (root == without parents)
*/
VectorWidgetPtr& loadLayout(const std::string& _file, const std::string& _prefix = "", Widget* _parent = nullptr);
/** Unload layout file */
void unloadLayout(VectorWidgetPtr& _widgets);
private:
void parseLayout(VectorWidgetPtr& _widgets, xml::ElementPtr _root);
void parseWidget(VectorWidgetPtr& _widgets, xml::ElementEnumerator& _widget, Widget* _parent);
private:
// для возврата последней загрузки
VectorWidgetPtr mVectorWidgetPtr;
// префикс при загрузке лейаута
std::string layoutPrefix;
// префикс при загрузке лейаута
Widget* layoutParent;
};
} // namespace MyGUI
#endif // __MYGUI_LAYOUT_MANAGER_H__

333
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_List.h vendored
View file

@ -1,333 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LIST_H__
#define __MYGUI_LIST_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
namespace MyGUI
{
typedef delegates::CDelegate2<List*, size_t> EventHandle_ListPtrSizeT;
class MYGUI_EXPORT List :
public Widget
{
MYGUI_RTTI_DERIVED( List )
public:
List();
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of items
size_t getItemCount() const { return mItemsInfo.size(); }
//! Insert an item into a array at a specified position
void insertItemAt(size_t _index, const UString& _name, Any _data = Any::Null);
//! Add an item to the end of a array
void addItem(const UString& _name, Any _data = Any::Null) { insertItemAt(ITEM_NONE, _name, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove all items
void removeAllItems();
//! Swap items at a specified positions
void swapItemsAt(size_t _index1, size_t _index2);
//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
size_t findItemIndexWith(const UString& _name);
//------------------------------------------------------------------------------//
// манипуляции выделениями
/** Get index of selected item (ITEM_NONE if none selected) */
size_t getIndexSelected() { return mIndexSelect; }
/** Select specified _index */
void setIndexSelected(size_t _index);
/** Clear item selection */
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data);
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "List::getItemDataAt");
return mItemsInfo[_index].second.castType<ValueType>(_throw);
}
//------------------------------------------------------------------------------//
// манипуляции отображением
//! Replace an item name at a specified position
void setItemNameAt(size_t _index, const UString& _name);
//! Get item name from specified position
const UString& getItemNameAt(size_t _index);
//------------------------------------------------------------------------------//
// манипуляции выдимостью
//! Move all elements so specified becomes visible
void beginToItemAt(size_t _index);
//! Move all elements so first becomes visible
void beginToItemFirst() { if (getItemCount()) beginToItemAt(0); }
//! Move all elements so last becomes visible
void beginToItemLast() { if (getItemCount()) beginToItemAt(getItemCount() - 1); }
//! Move all elements so selected becomes visible
void beginToItemSelected() { if (getIndexSelected() != ITEM_NONE) beginToItemAt(getIndexSelected()); }
//------------------------------------------------------------------------------//
// видим ли мы элемент, полностью или нет
/** Return true if item visible
@param
_index of item
@param
_fill false: function return true when whole item is visible
true: function return true when at least part of item is visible
*/
bool isItemVisibleAt(size_t _index, bool _fill = true);
//! Same as List::isItemVisible for selected item
bool isItemSelectedVisible(bool _fill = true) { return isItemVisibleAt(mIndexSelect, _fill); }
//! Set scroll visible when it needed
void setScrollVisible(bool _visible);
//! Set scroll position
void setScrollPosition(size_t _position);
//------------------------------------------------------------------------------------//
//! @copydoc Widget::setPosition(const IntPoint& _value)
virtual void setPosition(const IntPoint& _value);
//! @copydoc Widget::setSize(const IntSize& _value)
virtual void setSize(const IntSize& _value);
//! @copydoc Widget::setCoord(const IntCoord& _value)
virtual void setCoord(const IntCoord& _value);
/** @copydoc Widget::setPosition(int _left, int _top) */
void setPosition(int _left, int _top) { setPosition(IntPoint(_left, _top)); }
/** @copydoc Widget::setSize(int _width, int _height) */
void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
// возвращает максимальную высоту вмещающую все строки и родительский бордюр
//! Return optimal height to fit all items in List
int getOptimalHeight();
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*event:*/
/** Event : Enter pressed or double click.\n
signature : void method(MyGUI::List* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of selected item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ListPtrSizeT> eventListSelectAccept;
/** Event : Selected item position changed.\n
signature : void method(MyGUI::List* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of new item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ListPtrSizeT> eventListChangePosition;
/** Event : Item was selected by mouse.\n
signature : void method(MyGUI::List* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of selected item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ListPtrSizeT> eventListMouseItemActivate;
/** Event : Mouse is over item.\n
signature : void method(MyGUI::List* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of focused item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ListPtrSizeT> eventListMouseItemFocus;
/** Event : Position of scroll changed.\n
signature : void method(MyGUI::List* _sender, size_t _position)\n
@param _sender widget that called this event
@param _position of scroll
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_ListPtrSizeT> eventListChangeScroll;
/*internal:*/
// дебажная проверка на правильность выравнивания списка
void _checkAlign();
// вспомогательные методы для составных списков
void _setItemFocus(size_t _position, bool _focus);
void _sendEventChangeScroll(size_t _position);
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void Widget::setCoord(const IntCoord& _coord)")
void setPosition(const IntCoord& _coord) { setCoord(_coord); }
MYGUI_OBSOLETE("use : void Widget::setCoord(int _left, int _top, int _width, int _height)")
void setPosition(int _left, int _top, int _width, int _height) { setCoord(_left, _top, _width, _height); }
MYGUI_OBSOLETE("use : size_t List::getIndexSelected()")
size_t getItemIndexSelected() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void List::setIndexSelected(size_t _index)")
void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void List::clearIndexSelected()")
void clearItemSelected() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void List::insertItemAt(size_t _index, const UString& _name)")
void insertItem(size_t _index, const UString& _item) { insertItemAt(_index, _item); }
MYGUI_OBSOLETE("use : void List::setItemNameAt(size_t _index, const UString& _name)")
void setItem(size_t _index, const UString& _item) { setItemNameAt(_index, _item); }
MYGUI_OBSOLETE("use : const UString& List::getItemNameAt(size_t _index)")
const UString& getItem(size_t _index) { return getItemNameAt(_index); }
MYGUI_OBSOLETE("use : void List::removeItemAt(size_t _index)")
void deleteItem(size_t _index) { removeItemAt(_index); }
MYGUI_OBSOLETE("use : void List::removeAllItems()")
void deleteAllItems() { removeAllItems(); }
MYGUI_OBSOLETE("use : size_t List::findItemIndexWith(const UString& _name)")
size_t findItem(const UString& _item) { return findItemIndexWith(_item); }
MYGUI_OBSOLETE("use : size_t List::getIndexSelected()")
size_t getItemSelect() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void List::clearIndexSelected()")
void resetItemSelect() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void List::setIndexSelected(size_t _index)")
void setItemSelect(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void List::beginToItemAt(size_t _index)")
void beginToIndex(size_t _index) { beginToItemAt(_index); }
MYGUI_OBSOLETE("use : void List::beginToItemFirst()")
void beginToStart() { beginToItemFirst(); }
MYGUI_OBSOLETE("use : void List::beginToItemLast()")
void beginToEnd() { beginToItemLast(); }
MYGUI_OBSOLETE("use : void List::beginToItemSelected()")
void beginToSelect() { beginToItemSelected(); }
MYGUI_OBSOLETE("use : bool List::isItemVisibleAt(size_t _index, bool _fill)")
bool isItemVisible(size_t _index, bool _fill = true) { return isItemVisibleAt(_index, _fill); }
MYGUI_OBSOLETE("use : bool List::isItemSelectedVisible(bool _fill)")
bool isItemSelectVisible(bool _fill = true) { return isItemSelectedVisible(_fill); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~List();
void baseChangeWidgetSkin(ResourceSkin* _info);
void onMouseWheel(int _rel);
void onKeyLostFocus(Widget* _new);
void onKeySetFocus(Widget* _old);
void onKeyButtonPressed(KeyCode _key, Char _char);
void notifyScrollChangePosition(VScroll* _sender, size_t _rel);
void notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyMouseDoubleClick(Widget* _sender);
void notifyMouseWheel(Widget* _sender, int _rel);
void notifyMouseSetFocus(Widget* _sender, Widget* _old);
void notifyMouseLostFocus(Widget* _sender, Widget* _new);
void updateScroll();
void updateLine(bool _reset = false);
void _setScrollView(size_t _position);
// перерисовывает от индекса до низа
void _redrawItemRange(size_t _start = 0);
// перерисовывает индекс
void _redrawItem(size_t _index);
// ищет и выделяет елемент
void _selectIndex(size_t _index, bool _select);
void _updateState() { setState(mIsFocus ? "pushed" : "normal"); }
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void _checkMapping(const std::string& _owner);
Widget* _getClientWidget();
const Widget* _getClientWidget() const;
private:
std::string mSkinLine;
VScroll* mWidgetScroll;
// наши дети в строках
VectorWidgetPtr mWidgetLines;
int mHeightLine; // высота одной строки
int mTopIndex; // индекс самого верхнего элемента
int mOffsetTop; // текущее смещение
int mRangeIndex; // размерность скрола
size_t mLastRedrawLine; // последняя перерисованная линия
size_t mIndexSelect; // текущий выделенный элемент или ITEM_NONE
size_t mLineActive; // текущий виджет над которым мыша
typedef std::pair<UString, Any> PairItem;
typedef std::vector<PairItem> VectorItemInfo;
VectorItemInfo mItemsInfo;
// имеем ли мы фокус ввода
bool mIsFocus;
bool mNeedVisibleScroll;
IntSize mOldSize;
};
} // namespace MyGUI
#endif // __MYGUI_LIST_H__

147
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ListBox.h vendored
View file

@ -1,147 +0,0 @@
/*!
@file
@author Albert Semenov
@date 04/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LIST_BOX_H__
#define __MYGUI_LIST_BOX_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_ListCtrl.h"
namespace MyGUI
{
class MYGUI_EXPORT ListBox :
public ListCtrl
{
MYGUI_RTTI_DERIVED( ListBox )
public:
ListBox();
//------------------------------------------------------------------------------//
// ìàíèïóëÿöèè àéòåìàìè
//! Get number of items
size_t getItemCount() const { return mItemsInfo.size(); }
//! Insert an item into a array at a specified position
void insertItemAt(size_t _index, const UString& _name, Any _data = Any::Null);
//! Add an item to the end of a array
void addItem(const UString& _name, Any _data = Any::Null) { insertItemAt(ITEM_NONE, _name, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove all items
void removeAllItems();
//! Swap items at a specified positions
void swapItemsAt(size_t _index1, size_t _index2);
//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
size_t findItemIndexWith(const UString& _name);
//------------------------------------------------------------------------------//
// ìàíèïóëÿöèè âûäåëåíèÿìè
/** Get index of selected item (ITEM_NONE if none selected) */
size_t getIndexSelected() { return Base::getIndexSelected(); }
/** Select specified _index */
void setIndexSelected(size_t _index) { Base::setIndexSelected(_index); }
/** Clear item selection */
void clearIndexSelected() { Base::clearIndexSelected(); }
//------------------------------------------------------------------------------//
// ìàíèïóëÿöèè äàííûìè
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data) { Base::setItemDataAt(_index, _data); }
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { Base::clearItemDataAt(_index); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
return Base::getItemDataAt<ValueType>(_index, _throw);
}
//------------------------------------------------------------------------------//
// ìàíèïóëÿöèè îòîáðàæåíèåì
//! Replace an item name at a specified position
void setItemNameAt(size_t _index, const UString& _name);
//! Get item name from specified position
const UString& getItemNameAt(size_t _index);
//------------------------------------------------------------------------------//
// ìàíèïóëÿöèè âûäèìîñòüþ
//! Move all elements so specified becomes visible
void beginToItemAt(size_t _index);
//! Move all elements so first becomes visible
void beginToItemFirst() { if (getItemCount()) beginToItemAt(0); }
//! Move all elements so last becomes visible
void beginToItemLast() { if (getItemCount()) beginToItemAt(getItemCount() - 1); }
//! Move all elements so selected becomes visible
void beginToItemSelected() { if (getIndexSelected() != ITEM_NONE) beginToItemAt(getIndexSelected()); }
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~ListBox();
void baseChangeWidgetSkin(ResourceSkin* _info);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void notifyCreateWidgetItem(MyGUI::ListCtrl* _sender, MyGUI::Widget* _item);
void notifyDrawItem(MyGUI::ListCtrl* _sender, MyGUI::Widget* _item, const MyGUI::IBDrawItemInfo& _info, MyGUI::IntCoord& _coord);
private:
std::string mSkinLine;
int mHeightLine;
typedef std::vector<UString> VectorUTFString;
VectorUTFString mItemsInfo;
};
} // namespace MyGUI
#endif // __MYGUI_LIST_BOX_H__

301
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ListCtrl.h vendored
View file

@ -1,301 +0,0 @@
/*!
@file
@author Albert Semenov
@date 04/2009
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LIST_CTRL_H__
#define __MYGUI_LIST_CTRL_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_DDContainer.h"
#include "MyGUI_IBItemInfo.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_ScrollViewBase.h"
namespace MyGUI
{
typedef delegates::CDelegate2<ListCtrl*, Widget*> EventHandle_ListCtrlPtrWidgetPtr;
typedef delegates::CDelegate4<ListCtrl*, Widget*, const IBDrawItemInfo &, IntCoord&> EventHandle_ListCtrlPtrWidgetPtrCIBCellDrawInfoRef;
typedef delegates::CDelegate2<ListCtrl*, size_t> EventHandle_ListCtrlPtrSizeT;
typedef delegates::CDelegate2<ListCtrl*, const IBNotifyItemData &> EventHandle_ListCtrlPtrCIBNotifyCellDataRef;
class MYGUI_EXPORT ListCtrl :
public DDContainer,
protected ScrollViewBase
{
MYGUI_RTTI_DERIVED( ListCtrl )
public:
ListCtrl();
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of items
size_t getItemCount() const { return mItemsInfo.size(); }
//! Insert an item into a array at a specified position
void insertItemAt(size_t _index, Any _data = Any::Null);
//! Add an item to the end of a array
void addItem(Any _data = Any::Null) { insertItemAt(ITEM_NONE, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove all items
void removeAllItems();
//! Redraw at a specified position
void redrawItemAt(size_t _index);
//! Redraw all items
void redrawAllItems() { _updateAllVisible(ITEM_NONE, true, true); }
//------------------------------------------------------------------------------//
// манипуляции выделениями
//! Get index of selected item (ITEM_NONE if none selected)
size_t getIndexSelected() { return mIndexSelect; }
//! Select specified _index
void setIndexSelected(size_t _index);
//! Clear item selection
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data);
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "ListCtrl::getItemDataAt");
return mItemsInfo[_index].data.castType<ValueType>(_throw);
}
/** Get item index by item Widget pointer */
size_t getIndexByWidget(Widget* _widget);
/** Get widget created for drop */
Widget* getWidgetDrag() { return mItemDrag; }
/** Get item Widget pointer by item index if it is visible
@note returned widget can be deleted, so this pointer
is valid only at time when you got it and can be invalid
next frame
*/
Widget* getWidgetByIndex(size_t _index);
/** Interrupt drag as if widget was dropped into empty space */
void resetDrag();
//! @copydoc Widget::setPosition(const IntPoint& _value)
virtual void setPosition(const IntPoint& _value);
//! @copydoc Widget::setSize(const IntSize& _value)
virtual void setSize(const IntSize& _value);
//! @copydoc Widget::setCoord(const IntCoord& _value)
virtual void setCoord(const IntCoord& _value);
/** @copydoc Widget::setPosition(int _left, int _top) */
void setPosition(int _left, int _top) { setPosition(IntPoint(_left, _top)); }
/** @copydoc Widget::setSize(int _width, int _height) */
void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
/*event:*/
/** Event : request for creating new item
signature : void method(MyGUI::ListCtrl* _sender, MyGUI::Widget* _item)
@param _sender widget that called this event
@param _item widget item pointer
*/
EventHandle_ListCtrlPtrWidgetPtr requestCreateWidgetItem;
/** Event : request for item redraw
signature : void method(MyGUI::ListCtrl* _sender, MyGUI::Widget* _item, const MyGUI::IBDrawItemInfo& _info)
@param _sender widget that called this event
@param _item widget item pointer
@param _info item info
*/
EventHandle_ListCtrlPtrWidgetPtrCIBCellDrawInfoRef requestDrawItem;
/** Event : doubleclick or enter pressed on item
signature : void method(MyGUI::ListCtrl* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ListCtrlPtrSizeT eventSelectItemAccept;
/** Event : position of selected item was changed
signature : void method(MyGUI::ListCtrl* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ListCtrlPtrSizeT eventChangeItemPosition;
/** Event : click on item
signature : void method(MyGUI::ListCtrl* _sender, size_t _index)
@param _sender widget that called this event
@param _index item index
*/
EventHandle_ListCtrlPtrSizeT eventMouseItemActivate;
/** Event : notify about event in item widget
signature : void method(MyGUI::ListCtrl* _sender, const MyGUI::IBNotifyItemData& _info)
@param _sender widget that called this event
@param _info info about item notify
*/
EventHandle_ListCtrlPtrCIBNotifyCellDataRef eventNotifyItem;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~ListCtrl();
struct ItemDataInfo
{
ItemDataInfo(Any _data) :
data(_data) { }
Any data;
IntSize size;
};
typedef std::vector<ItemDataInfo> VectorItemInfo;
void baseChangeWidgetSkin(ResourceSkin* _info);
virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
virtual void onMouseDrag(int _left, int _top);
virtual void onMouseWheel(int _rel);
virtual void onKeyLostFocus(Widget* _new);
virtual void onKeySetFocus(Widget* _old);
void notifyKeyButtonPressed(Widget* _sender, KeyCode _key, Char _char);
void notifyKeyButtonReleased(Widget* _sender, KeyCode _key);
void notifyScrollChangePosition(VScroll* _sender, size_t _index);
void notifyMouseWheel(Widget* _sender, int _rel);
void notifyRootMouseChangeFocus(Widget* _sender, bool _focus);
void notifyMouseButtonDoubleClick(Widget* _sender);
void _requestGetContainer(Widget* _sender, Widget*& _container, size_t& _index);
void notifyMouseDrag(Widget* _sender, int _left, int _top);
void notifyMouseButtonPressed(Widget* _sender, int _left, int _top, MouseButton _id);
void notifyMouseButtonReleased(Widget* _sender, int _left, int _top, MouseButton _id);
virtual void removeDropItems();
virtual void updateDropItems();
virtual void updateDropItemsState(const DDWidgetState& _state);
// Обновляет данные о айтемах, при изменении размеров
void updateMetrics();
// просто обновляет все виджеты что видны
void _updateAllVisible(size_t _index, bool _needUpdateContetntSize, bool _update);
void updateFromResize();
// возвращает следующий айтем, если нет его, то создается
// запросы только последовательно
Widget* getItemWidget(size_t _index);
void _setContainerItemInfo(size_t _index, bool _set, bool _accept);
// сбрасываем старую подсветку
void resetCurrentActiveItem();
// ищет и устанавливает подсвеченный айтем
void findCurrentActiveItem();
// запрашиваем у конейтера айтем по позиции мыши
virtual size_t _getContainerIndex(const IntPoint& _point);
// сбрасывает зависимости, при любом колличественном изменении
virtual void _resetContainer(bool _update);
void _setScrollViewPage(size_t _size) { mScrollViewPage = _size; }
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
size_t calcIndexByWidget(Widget* _widget) { return *_widget->_getInternalData<size_t>(); }
virtual IntSize getContentSize();
virtual IntPoint getContentPosition();
virtual IntSize getViewSize() const;
virtual void eraseContent();
virtual size_t getHScrollPage();
virtual size_t getVScrollPage();
virtual Align getContentAlign();
virtual void setContentPosition(const IntPoint& _point);
Widget* _getClientWidget();
const Widget* _getClientWidget() const;
private:
// наши дети в строках
VectorWidgetPtr mVectorItems;
// размерность скролла в пикселях
IntSize mContentSize;
// позиция скролла п пикселях
IntPoint mContentPosition;
// текущий выделенный элемент или ITEM_NONE
size_t mIndexSelect;
// подсвеченный элемент или ITEM_NONE
size_t mIndexActive;
// индекс со свойством приема или ITEM_NONE
size_t mIndexAccept;
// индекс со свойством отказа или ITEM_NONE
size_t mIndexRefuse;
// имеем ли мы фокус ввода
bool mIsFocus;
// структура данных об айтеме
VectorItemInfo mItemsInfo;
Widget* mItemDrag;
IntPoint mPointDragOffset;
std::string mDragLayer;
size_t mScrollViewPage;
};
} // namespace MyGUI
#endif // __MYGUI_LIST_CTRL_H__

88
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LogManager.h vendored
View file

@ -1,88 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LOG_MANAGER_H__
#define __MYGUI_LOG_MANAGER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_LogStream.h"
#include <map>
namespace MyGUI
{
#define MYGUI_LOGGING(section, level, text) \
MyGUI::LogManager::out(section, MyGUI::LogManager::level) \
<< text \
<< MyGUI::LogManager::info(__FILE__, __LINE__) \
<< MyGUI::LogManager::end()
class MYGUI_EXPORT LogManager
{
public:
enum LogLevel
{
Info,
Warning,
Error,
Critical,
EndLogLevel
};
public:
static void shutdown();
static void initialise();
static void registerSection(const std::string& _section, const std::string& _file);
static void unregisterSection(const std::string& _section);
static LogStream& out(const std::string& _section, LogLevel _level);
static const std::string& info(const char * _file /* = __FILE__*/, int _line /* = __LINE__*/);
static const LogStream::LogStreamEnd& end();
// set logging enabled on std output device
static void setSTDOutputEnabled(bool _enable);
static bool getSTDOutputEnabled();
private:
LogManager();
~LogManager();
public:
static const std::string General;
static const std::string separator;
static LogStream::LogStreamEnd endl;
static const std::string LevelsName[EndLogLevel];
private:
static LogManager * msInstance;
typedef std::map<std::string, LogStream*> MapLogStream;
MapLogStream mMapSectionFileName;
bool mSTDOut;
};
} // namespace MyGUI
#endif // __MYGUI_LOG_MANAGER_H__

74
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_LogStream.h vendored
View file

@ -1,74 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_LOG_STREAM_H__
#define __MYGUI_LOG_STREAM_H__
#include "MyGUI_Prerequest.h"
#include <fstream>
#include <iostream>
#include <string>
namespace MyGUI
{
class MYGUI_EXPORT LogStream
{
friend class LogManager;
public:
struct LogStreamEnd { };
public:
LogStream& operator<<(const LogStreamEnd& _endl);
template <typename T>
inline LogStream& operator<<(T _value)
{
if (getSTDOutputEnabled()) std::cout << _value;
if (mStream.is_open()) mStream << _value;
return *this;
}
const std::string& getFileName() const { return mFileName; }
private:
LogStream();
~LogStream();
LogStream(const std::string& _file);
void start(const std::string& _section, const std::string& _level);
bool getSTDOutputEnabled();
void lock() const { }
void release() const { }
private:
std::ofstream mStream;
std::string mFileName;
};
} // namespace MyGUI
#endif // __MYGUI_LOG_STREAM_H__

41
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Macros.h vendored
View file

@ -1,41 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MACROS_H__
#define __MYGUI_MACROS_H__
namespace MyGUI
{
const size_t ITEM_NONE = ~(size_t)0;
const int DEFAULT ((int)-1);
const float ALPHA_MAX = 1.0f;
const float ALPHA_MIN = 0.0f;
//FIXME çàìåíèòü íà øàáëîíû
#define MYGUI_FLAG_NONE 0
#define MYGUI_FLAG(num) (1<<(num))
} // namespace MyGUI
#endif // __MYGUI_MACROS_H__

47
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MainSkin.h vendored
View file

@ -1,47 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MAIN_SKIN_H__
#define __MYGUI_MAIN_SKIN_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_SubSkin.h"
namespace MyGUI
{
class MYGUI_EXPORT MainSkin : public SubSkin
{
MYGUI_RTTI_DERIVED( MainSkin )
public:
MainSkin();
virtual ~MainSkin();
/*internal:*/
void _setAlign(const IntSize& _oldsize, bool _update);
void _setAlign(const IntCoord& _oldsize, bool _update) { SubSkin::_setAlign(_oldsize, _update); }
};
} // namespace MyGUI
#endif // __MYGUI_SUB_SKIN_H__

61
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MaskPickInfo.h vendored
View file

@ -1,61 +0,0 @@
/*!
@file
@author Albert Semenov
@date 12/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MASK_PICK_INFO_H__
#define __MYGUI_MASK_PICK_INFO_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
namespace MyGUI
{
class MYGUI_EXPORT MaskPickInfo
{
public:
MaskPickInfo() : width(0), height(0) { }
bool load(const std::string& _file);
bool pick(const IntPoint& _point, const IntCoord& _coord) const
{
if ((0 == _coord.width) || (0 == _coord.height)) return false;
int x = ((_point.left * width)-1) / _coord.width;
int y = ((_point.top * height)-1) / _coord.height;
return 0 != data[(size_t)(y * width + x)];
}
bool empty() const
{
return data.empty();
}
private:
std::vector<uint8> data;
int width, height;
};
} // namespace MyGUI
#endif // __MYGUI_MASK_PICK_INFO_H__

56
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MenuBar.h vendored
View file

@ -1,56 +0,0 @@
/*!
@file
@author Albert Semenov
@date 05/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MENU_BAR_H__
#define __MYGUI_MENU_BAR_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_MenuCtrl.h"
namespace MyGUI
{
class MYGUI_EXPORT MenuBar :
public MenuCtrl
{
MYGUI_RTTI_DERIVED( MenuBar )
public:
MenuBar();
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~MenuBar();
void baseChangeWidgetSkin(ResourceSkin* _info);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
};
} // namespace MyGUI
#endif // __MYGUI_MENU_BAR_H__

371
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MenuCtrl.h vendored
View file

@ -1,371 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MENU_CTRL_H__
#define __MYGUI_MENU_CTRL_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_MenuItemType.h"
#include "MyGUI_Widget.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_MenuItemType.h"
#include "MyGUI_ControllerFadeAlpha.h"
namespace MyGUI
{
typedef delegates::CDelegate2<MenuCtrl*, MenuItem*> EventHandle_MenuCtrlPtrMenuItemPtr;
typedef delegates::CDelegate1<MenuCtrl*> EventHandle_MenuCtrlPtr;
class MYGUI_EXPORT MenuCtrl :
public Widget
{
MYGUI_RTTI_DERIVED( MenuCtrl )
public:
MenuCtrl();
enum ItemImage
{
ItemImageNone,
ItemImagePopup
};
struct ItemInfo
{
ItemInfo(MenuItem* _item, const UString& _name, MenuItemType _type, MenuCtrl* _submenu, const std::string& _id, Any _data) :
item(_item),
name(_name),
type(_type),
submenu(_submenu),
id(_id),
data(_data),
width(0)
{
}
/** Item */
MenuItem* item;
/** Item name*/
UString name;
/** Widget have separator after item */
MenuItemType type;
/** Sub menu (or nullptr if no submenu) */
MenuCtrl* submenu;
/** Item id*/
std::string id;
/** User data */
Any data;
/** Item width */
int width;
};
typedef std::vector<ItemInfo> VectorMenuItemInfo;
public:
/** @copydoc Widget::setVisible */
virtual void setVisible(bool _value);
/** Hide or show Menu smooth */
void setVisibleSmooth(bool _value);
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of items
size_t getItemCount() const { return mItemsInfo.size(); }
//! Insert an item into a array at a specified position
MenuItem* insertItemAt(size_t _index, const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
//! Insert an item into a array
MenuItem* insertItem(MenuItem* _to, const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
//! Add an item to the end of a array
MenuItem* addItem(const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
//! Remove item at a specified position
void removeItemAt(size_t _index);
//! Remove item
void removeItem(MenuItem* _item);
//! Remove all items
void removeAllItems();
//! Get item from specified position
MenuItem* getItemAt(size_t _index);
//! Get item index
size_t getItemIndex(MenuItem* _item);
//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
size_t findItemIndex(MenuItem* _item);
//! Search item, returns the item of the first occurrence in array or nullptr if item not found
MenuItem* findItemWith(const UString& _name);
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data);
//! Replace an item data
void setItemData(MenuItem* _item, Any _data) { setItemDataAt(getItemIndex(_item), _data); }
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Clear an item data
void clearItemData(MenuItem* _item) { clearItemDataAt(getItemIndex(_item)); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuCtrl::getItemDataAt");
return mItemsInfo[_index].data.castType<ValueType>(_throw);
}
//! Get item data
template <typename ValueType>
ValueType * getItemData(MenuItem* _item, bool _throw = true)
{
return getItemDataAt<ValueType>(getItemIndex(_item), _throw);
}
//! Replace an item id at a specified position
void setItemIdAt(size_t _index, const std::string& _id);
//! Replace an item id
void setItemId(MenuItem* _item, const std::string& _id) { setItemIdAt(getItemIndex(_item), _id); }
//! Get item id from specified position
const std::string& getItemIdAt(size_t _index);
//! Get item id
const std::string& getItemId(MenuItem* _item) { return getItemIdAt(getItemIndex(_item)); }
/** Get item by id */
MenuItem* getItemById(const std::string& _id);
/** Get item index by id */
size_t getItemIndexById(const std::string& _id);
//------------------------------------------------------------------------------//
// манипуляции отображением
//! Replace an item name at a specified position
void setItemNameAt(size_t _index, const UString& _name);
//! Replace an item name
void setItemName(MenuItem* _item, const UString& _name) { setItemNameAt(getItemIndex(_item), _name); }
//! Get item from specified position
const UString& getItemNameAt(size_t _index);
//! Get item from specified position
const UString& getItemName(MenuItem* _item) { return getItemNameAt(getItemIndex(_item)); }
//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
size_t findItemIndexWith(const UString& _name);
/** Show or hide item (submenu) at a specified position */
void setItemChildVisibleAt(size_t _index, bool _visible);
/** Show or hide item (submenu) */
void setItemChildVisible(MenuItem* _item, bool _visible) { setItemChildVisibleAt(getItemIndex(_item), _visible); }
//------------------------------------------------------------------------------//
// остальные манипуляции
/** Create specific type child item (submenu) for item by index */
template <typename Type>
Type * createItemChildTAt(size_t _index)
{
return static_cast<Type*>(createItemChildByType(_index, Type::getClassTypeName()));
}
/** Create specific type child item (submenu) for item */
template <typename Type>
Type * createItemChildT(MenuItem* _item) { return createItemChildTAt<Type>(getItemIndex(_item)); }
/** Get child item (submenu) from item by index */
MenuCtrl* getItemChildAt(size_t _index);
/** Get child item (submenu) from item */
MenuCtrl* getItemChild(MenuItem* _item) { return getItemChildAt(getItemIndex(_item)); }
/** Create child item (submenu) for item by index */
MenuCtrl* createItemChildAt(size_t _index) { return createItemChildTAt<MenuCtrl>(_index); }
/** Create child item (submenu) for item */
MenuCtrl* createItemChild(MenuItem* _item) { return createItemChildAt(getItemIndex(_item)); }
/** Remove child item (submenu) for item by index */
void removeItemChildAt(size_t _index);
/** Remove child item (submenu) for item */
void removeItemChild(MenuItem* _item) { removeItemChildAt(getItemIndex(_item)); }
/** Get item type (see MenuItemType) from item by index */
MenuItemType getItemTypeAt(size_t _index);
/** Get item type (see MenuItemType) from item */
MenuItemType getItemType(MenuItem* _item) { return getItemTypeAt(getItemIndex(_item)); }
/** Set item type (see MenuItemType) from item by index */
void setItemTypeAt(size_t _index, MenuItemType _type);
/** Set item type (see MenuItemType) from item */
void setItemType(MenuItem* _item, MenuItemType _type) { setItemTypeAt(getItemIndex(_item), _type); }
/** Set mode when clicking on item with submenu generate eventMenuCtrlAccept and closes menu */
void setPopupAccept(bool _value) { mPopupAccept = _value; }
/** Get mode when clicking on item with submenu generate eventMenuCtrlAccept and closes menu */
bool getPopupAccept() { return mPopupAccept; }
/** Get parent menu item or nullptr if no item */
MenuItem* getMenuItemParent() { return mOwner; }
/*event:*/
/** Event : Enter pressed or mouse clicked.\n
signature : void method(MyGUI::MenuCtrl* _sender, MyGUI::MenuItem* _item)\n
@param _sender widget that called this event
@param _item Selected item
*/
EventHandle_MenuCtrlPtrMenuItemPtr eventMenuCtrlAccept;
/** Event : Menu was closed by select or focus change.\n
signature : void method(MyGUI::MenuCtrl* _sender)\n
@param _sender widget that called this event
*/
EventHandle_MenuCtrlPtr eventMenuCtrlClose;
/*internal:*/
void _notifyDeleteItem(MenuItem* _item);
void _notifyUpdateName(MenuItem* _item);
void _wrapItemChild(MenuItem* _item, MenuCtrl* _widget);
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void Widget::setVisible(bool _value)")
void showMenu() { setVisible(true); }
MYGUI_OBSOLETE("use : void Widget::setVisible(bool _value)")
void hideMenu() { setVisible(false); }
MYGUI_OBSOLETE("use : bool Widget::isVisible()")
bool isShowMenu() { return isVisible(); }
MYGUI_OBSOLETE("use : void setItemChildVisibleAt(size_t _index, bool _visible)")
void showItemChildAt(size_t _index) { setItemChildVisibleAt(_index, true); }
MYGUI_OBSOLETE("use : void setItemChildVisible(MenuItem* _item, bool _visible)")
void showItemChild(MenuItem* _item) { setItemChildVisible(_item, true); }
MYGUI_OBSOLETE("use : void setItemChildVisibleAt(size_t _index, bool _visible)")
void hideItemChildAt(size_t _index) { setItemChildVisibleAt(_index, false); }
MYGUI_OBSOLETE("use : void setItemChildVisible(MenuItem* _item, bool _visible)")
void hideItemChild(MenuItem* _item) { setItemChildVisible(_item, false); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~MenuCtrl();
void baseChangeWidgetSkin(ResourceSkin* _info);
// переопределяем для особого обслуживания
virtual Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name);
virtual void onKeyChangeRootFocus(bool _focus);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void notifyRootKeyChangeFocus(Widget* _sender, bool _focus);
void notifyMouseButtonClick(Widget* _sender);
void notifyMouseSetFocus(Widget* _sender, Widget* _new);
const std::string& getSkinByType(MenuItemType _type)
{
return _type == MenuItemType::Separator ? mSeparatorSkin : mSkinLine;
}
size_t getIconIndexByType(MenuItemType _type)
{
return _type == MenuItemType::Popup ? ItemImagePopup : ItemImageNone;
}
void update();
void setButtonImageIndex(Button* _button, size_t _index);
MenuItemType getItemType(bool _submenu, bool _separator)
{
if (_submenu) return MenuItemType::Popup;
else if (_separator) return MenuItemType::Separator;
return MenuItemType::Normal;
}
void notifyMenuCtrlAccept(MenuItem* _item);
Widget* createItemChildByType(size_t _index, const std::string& _type);
void _wrapItem(MenuItem* _item, size_t _index, const UString& _name, MenuItemType _type, const std::string& _id, Any _data);
ControllerFadeAlpha* createControllerFadeAlpha(float _alpha, float _coef, bool _enable);
Widget* _getClientWidget();
const Widget* _getClientWidget() const;
protected:
bool mHideByAccept;
// нужно ли выбрасывать по нажатию
bool mMenuDropMode;
bool mIsMenuDrop;
bool mHideByLostKey;
private:
VectorMenuItemInfo mItemsInfo;
int mHeightLine;
std::string mSkinLine;
int mSubmenuImageSize;
std::string mSubMenuSkin;
std::string mSubMenuLayer;
// флаг, чтобы отсеч уведомления от айтемов, при общем шутдауне виджета
bool mShutdown;
int mSeparatorHeight;
std::string mSeparatorSkin;
bool mAlignVert;
int mDistanceButton;
bool mPopupAccept;
MenuItem* mOwner;
bool mAnimateSmooth;
};
} // namespace MyGUI
#endif // __MYGUI_MENU_CTRL_H__

131
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MenuItem.h vendored
View file

@ -1,131 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MENU_ITEM_H__
#define __MYGUI_MENU_ITEM_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Button.h"
#include "MyGUI_MenuCtrl.h"
namespace MyGUI
{
class MYGUI_EXPORT MenuItem :
public Button
{
MYGUI_RTTI_DERIVED( MenuItem )
public:
MenuItem();
/** @copydoc Widget::setCaption(const UString& _value) */
virtual void setCaption(const UString& _value);
//! Replace an item name
void setItemName(const UString& _value);
//! Get item name
const UString& getItemName();
//! Replace an item name
void setItemData(Any _value);
//! Get item data
template <typename ValueType>
ValueType* getItemData(bool _throw = true)
{
return mOwner->getItemData<ValueType>(this, _throw);
}
//! Remove item
void removeItem();
//! Replace an item id at a specified position
void setItemId(const std::string& _value);
//! Get item id from specified position
const std::string& getItemId();
//! Get item index
size_t getItemIndex();
/** Create child item (submenu), MenuItem can have only one child */
MenuCtrl* createItemChild();
/** Create specific type child item (submenu), MenuItem can have only one child */
template <typename Type>
Type * createItemChildT()
{
return mOwner->createItemChildT<Type>(this);
}
/** Set item type (see MenuItemType) */
void setItemType(MenuItemType _value);
/** Get item type (see MenuItemType) */
MenuItemType getItemType();
/** Hide or show child item (submenu) */
void setItemChildVisible(bool _value);
/** Get parent MenuCtrl */
MenuCtrl* getMenuCtrlParent() { return mOwner; }
/** Get child item (submenu) */
MenuCtrl* getItemChild();
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : void setItemChildVisible(bool _visible)")
void showItemChild() { setItemChildVisible(true); }
MYGUI_OBSOLETE("use : void setItemChildVisible(bool _visible)")
void hideItemChild() { setItemChildVisible(false); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~MenuItem();
virtual Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name);
virtual void baseChangeWidgetSkin(ResourceSkin* _info);
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
private:
virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
private:
MenuCtrl* mOwner;
};
} // namespace MyGUI
#endif // __MYGUI_MENU_ITEM_H__

89
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MenuItemType.h vendored
View file

@ -1,89 +0,0 @@
/*!
@file
@author Albert Semenov
@date 11/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MENU_ITEM_TYPE_H__
#define __MYGUI_MENU_ITEM_TYPE_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct MYGUI_EXPORT MenuItemType
{
enum Enum
{
Normal,
Popup,
Separator,
MAX
};
static MenuItemType parse(const std::string& _value)
{
MenuItemType type;
int value = 0;
while (true)
{
const char * name = type.getValueName(value);
if (strcmp(name, "") == 0 || name == _value) break;
value++;
}
type.value = MenuItemType::Enum(value);
return type;
}
MenuItemType(Enum _value = MAX) : value(_value) { }
friend bool operator == (MenuItemType const& a, MenuItemType const& b) { return a.value == b.value; }
friend bool operator != (MenuItemType const& a, MenuItemType const& b) { return a.value != b.value; }
friend std::ostream& operator << ( std::ostream& _stream, const MenuItemType& _value )
{
_stream << _value.getValueName(_value.value);
return _stream;
}
friend std::istream& operator >> ( std::istream& _stream, MenuItemType& _value )
{
std::string value;
_stream >> value;
_value = MenuItemType::parse(value);
return _stream;
}
std::string print() const { return getValueName(value); }
private:
const char * getValueName(int _index) const
{
static const char * values[MAX + 1] = { "Normal", "Popup", "Separator", "" };
return values[(_index < MAX && _index >= 0) ? _index : MAX];
}
private:
Enum value;
};
} // namespace MyGUI
#endif // __MYGUI_MENU_ITEM_TYPE_H__

155
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Message.h vendored
View file

@ -1,155 +0,0 @@
/*!
@file
@author Albert Semenov
@date 01/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MESSAGE_H__
#define __MYGUI_MESSAGE_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Window.h"
#include "MyGUI_ResourceImageSet.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_MessageStyle.h"
#include "MyGUI_ControllerFadeAlpha.h"
namespace MyGUI
{
typedef delegates::CDelegate2<Message*, MessageBoxStyle> EventHandle_MessagePtrMessageStyle;
class MYGUI_EXPORT Message :
public Window
{
MYGUI_RTTI_DERIVED( Message )
public:
Message();
/** Set message text*/
void setMessageText(const UString& _value);
/** Create button with specific name*/
MessageBoxStyle addButtonName(const UString& _name);
/** Set smooth message showing*/
void setSmoothShow(bool _value);
/** Get name of default layer for Message*/
const std::string& getDefaultLayer() { return mDefaultLayer; }
/** Set message icon*/
void setMessageIcon(MessageBoxStyle _value);
/** Set fade under message*/
void setWindowFade(bool _value);
void endMessage(MessageBoxStyle _result);
void endMessage();
/** Create button using MessageBoxStyle*/
void setMessageButton(MessageBoxStyle _value);
/** Set message style (button and icon)*/
void setMessageStyle(MessageBoxStyle _value);
void setMessageModal(bool _value);
/** Static method for creating message with one command
@param
_modal if true all other GUI elements will be blocked untill message is closed
@param
_style any combination of flags from ViewValueInfo
@param
_button1 ... _button4 specific buttons names
*/
static MyGUI::Message* createMessageBox(
const std::string& _skin,
const UString& _caption,
const UString& _message,
MessageBoxStyle _style = MessageBoxStyle::Ok | MessageBoxStyle::IconDefault,
const std::string& _layer = "",
bool _modal = true,
const std::string& _button1 = "",
const std::string& _button2 = "",
const std::string& _button3 = "",
const std::string& _button4 = "");
/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
virtual void setProperty(const std::string& _key, const std::string& _value);
/*event:*/
/** Event : button on message window pressed.\n
signature : void method(MyGUI::Message* _sender, MyGUI::MessageBoxStyle _result)\n
@param _sender widget that called this event
@param _result - id of pressed button
*/
EventHandle_MessagePtrMessageStyle eventMessageBoxResult;
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
protected:
virtual ~Message();
void baseChangeWidgetSkin(ResourceSkin* _info);
void updateSize();
void notifyButtonClick(MyGUI::Widget* _sender);
void clearButton();
void onKeyButtonPressed(KeyCode _key, Char _char);
void _destroyMessage(MessageBoxStyle _result);
UString getButtonName(MessageBoxStyle _style);
const char * getIconName(size_t _index);
const char * getButtonName(size_t _index);
const char * getButtonTag(size_t _index);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
ControllerFadeAlpha* createControllerFadeAlpha(float _alpha, float _coef, bool _enable);
private:
IntSize mOffsetText;
Widget* mWidgetText;
std::string mButtonSkin, mButtonType;
IntSize mButtonSize, mButtonOffset;
VectorWidgetPtr mVectorButton;
MessageBoxStyle mInfoOk;
MessageBoxStyle mInfoCancel;
bool mSmoothShow;
std::string mDefaultLayer, mDefaultCaption;
std::string mFadeSkin, mFadeLayer;
Widget* mWidgetFade;
StaticImage* mIcon;
int mLeftOffset1;
int mLeftOffset2;
};
} // namespace MyGUI
#endif // __MYGUI_MESSAGE_H__

224
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MessageStyle.h vendored
View file

@ -1,224 +0,0 @@
/*!
@file
@author Albert Semenov
@date 08/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MESSAGE_BOX_STYLE_H__
#define __MYGUI_MESSAGE_BOX_STYLE_H__
#include "MyGUI_Prerequest.h"
namespace MyGUI
{
struct MYGUI_EXPORT MessageBoxStyle
{
enum Enum
{
None = MYGUI_FLAG_NONE,
Ok = MYGUI_FLAG(0),
Yes = MYGUI_FLAG(1),
No = MYGUI_FLAG(2),
Abort = MYGUI_FLAG(3),
Retry = MYGUI_FLAG(4),
Ignore = MYGUI_FLAG(5),
Cancel = MYGUI_FLAG(6),
Try = MYGUI_FLAG(7),
Continue = MYGUI_FLAG(8),
_IndexUserButton1 = 9, // èíäåêñ ïåðâîé êíîïêè þçåðà
Button1 = MYGUI_FLAG(_IndexUserButton1),
Button2 = MYGUI_FLAG(_IndexUserButton1 + 1),
Button3 = MYGUI_FLAG(_IndexUserButton1 + 2),
Button4 = MYGUI_FLAG(_IndexUserButton1 + 3),
_CountUserButtons = 4, // êîëëè÷åñòâî êíîïîê þçåðà
_IndexIcon1 = _IndexUserButton1 + _CountUserButtons, // èíäåêñ ïåðâîé èêîíêè
IconDefault = MYGUI_FLAG(_IndexIcon1),
IconInfo = MYGUI_FLAG(_IndexIcon1),
IconQuest = MYGUI_FLAG(_IndexIcon1 + 1),
IconError = MYGUI_FLAG(_IndexIcon1 + 2),
IconWarning = MYGUI_FLAG(_IndexIcon1 + 3),
Icon1 = MYGUI_FLAG(_IndexIcon1),
Icon2 = MYGUI_FLAG(_IndexIcon1 + 1),
Icon3 = MYGUI_FLAG(_IndexIcon1 + 2),
Icon4 = MYGUI_FLAG(_IndexIcon1 + 3),
Icon5 = MYGUI_FLAG(_IndexIcon1 + 4),
Icon6 = MYGUI_FLAG(_IndexIcon1 + 5),
Icon7 = MYGUI_FLAG(_IndexIcon1 + 6),
Icon8 = MYGUI_FLAG(_IndexIcon1 + 7)
};
MessageBoxStyle(Enum _value = None) : value(_value) { }
MessageBoxStyle& operator |= (MessageBoxStyle const& _other) { value = Enum(int(value) | int(_other.value)); return *this; }
friend MessageBoxStyle operator | (Enum const& a, Enum const& b) { return MessageBoxStyle(Enum(int(a) | int(b))); }
MessageBoxStyle operator | (Enum const& a) { return MessageBoxStyle(Enum(int(value) | int(a))); }
friend bool operator == (MessageBoxStyle const& a, MessageBoxStyle const& b) { return a.value == b.value; }
friend bool operator != (MessageBoxStyle const& a, MessageBoxStyle const& b) { return a.value != b.value; }
friend std::ostream& operator << ( std::ostream& _stream, const MessageBoxStyle& _value )
{
//_stream << _value.print();
return _stream;
}
friend std::istream& operator >> ( std::istream& _stream, MessageBoxStyle& _value )
{
std::string value;
_stream >> value;
_value = MessageBoxStyle::parse(value);
return _stream;
}
// âîçâðàùàåò èíäåêñ èêîíêè
size_t getIconIndex()
{
size_t index = 0;
int num = value >> _IndexIcon1;
while (num != 0)
{
if ((num & 1) == 1) return index;
++index;
num >>= 1;
}
return ITEM_NONE;
}
// âîçâðàùàåò èíäåêñ èêîíêè
size_t getButtonIndex()
{
size_t index = 0;
int num = value;
while (num != 0)
{
if ((num & 1) == 1) return index;
++index;
num >>= 1;
}
return ITEM_NONE;
}
// âîçâðàùàåò ñïèñîê êíîïîê
std::vector<MessageBoxStyle> getButtons()
{
std::vector<MessageBoxStyle> buttons;
size_t index = 0;
int num = value;
while (index < _IndexIcon1)
{
if ((num & 1) == 1)
{
buttons.push_back( MessageBoxStyle::Enum( MYGUI_FLAG(index) ) );
}
++index;
num >>= 1;
}
return buttons;
}
typedef std::map<std::string, int> MapAlign;
static MessageBoxStyle parse(const std::string& _value)
{
MessageBoxStyle result(MessageBoxStyle::Enum(0));
const MapAlign& map_names = result.getValueNames();
const std::vector<std::string>& vec = utility::split(_value);
for (size_t pos=0; pos<vec.size(); pos++)
{
MapAlign::const_iterator iter = map_names.find(vec[pos]);
if (iter != map_names.end())
{
result.value = Enum(int(result.value) | int(iter->second));
}
else
{
MYGUI_LOG(Warning, "Cannot parse type '" << vec[pos] << "'");
}
}
return result;
}
private:
const MapAlign& getValueNames()
{
static MapAlign map_names;
if (map_names.empty())
{
MYGUI_REGISTER_VALUE(map_names, None);
MYGUI_REGISTER_VALUE(map_names, Ok);
MYGUI_REGISTER_VALUE(map_names, Yes);
MYGUI_REGISTER_VALUE(map_names, No);
MYGUI_REGISTER_VALUE(map_names, Abort);
MYGUI_REGISTER_VALUE(map_names, Retry);
MYGUI_REGISTER_VALUE(map_names, Ignore);
MYGUI_REGISTER_VALUE(map_names, Cancel);
MYGUI_REGISTER_VALUE(map_names, Try);
MYGUI_REGISTER_VALUE(map_names, Continue);
MYGUI_REGISTER_VALUE(map_names, Button1);
MYGUI_REGISTER_VALUE(map_names, Button2);
MYGUI_REGISTER_VALUE(map_names, Button3);
MYGUI_REGISTER_VALUE(map_names, Button4);
MYGUI_REGISTER_VALUE(map_names, IconDefault);
MYGUI_REGISTER_VALUE(map_names, IconInfo);
MYGUI_REGISTER_VALUE(map_names, IconQuest);
MYGUI_REGISTER_VALUE(map_names, IconError);
MYGUI_REGISTER_VALUE(map_names, IconWarning);
MYGUI_REGISTER_VALUE(map_names, Icon1);
MYGUI_REGISTER_VALUE(map_names, Icon2);
MYGUI_REGISTER_VALUE(map_names, Icon3);
MYGUI_REGISTER_VALUE(map_names, Icon4);
MYGUI_REGISTER_VALUE(map_names, Icon5);
MYGUI_REGISTER_VALUE(map_names, Icon6);
MYGUI_REGISTER_VALUE(map_names, Icon7);
MYGUI_REGISTER_VALUE(map_names, Icon8);
}
return map_names;
}
private:
Enum value;
};
} // namespace MyGUI
#endif // __MYGUI_MESSAGE_BOX_STYLE_H__

385
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_MultiList.h vendored
View file

@ -1,385 +0,0 @@
/*!
@file
@author Albert Semenov
@date 04/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MULTI_LIST_H__
#define __MYGUI_MULTI_LIST_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
#include "MyGUI_List.h"
#include "MyGUI_Any.h"
#include "MyGUI_BiIndexBase.h"
#include "MyGUI_EventPair.h"
namespace MyGUI
{
//OBSOLETE
typedef delegates::CDelegate5<Widget*, size_t, const UString &, const UString &, bool &> EventHandle_WidgetIntUTFStringUTFStringBool;
typedef delegates::CDelegate5<MultiList*, size_t, const UString &, const UString &, bool &> EventHandle_MultiListPtrSizeTCUTFStringRefCUTFStringRefBoolRef;
typedef delegates::CDelegate2<MultiList*, size_t> EventHandle_MultiListPtrSizeT;
class MYGUI_EXPORT MultiList :
public Widget,
public BiIndexBase
{
MYGUI_RTTI_DERIVED( MultiList )
public:
MultiList();
//------------------------------------------------------------------------------//
// Methods for work with columns (RU:методы для работы со столбцами)
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of columns
size_t getColumnCount() { return mVectorColumnInfo.size(); }
/** Insert new column
@param _column New column will be inserted before _column
@param _name Name of new column
@param _width Width of new column
*/
void insertColumnAt(size_t _column, const UString& _name, int _width, Any _data = Any::Null);
/** Add new column at last position
@param _width Width of new column
@param _name Name of new column
*/
void addColumn(const UString& _name, int _width, Any _data = Any::Null) { insertColumnAt(ITEM_NONE, _name, _width, _data); }
/** Delete column */
void removeColumnAt(size_t _column);
/** Delete all columns */
void removeAllColumns();
//------------------------------------------------------------------------------//
// манипуляции отображением
/** Set column name
@param _column Index of column
@param _name New name of column
*/
void setColumnNameAt(size_t _column, const UString& _name);
/** Set column width
@param _column Index of column
@param _name New width of column
*/
void setColumnWidthAt(size_t _column, int _width);
/** Get _column name */
const UString& getColumnNameAt(size_t _column);
/** Get _column width */
int getColumnWidthAt(size_t _column);
/** Sort multilist by column */
void sortByColumn(size_t _column, bool _backward = false);
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setColumnDataAt(size_t _index, Any _data);
//! Clear an item data at a specified position
void clearColumnDataAt(size_t _index) { setColumnDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getColumnDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.size(), "MultiList::getItemDataAt");
return mVectorColumnInfo[_index].data.castType<ValueType>(_throw);
}
//------------------------------------------------------------------------------//
// Methods for work with lines (RU:методы для работы со строками)
/** @note
All indexes used here is indexes of unsorted Multilist. Even if you sorted
it - all items indexes will be same as before sort.
*/
//------------------------------------------------------------------------------//
// манипуляции айтемами
/** Get number of items (lines) */
size_t getItemCount() const;
/** Insert new item before _index line */
void insertItemAt(size_t _index, const UString& _name, Any _data = Any::Null);
/** Add new item at the end */
void addItem(const UString& _name, Any _data = Any::Null) { insertItemAt(ITEM_NONE, _name, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
/** Delete all items */
void removeAllItems();
//! Swap items at a specified positions
void swapItemsAt(size_t _index1, size_t _index2);
//------------------------------------------------------------------------------//
// манипуляции отображением
//! Replace an item name
void setItemNameAt(size_t _index, const UString& _name) { setSubItemNameAt(0, _index, _name); }
//! Get item name from specified position
const UString& getItemNameAt(size_t _index) { return getSubItemNameAt(0, _index); }
//------------------------------------------------------------------------------//
// манипуляции выделениями
/** Get index of selected item (ITEM_NONE if none selected) */
size_t getIndexSelected() { return mItemSelected; }
/** Select specified _index */
void setIndexSelected(size_t _index);
/** Clear item selection */
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data) { setSubItemDataAt(0, _index, _data); }
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
return getSubItemDataAt<ValueType>(0, _index, _throw);
}
//------------------------------------------------------------------------------//
// Methods for work with sub lines (RU:методы для работы со саб строками)
//------------------------------------------------------------------------------//
// манипуляции данными
/** Set sub item
@param _column Index of column
@param _index Index of line
@param _name New sub item value
*/
void setSubItemNameAt(size_t _column, size_t _index, const UString& _name);
/** Get sub item name*/
const UString& getSubItemNameAt(size_t _column, size_t _index);
/** Search item in specified _column, returns index of the first occurrence in column or ITEM_NONE if item not found */
size_t findSubItemWith(size_t _column, const UString& _name);
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setSubItemDataAt(size_t _column, size_t _index, Any _data);
//! Clear an item data at a specified position
void clearSubItemDataAt(size_t _column, size_t _index) { setSubItemDataAt(_column, _index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getSubItemDataAt(size_t _column, size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_column, mVectorColumnInfo.size(), "MultiList::getSubItemDataAt");
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiList::getSubItemDataAt");
size_t index = BiIndexBase::convertToBack(_index);
return mVectorColumnInfo[_column].list->getItemDataAt<ValueType>(index, _throw);
}
/*internal:*/
virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
/*event:*/
/** Event : Enter pressed or double click.\n
signature : void method(MyGUI::MultiList* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of selected item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_MultiListPtrSizeT> eventListSelectAccept;
/** Event : Selected item position changed.\n
signature : void method(MyGUI::MultiList* _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of new item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_MultiListPtrSizeT> eventListChangePosition;
/** Event : Less than operator for sort multilist by columns.\n
signature : void method(MyGUI::MultiList* _sender, size_t _column, const UString& _firstItem, const UString& _secondItem, bool& _less)\n
@param _sender widget that called this event
@param _column Index of column
@param _firstItem Strings for compare
@param _secondItem Strings for compare
@param _less Comparsion result (write your value here)
*/
EventHandle_MultiListPtrSizeTCUTFStringRefCUTFStringRefBoolRef requestOperatorLess;
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : size_t MultiList::getIndexSelected()")
size_t getItemIndexSelected() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::setIndexSelected(size_t _index)")
void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void MultiList::clearIndexSelected()")
void clearItemSelected() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : size_t MultiList::findSubItemWith(size_t _column, const UString& _name)")
size_t findItem(size_t _column, const UString& _name) { return findSubItemWith(_column, _name); }
MYGUI_OBSOLETE("use : const UString& MultiList::getSubItemNameAt(size_t _column, size_t _index)")
const UString& getSubItem(size_t _column, size_t _index) { return getSubItemNameAt(_column, _index); }
MYGUI_OBSOLETE("use : void MultiList::setSubItemNameAt(size_t _column, size_t _index, const UString& _name)")
void setSubItem(size_t _column, size_t _index, const UString& _name) { setSubItemNameAt(_column, _index, _name); }
MYGUI_OBSOLETE("use : void MultiList::removeColumnAt(size_t _column)")
void deleteColumn(size_t _column) { removeColumnAt(_column); }
MYGUI_OBSOLETE("use : void MultiList::removeAllColumns()")
void deleteAllColumns() { removeAllColumns(); }
MYGUI_OBSOLETE("use : int MultiList::getColumnWidthAt(size_t _column)")
int getColumnWidth(size_t _column) { return getColumnWidthAt(_column); }
MYGUI_OBSOLETE("use : const UString& MultiList::getColumnNameAt(size_t _column)")
const UString& getColumnName(size_t _column) { return getColumnNameAt(_column); }
MYGUI_OBSOLETE("use : void MultiList::setColumnWidthAt(size_t _column, int _width)")
void setColumnWidth(size_t _column, int _width) { setColumnWidthAt(_column, _width); }
MYGUI_OBSOLETE("use : void MultiList::addColumn(const UString& _name, int _width, Any _data)")
void addColumn(int _width, const UString& _name) { addColumn(_name, _width); }
MYGUI_OBSOLETE("use : void MultiList::setColumnNameAt(size_t _column, const UString& _name)")
void setColumnName(size_t _column, const UString& _name) { setColumnNameAt(_column, _name); }
MYGUI_OBSOLETE("use : void MultiList::insertColumnAt(size_t _column, const UString& _name, int _width, Any _data)")
void insertColumn(size_t _column, int _width, const UString& _name) { insertColumnAt(_column, _name, _width); }
MYGUI_OBSOLETE("use : size_t MultiList::getIndexSelected()")
size_t getItemSelect() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::clearIndexSelected()")
void resetItemSelect() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::setIndexSelected(size_t _index)")
void setItemSelect(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void MultiList::insertItemAt(size_t _index, const UString& _name, Any _data)")
void insertItem(size_t _index, const UString& _name) { insertItemAt(_index, _name); }
MYGUI_OBSOLETE("use : void MultiList::setItemNameAt(size_t _index, const UString& _name)")
void setItem(size_t _index, const UString& _name) { setItemNameAt(_index, _name); }
MYGUI_OBSOLETE("use : const UString& MultiList::getItemNameAt(size_t _index)")
const UString& getItem(size_t _index) { return getItemNameAt(_index); }
MYGUI_OBSOLETE("use : void MultiList::removeItemAt(size_t _index)")
void deleteItem(size_t _index) { removeItemAt(_index); }
MYGUI_OBSOLETE("use : void MultiList::removeAllItems()")
void deleteAllItems() { removeAllItems(); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
virtual ~MultiList();
void baseChangeWidgetSkin(ResourceSkin* _info);
void notifyListChangePosition(List* _sender, size_t _position);
void notifyListChangeFocus(List* _sender, size_t _position);
void notifyListChangeScrollPosition(List* _sender, size_t _position);
void notifyButtonClick(Widget* _sender);
void notifyListSelectAccept(List* _sender, size_t _position);
void updateColumns();
void redrawButtons();
void updateOnlyEmpty();
bool compare(List* _list, size_t _left, size_t _right);
void sortList();
void flipList();
Widget* getSeparator(size_t _index);
void setButtonImageIndex(Button* _button, size_t _index);
void updateBackSelected(size_t _index);
private:
void initialiseWidgetSkin(ResourceSkin* _info);
void shutdownWidgetSkin();
void frameEntered(float _frame);
void frameAdvise(bool _advise);
private:
struct ColumnInfo
{
List* list;
Button* button;
int width;
UString name;
Any data;
};
typedef std::vector<ColumnInfo> VectorColumnInfo;
enum ImageSort
{
SORT_NONE,
SORT_UP,
SORT_DOWN
};
private:
int mHeightButton;
int mWidthBar;
std::string mSkinButton, mSkinList;
Button* mButtonMain;
VectorColumnInfo mVectorColumnInfo;
VectorWidgetPtr mSeparators;
size_t mLastMouseFocusIndex;
bool mSortUp;
size_t mSortColumnIndex;
int mWidthSeparator;
std::string mSkinSeparator;
int mOffsetButtonSeparator;
size_t mItemSelected;
bool mFrameAdvise;
Widget* mClient;
};
} // namespace MyGUI
#endif // __MYGUI_MULTI_LIST_H__

74
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_OverlappedLayer.h vendored
View file

@ -1,74 +0,0 @@
/*!
@file
@author Albert Semenov
@date 02/2008
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_OVERLAPPED_LAYER_H__
#define __MYGUI_OVERLAPPED_LAYER_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_ILayer.h"
namespace MyGUI
{
class MYGUI_EXPORT OverlappedLayer :
public ILayer
{
MYGUI_RTTI_DERIVED( OverlappedLayer )
public:
OverlappedLayer();
virtual ~OverlappedLayer();
virtual void deserialization(xml::ElementPtr _node, Version _version);
// ñîçäàåì äî÷åðíèé íîä
virtual ILayerNode* createChildItemNode();
// óäàëÿåì äî÷åðíèé íîä
virtual void destroyChildItemNode(ILayerNode* _node);
// ïîäíèìàåì äî÷åðíèé íîä
virtual void upChildItemNode(ILayerNode* _node);
// ñïèñîê äåòåé
virtual EnumeratorILayerNode getEnumerator();
// âîçâðàùàåò âèäæåò ïî ïîçèöèè
virtual ILayerItem* getLayerItemByPoint(int _left, int _top);
virtual IntPoint getPosition(int _left, int _top) const;
virtual const IntSize& getSize() const;
// ðèñóåò ëååð
virtual void renderToTarget(IRenderTarget* _target, bool _update);
virtual void dumpStatisticToLog();
protected:
bool mIsPick;
VectorILayerNode mChildItems;
};
} // namespace MyGUI
#endif // __MYGUI_OVERLAPPED_LAYER_H__

151
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Platform.h vendored
View file

@ -1,151 +0,0 @@
/*!
@file
@author Denis Koronchik
@author Georgiy Evmenov
@author Albert Semenov
@date 09/2007
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_PLATFORM_H__
#define __MYGUI_PLATFORM_H__
// Definnition of platforms
#define MYGUI_PLATFORM_WIN32 1
#define MYGUI_PLATFORM_LINUX 2
#define MYGUI_PLATFORM_APPLE 3
// Definition of compilers
#define MYGUI_COMPILER_MSVC 1
#define MYGUI_COMPILER_GNUC 2
// Find platform
#if defined (__WIN32__) || defined (_WIN32)
# define MYGUI_PLATFORM MYGUI_PLATFORM_WIN32
#elif defined (__APPLE_CC__)
# define MYGUI_PLATFORM MYGUI_PLATFORM_APPLE
#else
# define MYGUI_PLATFORM MYGUI_PLATFORM_LINUX
#endif
// Find compiler
#if defined( _MSC_VER )
# define MYGUI_COMPILER MYGUI_COMPILER_MSVC
# define MYGUI_COMP_VER _MSC_VER
#elif defined( __GNUC__ )
# define MYGUI_COMPILER MYGUI_COMPILER_GNUC
# define MYGUI_COMP_VER (((__GNUC__)*100) + \
(__GNUC_MINOR__*10) + \
__GNUC_PATCHLEVEL__)
#else
# pragma error "Unknown compiler! Stop building!!!"
#endif
// See if we can use __forceinline or if we need to use __inline instead
#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
# if MYGUI_COMP_VER >= 1200
# define MYGUI_FORCEINLINE __forceinline
# endif
#elif defined(__MINGW32__)
# if !defined(MYGUI_FORCEINLINE)
# define MYGUI_FORCEINLINE __inline
# endif
#else
# define MYGUI_FORCEINLINE __inline
#endif
// Windows settings
#if MYGUI_PLATFORM == MYGUI_PLATFORM_WIN32
#
# if defined( MYGUI_STATIC )
# define MYGUI_EXPORT
# elif defined( MYGUI_BUILD )
# define MYGUI_EXPORT __declspec( dllexport )
# else
# if defined( __MINGW32__ )
# define MYGUI_EXPORT
# else
# define MYGUI_EXPORT __declspec( dllimport )
# endif
# endif
#
# if defined( MYGUI_STATIC )
# define MYGUI_EXPORT_DLL
# elif defined( MYGUI_BUILD_DLL )
# define MYGUI_EXPORT_DLL __declspec( dllexport )
# else
# if defined( __MINGW32__ )
# define MYGUI_EXPORT_DLL
# else
# define MYGUI_EXPORT_DLL __declspec( dllimport )
# endif
# endif
#
#// Win32 compilers use _DEBUG for specifying debug builds.
# ifdef _DEBUG
# define MYGUI_DEBUG_MODE 1
# else
# define MYGUI_DEBUG_MODE 0
# endif
#endif
// Linux/Apple Settings
#if MYGUI_PLATFORM == MYGUI_PLATFORM_LINUX || MYGUI_PLATFORM == MYGUI_PLATFORM_APPLE
#
// Add -fvisibility=hidden to compiler options. With -fvisibility=hidden, you are telling
// GCC that every declaration not explicitly marked with a visibility attribute (MYGUI_EXPORT)
// has a hidden visibility (like in windows).
# if __GNUC__ >= 4
# define MYGUI_EXPORT __attribute__ ((visibility("default")))
# else
# define MYGUI_EXPORT
# endif
#
# if __GNUC__ >= 4
# define MYGUI_EXPORT_DLL __attribute__ ((visibility("default")))
# else
# define MYGUI_EXPORT_DLL
# endif
#
// A quick define to overcome different names for the same function
# define stricmp strcasecmp
#
// Unlike the Win32 compilers, Linux compilers seem to use DEBUG for when
// specifying a debug build.
// (??? this is wrong, on Linux debug builds aren't marked in any way unless
// you mark it yourself any way you like it -- zap ???)
# ifdef DEBUG
# define MYGUI_DEBUG_MODE 1
# else
# define MYGUI_DEBUG_MODE 0
# endif
# if MYGUI_PLATFORM == MYGUI_PLATFORM_APPLE
# define MYGUI_PLATFORM_LIB "MYGUIPlatform.bundle"
# else // if MYGUI_PLATFORM_LINUX
# define MYGUI_PLATFORM_LIB "libMYGUIPlatform.so"
# endif
#endif
#endif // __MYGUI_PLATFORM_H__

67
extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Plugin.h vendored
View file

@ -1,67 +0,0 @@
/*!
@file
@author Denis Koronchik
@date 09/2007
@module
*/
/*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_PLUGIN_H__
#define __MYGUI_PLUGIN_H__
#include "MyGUI_Prerequest.h"
#include <string>
namespace MyGUI
{
/*! \brief Base plugin class
*/
class MYGUI_EXPORT IPlugin
{
public:
IPlugin() { }
virtual ~IPlugin() { }
/*! Get the name of the plugin.
@remarks An implementation must be supplied for this method to uniquely
identify the plugin
*/
virtual const std::string& getName() const = 0;
/*! Perform the plugin initial installation sequence
*/
virtual void install() = 0;
/*! Perform any tasks the plugin needs to perform on full system
initialisation.
*/
virtual void initialize() = 0;
/*! Perform any tasks the plugin needs to perform when the system is shut down
*/
virtual void shutdown() = 0;
/*! Perform the final plugin uninstallation sequence
*/
virtual void uninstall() = 0;
};
}
#endif // __MYGUI_PLUGIN_H__

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