From 2ba27dd9218f446ea52cc6380f1a4db4e4d87450 Mon Sep 17 00:00:00 2001 From: Malcolm Roberts Date: Wed, 20 Dec 2023 15:36:09 -0600 Subject: [PATCH] Initial attempt at using ISXEq2 from c++ --- .gitignore | 34 + CMakeLists.txt | 77 ++ libs/isxdk/include/ColumnRenderer.h | 153 ++++ libs/isxdk/include/FileList.h | 236 +++++ libs/isxdk/include/ISInterface.h | 464 ++++++++++ libs/isxdk/include/ISUI/LGUI.h | 100 +++ libs/isxdk/include/ISUI/LGUIButton.h | 55 ++ libs/isxdk/include/ISUI/LGUICheckBox.h | 34 + libs/isxdk/include/ISUI/LGUIComboBox.h | 40 + libs/isxdk/include/ISUI/LGUICommandButton.h | 23 + libs/isxdk/include/ISUI/LGUICommandCheckBox.h | 27 + libs/isxdk/include/ISUI/LGUICommandEntry.h | 33 + libs/isxdk/include/ISUI/LGUIConsole.h | 80 ++ libs/isxdk/include/ISUI/LGUIContextMenu.h | 170 ++++ libs/isxdk/include/ISUI/LGUIElement.h | 687 ++++++++++++++ libs/isxdk/include/ISUI/LGUIEmbeddedScript.h | 20 + libs/isxdk/include/ISUI/LGUIFont.h | 84 ++ libs/isxdk/include/ISUI/LGUIFrame.h | 41 + libs/isxdk/include/ISUI/LGUIGauge.h | 93 ++ libs/isxdk/include/ISUI/LGUIHudElement.h | 37 + libs/isxdk/include/ISUI/LGUIListBox.h | 145 +++ libs/isxdk/include/ISUI/LGUIManager.h | 175 ++++ libs/isxdk/include/ISUI/LGUIMap.h | 150 ++++ libs/isxdk/include/ISUI/LGUIMessageBox.h | 36 + libs/isxdk/include/ISUI/LGUIScreen.h | 20 + libs/isxdk/include/ISUI/LGUIScrollBar.h | 41 + libs/isxdk/include/ISUI/LGUISlider.h | 53 ++ libs/isxdk/include/ISUI/LGUITabControl.h | 93 ++ libs/isxdk/include/ISUI/LGUITable.h | 54 ++ libs/isxdk/include/ISUI/LGUIText.h | 69 ++ libs/isxdk/include/ISUI/LGUITextEdit.h | 260 ++++++ libs/isxdk/include/ISUI/LGUITextEntry.h | 83 ++ libs/isxdk/include/ISUI/LGUITexture.h | 75 ++ libs/isxdk/include/ISUI/LGUITooltip.h | 58 ++ libs/isxdk/include/ISUI/LGUITree.h | 99 ++ libs/isxdk/include/ISUI/LGUIVariableGauge.h | 55 ++ libs/isxdk/include/ISUI/LGUIVariableSlider.h | 29 + libs/isxdk/include/ISUI/LGUIWindow.h | 168 ++++ libs/isxdk/include/ISXDK.h | 527 +++++++++++ libs/isxdk/include/ISXInterface.h | 54 ++ libs/isxdk/include/Index.h | 131 +++ libs/isxdk/include/LavishScript/LSSTLTypes.h | 844 ++++++++++++++++++ libs/isxdk/include/LavishScript/LSType.h | 560 ++++++++++++ .../isxdk/include/LavishScript/LavishScript.h | 8 + libs/isxdk/include/Queue.h | 221 +++++ libs/isxdk/include/Services.h | 462 ++++++++++ libs/isxdk/include/Threading.h | 49 + libs/isxdk/include/WinThreading.h | 238 +++++ libs/isxdk/include/utf8string.h | 621 +++++++++++++ libs/isxdk/lib64/vs14/ISUI.lib | Bin 0 -> 194994 bytes libs/isxdk/lib64/vs14/ISUI_md.lib | Bin 0 -> 194994 bytes libs/isxdk/lib64/vs14/ISXDK.lib | Bin 0 -> 1080956 bytes libs/isxdk/lib64/vs14/ISXDK_md.lib | Bin 0 -> 1130860 bytes libs/isxdk/lib64/vs16/ISUI.lib | Bin 0 -> 194994 bytes libs/isxdk/lib64/vs16/ISUI_md.lib | Bin 0 -> 194994 bytes libs/isxdk/lib64/vs16/ISXDK.lib | Bin 0 -> 782832 bytes libs/isxdk/lib64/vs16/ISXDK_md.lib | Bin 0 -> 782860 bytes scripts/controller.iss | 1 + src/Commands.cpp | 6 + src/Commands.h | 20 + src/DataTypeList.h | 27 + src/DataTypes.cpp | 91 ++ src/DataTypes.h | 32 + src/ISXMr.cpp | 417 +++++++++ src/ISXMr.h | 96 ++ src/ISXMrServices.h | 91 ++ src/LGUIMrFrame.cpp | 50 ++ src/LGUIMrFrame.h | 19 + src/Services.cpp | 76 ++ src/Services.h | 25 + src/TopLevelObjects.cpp | 22 + src/TopLevelObjects.h | 31 + src/isxeq2/Actor.cpp | 139 +++ src/isxeq2/Actor.h | 65 ++ src/isxeq2/Character.cpp | 39 + src/isxeq2/Character.h | 31 + src/isxeq2/LSObject.cpp | 19 + src/isxeq2/LSObject.h | 21 + 78 files changed, 9184 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 libs/isxdk/include/ColumnRenderer.h create mode 100644 libs/isxdk/include/FileList.h create mode 100644 libs/isxdk/include/ISInterface.h create mode 100644 libs/isxdk/include/ISUI/LGUI.h create mode 100644 libs/isxdk/include/ISUI/LGUIButton.h create mode 100644 libs/isxdk/include/ISUI/LGUICheckBox.h create mode 100644 libs/isxdk/include/ISUI/LGUIComboBox.h create mode 100644 libs/isxdk/include/ISUI/LGUICommandButton.h create mode 100644 libs/isxdk/include/ISUI/LGUICommandCheckBox.h create mode 100644 libs/isxdk/include/ISUI/LGUICommandEntry.h create mode 100644 libs/isxdk/include/ISUI/LGUIConsole.h create mode 100644 libs/isxdk/include/ISUI/LGUIContextMenu.h create mode 100644 libs/isxdk/include/ISUI/LGUIElement.h create mode 100644 libs/isxdk/include/ISUI/LGUIEmbeddedScript.h create mode 100644 libs/isxdk/include/ISUI/LGUIFont.h create mode 100644 libs/isxdk/include/ISUI/LGUIFrame.h create mode 100644 libs/isxdk/include/ISUI/LGUIGauge.h create mode 100644 libs/isxdk/include/ISUI/LGUIHudElement.h create mode 100644 libs/isxdk/include/ISUI/LGUIListBox.h create mode 100644 libs/isxdk/include/ISUI/LGUIManager.h create mode 100644 libs/isxdk/include/ISUI/LGUIMap.h create mode 100644 libs/isxdk/include/ISUI/LGUIMessageBox.h create mode 100644 libs/isxdk/include/ISUI/LGUIScreen.h create mode 100644 libs/isxdk/include/ISUI/LGUIScrollBar.h create mode 100644 libs/isxdk/include/ISUI/LGUISlider.h create mode 100644 libs/isxdk/include/ISUI/LGUITabControl.h create mode 100644 libs/isxdk/include/ISUI/LGUITable.h create mode 100644 libs/isxdk/include/ISUI/LGUIText.h create mode 100644 libs/isxdk/include/ISUI/LGUITextEdit.h create mode 100644 libs/isxdk/include/ISUI/LGUITextEntry.h create mode 100644 libs/isxdk/include/ISUI/LGUITexture.h create mode 100644 libs/isxdk/include/ISUI/LGUITooltip.h create mode 100644 libs/isxdk/include/ISUI/LGUITree.h create mode 100644 libs/isxdk/include/ISUI/LGUIVariableGauge.h create mode 100644 libs/isxdk/include/ISUI/LGUIVariableSlider.h create mode 100644 libs/isxdk/include/ISUI/LGUIWindow.h create mode 100644 libs/isxdk/include/ISXDK.h create mode 100644 libs/isxdk/include/ISXInterface.h create mode 100644 libs/isxdk/include/Index.h create mode 100644 libs/isxdk/include/LavishScript/LSSTLTypes.h create mode 100644 libs/isxdk/include/LavishScript/LSType.h create mode 100644 libs/isxdk/include/LavishScript/LavishScript.h create mode 100644 libs/isxdk/include/Queue.h create mode 100644 libs/isxdk/include/Services.h create mode 100644 libs/isxdk/include/Threading.h create mode 100644 libs/isxdk/include/WinThreading.h create mode 100644 libs/isxdk/include/utf8string.h create mode 100644 libs/isxdk/lib64/vs14/ISUI.lib create mode 100644 libs/isxdk/lib64/vs14/ISUI_md.lib create mode 100644 libs/isxdk/lib64/vs14/ISXDK.lib create mode 100644 libs/isxdk/lib64/vs14/ISXDK_md.lib create mode 100644 libs/isxdk/lib64/vs16/ISUI.lib create mode 100644 libs/isxdk/lib64/vs16/ISUI_md.lib create mode 100644 libs/isxdk/lib64/vs16/ISXDK.lib create mode 100644 libs/isxdk/lib64/vs16/ISXDK_md.lib create mode 100644 scripts/controller.iss create mode 100644 src/Commands.cpp create mode 100644 src/Commands.h create mode 100644 src/DataTypeList.h create mode 100644 src/DataTypes.cpp create mode 100644 src/DataTypes.h create mode 100644 src/ISXMr.cpp create mode 100644 src/ISXMr.h create mode 100644 src/ISXMrServices.h create mode 100644 src/LGUIMrFrame.cpp create mode 100644 src/LGUIMrFrame.h create mode 100644 src/Services.cpp create mode 100644 src/Services.h create mode 100644 src/TopLevelObjects.cpp create mode 100644 src/TopLevelObjects.h create mode 100644 src/isxeq2/Actor.cpp create mode 100644 src/isxeq2/Actor.h create mode 100644 src/isxeq2/Character.cpp create mode 100644 src/isxeq2/Character.h create mode 100644 src/isxeq2/LSObject.cpp create mode 100644 src/isxeq2/LSObject.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1921de0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +# Ignore build folders +cmake-*/ + +# Ignore generated headers +scripts/*.h + +# Ignore common C++ and CMake build artifacts +*.o +*.lo +*.la +*.so +*.so.* +*.dylib +*.dll +*.exe +*.out +*.app + +# CMake specific files +CMakeFiles/ +CMakeCache.txt +cmake_install.cmake +Makefile + +# Ignore editor and IDE specific files +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# Miscellaneous +.DS_Store +Thumbs.db \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..17beb49 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,77 @@ +cmake_minimum_required(VERSION 3.27) +project(ISXMr VERSION 1.0.0) + +set(CMAKE_CXX_STANDARD 14) +#set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Set the project source directory +set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src) + +# Set the project include directory +include_directories(${SOURCE_DIR}) + +file(GLOB_RECURSE SCRIPT_FILES "scripts/*") + +foreach(FILE ${SCRIPT_FILES}) + get_filename_component(FILE_NAME ${FILE} NAME) + string(REGEX REPLACE "[^a-zA-Z0-9]" "_" FILE_IDENTIFIER ${FILE_NAME}) + set(HEADER_FILE "${CMAKE_CURRENT_SOURCE_DIR}/scripts/${FILE_NAME}.h") + + add_custom_command( + OUTPUT ${HEADER_FILE} + COMMAND xxd -i -n ${FILE_IDENTIFIER} ${FILE} ${HEADER_FILE} + COMMENT "Generating ${HEADER_FILE} from ${FILE_PATH}" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + DEPENDS ${FILE} + ) + list(APPEND GENERATED_HEADERS ${HEADER_FILE}) +endforeach() +add_custom_target(GenerateHeaders ALL DEPENDS ${GENERATED_HEADERS}) + +add_library(ISXMr SHARED ${SOURCE_DIR}/ISXMr.cpp + ${SOURCE_DIR}/Commands.cpp + ${SOURCE_DIR}/DataTypes.cpp + ${SOURCE_DIR}/LGUIMrFrame.cpp + ${SOURCE_DIR}/Services.cpp + ${SOURCE_DIR}/TopLevelObjects.cpp + ${SOURCE_DIR}/Commands.h + ${SOURCE_DIR}/DataTypeList.h + ${SOURCE_DIR}/DataTypes.h + ${SOURCE_DIR}/ISXMr.h + ${SOURCE_DIR}/ISXMrServices.h + ${SOURCE_DIR}/LGUIMrFrame.h + ${SOURCE_DIR}/Services.h + ${SOURCE_DIR}/TopLevelObjects.h + src/isxeq2/Character.cpp + src/isxeq2/Character.h + src/isxeq2/Actor.cpp + src/isxeq2/Actor.h + src/isxeq2/LSObject.cpp + src/isxeq2/LSObject.h) + +# Set the path to additional libraries +set(LIBS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libs/) + +# Find isxdk library +find_library(ISXDK_LIBRARY ISXDK HINTS ${LIBS_DIR}/isxdk/lib64/vs16) +if(NOT ISXDK_LIBRARY) + message(FATAL_ERROR "isxdk library not found") +endif() + +find_library(ISUI_LIBRARY ISUI HINTS ${LIBS_DIR}/isxdk/lib64/vs16) +if(NOT ISUI_LIBRARY) + message(FATAL_ERROR "isxui library not found") +endif() + +# Set include directories for isxdk +include_directories(${LIBS_DIR}/isxdk/include) + +# Link ISXMr with isxdk library +target_link_libraries(ISXMr PRIVATE ${ISUI_LIBRARY} ${ISXDK_LIBRARY}) + +# Set the output directory for the shared library +set_target_properties(ISXMr PROPERTIES + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin +) + +set_property(TARGET ISXMr PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") diff --git a/libs/isxdk/include/ColumnRenderer.h b/libs/isxdk/include/ColumnRenderer.h new file mode 100644 index 0000000..de82a74 --- /dev/null +++ b/libs/isxdk/include/ColumnRenderer.h @@ -0,0 +1,153 @@ +#pragma once +class CColumnRenderer; + +#ifndef __CColumnRenderer_h__ +#define __CColumnRenderer_h__ + +struct _ColumnRendererItem +{ + char *Text; + size_t Length; +}; + +class CColumnRenderer +{ +public: + CColumnRenderer() + { + LongestItem=0; + ItemCount=0; + } + + ~CColumnRenderer() + { + foreach(_ColumnRendererItem* pItem,i,Items) + { + free(pItem->Text); + } + } + + void AddItem(const char *Text) + { + if (!Text || !Text[0]) + return; + _ColumnRendererItem *pItem = new _ColumnRendererItem; + pItem->Text=strdup(Text); + size_t NewLength=strlen(Text); + if (const char *pColor=(const char *)strchr(Text,'\a')) + { + do + { + if (pColor[1]=='-') + NewLength--; + NewLength-=2; + } + while(pColor=strchr(&pColor[1],'\a')); + } + pItem->Length=NewLength; + if (NewLength>LongestItem) + LongestItem=NewLength; + Items+=pItem; + ItemCount++; + } + + void Render(class ISInterface *pISInterface) + { + if (!LongestItem) + return; // wtf. + size_t Width = pISInterface->GetTerminalWidth(); + size_t Columns = (Width - LongestItem) / LongestItem; + size_t ColumnWidth; + if (Columns<1) + { + Columns=1; + ColumnWidth=Width; + } + else if (Columns>10) + { + Columns=10; + ColumnWidth=Width/10; + } + else + ColumnWidth=Width/Columns; + char Row[1024]; + char *pColumn=Row; + + size_t Rows = (ItemCount / Columns) + 1; + + size_t ItemNumber = 0; + + //pISInterface->Printf("Items: %d. Rows: %d. Columns: %d.",ItemCount,Rows,Columns); + for (size_t i = 0; i < Rows; i++) + { + ItemNumber=i; + for (size_t Column = 0; Column < Columns; Column++) + { + if (ItemNumberText); + } + } + + ItemNumber+=Rows; + } + pISInterface->Printf("%s",Row); + pColumn=Row; + Row[0]=0; + + } + } + + void RenderLeftToRight(class ISInterface *pISInterface) + { + if (!LongestItem) + return; // wtf. + size_t Width = pISInterface->GetTerminalWidth(); + char Row[1024]; + size_t Columns = (Width - LongestItem) / LongestItem; + size_t ColumnWidth; + //pISInterface->Printf("Longest Item: %d. Width: %d. ColWidth: %d. Columns: %d.",LongestItem,Width,ColumnWidth,Columns); + if (Columns<1) + { + Columns=1; + ColumnWidth=Width; + } + else if (Columns>10) + { + Columns=10; + ColumnWidth=Width/10; + } + else + ColumnWidth=Width/Columns; + size_t Column = 0; + char *pColumn=Row; + + foreach(_ColumnRendererItem* pItem,i,Items) + { + pColumn+=sprintf(pColumn,"%-*s",(int)ColumnWidth,pItem->Text); + Column++; + if (Column>=Columns) + { + pISInterface->Printf("%s",Row); + Column=0; + pColumn=Row; + Row[0]=0; + } + } + if (Row[0]) + pISInterface->Printf("%s",Row); + } + + +protected: + unsigned int ItemCount; + size_t LongestItem; + CIndex<_ColumnRendererItem *> Items; + size_t Widest; +}; + + +#endif + diff --git a/libs/isxdk/include/FileList.h b/libs/isxdk/include/FileList.h new file mode 100644 index 0000000..c81dd30 --- /dev/null +++ b/libs/isxdk/include/FileList.h @@ -0,0 +1,236 @@ +#pragma once +struct _FileListEntry +{ + char Filename[512]; + char FilenameOnly[128]; + FILETIME ftCreationTime; + FILETIME ftLastWriteTime; + FILETIME ftLastAccessTime; + unsigned int FileSize; +}; + +class CFileList +{ +public: + CFileList() + { + nFiles=0; + } + ~CFileList() + { + List.Cleanup(); + } + + void AddFile(LPWIN32_FIND_DATA pFile, char *Path) + { + _FileListEntry *pNew = new _FileListEntry; + sprintf(pNew->Filename,"%s%s",Path,pFile->cFileName); + strcpy(pNew->FilenameOnly,pFile->cFileName); + pNew->ftCreationTime=pFile->ftCreationTime; + pNew->ftLastAccessTime=pFile->ftLastAccessTime; + pNew->ftLastWriteTime=pFile->ftLastWriteTime; + pNew->FileSize=pFile->nFileSizeLow; + List+=pNew; + nFiles++; + } + char *GetPath(char *Wildcard) + { + static char Path[512]; + if (char *pSlash=strrchr(Wildcard,'\\')) + { + strcpy(Path,Wildcard); + Path[(pSlash-Wildcard)+1]=0; + } + else + Path[0]=0; + return Path; + } + unsigned int EnumDirectories(char *Wildcard) + { + WIN32_FIND_DATA file; + HANDLE hSearch=FindFirstFile(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + char *Path=GetPath(Wildcard); + do + { + if (_stricmp(file.cFileName,".") && _stricmp(file.cFileName,"..")) + if (file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) + AddFile(&file,Path); + } while (FindNextFile(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + unsigned int EnumFiles(char *Wildcard) + { + WIN32_FIND_DATA file; + HANDLE hSearch=FindFirstFile(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + char *Path=GetPath(Wildcard); + do + { + if (!(file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)) + AddFile(&file,Path); + } while (FindNextFile(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + unsigned int EnumFilesAfter(FILETIME &filetime, char *Wildcard) + { + WIN32_FIND_DATA file; + HANDLE hSearch=FindFirstFile(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + char *Path=GetPath(Wildcard); + do + { + if (!(file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) && + CompareFileTime(&file.ftLastWriteTime,&filetime)>0) + { + AddFile(&file,Path); + } + } while (FindNextFile(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + + unsigned int nFiles; + CIndex <_FileListEntry *> List; +}; + +struct _FileListEntryW +{ + wchar_t Filename[512]; + wchar_t FilenameOnly[128]; + FILETIME ftCreationTime; + FILETIME ftLastWriteTime; + FILETIME ftLastAccessTime; + unsigned int FileSize; +}; + +class CFileListW +{ +public: + CFileListW() + { + nFiles=0; + } + ~CFileListW() + { + List.Cleanup(); + } + + void Clear() + { + List.Cleanup(); + nFiles=0; + } + + void AddFile(PWIN32_FIND_DATAW pFile, wchar_t *Path) + { + _FileListEntryW *pNew = new _FileListEntryW; + _snwprintf(pNew->Filename,512,L"%ls%ls",Path,pFile->cFileName); + wcsncpy(pNew->FilenameOnly,pFile->cFileName,sizeof(pNew->FilenameOnly)/sizeof(pNew->FilenameOnly[0])); + pNew->ftCreationTime=pFile->ftCreationTime; + pNew->ftLastAccessTime=pFile->ftLastAccessTime; + pNew->ftLastWriteTime=pFile->ftLastWriteTime; + pNew->FileSize=pFile->nFileSizeLow; + List+=pNew; + nFiles++; + } + inline wchar_t *ConvertSlashes(wchar_t *text) + { + wchar_t *temp=text; + while(wchar_t *pSlash=wcschr(temp,'\\')) + { + *pSlash='/'; + temp=&pSlash[1]; + } + return text; + } + wchar_t *GetPath(const wchar_t *Wildcard) + { + static wchar_t Path[512]; + wchar_t temp[512]; + wcsncpy(temp,Wildcard,512); + temp[511]=0; + + wchar_t *pLastSlash=wcsrchr(temp,'\\'); + if (pLastSlash) + { + wchar_t *pOtherSlash=wcsrchr(pLastSlash,'/'); + if (pOtherSlash && pOtherSlash>pLastSlash) + pLastSlash=pOtherSlash; + } + else + pLastSlash=wcsrchr(temp,'/'); + if (wchar_t *pSlash=pLastSlash) + { + wcsncpy(Path,temp,sizeof(Path)/sizeof(Path[0])); + Path[(pSlash-temp)+1]=0; + ConvertSlashes(Path); + } + else + Path[0]=0; + return Path; + } + unsigned int EnumDirectories(const wchar_t *Wildcard) + { + WIN32_FIND_DATAW file; + HANDLE hSearch=FindFirstFileW(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + wchar_t *Path=GetPath(Wildcard); + do + { + if (wcsicmp(file.cFileName,L".") && wcsicmp(file.cFileName,L"..")) + if (file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) + AddFile(&file,Path); + } while (FindNextFileW(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + unsigned int EnumFiles(const wchar_t *Wildcard) + { + WIN32_FIND_DATAW file; + HANDLE hSearch=FindFirstFileW(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + wchar_t *Path=GetPath(Wildcard); + do + { + if (!(file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)) + AddFile(&file,Path); + } while (FindNextFileW(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + unsigned int EnumFilesAfter(FILETIME &filetime, const wchar_t *Wildcard) + { + WIN32_FIND_DATAW file; + HANDLE hSearch=FindFirstFileW(Wildcard,&file); + if (hSearch==INVALID_HANDLE_VALUE) + return 0; + wchar_t *Path=GetPath(Wildcard); + do + { + if (!(file.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) && + CompareFileTime(&file.ftLastWriteTime,&filetime)>0) + { + AddFile(&file,Path); + } + } while (FindNextFileW(hSearch,&file)); + + FindClose(hSearch); + return nFiles; + } + + unsigned int nFiles; + CIndex <_FileListEntryW *> List; +}; diff --git a/libs/isxdk/include/ISInterface.h b/libs/isxdk/include/ISInterface.h new file mode 100644 index 0000000..88e1b14 --- /dev/null +++ b/libs/isxdk/include/ISInterface.h @@ -0,0 +1,464 @@ +#pragma once + +class ISLavishScriptInterface +{ +public: + // paths + virtual char *GetCWD(char *buffer, size_t buflen)=0; + virtual char *SetRoot(const char *Filename, char *Dest)=0; + + virtual bool AddCommand(const char *Command, fLSCommand Function, bool Parse=true, bool Hidden=false)=0; + virtual bool RemoveCommand(const char *Command)=0; + virtual bool AddAlias(const char *Replace, const char *With)=0; + virtual bool RemoveAlias(const char *Replace)=0; + virtual char *GetArgs(int BeginInclusive, int EndExclusive, char *argv[], char *buf, size_t buflen)=0; + virtual char *GetArgsQuoted(int BeginInclusive, int EndExclusive, char *argv[], char *buf, size_t buflen)=0; + virtual char *GetArgsQuotedNF(int BeginInclusive, int EndExclusive, char *argv[], char *buf, size_t buflen)=0; + virtual void ExecuteTimedCommand(unsigned int DelayMS, const char *Command)=0; + virtual int ExecuteCommand(const char *Text)=0; + virtual int DataParse(const char *ToParse, char *buf, size_t buflen)=0; + virtual bool DataParse(const char *Text, LSOBJECT &Object)=0; + virtual bool RunScript(const char *Filename)=0; + virtual bool EndScript(const char *Filename)=0; + virtual bool RunCommandFile(const char *Filename)=0; + virtual bool AddTopLevelObject(const char *Name, fLSTopLevelObject Function)=0; + virtual bool RemoveTopLevelObject(const char *Name)=0; + virtual bool AddLSTypeDefinition(class LSTypeDefinition &Type)=0; + virtual bool RemoveLSTypeDefinition(class LSTypeDefinition &Type)=0; + virtual LSTypeDefinition *FindLSTypeDefinition(const char *Name, char *subtypebuf=0, size_t subtypebuflen=0)=0; + virtual fLSCommand IsCommand(const char *Name)=0; + virtual bool IsAlias(const char *Name)=0; + virtual fLSTopLevelObject IsTopLevelObject(const char *Name)=0; + virtual bool IsLSTypeDefinition(const char *Name)=0; + virtual bool ResolveCommand(const char *Text, char *buf,size_t buflen)=0; + virtual void *GetTempBuffer(unsigned int Size, void *CopyFrom=0)=0; + virtual void AddTempObject(CTempObject *pObject)=0; + virtual bool RunScriptFromBuffer(const char *Name, const char *Buffer, size_t buflen, int argc=0, char *argv[]=0, const char *CWD=0)=0; + + // pre-compiled scripts + + // compiled text and data sequences (improve performance of reused text) + virtual unsigned int PreParseText(const char *Text, bool bDataSequence=false)=0; + virtual bool RetrieveOriginalText(unsigned int ID, char *buf, size_t buflen)=0; + virtual bool RetrieveProcessedText(unsigned int ID, char *buf, size_t buflen)=0; + virtual bool RetrieveProcessedResult(unsigned int ID, LSOBJECT &Result)=0; // data sequence only + virtual bool FreePreParsed(unsigned int ID)=0; + + // object persistence + virtual unsigned int RegisterPersistentClass(const char *Name)=0; + virtual void InvalidatePersistentClass(unsigned int Class)=0; + virtual void InvalidatePersistentObject(unsigned int Class, unsigned __int64 Value)=0; + virtual void SetPersistentClass(LSTypeDefinition *pType,unsigned int Class)=0; + + // object queries + virtual unsigned int CreateQuery(const char *Text)=0; + virtual bool RetrieveQueryExpression(unsigned int ID,char *buf, size_t buflen)=0; + virtual bool QueryEvaluate(unsigned int ID,LSOBJECT &Object, bool &bResult)=0; + virtual bool FreeQuery(unsigned int ID)=0; + + + virtual unsigned int PersistObject(LSOBJECT &object)=0; + virtual bool GetPersistedObject(unsigned int key, LSOBJECT &out_object)=0; + + virtual void ISLavishScriptInterface_06_Reserved() {} + virtual void ISLavishScriptInterface_07_Reserved() {} + virtual void ISLavishScriptInterface_08_Reserved() {} + virtual void ISLavishScriptInterface_09_Reserved() {} + virtual void ISLavishScriptInterface_10_Reserved() {} + virtual void ISLavishScriptInterface_11_Reserved() {} + virtual void ISLavishScriptInterface_12_Reserved() {} + virtual void ISLavishScriptInterface_13_Reserved() {} + virtual void ISLavishScriptInterface_14_Reserved() {} + virtual void ISLavishScriptInterface_15_Reserved() {} + + + + virtual unsigned int AddGlobalAtom(const char *Buffer, size_t buflen)=0; + virtual bool RemoveAtom(unsigned int AtomID)=0; + virtual int ExecuteAtom(unsigned int AtomID,int argc=0, char *argv[]=0, PLSOBJECT pThisLSObject=0, PLSOBJECT pContext=0, char *ReturnBuffer=0, size_t buflen=0)=0; + virtual int ExecuteAtom(const char *Name,int argc=0, char *argv[]=0, PLSOBJECT pContext=0, char *ReturnBuffer=0, size_t buflen=0)=0; + virtual int ExecuteAtom(const char *ScriptName, const char *Name,int argc=0, char *argv[]=0, PLSOBJECT pContext=0, char *ReturnBuffer=0, size_t buflen=0)=0; + virtual unsigned int ResolveAtom(const char *Name)=0; + + // enumerations + virtual unsigned int EnumAliases(fLSGenericEnumCallback Callback, void *pData)=0; + virtual unsigned int EnumCommands(fLSGenericEnumCallback Callback, void *pData)=0; + virtual unsigned int EnumLSTypeDefinitions(fLSGenericEnumCallback Callback, void *pData)=0; + virtual unsigned int EnumTopLevelObjects(fLSGenericEnumCallback Callback, void *pData)=0; + virtual unsigned int EnumScripts(fLSGenericEnumCallback Callback, void *pData)=0; + + // scripts + virtual bool GetCurrentScript(char *buffer, size_t buflen)=0; + virtual bool GetScriptCWD(const char *ScriptName, char *buffer, size_t buflen)=0; + virtual bool QueueCommand(const char *ScriptName, const char *Command)=0; + virtual unsigned int GetScriptRuntime(const char *ScriptName)=0; + virtual unsigned int PauseScripts()=0; + virtual unsigned int ResumeScripts()=0; + virtual unsigned int AddAtom(const char *ScriptName, const char *Buffer, size_t buflen)=0; + virtual bool ScriptEngineActive()=0; + virtual void LavishScriptPulse()=0; + + // events + virtual unsigned int RegisterEvent(const char *Name)=0; + virtual void UnregisterEvent(unsigned int EventID)=0; + virtual bool ExecuteEvent(unsigned int EventID,int BeginInclusive=0, int EndExclusive=0, char *argv[]=0, PLSOBJECT pThisLSObject=0)=0; + virtual bool AttachEventTarget(unsigned int EventID,unsigned int AtomID)=0; + virtual bool AttachEventTarget(unsigned int EventID,fLSEventTarget fCallback)=0; + virtual bool DetachEventTarget(unsigned int EventID,unsigned int AtomID)=0; + virtual bool DetachEventTarget(unsigned int EventID,fLSEventTarget fCallback)=0; + + // misc + virtual unsigned int GetRuntime()=0; + virtual char *Escape(const char *text, char *buf, size_t buflen)=0; + virtual char *EscapeQuotes(const char *text, char *buf, size_t buflen) = 0; + virtual bool CalculateResult(const char *Formula, double &Result)=0; + virtual bool CalculateResult(const char *Formula, __int64 &Result)=0; + + virtual void Printf(const char *Format, ...)=0; + virtual void Print(const char *Text)=0; + virtual unsigned int GetTerminalWidth()=0; + +// inline functions + inline bool AddLSType(class LSTypeDefinition &Type) { return AddLSTypeDefinition(Type); } + inline bool RemoveLSType(class LSTypeDefinition &Type) { return RemoveLSTypeDefinition(Type); } + inline LSTypeDefinition *FindLSType(char *Name) { return FindLSTypeDefinition(Name); } + + inline bool IsLSType(char *Name) { return IsLSTypeDefinition(Name); } +}; + +class ISServiceMasterInterface +{ +public: + // service master + virtual HISXSERVICE RegisterService(ISXInterface *pMaster, const char *Name, fISServiceRequest RequestCallback=0)=0; + virtual bool ServiceBroadcast(ISXInterface *pMaster, HISXSERVICE hService, unsigned int MSG, void *lpData)=0; + virtual bool ServiceNotify(ISXInterface *pMaster, HISXSERVICE hService, ISXInterface *pTarget, unsigned int MSG, void *lpData)=0; + virtual bool ShutdownService(ISXInterface *pMaster, HISXSERVICE hService)=0; +}; + +class ISServiceClientInterface +{ +public: + // service client + virtual HISXSERVICE ConnectService(ISXInterface *pClient, const char *ServiceName, fISService NotifyCallback)=0; + virtual bool ServiceRequest(ISXInterface *pClient, HISXSERVICE hService, unsigned int MSG, void *lpData)=0; + virtual void DisconnectService(ISXInterface *pClient, HISXSERVICE hService)=0; +}; + +class ISInputInterface +{ +public: + // input + virtual bool AddHotkey(const char *Name, const char *Combo, const char *Command, bool Press=false)=0; + virtual bool IsHotkey(const char *Name)=0; + virtual bool RemoveHotkey(const char *Name)=0; + virtual bool MouseTo(int X, int Y)=0; + virtual bool GetMousePos(int &X, int &Y)=0; + + virtual bool EmulateKeyPress(const char *Combo, bool Hold)=0; + virtual bool EmulateKeyRelease(const char *Combo)=0; + virtual bool EmulateTyping(const char *Text)=0; + virtual bool EmulateMousePress(unsigned int Button, bool Hold)=0; + virtual bool EmulateMouseRelease(unsigned int Button)=0; + + // disable binds + virtual unsigned int SetPrintableBindsAllowed(bool bEnable)=0; + virtual unsigned int GetPrintableBindsAllowedCount()=0; + + + virtual void ISInputInterface_00_Reserved() {} + virtual void ISInputInterface_01_Reserved() {} + virtual void ISInputInterface_02_Reserved() {} + virtual void ISInputInterface_03_Reserved() {} + virtual void ISInputInterface_04_Reserved() {} + virtual void ISInputInterface_05_Reserved() {} + +}; + +class ISLavishSettingsInterface +{ +public: + + /* DEPRECATED, TO BE REMOVED IN NEAR FUTURE ISXDK */ + virtual __declspec(deprecated) bool GetSetting(char *Filename, char *Set, char *Setting, char *buf, size_t buflen)=0; + virtual __declspec(deprecated) bool SetSetting(char *Filename, char *Set, char *Setting, char *Value)=0; + virtual __declspec(deprecated) bool GetSettingb(char *Filename, char *Set, char *Setting, bool &bValue)=0; + virtual __declspec(deprecated) bool GetSettingi(char *Filename, char *Set, char *Setting, int &iValue)=0; + virtual __declspec(deprecated) bool SetSettingi(char *Filename, char *Set, char *Setting, int iValue)=0; + virtual __declspec(deprecated) bool GetSettingf(char *Filename, char *Set, char *Setting, float &fValue)=0; + virtual __declspec(deprecated) bool SetSettingf(char *Filename, char *Set, char *Setting, float fValue)=0; + virtual __declspec(deprecated) bool IsSet(char *Filename, char *Set)=0; + virtual __declspec(deprecated) bool CreateSet(char *Filename, char *Set)=0; + virtual __declspec(deprecated) bool RemoveSet(char *Filename, char *Set)=0; + virtual __declspec(deprecated) bool RemoveSetting(char *Filename, char *Set, char *Setting)=0; + virtual __declspec(deprecated) unsigned int EnumSets(char *Filename, fSetEnumCallback Callback, void *pData)=0; + virtual __declspec(deprecated) unsigned int EnumSettings(char *Filename, char *Set, fSettingEnumCallback Callback, void *pData)=0; + + virtual __declspec(deprecated) bool UnloadSettings(char *Filename)=0; // Use UnloadSet + virtual __declspec(deprecated) bool SaveSettings(char *Filename)=0; // Use ExportSet + + /* NEW AND IMPROVED! */ + virtual unsigned int OpenSettings(const char *Filename)=0; + + virtual unsigned int FindFileSet(const char *Filename)=0; + virtual unsigned int FindSet(unsigned int &ParentSetGUID, const char *Name)=0; + virtual bool SaveFileSet(const char *Filename)=0; + + virtual bool ExportSet(unsigned int &SetGUID, const char *Filename)=0; + virtual bool ImportToSet(unsigned int &SetGUID, const char *Filename)=0; + virtual bool CopySet(unsigned int &ToSetGUID, unsigned int FromSetGUID)=0; + virtual bool UnloadSet(unsigned int &SetGUID)=0; + virtual bool ClearSet(unsigned int &SetGUID)=0; + virtual bool SortSet(unsigned int &SetGUID)=0; + virtual unsigned int CreateSet(unsigned int &SetGUID, const char *Name)=0; + virtual bool GetSetName(unsigned int &SetGUID, char *buf, size_t buflen)=0; + virtual bool GetSetParent(unsigned int &SetGUID, unsigned int &ParentSetGUID)=0; + + virtual bool RenameSetting(unsigned int &SetGUID, const char *Setting, const char *NewName)=0; + virtual bool RemoveSetting(unsigned int &SetGUID, const char *Setting)=0; + + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, const char *Value)=0; + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, bool &bValue)=0; + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, int iValue)=0; + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, float &fValue)=0; + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, unsigned int &ulValue)=0; + virtual bool AssertSetting(unsigned int &SetGUID, const char *Setting, __int64 &Value)=0; + + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, char *buf, size_t buflen)=0; + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, bool &bValue)=0; + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, int &iValue)=0; + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, float &fValue)=0; + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, unsigned int &ulValue)=0; + virtual bool GetSetting(unsigned int &SetGUID, const char *Setting, __int64 &Value)=0; + + virtual bool SetSetting(unsigned int &SetGUID, const char *Setting, const char *Value)=0; + virtual bool SetSetting(unsigned int &SetGUID, const char *Setting, int iValue)=0; + virtual bool SetSetting(unsigned int &SetGUID, const char *Setting, unsigned int &ulValue)=0; + virtual bool SetSetting(unsigned int &SetGUID, const char *Setting, float &fValue)=0; + virtual bool SetSetting(unsigned int &SetGUID, const char *Setting, __int64 &Value)=0; + + virtual bool CreateComment(unsigned int &SetGUID, const char *Text)=0; + + virtual unsigned int EnumSets(unsigned int &SetGUID, fSetEnumCallback Callback, void *pData)=0; + virtual unsigned int EnumSettings(unsigned int &SetGUID, fSettingEnumCallback Callback, void *pData)=0; + + virtual void ISLavishSettingsInterface_00_Reserved() {} + virtual void ISLavishSettingsInterface_01_Reserved() {} + virtual void ISLavishSettingsInterface_02_Reserved() {} + virtual void ISLavishSettingsInterface_03_Reserved() {} + virtual void ISLavishSettingsInterface_04_Reserved() {} + virtual void ISLavishSettingsInterface_05_Reserved() {} + virtual void ISLavishSettingsInterface_06_Reserved() {} + virtual void ISLavishSettingsInterface_07_Reserved() {} + virtual void ISLavishSettingsInterface_08_Reserved() {} + virtual void ISLavishSettingsInterface_09_Reserved() {} + virtual void ISLavishSettingsInterface_10_Reserved() {} + virtual void ISLavishSettingsInterface_11_Reserved() {} + virtual void ISLavishSettingsInterface_12_Reserved() {} + virtual void ISLavishSettingsInterface_13_Reserved() {} + virtual void ISLavishSettingsInterface_14_Reserved() {} + virtual void ISLavishSettingsInterface_15_Reserved() {} + virtual void ISLavishSettingsInterface_16_Reserved() {} + virtual void ISLavishSettingsInterface_17_Reserved() {} + virtual void ISLavishSettingsInterface_18_Reserved() {} + virtual void ISLavishSettingsInterface_19_Reserved() {} + virtual void ISLavishSettingsInterface_20_Reserved() {} + +}; + +class ISIPCInterface +{ +public: + // inter-process + virtual void Relay(const char *Session, const char *Command)=0; + virtual unsigned int GetSessionCount()=0; + virtual bool GetSessionName(unsigned int nSession, char *buf, size_t buflen) = 0; + + virtual void ISIPCInterface_00_Reserved() {} + virtual void ISIPCInterface_01_Reserved() {} + virtual void ISIPCInterface_02_Reserved() {} + virtual void ISIPCInterface_03_Reserved() {} + virtual void ISIPCInterface_04_Reserved() {} + virtual void ISIPCInterface_05_Reserved() {} + +}; + +class ISNavigationInterface +{ +public: + virtual unsigned int LNavAddRegion(unsigned int ParentGUID, const char *Type, const char *Name, int BeginInclusive, int EndExclusive, char *argv[])=0; + virtual bool LNavRemoveRegion(unsigned int RegionGUID)=0; + + virtual unsigned int LNavAddConnection(unsigned int FromGUID, unsigned int ToGUID, int BeginInclusive, int EndExclusive, char *argv[])=0; + virtual bool LNavRemoveConnection(unsigned int ConnectionGUID)=0; + + virtual unsigned int LNavResolveFQN(const char *FQN, unsigned int FromGUID=0)=0; + + virtual bool LNavImportXML(unsigned int ParentGUID, const char *Filename)=0; + virtual bool LNavExportXML(unsigned int RegionGUID, const char *Filename, bool OnlyChildren)=0; + + virtual void ISNavigationInterface_00_Reserved() {} + virtual void ISNavigationInterface_01_Reserved() {} + virtual void ISNavigationInterface_02_Reserved() {} + virtual void ISNavigationInterface_03_Reserved() {} + virtual void ISNavigationInterface_04_Reserved() {} + virtual void ISNavigationInterface_05_Reserved() {} + virtual void ISNavigationInterface_06_Reserved() {} + virtual void ISNavigationInterface_07_Reserved() {} + virtual void ISNavigationInterface_08_Reserved() {} + virtual void ISNavigationInterface_09_Reserved() {} + virtual void ISNavigationInterface_10_Reserved() {} + virtual void ISNavigationInterface_11_Reserved() {} + virtual void ISNavigationInterface_12_Reserved() {} + virtual void ISNavigationInterface_13_Reserved() {} + virtual void ISNavigationInterface_14_Reserved() {} + virtual void ISNavigationInterface_15_Reserved() {} + virtual void ISNavigationInterface_16_Reserved() {} + virtual void ISNavigationInterface_17_Reserved() {} + virtual void ISNavigationInterface_18_Reserved() {} + virtual void ISNavigationInterface_19_Reserved() {} + virtual void ISNavigationInterface_20_Reserved() {} + +}; + +class ISDisplayInterface +{ +public: + // display + virtual bool GetDisplaySize(unsigned int &Height, unsigned int &Width)=0; + virtual bool GetPixel(int X, int Y, RGBCOLOR &Color)=0; + virtual bool GetPixels(int X, int Y, unsigned int nRows, unsigned int nColumns, RGBCOLOR **Rows)=0; + virtual bool GetDisplayRect(enum _D3DXIMAGE_FILEFORMAT format, bool front_buffer, RECT *optional_area, struct ID3DXBuffer **ppScreenshot)=0; + + virtual void ISDisplayInterface_01_Reserved() {} + virtual void ISDisplayInterface_02_Reserved() {} + virtual void ISDisplayInterface_03_Reserved() {} + virtual void ISDisplayInterface_04_Reserved() {} + virtual void ISDisplayInterface_05_Reserved() {} + virtual void ISDisplayInterface_06_Reserved() {} + virtual void ISDisplayInterface_07_Reserved() {} + virtual void ISDisplayInterface_08_Reserved() {} + virtual void ISDisplayInterface_09_Reserved() {} + virtual void ISDisplayInterface_10_Reserved() {} + virtual void ISDisplayInterface_11_Reserved() {} + virtual void ISDisplayInterface_12_Reserved() {} + virtual void ISDisplayInterface_13_Reserved() {} + virtual void ISDisplayInterface_14_Reserved() {} + virtual void ISDisplayInterface_15_Reserved() {} + virtual void ISDisplayInterface_16_Reserved() {} + virtual void ISDisplayInterface_17_Reserved() {} + virtual void ISDisplayInterface_18_Reserved() {} + virtual void ISDisplayInterface_19_Reserved() {} + virtual void ISDisplayInterface_20_Reserved() {} + +}; + +class ISLavishVMInterface +{ +public: + /* LavishVM */ + virtual bool IsAvailable()=0; + virtual bool TryInitialize()=0; + virtual bool RegisterLibrary(const char *Name,fGetAPI)=0; + virtual bool UnregisterLibrary(const char *Name)=0; + virtual bool Execute(const char *Domain, const char *AssemblyName, int argc=0, const char *argv[]=0)=0; + virtual bool UnloadDomain(const char *Name)=0; + + virtual unsigned int EnumDomains(fDomainEnumCallback, void *pData)=0; + virtual bool IsDomainActive(const char *Name)=0; + + /* Threading (including LavishVM) */ + virtual void FrameLock()=0; + virtual void FrameUnlock()=0; + virtual bool FrameTryLock()=0; + virtual void FrameWait(bool bLock)=0; +}; + +class ISInterface : public ISLavishScriptInterface, + public ISServiceMasterInterface, + public ISServiceClientInterface, + public ISInputInterface, + public ISLavishSettingsInterface, + public ISIPCInterface, + public ISNavigationInterface, + public ISDisplayInterface, + public ISLavishVMInterface +{ +public: + virtual unsigned int GetVersion()=0; + virtual unsigned int GetBuildNumber()=0; + + virtual unsigned int GetExtensionSetGUID(const char *Extension)=0; + virtual unsigned int GetScriptSetGUID(const char *Script)=0; + virtual unsigned int CreateExtensionSet(const char *Extension)=0; + virtual unsigned int CreateScriptSet(const char *Script)=0; + + virtual unsigned int GetGameSetGUID()=0; + virtual unsigned int GetProfileSetGUID()=0; + + virtual bool LoadExtension(const char *Filename)=0; + virtual bool UnloadExtension(const char *Filename, bool &denied_by_extension)=0; + virtual bool IsExtensionLoaded(const char *Filename)=0; + + // High Stealth is intended for temporarily increasing stealth while an application + // performs scanning and detection methods + virtual bool HighStealthEnabled()=0; + virtual void EnableHighStealth()=0; + virtual void DisableHighStealth()=0; + + // paths + virtual char *GetInnerSpacePath(char *buffer, size_t buflen)=0; + virtual char *GetLogsPath(const char *extension_subdir, char *buffer, size_t buflen) = 0; + + virtual char *GetSettingsPath(char *buffer, size_t buflen) = 0; + virtual char *GetNETProgramsPath(char *buffer, size_t buflen) = 0; + virtual char *GetExtensionsPath(char *buffer, size_t buflen) = 0; + virtual char *GetInterfacePath(char *buffer, size_t buflen) = 0; + virtual char *GetLavishScriptModulesPath(char *buffer, size_t buflen) = 0; + virtual char *GetScreenshotsPath(char *buffer, size_t buflen) = 0; + virtual char *GetScriptsPath(char *buffer, size_t buflen) = 0; + + // hud + virtual bool AddElement(const char *Name, const char *Data, int X, int Y, unsigned int Color, const char *Group="Default")=0; + virtual bool RemoveElement(const char *Name)=0; + + // console + virtual void ClearConsole()=0; + + virtual void EnableStealth()=0; + virtual bool StealthEnabled()=0; + + virtual void StoreInnerSpaceSettings() {}; + + + + virtual bool GetLavishScript2Environment_(unsigned int LS2MODULE_SDK_VERSION, void **ppEnvironment)=0; + bool GetLavishScript2Environment(unsigned int LS2MODULE_SDK_VERSION, void **ppEnvironment) + { + if (GetBuildNumber()>=5671) + return GetLavishScript2Environment_(LS2MODULE_SDK_VERSION,ppEnvironment); + return false; + } + + virtual void ISInterface_01_Reserved() {} + virtual void ISInterface_02_Reserved() {} + virtual void ISInterface_03_Reserved() {} + virtual void ISInterface_04_Reserved() {} + virtual void ISInterface_05_Reserved() {} + virtual void ISInterface_06_Reserved() {} + virtual void ISInterface_07_Reserved() {} + virtual void ISInterface_08_Reserved() {} + virtual void ISInterface_09_Reserved() {} + virtual void ISInterface_10_Reserved() {} + virtual void ISInterface_11_Reserved() {} + virtual void ISInterface_12_Reserved() {} + virtual void ISInterface_13_Reserved() {} + virtual void ISInterface_14_Reserved() {} + virtual void ISInterface_15_Reserved() {} + virtual void ISInterface_16_Reserved() {} + virtual void ISInterface_17_Reserved() {} + virtual void ISInterface_18_Reserved() {} + virtual void ISInterface_19_Reserved() {} + virtual void ISInterface_20_Reserved() {} +}; + diff --git a/libs/isxdk/include/ISUI/LGUI.h b/libs/isxdk/include/ISUI/LGUI.h new file mode 100644 index 0000000..1dfce74 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUI.h @@ -0,0 +1,100 @@ +#pragma once +#ifdef LGUI_LIBRARY +#define LGUI_API +#else +#ifdef LGUI_EXPORTS +#define LGUI_API __declspec(dllexport) +#else +#define LGUI_API __declspec(dllimport) +#endif +#endif + +#include +//#include +#include +using namespace std; + +#define LGUI_VERSION 0x12 +#define LGUI_VERSIONSTRING "0.73" + +class LGUIPreParse +{ +public: + LGUI_API LGUIPreParse(const char *Text); + LGUI_API LGUIPreParse(); + LGUI_API ~LGUIPreParse(); + + LGUI_API void Clear(); + LGUI_API void PreParse(const char *Text); + LGUI_API bool RetrieveProcessedText(char *buf, unsigned int buflen); + + inline const char *GetOriginalText() + { + return OriginalText; + } + + inline unsigned int GetID() + { + return ID; + } +protected: + const char *OriginalText; + unsigned int ID; +}; + +class LGUIDataSequence +{ +public: + LGUI_API LGUIDataSequence(); + LGUI_API LGUIDataSequence(const char *DataSequence); + LGUI_API ~LGUIDataSequence(); + + LGUI_API void Clear(); + LGUI_API void PreParse(const char *DataSequence); + LGUI_API bool RetrieveOriginalText(char *buf, unsigned int buflen); + LGUI_API bool RetrieveProcessedText(char *buf, unsigned int buflen); + LGUI_API bool RetrieveProcessedResult(LSOBJECT &Result); + + inline unsigned int GetID() + { + return ID; + } + +protected: + unsigned int ID; +}; + +#include "LGUIEmbeddedScript.h" +#include "LGUITexture.h" +#include "LGUIFont.h" +#include "LGUIElement.h" +#include "LGUIFrame.h" +#include "LGUIContextMenu.h" +#include "LGUIWindow.h" +#include "LGUIText.h" +#include "LGUITextEntry.h" +#include "LGUITextEdit.h" +#include "LGUICommandEntry.h" +#include "LGUIConsole.h" +#include "LGUIHudElement.h" +#include "LGUIScreen.h" +#include "LGUIButton.h" +#include "LGUICommandButton.h" +#include "LGUICheckBox.h" +#include "LGUICommandCheckBox.h" +#include "LGUISlider.h" +#include "LGUIVariableSlider.h" +#include "LGUIScrollBar.h" +#include "LGUIMessageBox.h" +#include "LGUIGauge.h" +#include "LGUIVariableGauge.h" +#include "LGUIListBox.h" +#include "LGUIComboBox.h" +#include "LGUITabControl.h" +#include "LGUITooltip.h" +#include "LGUITable.h" +#include "LGUIMap.h" +#include "LGUITree.h" +#include "LGUIManager.h" + +#define SELECT(possiblevalue,defaultvalue) ((possiblevalue)?(possiblevalue):(defaultvalue)) \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIButton.h b/libs/isxdk/include/ISUI/LGUIButton.h new file mode 100644 index 0000000..600a28f --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIButton.h @@ -0,0 +1,55 @@ +#pragma once +#include "LGUIelement.h" + +struct _CreateButton : public _CreateElement +{ + char *Text; // may be 0 for no text +// char *Font; +// unsigned int FontSize; // may be 0 to use default +// unsigned int TextColor; // may be 0 to use default (use 0xFF000000 for solid black) + + + _CreateFont Font; + + unsigned int BackgroundColor; // may be 0 to use default (0xFF000000 for solid black) + + bool DefaultTextures; // // You may create textures directly if you do not use default textures flag + + unsigned int Border; + unsigned int BorderColor; // may be 0 to use default (use 0xFF000000 for solid black) + +}; + +class LGUIButton : + public LGUIElement +{ +public: + LGUI_API LGUIButton(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIButton(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateButton &CreateInfo, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + + // -- XML Properties -- + LGUIPreParse Text; + + LGUIFont *pFont; + + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; + + LGUITexture *pTexture; + LGUITexture *pTexturePressed; + LGUITexture *pTextureHover; + // -------------------- + + bool bDown; +}; diff --git a/libs/isxdk/include/ISUI/LGUICheckBox.h b/libs/isxdk/include/ISUI/LGUICheckBox.h new file mode 100644 index 0000000..4a0cf4a --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUICheckBox.h @@ -0,0 +1,34 @@ +#pragma once +#include "LGUIelement.h" + +class LGUICheckBox : + public LGUIElement +{ +public: + LGUI_API LGUICheckBox(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUICheckBox(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + + // -- XML Properties -- + LGUIPreParse Text; + LGUIFont *pFont; + + LGUITexture *pTexture; + LGUITexture *pTexturePressed; + LGUITexture *pTextureHover; + LGUITexture *pTextureChecked; + LGUITexture *pTextureCheckedPressed; + LGUITexture *pTextureCheckedHover; + + // -------------------- + + bool bDown; + bool bChecked; +}; diff --git a/libs/isxdk/include/ISUI/LGUIComboBox.h b/libs/isxdk/include/ISUI/LGUIComboBox.h new file mode 100644 index 0000000..1faeacb --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIComboBox.h @@ -0,0 +1,40 @@ +#pragma once + +class LGUIComboBox : + public LGUIElement +{ +public: + LGUI_API LGUIComboBox(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIComboBox(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void RecalculateSize(bool RecalculateChildren); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API void OnLMouseDownOther(LGUIElement *pOther); + + // -- XML Properties -- + LGUITexture *pTexture; + LGUITexture *pButtonTexture; + LGUIFont *pFont; + + unsigned int Border; + + unsigned int FullHeight; + + + unsigned int ButtonWidth; + + LGUIEmbeddedScript *pOnSelect; + // ---------------------- + + + LGUIListBox *pListBox; + bool bDown; + unsigned int NormalHeight; + int Selection; +}; diff --git a/libs/isxdk/include/ISUI/LGUICommandButton.h b/libs/isxdk/include/ISUI/LGUICommandButton.h new file mode 100644 index 0000000..37ce66d --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUICommandButton.h @@ -0,0 +1,23 @@ +#pragma once +#include "LGUIelement.h" + +class LGUICommandButton : + public LGUIButton +{ +public: + LGUI_API LGUICommandButton(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUICommandButton(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + + // -- XML Properties -- + + char *Command; + char *Console; + // -------------------- + +}; diff --git a/libs/isxdk/include/ISUI/LGUICommandCheckBox.h b/libs/isxdk/include/ISUI/LGUICommandCheckBox.h new file mode 100644 index 0000000..749661c --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUICommandCheckBox.h @@ -0,0 +1,27 @@ +#pragma once +#include "LGUIelement.h" + +class LGUICommandCheckBox : + public LGUICheckBox +{ +public: + LGUI_API LGUICommandCheckBox(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUICommandCheckBox(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API void Render(); + + // -- XML Properties -- + LGUIPreParse Data; + + char *Command; + char *CommandChecked; + char *Console; + + // -------------------- + +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUICommandEntry.h b/libs/isxdk/include/ISUI/LGUICommandEntry.h new file mode 100644 index 0000000..d4570c3 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUICommandEntry.h @@ -0,0 +1,33 @@ +#pragma once +#include "LGUItextentry.h" + +class LGUICommandEntry : + public LGUITextEntry +{ +public: + LGUI_API LGUICommandEntry(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUICommandEntry(void); + LGUI_API bool IsTypeOf(char *TestFactory); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API virtual bool OnKeyDown(unsigned int VKey); + LGUI_API virtual void HandleEnter(); + LGUI_API virtual void PasteClipboard(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void OnCommand(char *Text); + + // + char *Console; + + // + unsigned int CmdHistorySize; + char **CmdHistory; + + int HistoryLine; + int HistoryView; + int HistoryLines; + + void InsertCmdHistory(char *Text); + LGUIEmbeddedScript *pOnCommand; +}; diff --git a/libs/isxdk/include/ISUI/LGUIConsole.h b/libs/isxdk/include/ISUI/LGUIConsole.h new file mode 100644 index 0000000..87afd2f --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIConsole.h @@ -0,0 +1,80 @@ +#pragma once +#include "LGUIelement.h" + +class LGUIConsoleSelector +{ +public: + LGUI_API LGUIConsoleSelector(class LGUIConsole *pConsole); + LGUI_API LGUIConsoleSelector(const char *FullyQualifiedName); + LGUI_API ~LGUIConsoleSelector(); +protected: + char PreviousConsole[1024]; +}; + + +class LGUIConsole : + public LGUIElement +{ +public: + LGUI_API LGUIConsole(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIConsole(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void SizeRecalculated(bool Changed); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API void Render(); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + + LGUI_API virtual void HandlePageUp(); + LGUI_API virtual void HandlePageDown(); + LGUI_API virtual void HandleUp(); + LGUI_API virtual void HandleDown(); + + LGUI_API void SetFontSize(unsigned int NewHeight); + LGUI_API void SnapToGrid(POINT2I &pt); + LGUI_API void CopySelection(); + + + LGUI_API void SplitFixed(char *in, size_t MaxWidth); + LGUI_API void Clear(); + LGUI_API void Printf(const char *szFormat, ...); + LGUI_API void Print(const char *Text); + + +// -- XML PROPERTIES -- + LGUIFixedFont *pFont; + + unsigned int Border; + unsigned int BorderColor; + unsigned int ScrollbackColor; + unsigned int BackgroundColor; + + unsigned int SelectionColor; + + LGUITexture *pTexture; + LGUITexture *pTextureScrollback; + +// ---------------------- + + + unsigned int BackBufferSize; + char **BackBuffer; + int LastLine; + + class LGUIScrollBar *pVerticalBar; + + int ScrollBack; + int VisibleLines; + + bool bSelect; + RECT Selection; + +protected: + LGUI_API virtual void AddLineInternal(char *Line); +}; diff --git a/libs/isxdk/include/ISUI/LGUIContextMenu.h b/libs/isxdk/include/ISUI/LGUIContextMenu.h new file mode 100644 index 0000000..1f765c7 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIContextMenu.h @@ -0,0 +1,170 @@ +#pragma once + +enum ContextMenuType +{ + CMT_ITEM=1, + CMT_SUBMENU=2, + CMT_SEPARATOR=3, +}; + +class LGUIContextMenuNode +{ +public: + LGUIContextMenuNode(class LGUIContextMenu *p_pParent, ContextMenuType p_Type, unsigned int p_ID=0); + + LGUIContextMenuNode(class LGUIContextMenu *p_pParent, LGUIContextMenuNode *pInsertAfter, ContextMenuType p_Type, unsigned int ID=0); + virtual ~LGUIContextMenuNode(); + + RECT r; + virtual size_t Render()=0; + virtual void OnLMouseUp()=0; + + class LGUIContextMenu *pMenu; + LGUIContextMenuNode *pPrev; + LGUIContextMenuNode *pNext; + + ContextMenuType Type; + unsigned int ID; +}; + +class LGUIContextMenuItem : public LGUIContextMenuNode +{ +public: + LGUIContextMenuItem(class LGUIContextMenu *p_pParent, char *p_Text, unsigned int p_ID=0); + ~LGUIContextMenuItem(); + + size_t Render(); + void OnLMouseUp(); + + char *Text; + + bool bChecked; +}; + + +class LGUIContextMenuSubmenu : public LGUIContextMenuNode +{ +public: + LGUIContextMenuSubmenu(class LGUIContextMenu *p_pParent, char *Text, class CContextMenuHandler *p_pHandler, unsigned int p_ID=0); + ~LGUIContextMenuSubmenu(); + size_t Render(); + void OnLMouseUp(); + + char *Text; + class CContextMenuHandler *pHandler; +}; + +class LGUIContextMenuSeparator : public LGUIContextMenuNode +{ +public: + LGUIContextMenuSeparator(class LGUIContextMenu *p_pParent); + ~LGUIContextMenuSeparator(); + size_t Render(); + void OnLMouseUp() + { + } +}; + +class LGUIContextMenu : + public LGUIFrame +{ +public: + LGUIContextMenu(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + ~LGUIContextMenu(void); + bool IsTypeOf(char *TestFactory); +// class LSTypeDefinition *GetLSType(); + + bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + bool Create(class CContextMenuHandler *p_pMenuHandler, class XMLNode *pTemplate=0); + + + void Render(); + + bool OnLMouseUp(POINT2I &pt); + bool OnLMouseDown(POINT2I &pt); + bool OnMouseMove(POINT2I &pt); + + unsigned int AddItem(char *Text, unsigned int ID=0); + unsigned int AddSubmenu(char *Text, CContextMenuHandler *pHandler, unsigned int ID=0); + unsigned int AddSeparator(); + bool GetItemCheck(unsigned int ID, bool &bChecked); + void SetItemCheck(unsigned int ID, bool bChecked); + + void OnKeyboardExit(LGUIElement *pNewFocus); + void OnLMouseDownOther(LGUIElement *pOther); + + // -- From XML -- + LGUIFont *pFont; + unsigned int HighlightColor; + + LGUITexture *pItemTexture; + LGUITexture *pSubmenuTexture; + LGUITexture *pSeparatorTexture; + LGUITexture *pHighlightItemTexture; + LGUITexture *pHighlightSubmenuTexture; + LGUITexture *pItemCheckTexture; + + + // -------------------------------- + + unsigned int ParentMenuID; + unsigned int ChildMenuID; + + + unsigned int NextID; + LGUIContextMenuNode *pItems; + unsigned int nItems; + + LGUIContextMenuNode *pMouseOver; + class CContextMenuHandler *pMenuHandler; +}; + +class CContextMenuHandler +{ +public: + LGUI_API CContextMenuHandler() + { + pMenu=0; + pTemplate=0; + pChildMenu=0; + pParentMenu=0; + } + LGUI_API virtual ~CContextMenuHandler() + { + DestroyMenu(); + } + + inline bool IsMenu() + { + return pMenu!=0; + } + inline void SetTemplate(class XMLNode *pNewTemplate) + { + pTemplate=pNewTemplate; + } + + bool Create(CContextMenuHandler *p_pParentMenu, unsigned int ParentItemID, int X, int Y); + LGUI_API bool Create(int X, int Y); + LGUI_API unsigned int AddItem(char *Text, unsigned int ID=0); + LGUI_API unsigned int AddSubMenu(char *Text, CContextMenuHandler *pHandler, unsigned int ID=0); + LGUI_API unsigned int AddSeparator(); + LGUI_API bool GetItemCheck(unsigned int ID, bool &bChecked); + LGUI_API void SetItemCheck(unsigned int ID, bool bChecked); + + LGUI_API virtual void OnCreate(unsigned int ParentItemID) {} + virtual void OnClick(unsigned int ItemID)=0; + + LGUI_API void DestroyMenu(bool bParentsToo=false); + + LGUI_API virtual void OnMenuDestroyed() + { + pMenu=0; + } + +private: + class XMLNode *pTemplate; + class LGUIContextMenu *pMenu; + + class CContextMenuHandler *pChildMenu; + class CContextMenuHandler *pParentMenu; +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIElement.h b/libs/isxdk/include/ISUI/LGUIElement.h new file mode 100644 index 0000000..355a524 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIElement.h @@ -0,0 +1,687 @@ +#pragma once +#include "LGUIManager.h" + +#define NOTIFICATION_USER (0x10000000) + +#define NOTIFICATION_NULL 0 +#define NOTIFICATION_CLICKED 1 +//#define NOTIFICATION_CLOSE 2 +#define NOTIFICATION_CHANGETEXT 3 +#define NOTIFICATION_CHANGENUMBER 4 +#define NOTIFICATION_ENTER 5 +#define NOTIFICATION_LMOUSEDOWN 6 +#define NOTIFICATION_LMOUSEUP NOTIFICATION_CLICKED +#define NOTIFICATION_RMOUSEDOWN 7 +#define NOTIFICATION_RMOUSEUP 8 +#define NOTIFICATION_CHANGESELECTION 9 +#define NOTIFICATION_LMOUSEDOUBLECLICK 10 +#define NOTIFICATION_RMOUSEDOUBLECLICK 11 +#define NOTIFICATION_DOUBLECLICKSELECTION 12 +#define NOTIFICATION_CHANGEORDER 13 +#define NOTIFICATION_MOUSEMOVE 14 +#define NOTIFICATION_MOUSEWHEEL 15 + +#define NOTIFICATION_FONTCHANGED 50 +#define NOTIFICATION_DELETING 51 + + +enum eElementPositionType +{ + EPT_FIXED=0, + EPT_VARIABLE=1, + EPT_PERCENT=2, + EPT_REVERSE_FIXED=3, +}; + +enum eElementFadeState +{ + EFS_NORMAL=0, + EFS_DELAYING=1, + EFS_FADING=2, + EFS_FADED=3, + + EFS_IN_DELAYING=4, + EFS_IN_FADING=5, + EFS_IN_FADED=6, +}; + +struct ElementPosition +{ + eElementPositionType Type; + union + { + unsigned int Size; + float fSize; + }; +}; + + +class XMLHelper +{ +public: + LGUI_API static bool GetToggle(class XMLNode *pXML, const char *Name, bool Default=0); + + LGUI_API static unsigned int GetIntValue(class XMLNode *pXML, const char *Name, unsigned int Default=0); + LGUI_API static float GetFloatValue(class XMLNode *pXML, const char *Name, float Default=0.0f); + LGUI_API static unsigned int GetHexValue(class XMLNode *pXML, const char *Name, unsigned int Default=0); + LGUI_API static unsigned int GetFactorValue(class XMLNode *pXML, const char *Name, float &FactorResult, unsigned int Default=0); + LGUI_API static unsigned int GetElementPositionValue(class XMLNode *pXML, const char *Name, ElementPosition &EPResult, unsigned int Default=0); + LGUI_API static bool GetElementPositionValueEx(class XMLNode *pXML, const char *Name, ElementPosition &EPResult, unsigned int &ulResult); + LGUI_API static const char *GetStringValue(class XMLNode *pXML, const char *Name, const char *Default = ""); + + LGUI_API static class XMLNode *GetChild(class XMLNode *pXML, const char *Name); + LGUI_API static const char *GetText(class XMLNode *pXML); + LGUI_API static class XMLNode *GetPrev(class XMLNode *pXML); + LGUI_API static class XMLNode *GetParent(class XMLNode *pXML); + LGUI_API static class XMLNode *GetNext(class XMLNode *pXML); + LGUI_API static class XMLNode *GetFirstChild(class XMLNode *pXML); + + LGUI_API static unsigned int GetIntAttribute(class XMLNode *pXML, const char *Name, unsigned int Default=0); + LGUI_API static float GetFloatAttribute(class XMLNode *pXML, const char *Name, float Default=0.0f); + LGUI_API static unsigned int GetHexAttribute(class XMLNode *pXML, const char *Name, unsigned int Default=0); + LGUI_API static unsigned int GetFactorAttribute(class XMLNode *pXML, const char *Name, float &FactorResult, unsigned int Default=0); + LGUI_API static unsigned int GetElementPositionAttribute(class XMLNode *pXML, const char *Name, ElementPosition &EPResult, unsigned int Default=0); + LGUI_API static const char *GetStringAttribute(class XMLNode *pXML, const char *Name, const char *Default=""); + + + static inline bool GetTemplateToggle(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, bool Default=0) + { + Default=GetToggle(pTemplate,Name,Default); + return GetToggle(pXML,Name,Default); + } + static inline unsigned int GetTemplateIntValue(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, unsigned int Default=0) + { + Default=GetIntValue(pTemplate,Name,Default); + return GetIntValue(pXML,Name,Default); + } + static inline float GetTemplateFloatValue(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, float Default=0) + { + Default=GetFloatValue(pTemplate,Name,Default); + return GetFloatValue(pXML,Name,Default); + } + static inline unsigned int GetTemplateHexValue(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, unsigned int Default=0) + { + Default=GetHexValue(pTemplate,Name,Default); + return GetHexValue(pXML,Name,Default); + } + static inline unsigned int GetTemplateFactorValue(class XMLNode *pXML, const char *Name, float &FactorResult, class XMLNode *pTemplate) + { + float TempFactorResult; + unsigned int Default=GetFactorValue(pTemplate,Name,TempFactorResult,0); + unsigned int Ret=GetFactorValue(pXML,Name,FactorResult,0); + if (!Ret && !FactorResult) + { + FactorResult=TempFactorResult; + return Default; + } + return Ret; + } + static inline unsigned int GetTemplateElementPositionValue(class XMLNode *pXML, const char *Name, ElementPosition &EPResult, class XMLNode *pTemplate) + { + unsigned int Ret=0; + if (GetElementPositionValueEx(pXML,Name,EPResult,Ret)) + return Ret; + return GetElementPositionValue(pTemplate,Name,EPResult,0); + } + static inline const char *GetTemplateStringValue(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, const char *Default="") + { + Default=GetStringValue(pTemplate,Name,Default); + return GetStringValue(pXML,Name,Default); + } + + static inline class XMLNode *GetTemplateChild(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate) + { + class XMLNode *pNode=GetChild(pXML,Name); + if (pNode) + return pNode; + return GetChild(pTemplate,Name); + } + + static inline unsigned int GetTemplateIntAttribute(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, unsigned int Default=0) + { + Default=GetIntAttribute(pTemplate,Name,Default); + return GetIntAttribute(pXML,Name,Default); + } + static inline float GetTemplateFloatAttribute(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, float Default=0) + { + Default=GetFloatAttribute(pTemplate,Name,Default); + return GetFloatAttribute(pXML,Name,Default); + } + static inline unsigned int GetTemplateHexAttribute(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate,unsigned int Default=0) + { + Default=GetHexAttribute(pTemplate,Name,Default); + return GetHexAttribute(pXML,Name,Default); + } + static inline unsigned int GetTemplateFactorAttribute(class XMLNode *pXML, const char *Name, float &FactorResult, class XMLNode *pTemplate) + { + float TempFactorResult; + unsigned int Default=GetFactorAttribute(pTemplate,Name,TempFactorResult,0); + unsigned int Ret=GetFactorAttribute(pXML,Name,FactorResult,0); + if (!Ret && !FactorResult) + { + FactorResult=TempFactorResult; + return Default; + } + return Ret; + } + static inline const char *GetTemplateStringAttribute(class XMLNode *pXML, const char *Name, class XMLNode *pTemplate, const char *Default = "") + { + Default=GetStringAttribute(pTemplate,Name,Default); + return GetStringAttribute(pXML,Name,Default); + } +}; + +struct _Line +{ + POINT2I A; + POINT2I B; +}; + +/* +struct _TexturedPoint +{ + POINT2I pt; + LGUITexture *pTexture; + unsigned int Weight; +}; +/**/ + +struct _CreateElement +{ + int X; + int Y; + unsigned int Width; + unsigned int Height; + ElementPosition XFactor; + ElementPosition YFactor; + ElementPosition HeightFactor; + ElementPosition WidthFactor; + bool bVisible; + char bAlwaysOnTop; +}; + +struct FullElementPosition +{ + int X; + ElementPosition XFactor; + int Y; + ElementPosition YFactor; + unsigned int Height; + ElementPosition HeightFactor; + unsigned int Width; + ElementPosition WidthFactor; +}; + +class LGUIElement +{ +public: + LGUI_API LGUIElement(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API virtual ~LGUIElement(); + + LGUI_API void Delete(); // dont call this. use Destroy() instead. + + LGUI_API bool TextureFromArgs(int argc, char *argv[], LGUITexture **ppTexture); + + LGUI_API virtual bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API virtual LGUITexture *TextureFromXML(class XMLNode *pXML, const char *ValueName, class XMLNode *pTemplate = 0); + LGUI_API virtual LGUIFont *FontFromXML(class XMLNode *pXML, const char *ValueName, class XMLNode *pTemplate = 0); + LGUI_API virtual LGUIFixedFont *FixedFontFromXML(class XMLNode *pXML, const char *ValueName, class XMLNode *pTemplate = 0); + LGUI_API virtual LGUIEmbeddedScript *EmbeddedScriptFromXML(class XMLNode *pXML, const char *ValueName, class XMLNode *pTemplate = 0, const char *Parameters = ""); + + LGUI_API virtual bool IsTypeOf(char *TestFactory); + + LGUI_API virtual void RecalculateSize(bool RecalculateChildren); + LGUI_API virtual void RecalculateChildrenSize(); + LGUI_API virtual void SizeRecalculated(bool Changed) {}; + LGUI_API virtual void Render(); + LGUI_API virtual void RenderChildren(); + LGUI_API virtual void Show(bool bShow) {bVisible=bShow;} + LGUI_API virtual void Center(); + + LGUI_API virtual bool OnLMouseUp(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnLMouseDown(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnRMouseUp(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnRMouseDown(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnLMouseDoubleClick(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnRMouseDoubleClick(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnMouseMove(POINT2I &pt);// {return false;} + LGUI_API virtual bool OnMouseWheel(int Offset);// {return false;}; + LGUI_API virtual bool OnKeyUp(unsigned int VKey);// {return false;} + LGUI_API virtual bool OnKeyDown(unsigned int VKey);// {return false;} + LGUI_API virtual void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value) {if (pParent) pParent->OnNotify(pElement,Notification,Value);}; + LGUI_API virtual void OnMouseEnter(POINT2I &pt);// {} + LGUI_API virtual void OnMouseExit(LGUIElement *pNewFocus);// {} + LGUI_API virtual void OnKeyboardEnter();// {} + LGUI_API virtual void OnKeyboardExit(LGUIElement *pNewFocus);// {} + LGUI_API virtual void OnLMouseDownOther(LGUIElement *pOther) {} + LGUI_API virtual void OnCreate() {} + LGUI_API virtual void OnDestroy() {} + + LGUI_API virtual class LSTypeDefinition *GetLSType(); + + LGUI_API virtual bool GetStoragePosition(int &StoreX, int &StoreY, unsigned int &StoreWidth, unsigned int &StoreHeight); + + inline LGUIElement *GetParent() {return pParent;} + inline LGUIElement *GetFirstChild() {return pFirstChild;} + inline LGUIElement *GetLastChild() {return pLastChild;} + inline LGUIElement *GetPrev() {return pPrev;} + inline LGUIElement *GetNext() {return pNext;} + + LGUI_API LGUIElement *Walk(bool bRequireVisible, LGUIElement *pStopAtParent); + LGUI_API LGUIElement *WalkReverse(bool bRequireVisible, LGUIElement *pStopAtParent); + + inline void SetNext(LGUIElement *pElement) {pNext=pElement;} + inline void SetPrev(LGUIElement *pElement) {pPrev=pElement;} + inline void SetLastChild(LGUIElement *pElement) {pLastChild=pElement;} + inline void SetFirstChild(LGUIElement *pElement) {pFirstChild=pElement;} + + inline bool IsDescendentOf(LGUIElement *pElement) + { + LGUIElement *pTest=pParent; + while(pTest) + { + if (pElement==pTest) + return true; + pTest=pTest->pParent; + } + return false; + } + + inline char *GetName() {return Name;} + inline char *GetFullName() {return FullName;} + inline char *GetFactory() {return Factory;} + + LGUI_API void AddChild(LGUIElement *pElement); + LGUI_API void DeleteChild(LGUIElement *pElement); + + LGUI_API virtual LGUIElement *FindChild(const char *Name); + LGUI_API LGUIElement *FindUsableChild(const char *Name, const char *Type); + + inline void SetLeft(int NewValue) {X=NewValue;} + inline void SetTop(int NewValue) {Y=NewValue;} + inline void GetXFactor(ElementPosition &EP) {EP=XFactor;} + inline void GetYFactor(ElementPosition &EP) {EP=YFactor;} + inline void GetHeightFactor(ElementPosition &EP) {EP=HeightFactor;} + inline void GetWidthFactor(ElementPosition &EP) {EP=WidthFactor;} + inline void SetWidth(unsigned int NewValue) {Width=NewValue;} + inline void SetHeight(unsigned int NewValue) {Height=NewValue;} + inline int GetRight() {return X+Width;} + inline int GetBottom() {return Y+Height;} + inline int GetTop() {return Y;} + inline int GetLeft() {return X;} + inline unsigned int GetHeight() {return Height;} + inline unsigned int GetWidth() {return Width;} + inline unsigned int GetID() {return ID;} + inline bool IsVisible() {return bVisible;} + LGUI_API bool IsReallyVisible(); + inline unsigned char GetAlwaysOnTop() {return bAlwaysOnTop;} + inline void SetAlwaysOnTop(unsigned char NewValue) { bAlwaysOnTop = NewValue; } + inline bool GetStorePosition() {return bStorePosition;} + inline void Destroy() {pParent->DeleteChild(this);} + inline void GetOriginalPosition(FullElementPosition &Dest) {Dest=OriginalPosition;} + + inline void ResetPosition() + { + X=OriginalPosition.X; + Y=OriginalPosition.Y; + Height=OriginalPosition.Height; + Width=OriginalPosition.Width; + XFactor=OriginalPosition.XFactor; + YFactor=OriginalPosition.YFactor; + HeightFactor=OriginalPosition.HeightFactor; + WidthFactor=OriginalPosition.WidthFactor; + RecalculateSize(true); + } + + LGUI_API virtual bool SetFocus(); + LGUI_API virtual bool SetMouseOver(); + + LGUI_API bool IsMouseOver(); + LGUI_API bool IsFocus(); + + LGUI_API bool FillRect(RECT &r,unsigned int Color); + LGUI_API bool FillRectBordered(RECT &r,unsigned int Color,unsigned int BorderSize,unsigned int BorderColor); + LGUI_API bool DrawBorder(RECT &r,unsigned int BorderSize,unsigned int BorderColor); + + LGUI_API bool TexturedRect(RECT &r,LGUITexture *pTexture); + LGUI_API bool TexturedRectBordered(RECT &r,LGUITexture *pTexture, unsigned int BorderSize); + LGUI_API bool TexturedRects(unsigned int nRects, LGUITexturedRect *pRects); + + LGUI_API bool FillTriangle(LGUITriangle &t,unsigned int Color); + LGUI_API bool TexturedTriangle(LGUITriangle &t,LGUITexture *pTexture); + LGUI_API bool TexturedTriangles(unsigned int nTriangles, LGUITexturedTriangle *pTriangles); + + LGUI_API bool DrawLine(_Line &Line, LGUITexture *pTexture, unsigned int Weight=1); + LGUI_API bool DrawLines(_Line *Lines, unsigned int nLines, LGUITexture *pTexture, unsigned int Weight=1); + + LGUI_API bool DrawLine(_Line &Line, unsigned int Color, unsigned int Weight=1); + LGUI_API bool DrawLines(_Line *Lines, unsigned int nLines, unsigned int Color, unsigned int Weight=1); + + +// LGUI_API bool DrawPoint(_ColoredPoint &pt); +// LGUI_API bool DrawPoints(_ColoredPoint *Points, unsigned int nPoints); + + + LGUI_API size_t DrawText(LGUIFont *pFont,const char *Text,int X, int Y); + LGUI_API size_t DrawTextClipped(LGUIFont *pFont,const char *Text,int X, int Y); + LGUI_API size_t DrawTextCenter(LGUIFont *pFont,const char *Text,int X, int Y); + LGUI_API size_t DrawTextRight(LGUIFont *pFont,const char *Text,int X, int Y); + + LGUI_API size_t DrawTextClipped(LGUIFont *pFont,const char *Text,int X, int Y, int RightX); + LGUI_API size_t DrawTextCenter(LGUIFont *pFont,const char *Text,int X, int Y, int RightX); + LGUI_API size_t DrawTextRight(LGUIFont *pFont,const char *Text,int X, int Y, int RightX); + + LGUI_API size_t DrawColoredText(LGUIFont *pFont,const char *buffer, int X, int Y); + LGUI_API size_t DrawColoredTextClipped(LGUIFont *pFont,const char *buffer, int X, int Y, int RightX); + + static LGUI_API void StripColor(const char *In, char *Out); + static LGUI_API size_t ColorStrlen(const char *Text); + + LGUI_API virtual LGUIElement *FindMouseOver(POINT2I &pt, LGUIElement *pStart); + LGUI_API bool HitTest(POINT2I &pt); + + inline void SetAbsolute(POINT2I &pt) {Absolute=pt;} + inline void GetAbsolute(POINT2I &pt) {pt=Absolute;} + + inline bool GetLeftClickThru() {return bLeftClickThru;} + inline bool GetRightClickThru() {return bRightClickThru;} + + inline void SetLeftClickThru(bool Value) {bLeftClickThru=Value;} + inline void SetRightClickThru(bool Value) {bRightClickThru=Value;} + + inline void SetAbsoluteAlpha(float Value) {AbsoluteAlpha=Value;} + inline float GetAbsoluteAlpha() {return AbsoluteAlpha;} + + inline void SetAlpha(float Value) {AlphaLevel=Value;} + inline float GetAlpha() {return AlphaLevel;} + + inline void SetFadeAlpha(float Value) {FadeAlphaLevel=Value;} + inline float GetFadeAlpha() {return FadeAlphaLevel;} + + inline unsigned int GetFadeDelay() {return FadeDelay;} + inline void SetFadeDelay(unsigned int Value) {FadeDelay=Value;} + + inline unsigned int GetFadeDuration() {return FadeDuration;} + inline void SetFadeDuration(unsigned int Value) {FadeDuration=Value;} + + inline void BeginFade() {FadeState=EFS_DELAYING;FadeBegan=g_UIManager.RenderTime;} + inline void InstantFade() {FadeState=EFS_FADED;} // FadeDelay must be non-zero to fade normally. + inline void ResetFade() {FadeState=EFS_NORMAL;} + inline eElementFadeState GetFadeState() {return FadeState;} + + inline void UpdateFadeState() + { + if (!FadeDelay) + return; + if (FadeState==EFS_NORMAL) + { + if (!HitTest(g_UIManager.MousePos)) + { + BeginFade(); + } + } + else + { + if (HitTest(g_UIManager.MousePos)) + { + ResetFade(); + } + } + } + + LGUI_API float GetCurrentAlpha(); + + inline unsigned char ApplyAlpha(unsigned char Value) + { + float fValue=((((float)Value/255.0f)*AbsoluteAlpha)*255.0f); + if (fValue>255) + return 255; + return (unsigned char)fValue; + } + inline unsigned int ApplyAlpha(unsigned int &Value) + { + RGBCOLOR Color; + Color.ARGB=Value; + Color.A=ApplyAlpha(Color.A); + return Color.ARGB; + } + inline float ApplyAlpha(float Value) + { + return Value*AbsoluteAlpha; + } + + inline void ExecuteOnLoad() {if (pOnLoad) pOnLoad->Execute();} + inline void ExecuteOnRender() {if (pOnRender) pOnRender->Execute();} + + LGUI_API virtual void MoveZUp(); + LGUI_API virtual void MoveZDown(); + LGUI_API virtual void MoveZTop(bool bAncestorsToo=true); + LGUI_API virtual void MoveZBottom(); + + void MoveContainerZTop(); + + static void StripSlashes(char *Text); +// void GetAbsolute(); +protected: + char *Factory; + unsigned int ID; // globally unique + char *Name; + char *FullName; + + LGUIElement *pParent; + LGUIElement *pPrev; + LGUIElement *pNext; + LGUIElement *pFirstChild; + LGUIElement *pLastChild; // top of Z order + + LGUIEmbeddedScript *pOnLoad; + LGUIEmbeddedScript *pOnUnload; + LGUIEmbeddedScript *pOnLeftClick; + LGUIEmbeddedScript *pOnRightClick; + LGUIEmbeddedScript *pOnDoubleLeftClick; + LGUIEmbeddedScript *pOnDoubleRightClick; + LGUIEmbeddedScript *pOnMouseEnter; + LGUIEmbeddedScript *pOnMouseExit; + LGUIEmbeddedScript *pOnMouseMove; + LGUIEmbeddedScript *pOnMouseWheel; + LGUIEmbeddedScript *pOnKeyboardEnter; + LGUIEmbeddedScript *pOnKeyboardExit; + LGUIEmbeddedScript *pOnKeyUp; + LGUIEmbeddedScript *pOnKeyDown; + LGUIEmbeddedScript *pOnLeftDown; + LGUIEmbeddedScript *pOnRightDown; + LGUIEmbeddedScript *pOnRender; + + int X; + ElementPosition XFactor; + int Y; + ElementPosition YFactor; + unsigned int Height; + ElementPosition HeightFactor; + unsigned int Width; + ElementPosition WidthFactor; + + FullElementPosition OriginalPosition; + + bool bStorePosition; + + bool bVisible; + char bAlwaysOnTop; + bool bLeftClickThru; + bool bRightClickThru; + + float AlphaLevel; + + unsigned int FadeBegan; + unsigned int FadeDelay; + unsigned int FadeDuration; + float FadeAlphaLevel; + eElementFadeState FadeState; + + unsigned int FadeInDelay; + unsigned int FadeInDuration; + + char *AutoTooltip; + + inline void Create(_CreateElement &CreateInfo) + { + X=CreateInfo.X; + Y=CreateInfo.Y; + Width=CreateInfo.Width; + Height=CreateInfo.Height; + bVisible=CreateInfo.bVisible; + XFactor=CreateInfo.XFactor; + YFactor=CreateInfo.YFactor; + WidthFactor=CreateInfo.WidthFactor; + HeightFactor=CreateInfo.HeightFactor; + bAlwaysOnTop=CreateInfo.bAlwaysOnTop; + MoveZTop(); + } + + float AbsoluteAlpha; + POINT2I Absolute; +}; + +class LGUIElementDeleter +{ +public: + virtual void Delete(LGUIElement *pElement) + { + pElement->OnDestroy(); + delete pElement; + } +}; + +class LGUIElementFactory +{ +public: + LGUIElementFactory(const char *p_Type, unsigned int LGUIVersion) + { + Register(p_Type,LGUIVersion); + pDeleter = new LGUIElementDeleter; + } + ~LGUIElementFactory() + { + if (Type) + { + map::iterator i=Elements.begin(); + while(i!=Elements.end()) + { + map::iterator cur=i; + i++; + + if (cur->second) + { + cur->first->OnDestroy(); + if (cur->first->GetParent()) + cur->first->GetParent()->DeleteChild(cur->first); + else + { +// delete i->first; // fuck it, avoid crashing + } + } + } + } + Unregister(); + delete pDeleter; + } + + LGUI_API void Register(const char *p_Type, unsigned int LGUIVersion); + LGUI_API void Unregister(); + + LGUI_API virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name, class XMLNode *pXML, const char *Template = 0) = 0; + LGUI_API virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name) = 0; + virtual void UnregisterUIElement(LGUIElement *pElement) + { + Elements.erase(pElement); + } + inline const char *GetTypeName() + { + return Type; + } + + map Elements; + + void DeleteUIElement(LGUIElement *pElement) + { + //pElement->OnDestroy(); + pDeleter->Delete(pElement); + } +protected: + LGUIElementDeleter *pDeleter; + const char *Type; + +}; + +template +class LGUIFactory : public LGUIElementFactory +{ +public: + + LGUIFactory(const char *p_Type) :LGUIElementFactory(p_Type, LGUI_VERSION) + { + } + + ~LGUIFactory() + { + } + + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name, class XMLNode *pXML, const char *Template = 0) + { + T *pElement = new T((char*)Type,pParent,(char*)Name); + + if (!pElement->FromXML(pXML,g_UIManager.FindTemplate(Template))) + { + if (pParent) + pParent->DeleteChild(pElement); + else + delete pElement; + return 0; + } + Elements[pElement]=1; + return pElement; + } + + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name) + { + T *pElement = new T((char*)Type,pParent,(char*)Name); + Elements[pElement]=1; + return pElement; + } +}; + +template +class DelayedLGUIFactory +{ +public: + + DelayedLGUIFactory(const char *p_Type) + { + Type=strdup(p_Type); + pFactory=0; + } + + ~DelayedLGUIFactory() + { + Shutdown(); + free((void*)Type); + } + + void Initialize() + { + if (pFactory) + return; + pFactory = new LGUIFactory(Type); + } + + void Shutdown() + { + if (!pFactory) + return; + delete pFactory; + pFactory=0; + } + + const char *Type; + LGUIFactory *pFactory; +}; diff --git a/libs/isxdk/include/ISUI/LGUIEmbeddedScript.h b/libs/isxdk/include/ISUI/LGUIEmbeddedScript.h new file mode 100644 index 0000000..cf3a3b0 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIEmbeddedScript.h @@ -0,0 +1,20 @@ +#pragma once + +class LGUIEmbeddedScript +{ +public: + LGUIEmbeddedScript(unsigned int AtomID, class LGUIElement *pThis); + virtual ~LGUIEmbeddedScript(); + + LGUI_API static LGUIEmbeddedScript *New(class LGUIElement *pThis, const char *Buffer, const char *Parameters); + LGUI_API virtual void Delete(); + + LGUI_API virtual int Execute(int argc=0, char *argv[]=0); + LGUI_API virtual int Execute(class LGUIElement *pThis, int argc=0, char *argv[]=0); + +protected: + unsigned int AtomID; + class LGUIElement *pThis; + unsigned int RefCount; +}; + diff --git a/libs/isxdk/include/ISUI/LGUIFont.h b/libs/isxdk/include/ISUI/LGUIFont.h new file mode 100644 index 0000000..135f5b8 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIFont.h @@ -0,0 +1,84 @@ +#pragma once + +struct _CreateFont +{ + char *Name; + unsigned char Height; + unsigned int Color; + bool Bold; + bool Fixed; +}; + +class LGUIFont +{ +public: + LGUIFont(LGUIElement *pParent, const char *Face, unsigned char Height, bool Fixed, bool Bold); + LGUIFont(LGUIElement *pParent, const LGUIFont&); + LGUIFont(LGUIElement *pParent, _CreateFont &CreateFont, XMLNode *pTemplate); + virtual ~LGUIFont(); + +// LGUI_API virtual bool FromXML(class XMLNode *pXML, char *Template=""); + + LGUI_API static LGUIFont *New(LGUIElement *pParent,const char *Face, unsigned char Height, bool Fixed, bool Bold); + LGUI_API static LGUIFont *New(LGUIElement *pParent,_CreateFont &CreateFont, class XMLNode *pTemplate=0); + LGUI_API static LGUIFont *New(LGUIElement *pParent,const LGUIFont&); + LGUI_API virtual void Delete(); + LGUI_API virtual bool Prepare(); + LGUI_API void Release(); + + LGUI_API bool IsFixedFont(); +// LGUI_API float GetBaseHeight(); + LGUI_API size_t Draw(const char *Text, int X, int Y, size_t ClipLength = 0); + LGUI_API size_t DrawCenter(const char *Text, int X, int Y, size_t ClipLength); + LGUI_API size_t DrawRight(const char *Text, int X, int Y, size_t ClipLength); + LGUI_API size_t GetTextWidth(const char *Text); + LGUI_API size_t GetTextWidth(const char *Text, size_t Length); +// LGUI_API unsigned int GetCharWidth(unsigned int c); + LGUI_API unsigned int GetCharByOffset(const char *Text, size_t Offset); + + LGUI_API void SetName(const char *p_Name); + LGUI_API void SetBold(bool Bold); + + inline char *GetName() {return Name;} + inline unsigned int GetColor() {return Color;} + inline unsigned char GetHeight() {return Height;} + inline bool GetBold() {return Bold;} + + LGUI_API void SetHeight(unsigned char NewHeight); + inline void SetColor(unsigned int NewColor) {Color=NewColor;} + +protected: + unsigned int FontID; + + char *Name; + unsigned char Height; + unsigned int Color; + bool Bold; + bool Fixed; + + LGUIElement *pParent; +}; + +class LGUIFixedFont : public LGUIFont +{ +public: + LGUIFixedFont(LGUIElement *pParent, const char *Face, unsigned char Height, bool Bold); + LGUIFixedFont(LGUIElement *pParent,const LGUIFixedFont&); + LGUIFixedFont(LGUIElement *pParent,_CreateFont &CreateFont, class XMLNode *pTemplate); + ~LGUIFixedFont(); + + LGUI_API static LGUIFixedFont *New(LGUIElement *pParent, const char *Face, unsigned char Height, bool Bold); + LGUI_API static LGUIFixedFont *New(LGUIElement *pParent,const LGUIFixedFont&); + LGUI_API static LGUIFixedFont *New(LGUIElement *pParent,_CreateFont &CreateFont, class XMLNode *pTemplate=0); + LGUI_API virtual void Delete(); + + LGUI_API virtual bool Prepare(); + LGUI_API size_t GetCharWidth(); +/* +protected: + inline class CLavishFontFixed *GetFixedFont() + { + return (class CLavishFontFixed *)pFont; + } +/**/ +}; diff --git a/libs/isxdk/include/ISUI/LGUIFrame.h b/libs/isxdk/include/ISUI/LGUIFrame.h new file mode 100644 index 0000000..cdbb987 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIFrame.h @@ -0,0 +1,41 @@ +#pragma once + + +struct _CreateFrame : public _CreateElement +{ + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; +}; + +class LGUIFrame : + public LGUIElement +{ +public: + LGUI_API LGUIFrame(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIFrame(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void Create(_CreateFrame &CreateInfo); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnLMouseDoubleClick(POINT2I &pt); + LGUI_API bool OnRMouseDoubleClick(POINT2I &pt); + LGUI_API bool OnRMouseUp(POINT2I &pt); + LGUI_API bool OnRMouseDown(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + + // -- XML Properties -- + LGUITexture *pTexture; + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; + + // ---------------------- + +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIGauge.h b/libs/isxdk/include/ISUI/LGUIGauge.h new file mode 100644 index 0000000..e6a069a --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIGauge.h @@ -0,0 +1,93 @@ +#pragma once + +class LGUIGauge : + public LGUIFrame +{ +public: + LGUI_API LGUIGauge(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIGauge(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API virtual void SetValue(float NewValue); + + // -- XML Properties -- + LGUITexture *pTopTexture; + + bool bVertical; + + float fRange; + + // -------------------- + + bool Mod; + class LGUIGaugeFiller* pFiller; + float fValue; +}; + +class LGUIGaugeFiller: + public LGUIElement +{ +public: + LGUIGaugeFiller(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + ~LGUIGaugeFiller(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + + void Render(); + bool FromXML(class XMLNode *pXML); + bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate); + + bool IsTypeOf(char *TestFactory); +// void Default(); + virtual void SetValue(float NewValue); + void RecalculateSize(bool RecalculateChildren); + + // -- XML Properties -- + LGUITexture *pTexture; + // -------------------- + + float fRange; + float fValue; + bool bVertical; + unsigned int Repeat; + + class LGUIGauge *pGauge; +}; + +class LGUIGaugeFactory : public LGUIElementFactory +{ +public: + LGUIGaugeFactory():LGUIElementFactory("gauge",LGUI_VERSION) + { + } + + ~LGUIGaugeFactory() + { + } + + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name, class XMLNode *pXML, const char *Template = 0) + { + LGUIGauge *pElement = new LGUIGauge(Type,pParent,Name); + + if (!pElement->FromXML(pXML,g_UIManager.FindTemplate(Template))) + { + delete pElement; + return 0; + } + Elements[pElement]=1; + if (pElement->pFiller) + return pElement->pFiller; + return pElement; + } + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name) + { + LGUIGauge *pElement = new LGUIGauge(Type,pParent,Name); + Elements[pElement]=1; + return pElement; + } + + virtual LSType *GetLSType(); +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIHudElement.h b/libs/isxdk/include/ISUI/LGUIHudElement.h new file mode 100644 index 0000000..ce71eaf --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIHudElement.h @@ -0,0 +1,37 @@ +#pragma once +#include "LGUIelement.h" + +class LGUIHudElement : + public LGUIElement +{ +public: + LGUIHudElement(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + ~LGUIHudElement(void); + bool IsTypeOf(char *TestFactory); + class LSTypeDefinition *GetLSType(); + + bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + bool OnLMouseUp(POINT2I &pt); + bool OnLMouseDown(POINT2I &pt); + bool OnMouseMove(POINT2I &pt); + void Render(); + + virtual void UpdateElement(); + virtual void SetText(char *NewValue); + // -- From XML -- + //char *Text; + LGUIPreParse PreParsed; + char *Group; + + LGUIFont *pFont; + + unsigned int UpdateInterval; + + // -------------------------------- + + char *CurrentValue; + unsigned int CurrentInterval; + bool bMoving; + POINT2I MovingOffset; +}; diff --git a/libs/isxdk/include/ISUI/LGUIListBox.h b/libs/isxdk/include/ISUI/LGUIListBox.h new file mode 100644 index 0000000..6eaf05c --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIListBox.h @@ -0,0 +1,145 @@ +#pragma once + +enum eListBoxSort +{ + LBSORT_NONE=0, + LBSORT_USER=1, + LBSORT_TEXT=2, + LBSORT_VALUE=3, + LBSORT_CUSTOM=4, + LBSORT_TEXTREVERSE=5, + LBSORT_VALUEREVERSE=6, +}; + + +class ListBoxItem +{ +public: + ListBoxItem(class LGUIListBox *p_pListBox, const char *p_Text, unsigned int p_Color, const char *p_Value, unsigned int p_ID) + { + pListBox=p_pListBox; + Text=strdup(p_Text); + Color=p_Color; + if (p_Value) + Value=p_Value; + ID=p_ID; + + Order=0; + } + + ~ListBoxItem() + { + free(Text); + Text="Error"; + } + + unsigned int ID; + char *Text; + unsigned int Color; + std::string Value; + + unsigned int Order; + + class LGUIListBox *pListBox; +}; + +struct _CreateListBox : public _CreateElement +{ +// unsigned int FontSize; +// unsigned int TextColor; + _CreateFont Font; + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; + + unsigned int SelectionColor; + + eListBoxSort SortType; + + bool bSelectMultiple; + + char *ScrollBarTemplate; +}; + +class LGUIListBox : + public LGUIElement +{ +public: + LGUI_API LGUIListBox(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIListBox(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateListBox &CreateInfo, class XMLNode *pTemplate=0); + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void RecalculateSize(bool RecalculateChildren); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDoubleClick(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + + LGUI_API virtual void DeselectItem(unsigned int ID); + LGUI_API virtual void SelectItem(unsigned int ID); + LGUI_API virtual void ItemToggleSelect(unsigned int ID); + LGUI_API virtual void ClearSelection(); + LGUI_API virtual unsigned int AddItem(const char *Text, const char *Value, unsigned int Color=0); + LGUI_API virtual void RemoveItem(unsigned int ID); + LGUI_API virtual void ClearItems(); + LGUI_API virtual bool GetItemValue(unsigned int ID, unsigned int &Value); + + LGUI_API virtual void SetItemText(unsigned int ID, const char *Text); + LGUI_API virtual void SetItemColor(unsigned int ID, unsigned int Color); + + LGUI_API virtual unsigned int FindItemByText(const char *Text, unsigned int BeginInclusive=1); + LGUI_API virtual unsigned int FindItemByValue(const char *Value, unsigned int BeginInclusive=1); + + LGUI_API virtual unsigned int GetItemFromPoint(POINT2I &pt); + LGUI_API virtual unsigned int GetOrderFromPoint(POINT2I &pt); + + LGUI_API virtual void ApplySort(); + + LGUI_API ListBoxItem *RetrieveItem(unsigned int ID); + + void Sort(int (__cdecl* customCompare)(const void *,const void *)); + + // -- XML Properties -- + LGUIFont *pFont; + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; + + unsigned int SelectionColor; + + eListBoxSort SortType; + + bool bSelectMultiple; + + LGUITexture *pTexture; + + LGUIEmbeddedScript *pOnSelect; + LGUIEmbeddedScript *pOnDeSelect; + + // -------------------- + + unsigned int TextColor; + + LGUIScrollBar *pVerticalBar; + + bool bAutoSort; + + int (__cdecl* fCustomCompare)(const void *,const void *); + + unsigned int VisiblePos; + set Selection; + + CIndex Items; + CIndex OrderedItems; + unsigned int nItems; + + unsigned int DraggingID; + bool Reordered; +}; diff --git a/libs/isxdk/include/ISUI/LGUIManager.h b/libs/isxdk/include/ISUI/LGUIManager.h new file mode 100644 index 0000000..1639ce3 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIManager.h @@ -0,0 +1,175 @@ +#pragma once +#include "LGUI.h" + + +struct _UISettings +{ + unsigned int AutoTooltipTime; + unsigned int DoubleClickTime; + unsigned int TypematicRate; + unsigned int TypematicDelay; +}; + +class LGUISkin +{ +public: + LGUISkin(const char *p_Name); + ~LGUISkin(); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void AddTemplate(const char *BaseTemplate, const char *SkinTemplate); + LGUI_API void RemoveTemplate(const char *BaseTemplate); + + char *Name; + map Templates; +}; + +class MetadataStore +{ +public: + const char *Get(const char *key); + bool Set(const char *key, const char *value); + bool Unset(const char *key); + + map m_Metadata; +}; + +class CUIManager +{ +public: + CUIManager(void); + ~CUIManager(void); + + virtual void Initialize(); + virtual void Shutdown(); + + virtual unsigned int GetVersion(); + virtual void DisableMouse(); + + LGUI_API void Reset(); + LGUI_API bool LoadInterfaceXML(const char *Filename, bool Reload = false, LGUISkin *pSkin = 0); + LGUI_API bool LoadInterfaceXML(const char *Filename, const char *Element, const char *NewName, bool Reload = false, LGUISkin *pSkin = 0); + LGUI_API bool LoadInterfaceXML(LGUIElement *pParent, const char *Filename, bool Reload = false, LGUISkin *pSkin = 0); + LGUI_API bool LoadInterfaceXML(LGUIElement *pParent, const char *Filename, const char *Element, const char *NewName, bool Reload = false, LGUISkin *pSkin = 0); + LGUI_API bool UnloadInterfaceXML(const char *Filename); + + LGUI_API bool OnLMouseUp(); + LGUI_API bool OnLMouseDown(); + LGUI_API bool OnRMouseUp(); + LGUI_API bool OnRMouseDown(); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + LGUI_API bool OnKeyUp(unsigned int VKey); + LGUI_API bool OnKeyDown(unsigned int VKey); + + LGUI_API void SetFocusElement(class LGUIElement *pElement); + + inline class LGUIElement *GetElementByID(unsigned int ID) + { + map::iterator i=AllElements.find(ID); + if (i==AllElements.end()) + return 0; + return i->second; + } + + LGUI_API class LGUIElement *GetFocusElement(); + LGUI_API class LGUIElement *SetFocusElement(); + LGUI_API class LGUIElement *GetMouseOverElement(); + + LGUI_API class LGUIElement *SetMouseOverElement(); + + LGUI_API bool ShowElement(const char *Name, bool Show); + LGUI_API bool ToggleElement(const char *Name); + + LGUI_API void Render(); + + LGUI_API class LGUIElementFactory *FindFactory(const char *Type); + LGUI_API class LGUIElement *FindElement(const char *Name); + + unsigned int LoadTexture(const char *Filename, unsigned int ColorKey); + LGUI_API bool GetTextureSize(unsigned int ID, POINT2I &pt); + void ReleaseTexture(unsigned int ID); + + unsigned int LoadFont(const char *Face, unsigned char Height, bool Fixed, bool Bold=0); + void ReleaseFont(unsigned int ID); + +// LGUI_API unsigned int DrawText(const char *Text,int p_X, int p_Y,unsigned int Color,unsigned int FontHeight); + + unsigned int FocusID; + unsigned int MouseOverID; + unsigned int LockMouseOverIDLeft; + unsigned int LockMouseOverIDRight; + unsigned int MousePriorityID; + + unsigned int CurrentFontID; + + bool bShift; + bool bAlt; + bool bCtrl; + + char LeftMouse; + char RightMouse; + POINT2I MousePos; + + unsigned char KeyboardState[256]; + + map AllElementsByName; + map AllElements; + class LGUIElement *pScreen; + map ElementFactories; + unsigned int NextID; + CSemaphore S; + + LGUI_API class XMLNode *AddTemplate(const char *Name, const char *XML); + LGUI_API class XMLNode *AddTemplate(const char *Name, class XMLNode *pXML); + LGUI_API void RemoveTemplate(const char *Name); + LGUI_API class XMLNode *FindTemplate(const char *Name); + LGUI_API void ClearTemplates(); + + map Templates; + map Skins; + + LGUI_API LGUISkin *NewSkin(const char *Name); + LGUI_API LGUISkin *FindSkin(const char *Name); + LGUI_API void RemoveSkin(const char *Name); + + LGUISkin *pCurrentSkin; + + char OuterTag[64]; + char CurrentXMLFile[512]; + + bool bShutdown; + unsigned int MouseOverTime; + unsigned int LastActionTime; + + POINT2I LastClickPos; + unsigned int LastLeftClickTime; + unsigned int LastLeftClickID; + unsigned int LastRightClickTime; + unsigned int LastRightClickID; + + unsigned int RenderTime; + + unsigned int AutoTooltipShownID; + + _UISettings Settings; + + bool bZOrderChanged; + + map KeyboardStateEx; + unsigned int PersistentClass; + + void OnDeleteElement(class LGUIElement *pElement); + + const char *GetMetadata(unsigned int elementid, const char *key); + bool SetMetadata(unsigned int elementid, const char *key, const char *value); + bool UnsetMetadata(unsigned int elementid, const char *key); + map m_MetadataStores; + +//protected: + LGUI_API LGUIElement *LoadElement(class LGUIElement *pParent, const char *Type, const char *Name, class XMLNode *pXML, const char *Template = 0); + LGUI_API LGUIElement *LoadElement(class LGUIElement *pParent, const char *Type, const char *Name); +}; + +extern LGUI_API CUIManager g_UIManager; diff --git a/libs/isxdk/include/ISUI/LGUIMap.h b/libs/isxdk/include/ISUI/LGUIMap.h new file mode 100644 index 0000000..ced8001 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIMap.h @@ -0,0 +1,150 @@ +#pragma once +class LGUIMapBlip : + public LGUIFrame +{ +public: + LGUI_API LGUIMapBlip(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIMapBlip(void); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void OnMouseEnter(POINT2I &pt); + LGUI_API void OnMouseExit(LGUIElement *pNewFocus); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + + LGUI_API bool SetTooltip(LGUITooltip *pTooltip); + + LGUIFont *pFont; + LGUIEmbeddedScript *pSetTooltip; + + POINT3F Point; + char *Custom; + char *Label; +}; + +class LGUIMapBlipView : + public LGUIFrame +{ +public: + LGUI_API LGUIMapBlipView(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIMapBlipView(void); + LGUI_API bool IsTypeOf(char *TestFactory); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void OnMouseEnter(POINT2I &pt); + LGUI_API void OnMouseExit(LGUIElement *pNewFocus); + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void UpdateSize(); + LGUI_API void Render(); + LGUI_API bool SetTooltip(LGUITooltip *pTooltip); + + LGUIMapBlip *pBlip; +}; + +class LGUIMapView; + +class LGUIMap : + public LGUIElement +{ +public: + LGUI_API LGUIMap(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIMap(void); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void OnCreate(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + + char BlipFactory[64]; + char *BlipTemplate; + + POINT3F Origin; // center of Map (player location?) + float Rotation; // rotation of Map (player heading?) + float MapSizeX; // size of Map box in game units (east-west) - MapSizeY not used if ClipRadius is set. + float MapSizeY; // size of Map box in game units (north-south) + bool bClipRadius; // use radius clipping instead of box clipping + bool bClipZ; // height clipping + bool bShowLabels; // show labels? + bool bRotation; // Rotate Map around origin? + bool bClipText; // Clip text to Map edge? + POINT2F ZClipping; // min/max height difference from origin. X = min, Y = max + + LGUI_API virtual void BlipHover(LGUIMapBlip *pBlip, POINT2I &Pos); + LGUI_API virtual void BlipHoverStop(LGUIMapBlip *pBlip); + +// Blip Manipulation + LGUI_API virtual unsigned int AddBlip(char *Name, POINT3F &Point, unsigned int Size, char *Label=0, char *BlipTemplate=0, char *BlipFactory=0); + LGUI_API virtual void RemoveBlip(unsigned int ID); + LGUI_API virtual void ClearBlips(); + LGUI_API virtual void UpdateBlip(unsigned int ID, POINT3F &Point); + LGUI_API virtual void UpdateBlipLabel(unsigned int ID, char *Label); + LGUI_API virtual void UpdateBlipSize(unsigned int ID, unsigned int Size); + + + LGUI_API virtual LGUIMapBlip *NewBlip(char *Name, char *BlipTemplate=0, char *BlipFactory=0); + LGUI_API virtual LGUIMapBlip *FindBlip(char *Name); + + LGUI_API virtual void UpdateRadius(); + LGUI_API virtual void UpdateBox(); + + map Blips; + map BlipsByName; + map Views; + + unsigned int HoverID; + unsigned int nBlips; + + LGUITooltip *pTooltip; +}; + +class LGUIMapView : + public LGUIElement +{ +public: + LGUI_API LGUIMapView(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIMapView(void); + LGUI_API bool IsTypeOf(char *TestFactory); +// LGUI_API class LSTypeDefinition *GetLSType(); + +// LGUI_API void ClearBlips(); + + LGUI_API void OnCreate(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + + POINT3F Origin; // center of Map (player location?) + float Rotation; // rotation of Map (player heading?) + float MapSizeX; // size of Map box in game units (east-west) - MapSizeY not used if ClipRadius is set. + float MapSizeY; // size of Map box in game units (north-south) + bool bClipRadius; // use radius clipping instead of box clipping + bool bClipZ; // height clipping + bool bShowLabels; // show labels? + bool bRotation; // Rotate Map around origin? + bool bClipText; // Clip text to Map edge? + POINT2F ZClipping; // min/max height difference from origin. X = min, Y = max + + LGUI_API virtual void BlipHover(LGUIMapBlipView *pBlip, POINT2I &Pos); + LGUI_API virtual void BlipHoverStop(LGUIMapBlipView *pBlip); + + + LGUI_API virtual void UpdateRadius(); + LGUI_API virtual void UpdateBox(); + +// LGUI_API virtual void AddBlipView(LGUIMapBlip *pBlip); +// LGUI_API virtual void RemoveBlipView(LGUIMapBlip *pBlip); + + map BlipViews; + LGUIMap *pMap; + + unsigned int HoverID; + + LGUITooltip *pTooltip; +}; diff --git a/libs/isxdk/include/ISUI/LGUIMessageBox.h b/libs/isxdk/include/ISUI/LGUIMessageBox.h new file mode 100644 index 0000000..1fdfcd6 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIMessageBox.h @@ -0,0 +1,36 @@ +#pragma once + +enum eMessageBoxType +{ + MSGBOX_OK=1, + MSGBOX_OKCANCEL=2, + MSGBOX_YESNO=3, +}; + +class LGUIMessageBox : public LGUIWindow +{ +public: + LGUI_API LGUIMessageBox(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIMessageBox(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(char *p_Title, char *p_Text, eMessageBoxType p_Type, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + + // Text + LGUIFont *pFont; + + eMessageBoxType MessageBoxType; + + // -------------------- + + LGUIButton *pOK; + LGUIButton *pCancel; + LGUIButton *pYes; + LGUIButton *pNo; +}; diff --git a/libs/isxdk/include/ISUI/LGUIScreen.h b/libs/isxdk/include/ISUI/LGUIScreen.h new file mode 100644 index 0000000..c7043a9 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIScreen.h @@ -0,0 +1,20 @@ +#pragma once +#include "LGUIelement.h" + +class LGUIScreen : + public LGUIElement +{ +public: + LGUIScreen(void); + ~LGUIScreen(void); + bool IsTypeOf(char *TestFactory); + + //void Render(); + void RecalculateSize(bool RecalculateChildren); + void MoveZTop(bool bAncestorsToo); + void MoveZUp(); + void MoveZDown(); + void MoveZBottom(); + + bool OnLMouseDown(POINT2I &pt); +}; diff --git a/libs/isxdk/include/ISUI/LGUIScrollBar.h b/libs/isxdk/include/ISUI/LGUIScrollBar.h new file mode 100644 index 0000000..0f9cc12 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIScrollBar.h @@ -0,0 +1,41 @@ +#pragma once + +struct _CreateScrollBar : public _CreateElement +{ + unsigned int Range; + bool bVertical; + bool DefaultTextures; +}; + +class LGUIScrollBar : + public LGUIElement +{ +public: + LGUI_API LGUIScrollBar(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIScrollBar(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateScrollBar &CreateInfo, class XMLNode *pTemplate=0); + + LGUI_API void SizeRecalculated(bool Changed); +// LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + +// LGUI_API void RecalculateSize(); + + LGUI_API virtual void SetRange(unsigned int NewRange); + LGUI_API virtual void SetValue(unsigned int NewValue); + LGUI_API virtual void RaiseValue(unsigned int Offset); + LGUI_API virtual void LowerValue(unsigned int Offset); + LGUI_API virtual unsigned int GetValue(); + + + unsigned int Range; + bool bVertical; + + LGUIButton *pUp; + LGUIButton *pDown; + LGUISlider *pSlider; +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUISlider.h b/libs/isxdk/include/ISUI/LGUISlider.h new file mode 100644 index 0000000..4e3a096 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUISlider.h @@ -0,0 +1,53 @@ +#pragma once +#include "LGUIelement.h" + +struct _CreateSlider : public _CreateElement +{ + unsigned int Border; + unsigned int Range; + + bool bVertical; + + bool DefaultTextures; +}; + +class LGUISlider : + public LGUIElement +{ +public: + LGUI_API LGUISlider(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUISlider(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateSlider &CreateInfo, class XMLNode *pTemplate=0); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + + LGUI_API virtual void SetValue(unsigned int NewValue); + LGUI_API virtual void SetPosition(unsigned int NewPosition); + LGUI_API void RecalculateSize(bool RecalculateChildren); + + // -- XML Properties -- + LGUITexture *pTexture; + LGUITexture *pHandleTexture; + unsigned int Border; + + bool bVertical; + + unsigned int Range; + + LGUIEmbeddedScript *pOnChange; + // -------------------- + + unsigned int HandleWidth; + unsigned int HandleHeight; + unsigned int Value; + unsigned int Position; + bool bSliding; +}; diff --git a/libs/isxdk/include/ISUI/LGUITabControl.h b/libs/isxdk/include/ISUI/LGUITabControl.h new file mode 100644 index 0000000..6f11f9f --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITabControl.h @@ -0,0 +1,93 @@ +#pragma once + +class CLGUITab +{ +public: + CLGUITab(class LGUITabControl *p_Control,const char *p_Name, unsigned int p_ID) + { + Name=strdup(p_Name); + ID=p_ID; + Order=0; + pFrame=0; + pTabControl=p_Control; +// Length=strlen(Name); + } + ~CLGUITab() + { + free(Name); + } + + LGUI_API void Rename(const char *NewName); + + char *Name; +// unsigned int Length; + unsigned int FullWidth; + + unsigned int ID; + unsigned int Order; + + LGUIFrame *pFrame; + class LGUITabControl *pTabControl; +}; + +class LGUITabControl : + public LGUIElement +{ +public: + LGUI_API LGUITabControl(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITabControl(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API void RecalculateSize(bool RecalculateChildren); + LGUI_API void SizeRecalculated(bool Changed); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API virtual unsigned int AddTab(const char *Text,XMLNode *pXML, const char *ChildName, const char *Template); + LGUI_API virtual void RemoveTab(unsigned int ID); + LGUI_API virtual unsigned int GetTabFromPoint(POINT2I &pt); + LGUI_API virtual unsigned int GetOrderFromPoint(POINT2I &pt); + + LGUI_API void MoveTab(CLGUITab *pTab, unsigned int Order); + LGUI_API virtual void SelectTab(unsigned int ID); + LGUI_API virtual void ClearSelection(); + + LGUI_API CLGUITab *GetTabFromName(const char *Name); + + + // -- XML Properties -- + LGUIFont *pFont; + LGUITexture *pTabTexture; + LGUITexture *pTabSelectedTexture; + + LGUITexture *pFrameTexture; + unsigned int FrameBackgroundColor; + unsigned int FrameBorder; + unsigned int FrameBorderColor; + + unsigned int TabHeight; + unsigned int TabBorder; + unsigned int SelectedTextColor; + bool bDraggable; + + LGUIEmbeddedScript *pOnSelect; + // ---------------------- + + LGUIButton *pLeft; + LGUIButton *pRight; + + unsigned int VisiblePos; + unsigned int Selection; + CIndex Tabs; + CIndex OrderedTabs; + + unsigned int nTabs; + unsigned int DraggingID; + +}; + diff --git a/libs/isxdk/include/ISUI/LGUITable.h b/libs/isxdk/include/ISUI/LGUITable.h new file mode 100644 index 0000000..9290404 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITable.h @@ -0,0 +1,54 @@ +#pragma once + +class LGUITableCell : + public LGUIFrame +{ +public: + LGUI_API LGUITableCell(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITableCell(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + +// LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + // -- XML Properties -- + unsigned int RowSpan; + + unsigned int ColSpan; + // ---------------------- + unsigned int Row; + unsigned int Column; +}; + +class LGUITable : + public LGUIFrame +{ +public: + LGUI_API LGUITable(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITable(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + +// LGUI_API void Render(); + LGUI_API virtual void RecalculateSize(bool RecalculateChildren); + LGUI_API virtual void SizeRecalculated(bool Changed); + + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + // -- XML Properties -- + + char *CellTemplate; + //unsigned int CellSpacing; // TODO + + // ---------------------- + + LGUITableCell **Cell; + ElementPosition *ColumnWidth; + ElementPosition *RowHeight; + + unsigned int nRows; + unsigned int nColumns; + +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIText.h b/libs/isxdk/include/ISUI/LGUIText.h new file mode 100644 index 0000000..bd7f9c8 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIText.h @@ -0,0 +1,69 @@ +#pragma once +#include "LGUIelement.h" + +enum eTextAlign +{ + ALIGN_LEFT=0, + ALIGN_CENTER=1, + ALIGN_RIGHT=2, + + VALIGN_TOP=3, + VALIGN_CENTER=4, + VALIGN_BOTTOM=5, +}; + +struct _CreateText : public _CreateElement +{ + char *Text; + _CreateFont Font; +// char *Font; +// unsigned int FontSize; +// unsigned int Color; + + bool bWrap; + eTextAlign Alignment; + eTextAlign VerticalAlignment; +}; + +class LGUIText : public LGUIElement +{ +public: + LGUI_API LGUIText(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIText(void); + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API static size_t SplitFixed(char *Value, size_t MaxChars, size_t &Width); + LGUI_API static size_t Split(char *Value, size_t MaxWidth, LGUIFont *pFont, size_t &Width); + LGUI_API size_t Split(char *Value); + + LGUI_API void Render(); + LGUI_API bool RenderCustom(); + + LGUI_API void Create(_CreateText &CreateInfo, class XMLNode *pTemplate=0); + + LGUI_API void RenderLeft(char *Value); + LGUI_API void RenderCenter(char *Value); + LGUI_API void RenderRight(char *Value); + LGUI_API void RecalculateSize(bool RecalculateChildren); + + + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + + LGUI_API void SetText(char *NewText); + LGUI_API void SetHorizontalAlignment(eTextAlign value); + LGUI_API void SetVerticalAlignment(eTextAlign value); + LGUI_API void SetWrap(bool value); + + // -- XML Properties -- + char *Text; + LGUIFont *pFont; + + bool bWrap; + eTextAlign Alignment; + eTextAlign VerticalAlignment; + // -------------------- + + char *NonVariable; + size_t nLines; +}; diff --git a/libs/isxdk/include/ISUI/LGUITextEdit.h b/libs/isxdk/include/ISUI/LGUITextEdit.h new file mode 100644 index 0000000..ccaa336 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITextEdit.h @@ -0,0 +1,260 @@ +#pragma once +#include "LGUIelement.h" + +class CTextEditLine +{ +public: + CTextEditLine(const char *p_Text, size_t p_nLine) + { + nLine=p_nLine; + pPrev=0; + pNext=0; + if (p_Text) + { + Used=strlen(p_Text); + Allocated=Used+1; + Text=(char*)malloc(Allocated); + memcpy(Text,p_Text,Allocated); + } + else + { + Text=_strdup(""); + Used=0; + Allocated=1; + } + } + ~CTextEditLine() + { + free(Text); + } + + bool InsertText(size_t Position, const char *Insert, size_t InsertSize) + { + if (!InsertSize) + return true; + if (Position>Used) + return false; + if (Used+InsertSize>Allocated) + { + Text=(char*)realloc(Text,Used+InsertSize+7); + } + + if (Position!=Used+1) + { + // shift to the right + memmove(&Text[Position+InsertSize],&Text[Position],(Used+1-Position)+InsertSize); + } + else + Text[Position+Used+1]=0; + Used+=InsertSize; + memcpy(&Text[Position],Insert,InsertSize); + return true; + } + + bool InsertCharacter(size_t Position, char C) + { + if (Position>Used) + return false; + if (Used+2>=Allocated) + { + Text=(char*)realloc(Text,Used+7); + } + + if (Position!=Used+1) + { + // shift to the right + memmove(&Text[Position+1],&Text[Position],(Used+1-Position)+1); + } + else + Text[Position+1]=0; + Used++; + Text[Position]=C; + + return true; + } + bool OverwriteCharacter(size_t Position, char C) + { + if (Position>Used) + return false; + + if (Position==Used) + { + if (Used+1>=Allocated) + { + Text=(char*)realloc(Text,Used+7); + } + Used++; + Text[Position+1]=0; + } + Text[Position]=C; + } + inline bool DeleteCharacter(size_t Position) + { + if (Position>=Used) + return false; + + memmove(&Text[Position],&Text[Position+1],(Used+1-Position)); + Used--; + return true; + } + inline bool Truncate(size_t Position) + { + if (Position>Used) + return false; + Text[Position]=0; + Used=Position; + return true; + } + + + char *Text; + size_t Allocated; + size_t Used; + + size_t nLine; + + CTextEditLine *pPrev; + CTextEditLine *pNext; +}; + +struct TextEditPos +{ + CTextEditLine *pLine; + size_t Position; + + bool operator==(const TextEditPos& other ) const + { + return pLine==other.pLine && Position==other.Position; + } + bool operator!=(const TextEditPos& other ) const + { + return pLine!=other.pLine || Position!=other.Position; + } + bool operator<(const TextEditPos& other ) const + { + if (pLine==other.pLine) + return PositionnLinenLine; + } + bool operator>(const TextEditPos& other ) const + { + if (pLine==other.pLine) + return Position>other.Position; + else + return pLine->nLine>other.pLine->nLine; + } + bool operator<=(const TextEditPos& other ) const + { + if (pLine==other.pLine) + return Position<=other.Position; + else + return pLine->nLine<=other.pLine->nLine; + } + bool operator>=(const TextEditPos& other ) const + { + if (pLine==other.pLine) + return Position>=other.Position; + else + return pLine->nLine>=other.pLine->nLine; + } +}; + +class LGUITextEdit : + public LGUIFrame +{ +public: + LGUI_API LGUITextEdit(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITextEdit(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API virtual void SetText(const char *NewValue); + LGUI_API virtual void AddText(const char *Text); + LGUI_API virtual void AddLine(const char *Text); + + LGUI_API virtual void InsertText(TextEditPos &Pos, const char *Text); + LGUI_API virtual CTextEditLine *InsertLineAfter(CTextEditLine *pLine, const char *Text); + LGUI_API virtual void RemoveLine(CTextEditLine *pLine, bool bReverseCursor=false); + + LGUI_API virtual bool OnKeyUp(unsigned int VKey); + LGUI_API virtual bool OnKeyDown(unsigned int VKey); + LGUI_API virtual bool OnLMouseDown(POINT2I &pt); + LGUI_API virtual bool OnLMouseUp(POINT2I &pt); + LGUI_API virtual bool OnMouseMove(POINT2I &pt); + + LGUI_API virtual void InsertCharacter(char C); + LGUI_API virtual void HandleBackspace(); + LGUI_API virtual void HandleDelete(); + LGUI_API virtual void HandleEnter(); + + LGUI_API virtual void HandleUp(unsigned int Count=1); + LGUI_API virtual void HandleDown(unsigned int Count=1); + LGUI_API virtual void HandleLeft(); + LGUI_API virtual void HandleRight(); + LGUI_API virtual void HandlePageUp(); + LGUI_API virtual void HandlePageDown(); + LGUI_API virtual void HandleHome(); + LGUI_API virtual void HandleEnd(); + + LGUI_API virtual void HandleCtrlHome(); + LGUI_API virtual void HandleCtrlEnd(); + + LGUI_API virtual void PasteClipboard(); + LGUI_API virtual void CopySelection(); + + LGUI_API virtual void GetPositionFromPoint(POINT2I &pt, TextEditPos &Position); + LGUI_API virtual bool OnMouseWheel(int Offset); + LGUI_API virtual void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API virtual void OnKeyboardExit(LGUIElement *pNewFocus); + + bool IsSelected(CTextEditLine *pLine, POINT2I &Selected); + void ClearSelection(); + void UpdateSelection(); + + // -- XML PROPERTIES -- + LGUIFixedFont *pFont; + unsigned int SelectionColor; + unsigned int CaretOuterColor; + unsigned int CaretInnerColor; + + LGUITexture *pTextureCaret; + LGUITexture *pTextureCaretOverwrite; + //--------------------- + + + CTextEditLine *pFirstLine; + CTextEditLine *pLastLine; + + + bool InsertMode; + size_t MaxLines; + size_t CharactersWide; + + TextEditPos SelectionBegin; + TextEditPos SelectionEnd; + + TextEditPos Position; + + TextEditPos UpperLeft; + TextEditPos LowerLeft; + + unsigned int LastVKey; + unsigned int LastVKeyTimer; + + size_t VisibleLines; + + class LGUIScrollBar *pVerticalScrollbar; + class LGUIScrollBar *pHorizontalScrollbar; + + size_t nLines; + + bool bDragging; +protected: + LGUI_API virtual void Clear(); + +}; diff --git a/libs/isxdk/include/ISUI/LGUITextEntry.h b/libs/isxdk/include/ISUI/LGUITextEntry.h new file mode 100644 index 0000000..097658e --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITextEntry.h @@ -0,0 +1,83 @@ +#pragma once +#include "LGUIelement.h" + +struct _CreateTextEntry : public _CreateElement +{ + char *Text; + _CreateFont Font; +// char *Font; + +// unsigned int FontHeight; +// unsigned int TextColor; + unsigned int BackgroundColor; + unsigned int SelectionColor; + unsigned int MaxLength; + unsigned int BorderColor; + unsigned int Border; + unsigned int CaretOuterColor; + unsigned int CaretInnerColor; + char PasswordChar; +}; + +class LGUITextEntry : + public LGUIElement +{ +public: + LGUI_API LGUITextEntry(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITextEntry(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateTextEntry &CreateInfo, class XMLNode *pTemplate=0); + LGUI_API void Render(); + LGUI_API void RenderCustom(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API virtual void SetText(char *NewValue); + LGUI_API virtual void SetFontSize(unsigned int NewHeight); + LGUI_API virtual bool OnKeyUp(unsigned int VKey); + LGUI_API virtual bool OnKeyDown(unsigned int VKey); + LGUI_API virtual bool OnLMouseDown(POINT2I &pt); + LGUI_API virtual void InsertCharacter(char C); + LGUI_API virtual void HandleBackspace(); + LGUI_API virtual void HandleDelete(); + LGUI_API virtual void HandleEnter(); + LGUI_API virtual void HandleEscape(); + + LGUI_API virtual void PasteClipboard(); + + LGUI_API unsigned int GetPositionFromPoint(POINT2I &pt); + + LGUI_API virtual void OnKeyboardExit(LGUIElement *pNewFocus); + + // -- XML PROPERTIES -- + char *Text; + LGUIFont *pFont; + unsigned int BackgroundColor; + unsigned int SelectionColor; + unsigned int MaxLength; + unsigned int BorderColor; + unsigned int Border; + unsigned int CaretOuterColor; + unsigned int CaretInnerColor; + + LGUITexture *pTexture; + LGUITexture *pTextureFocused; + LGUITexture *pTextureCaret; + LGUITexture *pTextureCaretOverwrite; + + LGUIEmbeddedScript *pOnChange; + + char PasswordChar; + //--------------------- + +// unsigned int FontWidth; + + bool InsertMode; + size_t Position; + + unsigned int LastVKey; + size_t TextEnd; + unsigned int LastVKeyTimer; + size_t VisiblePos; +}; diff --git a/libs/isxdk/include/ISUI/LGUITexture.h b/libs/isxdk/include/ISUI/LGUITexture.h new file mode 100644 index 0000000..e894edd --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITexture.h @@ -0,0 +1,75 @@ +#pragma once + +#define TR_TEXTURERECT 1 +#define TR_ALPHA 2 +#define TR_COLORMASK 4 +#define TR_NOSIZE 8 +#define TR_TEXTURETRIANGLE 16 + +struct LGUITexturedRect +{ +public: + class LGUITexture *pTexture; + + RECT Rect; + + DWORD Flags; + RECT TextureRect; + unsigned char Alpha; + unsigned int ColorMask; + unsigned char Orientation; +}; + +struct LGUITriangle +{ + POINT2F Point[3]; +}; + +struct LGUITexturedTriangle +{ +public: + class LGUITexture *pTexture; + + LGUITriangle Triangle; + + DWORD Flags; + LGUITriangle TextureTriangle; + unsigned char Alpha; + unsigned int ColorMask; + unsigned char Orientation; +}; + +class LGUITexture +{ +public: + LGUITexture(const char *p_Name); + LGUITexture(const LGUITexture&); + ~LGUITexture(); + + void CopyFrom(const LGUITexture &other); + + LGUI_API static LGUITexture *New(const char *p_Name); + LGUI_API static LGUITexture *New(const LGUITexture&); + LGUI_API void Delete(); + LGUI_API bool Prepare(); + LGUI_API bool GetSize(); + LGUI_API bool FromXML(class XMLNode *pXML); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate); + + LGUI_API void Set(const char *Filename, unsigned int ColorKey=0); + LGUI_API void SetFrom(const LGUITexture& other); + + char *Name; + unsigned int TextureID; + unsigned int ColorKey; + + DWORD Flags; + RECT TextureRect; + LGUITriangle TextureTriangle; + + float Alpha; + unsigned int ColorMask; + unsigned int Border; + unsigned char Orientation; +}; + diff --git a/libs/isxdk/include/ISUI/LGUITooltip.h b/libs/isxdk/include/ISUI/LGUITooltip.h new file mode 100644 index 0000000..f5b1d6a --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITooltip.h @@ -0,0 +1,58 @@ +#pragma once + + +struct _CreateTooltip : public _CreateElement +{ + unsigned int BackgroundColor; + unsigned int Border; + unsigned int BorderColor; + _CreateFont Font; +// unsigned int TextColor; +// unsigned int FontSize; + bool DefaultTextures; +}; + +class LGUITooltipLine +{ +public: + LGUI_API LGUITooltipLine(const char *p_Text); + LGUI_API ~LGUITooltipLine(); + LGUI_API char *Parse(); + + LGUI_API void Set(const char *p_Text); + + char *Text; + bool bVariable; +}; + +class LGUITooltip : + public LGUIFrame +{ +public: + LGUI_API LGUITooltip(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITooltip(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); +// LGUI_API void Create(_CreateTooltip &CreateInfo, class XMLNode *pTemplate=0); + LGUI_API bool OnMouseMove(POINT2I &pt); + + LGUI_API void Reset(); + LGUI_API void Printf(const char *Format, ...); + LGUI_API void Print(const char *Text); + + // -- XML Properties -- + LGUIFont *pFont; + + // ---------------------- + + CIndex Lines; + unsigned int nLines; + +protected: + LGUI_API void AddLine(const char *Text); + +}; + diff --git a/libs/isxdk/include/ISUI/LGUITree.h b/libs/isxdk/include/ISUI/LGUITree.h new file mode 100644 index 0000000..17f4512 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUITree.h @@ -0,0 +1,99 @@ +#pragma once + +class LGUITreeNode +{ +public: + LGUI_API LGUITreeNode(class LGUITree *p_pTree, LGUITreeNode *p_pParent, const char *p_Text, unsigned int p_Color); + LGUI_API ~LGUITreeNode(); + + bool Render(RECT &bounds, unsigned int height, int &Skip); + bool RenderChildren(RECT &bounds, unsigned int height, int &Skip); + + void ClearChildren(); + + void ToggleExpand(); + void Expand(bool bExpand); + void Remove(); + void SetText(const char *text); + + LGUITreeNode *ParseNode(int argc, char *argv[]); + + LGUITreeNode *AddChild(int argc, char *argv[]); + LGUITreeNode *InsertSiblingBefore(int argc, char *argv[]); + LGUITreeNode *InsertSiblingAfter(int argc, char *argv[]); + + LGUITreeNode *m_pParent; + LGUITreeNode *m_pChildren; + LGUITreeNode *m_pPrevious; + LGUITreeNode *m_pNext; + + LGUITreeNode *WalkTree(bool bIncludeCollapsed); + + class LGUITexture *m_pImage; + class LGUITexture *m_pImageCollapsible; + class LGUITexture *m_pImageCollapsed; + const char *m_Text; + bool m_bExpanded; + + unsigned int m_Color; + + class LGUITree *m_pTree; + MetadataStore *m_pMetadataStore; + + const char *GetMetadata(const char *key); + bool SetMetadata(const char *key, const char *value); + bool UnsetMetadata(const char *key); +}; + +class LGUITree : + public LGUIFrame +{ +public: + LGUI_API LGUITree(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUITree(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDoubleClick(POINT2I &pt); + LGUI_API bool OnRMouseUp(POINT2I &pt); + LGUI_API bool OnRMouseDown(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + + LGUITreeNode *GetNodeByHandle(UINT_PTR handle); + LGUITreeNode *GetNodeByQuery(const char *query); + LGUITreeNode *GetNodeByPosition(int X, int Y, bool &bOnImage); + void SetSelected(LGUITreeNode *node); + + LGUIFont *pFont; + class LGUITexture *m_pImage; + class LGUITexture *m_pImageCollapsible; + class LGUITexture *m_pImageCollapsed; + unsigned int VisiblePos; + + unsigned int IndentPerDepth; + unsigned int ImageSize; + unsigned int ImageBorder; + unsigned int TextMargin; + unsigned int TextColor; + unsigned int ItemHeight; + + unsigned int SelectionBackgroundColor; + unsigned int SelectionTextColor; + LGUITreeNode *pRoot; + + LGUIScrollBar *pVerticalBar; + LGUIEmbeddedScript *pOnSelect; + LGUIEmbeddedScript *pOnDeSelect; + + LGUITreeNode *pSelectedNode; + + std::set m_AllNodes; +}; diff --git a/libs/isxdk/include/ISUI/LGUIVariableGauge.h b/libs/isxdk/include/ISUI/LGUIVariableGauge.h new file mode 100644 index 0000000..4274e00 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIVariableGauge.h @@ -0,0 +1,55 @@ +#pragma once + +class LGUIVariableGauge : + public LGUIGauge +{ +public: + LGUI_API LGUIVariableGauge(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIVariableGauge(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + + // -- XML Properties -- + LGUIDataSequence Data; + float Offset; + // -------------------- + +}; + + +class LGUIVariableGaugeFactory : public LGUIElementFactory +{ +public: + LGUIVariableGaugeFactory():LGUIElementFactory("variablegauge",LGUI_VERSION) + { + } + + ~LGUIVariableGaugeFactory() + { + } + + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name, class XMLNode *pXML, const char *Template = 0) + { + LGUIVariableGauge *pElement = new LGUIVariableGauge(Type,pParent,Name); + + if (!pElement->FromXML(pXML,g_UIManager.FindTemplate(Template))) + { + delete pElement; + return 0; + } + Elements[pElement]=1; + if (pElement->pFiller) + return pElement->pFiller; + return pElement; + } + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name) + { + LGUIVariableGauge *pElement = new LGUIVariableGauge(Type,pParent,Name); + Elements[pElement]=1; + return pElement; + } + +}; \ No newline at end of file diff --git a/libs/isxdk/include/ISUI/LGUIVariableSlider.h b/libs/isxdk/include/ISUI/LGUIVariableSlider.h new file mode 100644 index 0000000..a8bfe81 --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIVariableSlider.h @@ -0,0 +1,29 @@ +#pragma once + +class LGUIVariableSlider : + public LGUISlider +{ +public: + LGUI_API LGUIVariableSlider(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIVariableSlider(void); +// LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Render(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API bool IsTypeOf(char *TestFactory); + +// LGUI_API bool OnLMouseUp(POINT2I &pt); +// LGUI_API bool OnLMouseDown(POINT2I &pt); +// LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API void SetValue(unsigned int NewValue); + + // -- XML Properties -- + LGUIDataSequence Data; + const char *OriginalData; + + float Offset; + float VariableRange; + // -------------------- + + bool InitialValue; +}; diff --git a/libs/isxdk/include/ISUI/LGUIWindow.h b/libs/isxdk/include/ISUI/LGUIWindow.h new file mode 100644 index 0000000..b532b9f --- /dev/null +++ b/libs/isxdk/include/ISUI/LGUIWindow.h @@ -0,0 +1,168 @@ +#pragma once +#include "LGUIElement.h" + +#define ISW_CLOSE 1 +#define ISW_MINIMIZE 2 +//#define ISW_TITLEBAR 4 +#define ISW_RESIZEWIDTH 8 +#define ISW_RESIZEHEIGHT 16 +#define ISW_RESIZE (ISW_RESIZEWIDTH|ISW_RESIZEHEIGHT) +#define ISW_OFFSETTITLEBARWIDTH 32 +#define ISW_OFFSETTITLEBARHEIGHT 64 + +#define SIZING_LEFT 1 +#define SIZING_RIGHT 2 +#define SIZING_TOP 4 +#define SIZING_BOTTOM 8 + +struct _CreateWindow : public _CreateFrame +{ + unsigned int Flags; + char *Title; + char *ClickFocus; +}; + +class CWindowContextMenu : public CContextMenuHandler +{ +public: + LGUI_API CWindowContextMenu(); + LGUI_API ~CWindowContextMenu(); + + LGUI_API virtual void OnCreate(unsigned int ParentItemID); + LGUI_API virtual void OnClick(unsigned int ItemID); + + class LGUIWindow *pWindow; +}; + +class LGUIWindow : public LGUIFrame +{ +public: + LGUI_API LGUIWindow(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + LGUI_API ~LGUIWindow(void); + LGUI_API class LSTypeDefinition *GetLSType(); + + LGUI_API void Create(_CreateWindow &CreateInfo, class XMLNode *pTemplate=0); + + LGUI_API bool IsTypeOf(char *TestFactory); + LGUI_API void Render(); + LGUI_API void RenderChildren(); + LGUI_API void OnCreate(); + LGUI_API bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + LGUI_API void RecalculateSize(bool RecalculateChildren); + LGUI_API bool OnLMouseUp(POINT2I &pt); + LGUI_API bool OnLMouseDown(POINT2I &pt); + LGUI_API bool OnLMouseDoubleClick(POINT2I &pt); + LGUI_API bool OnRMouseUp(POINT2I &pt); + LGUI_API bool OnRMouseDown(POINT2I &pt); + LGUI_API bool OnMouseMove(POINT2I &pt); + LGUI_API bool OnMouseWheel(int Offset); + LGUI_API void Show(bool bShow); + LGUI_API void OnNotify(LGUIElement *pElement, unsigned int Notification, UINT_PTR Value); + + LGUI_API virtual void OnResize(); + + LGUI_API LGUIElement *FindChild(const char *Name); + + LGUI_API void Minimize(bool bMinimize); + + + LGUI_API void ResetWindowPosition(); + + LGUI_API bool GetStoragePosition(int &StoreX, int &StoreY, unsigned int &StoreWidth, unsigned int &StoreHeight); + + LGUI_API void SetTitle(const char *title); + + // -- XML Properties -- + + unsigned int Flags; + + char *Title; + char *ClickFocus; + unsigned int MinHeight; + unsigned int MinWidth; + + LGUIEmbeddedScript *pOnMove; + LGUIEmbeddedScript *pOnSize; + LGUIEmbeddedScript *pOnReset; + // --- + + unsigned int PreMinimizeHeight; + unsigned int PreMinimizeWidth; + int PreMinimizeTitleBarX; + int PreMinimizeTitleBarY; + bool bMinimized; + bool bMoving; + bool bLocked; + unsigned int Sizing; + POINT2I SizingOffset; + POINT2I MovingOffset; + + class LGUIWindowClient *pClient; + class LGUIFrame *pTitleBar; + class LGUIText *pTitle; + class LGUIButton *pMinimize; + class LGUIButton *pMaximize; + class LGUIButton *pClose; + + CWindowContextMenu ContextMenu; +// CWindowSubmenu SubMenu; +}; + +class LGUIWindowClient : public LGUIFrame +{ +public: + LGUIWindowClient(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + ~LGUIWindowClient(void); + + bool IsTypeOf(char *TestFactory); + void OnCreate() + { + pWindow->OnCreate(); + } + void OnNotify(LGUIElement *pElement, unsigned int Notification, unsigned int Value) + { + pWindow->OnNotify(pElement,Notification,Value); + } + + class LGUIWindow *pWindow; +}; + +template +class LGUIWindowFactory : public LGUIElementFactory +{ +public: + LGUIWindowFactory(const char *p_Type):LGUIElementFactory(p_Type,LGUI_VERSION) + { + } + + ~LGUIWindowFactory() + { + } + + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name, class XMLNode *pXML, const char *Template = 0) + { + T *pElement = new T(Type,pParent,Name); + + if (!pElement->FromXML(pXML,g_UIManager.FindTemplate(Template))) + { + if (pParent) + pParent->DeleteChild(pElement); + else + delete pElement; + return 0; + } + Elements[pElement]=1; + pElement->OnCreate(); + pElement->ExecuteOnLoad(); + return pElement->pClient; + } + virtual LGUIElement *CreateUIElement(LGUIElement *pParent, const char *Name) + { + T *pElement = new T(Type,pParent,Name); + Elements[pElement]=1; + return pElement; + } + + virtual LSTypeDefinition *GetLSType() {if (!Q) return 0; return *Q;} +}; +/**/ diff --git a/libs/isxdk/include/ISXDK.h b/libs/isxdk/include/ISXDK.h new file mode 100644 index 0000000..4f26bbf --- /dev/null +++ b/libs/isxdk/include/ISXDK.h @@ -0,0 +1,527 @@ +#pragma once +#pragma pack(push) +#pragma pack(8) +// +// Inner Space Extension Library +// (c) 2004-2016 Lavish Software, LLC +// + +#define ISXDK_VERSION 0x0035 +#pragma warning( push ) +#pragma warning( disable : 4996 ) + +//#include +#include +#include +#include +#include "utf8string.h" +#include +#include +#include "WinThreading.h" +#include "Index.h" +#include "Queue.h" +#include "FileList.h" +#ifndef ISXDK_NOLAVISHSCRIPT +#include "LavishScript/LavishScript.h" +#else +#define LSType unsigned int +#define fLSCommand unsigned int +#define fLSTopLevelObject unsigned int +#define PLSOBJECT unsigned int +#define CTempObject unsigned int +#define CNavPath unsigned int +#define RGBCOLOR unsigned int +//#define fLSEventTarget unsigned int + +struct POINT2I +{ + int X; + int Y; +}; + +struct POINT2F +{ + float X; + float Y; +}; +struct POINT3F : public POINT2F +{ + float Z; +}; +#endif + +#ifndef ISXDK_NOLAVISHSCRIPT +typedef void (__cdecl *fLSEventTarget)(int argc, char *argv[], PLSOBJECT); +#else +typedef void (__cdecl *fLSEventTarget)(int argc, char *argv[], void *); +typedef void (__cdecl *fLSGenericEnumCallback)(const char *Name, void *pData); + +#ifdef RGBCOLOR +#undef RGBCOLOR +#endif + +typedef struct _RGBColor +{ + union { + unsigned int ulColor; + struct { + unsigned char Red; + unsigned char Green; + unsigned char Blue; + unsigned char Reserved; + }; + struct { + unsigned char B; + unsigned char G; + unsigned char R; + unsigned char A; + }; + unsigned int ARGB; + }; +} RGBCOLOR, *PRGBCOLOR; +#endif + +#ifndef ISXDK_NOISUI +#pragma comment(lib,"ISUI.lib") +#include "ISUI/LGUI.h" +#endif +using namespace std; +#define MakeLower(yourstring) transform (yourstring.begin(),yourstring.end(), yourstring.begin(), tolower); + + +// from Blech.h +#ifndef BLECHVERSION +typedef struct _BLECHVALUE { + char *Name; + char *Value; + struct _BLECHVALUE *pNext; +} BLECHVALUE, *PBLECHVALUE; + +typedef unsigned int (__stdcall *fBlechVariableValue)(char *VarName, char *Value); +typedef void (__stdcall *fBlechCallback)(unsigned int ID, void *pData, PBLECHVALUE pValues); +#endif + +#ifndef FUNCTION_AT_ADDRESS +#define FUNCTION_AT_ADDRESS(function,offset) __declspec(naked) function\ +{\ + __asm{mov eax, offset};\ + __asm{jmp eax};\ +} +#endif + +#ifndef FUNCTION_AT_VARIABLE_ADDRESS +#define FUNCTION_AT_VARIABLE_ADDRESS(function,variable) __declspec(naked) function\ +{\ + __asm{mov eax, [variable]};\ + __asm{jmp eax};\ +} +#endif + +#ifndef FUNCTION_AT_VIRTUAL_ADDRESS +#define FUNCTION_AT_VIRTUAL_ADDRESS(function,virtualoffset) __declspec(naked) function\ +{\ + __asm{mov eax, [ecx]};\ + __asm{lea eax, [eax+virtualoffset]};\ + __asm{mov eax, [eax]};\ + __asm{jmp eax};\ +} +#endif + +#ifndef DETOUR_TRAMPOLINE_EMPTY +#define DETOUR_TRAMPOLINE_EMPTY(trampoline) \ +__declspec(naked) trampoline \ +{ \ + __asm { nop };\ + __asm { nop };\ + __asm { xor eax, eax };\ + __asm { mov eax, [eax] };\ + __asm { ret };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ + __asm { nop };\ +} +#endif + +#ifndef ISXDK_NOLAVISHSCRIPT +struct NamedPoint +{ + char Name[128]; + POINT3F pt; +}; + +class CNavPath +{ +public: + CNavPath() + { + nPoints=0; + } + + ~CNavPath() + { + Reset(); + } + + void Reset() + { + Points.Cleanup(); + nPoints=0; + } + + void RemoveLast() + { + if (nPoints) + { + nPoints--; + delete Points[nPoints]; + Points[nPoints]=0; + } + } + + void AddPoint(POINT3F &pt, char *Name=0) + { + NamedPoint *pPoint=new NamedPoint; + pPoint->pt=pt; + if (Name) + { + strncpy(pPoint->Name,Name,128); + pPoint->Name[127]=0; + } + else + pPoint->Name[0]=0; + Points+=pPoint; + nPoints++; + } + + void Reverse() + { + if (nPoints) + { + CLock L(&Points.CS,1); + unsigned int Mid=nPoints/2; + unsigned int nPointsLess1=nPoints-1; + for (unsigned int i = 0 ; i < Mid ; i++) + { + unsigned int Second=nPointsLess1-i; + NamedPoint* Temp=Points[i]; + Points[i]=Points[Second]; + Points[Second]=Temp; + } + } + } + + unsigned int nPoints; + CIndex Points; +}; + +class CPixelMap +{ +public: + CPixelMap(unsigned int nRows, unsigned int nColumns) + { + Rows=(RGBCOLOR**)malloc(nRows*sizeof(RGBCOLOR**)); + unsigned int BufferSize=nRows*nColumns*sizeof(RGBCOLOR); + Buffer=(RGBCOLOR*)malloc(BufferSize); + ZeroMemory(Buffer,BufferSize); + for (unsigned int i = 0 ; i < nRows ; i++) + { + Rows[i]=&Buffer[nColumns*i]; + } + } + ~CPixelMap() + { + free(Rows); + free(Buffer); + }; + RGBCOLOR **Rows; +private: + RGBCOLOR *Buffer; +}; + +static inline bool IsNumber(const char *String) +{ + if (*String==0) + return false; + if (*String=='-') + String++; + while(*String) + { + if (!((*String>='0' && *String<='9') || *String=='.')) + return false; + ++String; + } + return true; +} + +static inline bool IsHex(const char *String) +{ + if (*String==0) + return false; + while(*String) + { + if ((*String<'0' || *String>'9') && + (*String<'a' || *String>'f') && + (*String<'A' || *String>'F') + ) + return false; + ++String; + } + return true; +} +#endif + +static inline bool IsAbsolutePath(const char *String) +{ + if (!String) + return false; + if (String[0]=='\\' || String[0]=='/') + return true; + if (strchr(String,':')) + return true; + return false; +} + +static inline bool IsAbsolutePath(const wchar_t *String) +{ + if (!String) + return false; + if (String[0]=='\\' || String[0]=='/') + return true; + if (wcschr(String,':')) + return true; + return false; +} + +#ifndef FOPEN_UTF8 +#define FOPEN_UTF8 +static inline FILE *fopen_utf8(const char *filename, const char *mode) +{ + WCHAR wFilename[512]; + wFilename[0]=0; + MultiByteToWideChar(CP_UTF8,0,filename,-1,wFilename,512); + wFilename[511]=0; + WCHAR wMode[512]; +#pragma warning( push ) +#pragma warning( disable : 4996 ) + swprintf(wMode,L"%S",mode); + return _wfopen(wFilename,wMode); +#pragma warning( pop ) +} +#endif + +#ifndef FEXISTS_UTF8 +#define FEXISTS_UTF8 +static inline bool fexists_utf8(const char *filename) +{ + WCHAR wFilename[512]; + wFilename[0]=0; + MultiByteToWideChar(CP_UTF8,0,filename,-1,wFilename,512); + wFilename[511]=0; + return (_waccess( wFilename, 0 )) != -1; +} +#endif + +#ifndef WFEXISTS +#define WFEXISTS +static inline bool _wfexists(const wchar_t *wFilename) +{ + return (_waccess( wFilename, 0 )) != -1; +} +#endif + +typedef unsigned int HISXSERVICE; + +class ISXInterface; +#ifndef LVM_TYPEDEFS +#define LVM_TYPEDEFS +typedef void (__stdcall *fDomainEnumCallback)(const char *Name, void *pData); +typedef void * (__stdcall *fGetAPI)(const char *Name, unsigned int Version); +#endif + +typedef void (__cdecl *fISService)(bool Broadcast, unsigned int MSG, void *lpData); +typedef void (__cdecl *fISServiceRequest)(ISXInterface *pClient, unsigned int MSG, void *lpData); +typedef ISXInterface *(__cdecl *fCreateISXInterface)(unsigned int); + +typedef void (__cdecl *fSetEnumCallback)(const char *Name, void *pData); +typedef void (__cdecl *fNavWorldEnumCallback)(const char *Name, void *pData); +typedef void (__cdecl *fSettingEnumCallback)(const char *Name, const char *Value, void *pData); + +#include "ISInterface.h" +#include "ISXInterface.h" +#include "ColumnRenderer.h" +#include "Services.h" + +class ISXPreParse +{ +public: + inline ISXPreParse(class ISInterface *pInterface, const char *Text) + { + ID=pInterface->PreParseText(Text); + } + inline ~ISXPreParse() + { + pInterface->FreePreParsed(ID); + } + + inline bool RetrieveOriginalText(char *buf, size_t buflen) + { + return pInterface->RetrieveOriginalText(ID,buf,buflen); + } + inline bool RetrieveProcessedText(char *buf, size_t buflen) + { + return pInterface->RetrieveProcessedText(ID,buf,buflen); + } + + unsigned int ID; + ISInterface *pInterface; +}; + +class ISXDataSequence +{ +public: + inline ISXDataSequence(class ISInterface *pInterface, const char *DataSequence) + { + ID=pInterface->PreParseText(DataSequence,true); + } + inline ~ISXDataSequence() + { + pInterface->FreePreParsed(ID); + } + + inline bool RetrieveOriginalText(char *buf, unsigned int buflen) + { + return pInterface->RetrieveOriginalText(ID,buf,buflen); + } + inline bool RetrieveProcessedText(char *buf, unsigned int buflen) + { + return pInterface->RetrieveProcessedText(ID,buf,buflen); + } + inline bool RetrieveProcessedResult(LSOBJECT &Result) + { + return pInterface->RetrieveProcessedResult(ID,Result); + } + + unsigned int ID; + ISInterface *pInterface; +}; + + +#define ISXDllMain(_name_,_class_) \ + BOOL APIENTRY DllMain(HANDLE hModule, \ + DWORD ul_reason_for_call, \ + LPVOID lpReserved \ + ) \ +{ \ + if (ul_reason_for_call == DLL_PROCESS_ATTACH) \ + { \ + g_hModule = (HMODULE)hModule; \ + DWORD ResultLen = GetModuleFileName((HMODULE)hModule, ModulePath, sizeof(ModulePath)); \ + memcpy(ActualModulePath, ModulePath, ResultLen + 1); \ + if (char *pSlash = strrchr(ModulePath, '\\')) \ + { \ + *pSlash = 0; \ + ModuleFileName = &pSlash[1]; \ + }\ + else \ + {\ + ModuleFileName = ActualModulePath; \ + ModulePath[0] = '.'; \ + ModulePath[1] = 0; \ + }\ + sprintf_s(INIFileName, "%s\\%s.ini", ModulePath, _name_); \ + sprintf_s(XMLFileName, "%s.xml", _name_); \ + sprintf_s(PluginLog, "%s\\%s.log", ModulePath, _name_); \ + }\ + else if (ul_reason_for_call == DLL_PROCESS_DETACH)\ + {\ + if (pExtension)\ + {\ + delete pExtension; \ + pExtension = 0; \ + }\ + }\ + return TRUE; \ +} + +#define ISXDKDependencies(_name_,_class_) \ +class LSTypeDefinition * FindLSTypeDefinition(const char *Name)\ +{\ + return pISInterface->FindLSTypeDefinition(Name); \ +}\ +void *GetTempBuffer(size_t Size, const void *Copy)\ +{\ + return pISInterface->GetTempBuffer((unsigned int)Size, (void*)Copy); \ +}\ +void RegisterTemporaryObject(class CTempObject *pObject)\ +{\ + pISInterface->AddTempObject(pObject); \ +}\ +void InvalidatePersistentObject(unsigned int persistentClass, unsigned __int64 persistedValue)\ +{\ + pISInterface->InvalidatePersistentObject(persistentClass, persistedValue); \ +}\ +unsigned int RegisterPersistentClass(const char *name)\ +{\ + return pISInterface->RegisterPersistentClass(name); \ +} + +#define ISXExports(_name_,_class_) \ +extern "C" __declspec(dllexport) ISXInterface * __cdecl CreateISXInterface(unsigned int ISInterfaceVersion) \ +{\ + if (pExtension || ISInterfaceVersion != ISXDK_VERSION) \ + return 0; \ + pExtension = new _class_; \ + return pExtension; \ +}\ +extern void __cdecl InitializeISXDK(void *); \ +extern "C" __declspec(dllexport) ISXInterface * __cdecl CreateISXInterfaceEx(void *p) \ +{\ + if (pExtension)\ + return 0; \ + InitializeISXDK(p); \ + pExtension = new _class_; \ + return pExtension; \ +}\ +extern "C" __declspec(dllexport) unsigned int ISXDK_Version = ISXDK_VERSION; \ +extern "C" __declspec(dllexport) unsigned int LGUI_Version = LGUI_VERSION; + +#define ISXVariables(_name_,_class_) \ + char ActualModulePath[MAX_PATH] = { 0 }; \ + char ModulePath[MAX_PATH] = { 0 }; \ + char PluginLog[MAX_PATH] = { 0 }; \ + char INIFileName[MAX_PATH] = { 0 }; \ + char XMLFileName[MAX_PATH] = { 0 }; \ + const char *ModuleFileName = 0; \ + _class_ *pExtension = 0; \ + HMODULE g_hModule = 0; + +#define ISXPreSetup(_name_,_class_) \ + ISXVariables(_name_, _class_) \ + ISXDllMain(_name_, _class_); \ + ISXExports(_name_, _class_); \ + ISXDKDependencies(_name_, _class_); + +#pragma warning(pop) +#pragma pack(pop) diff --git a/libs/isxdk/include/ISXInterface.h b/libs/isxdk/include/ISXInterface.h new file mode 100644 index 0000000..7f81d6e --- /dev/null +++ b/libs/isxdk/include/ISXInterface.h @@ -0,0 +1,54 @@ +#pragma once + +typedef struct _ISXSCRIPTENGINECAPS +{ + unsigned int Sizeof; // set by the caller before calling GetCaps, to sizeof(ISXSCRIPTENGINECAPS) + // use Sizeof to fill in the caps structure only up to the correct size + + bool bPreprocessor; // engine has a preprocessor (e.g. #define, #include, etc) + bool bPersistent; // can run persistent scripts + bool bMultipleScripts; // can run multiple scripts +} ISXSCRIPTENGINECAPS, *PISXSCRIPTENGINECAPS; + +class ISXScriptEngine +{ +public: + virtual const char *GetName()=0; // unix name if possible, e.g. #!/usr/bin/perl would be "perl" + virtual const char *GetVersion()=0; // used by extensions. implement however you want + virtual bool GetCaps(ISXSCRIPTENGINECAPS &Dest)=0; // used by extensions to retrieve engine capabilities + + virtual void Pulse()=0; // for persistent scripts, use this to process microthreads, etc. + + virtual bool ExecuteScript(const char *FullFilename, int argc, char *argv[])=0; // used by RunScript command + virtual bool EndScript(const char *Name)=0; // used by EndScript + + virtual bool IsScript(const char *FullFilename) {return true;} +}; + +class ISXSoftwareCursorInterface +{ +public: + virtual bool CursorEnabled()=0; + virtual bool GetPosition(int &X, int &Y)=0; + + virtual bool SetPosition(int X, int Y)=0; + + virtual bool DrawCursor() {return false;} +}; + +class ISXInterface +{ +public: + virtual unsigned int GetVersion(); + + virtual bool Initialize(ISInterface *pISInterface)=0; + virtual void Shutdown()=0; + + virtual bool RequestShutdown() + { + // return false if you must handle asynchronous shutdown behaviors first + // doing so will require an additional unload request. + return true; + } + +}; diff --git a/libs/isxdk/include/Index.h b/libs/isxdk/include/Index.h new file mode 100644 index 0000000..5e266f8 --- /dev/null +++ b/libs/isxdk/include/Index.h @@ -0,0 +1,131 @@ +#pragma once +#ifndef __INDEX_H__ +#define __INDEX_H__ +#include +//#include +#define foreach(variable,counter,index) for (size_t counter=0 ; counter < index.Size ; counter++) if (variable=index[counter]) +#define foreachp(variable,counter,index) for (size_t counter=0 ; counter < index->Size ; counter++) if (variable=(*index)[counter]) + +template +class CIndex +{ +public: + CIndex() + { + Size=0; + List=0; + } + + CIndex(size_t InitialSize) + { + Size=0; + List=0; + Resize(InitialSize); + } + + ~CIndex() + {// user is responsible for managing elements + CLock(&CS,true); + if (List) + Free(List); + List=0; + Size=0; + } + + void Clear() + { + CLock(&CS,true); + for (size_t i = 0 ; i < Size ; i++) + { + if (List[i]) + { + List[i]=0; + } + } + } + + void Cleanup() + { + CLock(&CS,true); + for (size_t i = 0 ; i < Size ; i++) + { + if (List[i]) + { + delete List[i]; + List[i]=0; + } + } + } + + void Resize(size_t NewSize) + { + CLock(&CS,true); + if (List) + { + if (NewSize>Size) + { + // because we want to zero out the unused portions, we wont use realloc + Any *NewList=(Any*)Malloc(NewSize*sizeof(Any)); + memset(NewList,0,NewSize*sizeof(Any)); + memcpy(NewList,List,Size*sizeof(Any)); + Free(List); + List=NewList; + Size=NewSize; + } + } + else + { + List=(Any*)Malloc(NewSize*sizeof(Any)); + memset(List,0,NewSize*sizeof(Any)); + Size=NewSize; + } + } + + // gets the next unused index, resizing if necessary + inline size_t GetUnused() + { + CLock(&CS,true); + size_t i; + for ( i = 0 ; i < Size ; i++) + { + if (!List[i]) + return i; + } + Resize(Size+10); + return i; + } + + size_t Count() + { + CLock(&CS,true); + size_t ret=0; + for (size_t i = 0 ; i < Size ; i++) + { + if (List[i]) + ret++; + } + return ret; + } + + virtual void *Malloc(size_t _Size) + { + return malloc(_Size); + } + virtual void Free(const void *mem) + { + free((void*)mem); + } + + size_t Size; + Any *List; + + inline Any& operator+=(Any& Value){return List[GetUnused()]=Value;} + inline Any& operator[](size_t Index){return List[Index];} + CSemaphore CS; +}; + + + + +#endif + diff --git a/libs/isxdk/include/LavishScript/LSSTLTypes.h b/libs/isxdk/include/LavishScript/LSSTLTypes.h new file mode 100644 index 0000000..badd50a --- /dev/null +++ b/libs/isxdk/include/LavishScript/LSSTLTypes.h @@ -0,0 +1,844 @@ +#pragma once +#include +#include +using namespace std; +#include +extern void InvalidatePersistentObject(unsigned int persistentClass, unsigned __int64 persistedValue); +extern unsigned int RegisterPersistentClass(const char *name); + +// Symbiotic base class (e.g. iterator <-> iterator target) +class LSSym +{ +public: + virtual void RegisterSym(LSSym*)=0; + virtual void UnregisterSym(LSSym*)=0; +}; + +class LSIterator : public LSSym +{ +public: + LSIterator(class LSIteratable *p_pIteratable, bool b_Reversible, bool b_Const, bool b_RandomAccess); + virtual ~LSIterator(); + + virtual void RegisterSym(LSSym*) {}; + virtual void UnregisterSym(LSSym*) {pIteratable=0;}; + + virtual bool IsValid()=0; + + virtual bool First()=0; + virtual bool Last()=0; + virtual bool GetKey(LSOBJECT &Object)=0; + virtual bool GetValue(LSOBJECT &Object)=0; + virtual bool SetValue(int argc, char *argv[])=0; + virtual bool Jump(int argc, char *argv[])=0; + virtual bool Next()=0; + virtual bool Previous()=0; + + + virtual void Delete(); + + virtual class LSIteratable *GetIteratable() {return (class LSIteratable *)pIteratable;} + inline bool IsReversible() {return bReversible;} + inline bool IsConstant() {return bConst;} + inline bool IsRandomAccess() {return bRandomAccess;} +protected: + LSSym *pIteratable; + bool bReversible; + bool bConst; + bool bRandomAccess; +}; + +class LSIteratable : public LSSym +{ +public: + LSIteratable(const char *p_IteratableType); + virtual ~LSIteratable(); + + virtual void RegisterSym(LSSym* pSym) + { + Iterators.insert((LSIterator*)pSym); + } + virtual void UnregisterSym(LSSym* pSym) + { + Iterators.erase((LSIterator*)pSym); + } + + virtual LSIterator *NewIterator(void *PassAlong)=0; + + bool NewIterator(LSOBJECT &Dest); + + inline const char *GetIteratableType() {return IteratableType;} + +protected: + set Iterators; + const char *IteratableType; +}; + +class LSContainer : public LSIteratable +{ +public: + LSContainer(const char *p_IteratableType):LSIteratable(p_IteratableType) + { + RegisterContainer(); + } + ~LSContainer() + { + UnregisterContainer(); + InvalidatePersistentObject(RegisterPersistentClass("internal_pointer"), (unsigned __int64)this); + } + + virtual bool Clear()=0; + virtual size_t GetContainerSize() = 0; + virtual size_t GetContainerUsed() = 0; + + virtual void OnRemoveType(class LSTypeDefinition *pType)=0; + + void RegisterContainer(); + void UnregisterContainer(); +}; + +/* QUEUE */ +struct LSQueueNode +{ + LSOBJECT Object; + LSQueueNode *pNext; +}; + +class LSQueueIterator : public LSIterator +{ +public: + LSQueueIterator(class LSQueue *p_pQueue); + + virtual bool First(); + virtual bool Last(); + virtual bool IsValid(); + virtual bool GetKey(LSOBJECT &Object); + virtual bool GetValue(LSOBJECT &Object); + virtual bool SetValue(int argc, char *argv[]); + virtual bool Jump(int argc, char *argv[]) {return false;} + virtual bool Next(); + virtual bool Previous(); + + LSQueueNode *pNode; +}; + +class LSQueue : public LSContainer +{ +public: + LSQueue(LSTypeDefinition *p_pType, const char *p_SubType) : LSContainer("queue") + { + Count=0; + pHead=0; + pTail=0; + pType=p_pType; + SubType=strdup(p_SubType); + + } + virtual ~LSQueue() + { + Clear(); + free((void*)SubType); + } + + virtual bool Clear() + { + CLock L(&S,1); + Count=0; + + for (set::iterator i = Iterators.begin() ; i!=Iterators.end() ; i++) + { + LSQueueIterator *pIterator=(LSQueueIterator *)(*i); + pIterator->pNode=0; + } + + while(pHead) + { + LSQueueNode *pNext=pHead->pNext; + pType->FreeVariable(pHead->Object.GetObjectData()); + delete pHead; + pHead=pNext; + } + pTail=0; + return true; + } + + virtual bool Queue(int argc, char *argv[]) + { + CLock L(&S,1); + LSOBJECTDATA Val; + if (!pType->InitVariable(Val,SubType)) + return false; + if (!pType->FromText(Val,argc,argv)) + { + pType->FreeVariable(Val); + return false; + } + LSQueueNode *pNode=new LSQueueNode; + pNode->pNext=0; + pNode->Object.SetObjectData(Val); + pNode->Object.Type=pType; + if (pTail) + { + pTail->pNext=pNode; + pTail=pNode; + } + else + { + pHead=pTail=pNode; + } + Count++; + return true; + } + + virtual bool Dequeue() + { + CLock L(&S,1); + if (!pHead) + return false; + + for (set::iterator i = Iterators.begin() ; i!=Iterators.end() ; i++) + { + LSQueueIterator *pIterator=(LSQueueIterator *)(*i); + if (pIterator->pNode==pHead) + pIterator->pNode=0; + } + + LSQueueNode *pNext=pHead->pNext; + pType->FreeVariable(pHead->Object.GetObjectData()); + delete pHead; + pHead=pNext; + if (!pHead) + pTail=0; + Count--; + return true; + } + + virtual bool Peek(LSOBJECT &Object) + { + CLock L(&S,1); + if (!pHead) + return 0; + Object.Ptr=&pHead->Object; + Object.Type=GetLSVariableType(); + return true; + } + LSTypeDefinition *GetLSVariableType(); + + inline size_t GetCount() { return Count; } + + virtual LSIterator *NewIterator(void *PassAlong); + + inline LSQueueNode *GetHead() { return pHead; } + inline LSQueueNode *GetTail() {return pTail; } + inline LSType *GetType() {return pType; } + inline const char *GetSubType() {return SubType; } + + virtual size_t GetContainerSize() { return Count; } + virtual size_t GetContainerUsed() { return Count; } + virtual void OnRemoveType(class LSTypeDefinition *pType); + +protected: + LSType *pType; + const char *SubType; + + LSQueueNode *pHead; + LSQueueNode *pTail; + + size_t Count; + CSemaphore S; +}; + +/* STACK */ +struct LSStackNode +{ + LSOBJECT Object; + LSStackNode *pNext; +}; + +class LSStackIterator : public LSIterator +{ +public: + LSStackIterator(class LSStack *p_pStack); + + virtual bool First(); + virtual bool Last(); + virtual bool IsValid(); + virtual bool GetKey(LSOBJECT &Object); + virtual bool GetValue(LSOBJECT &Object); + virtual bool SetValue(int argc, char *argv[]); + virtual bool Jump(int argc, char *argv[]) {return false;} + virtual bool Next(); + virtual bool Previous(); + + LSStackNode *pNode; +}; + +class LSStack : public LSContainer +{ +public: + LSStack(LSTypeDefinition *p_pType, const char *p_SubType) : LSContainer("stack") + { + Count=0; + pTop=0; + pType=p_pType; + SubType=strdup(p_SubType); + + } + virtual ~LSStack() + { + Clear(); + free((void*)SubType); + } + + virtual bool Clear() + { + CLock L(&S,1); + Count=0; + for (set::iterator i = Iterators.begin() ; i!=Iterators.end() ; i++) + { + LSStackIterator *pIterator=(LSStackIterator *)(*i); + pIterator->pNode=0; + } + + + while(pTop) + { + LSStackNode *pNext=pTop->pNext; + pType->FreeVariable(pTop->Object.GetObjectData()); + delete pTop; + pTop=pNext; + } + return true; + } + + virtual bool Push(int argc, char *argv[]) + { + CLock L(&S,1); + LSOBJECTDATA Val; + if (!pType->InitVariable(Val,SubType)) + return false; + if (!pType->FromText(Val,argc,argv)) + { + pType->FreeVariable(Val); + return false; + } + LSStackNode *pNode=new LSStackNode; + pNode->pNext=pTop; + pNode->Object.SetObjectData(Val); + pNode->Object.Type=pType; + pTop=pNode; + Count++; + return true; + } + + virtual bool Pop() + { + CLock L(&S,1); + if (!pTop) + return false; + + for (set::iterator i = Iterators.begin() ; i!=Iterators.end() ; i++) + { + LSStackIterator *pIterator=(LSStackIterator *)(*i); + if (pIterator->pNode==pTop) + pIterator->pNode=0; + } + + LSStackNode *pNext=pTop->pNext; + pType->FreeVariable(pTop->Object.GetObjectData()); + delete pTop; + pTop=pNext; + Count--; + return true; + } + + virtual bool Top(LSOBJECT &Object) + { + CLock L(&S,1); + if (!pTop) + return 0; + Object.Ptr=&pTop->Object; + Object.Type=GetLSVariableType(); + return true; + } + + LSTypeDefinition *GetLSVariableType(); + + + inline size_t GetCount() { return Count; } + + virtual LSIterator *NewIterator(void *PassAlong); + + inline LSStackNode *GetTop() { return pTop; } + inline LSType *GetType() {return pType; } + inline const char *GetSubType() {return SubType; } + + virtual size_t GetContainerSize() { return Count; } + virtual size_t GetContainerUsed() { return Count; } + virtual void OnRemoveType(class LSTypeDefinition *pType); + +protected: + LSType *pType; + const char *SubType; + + LSStackNode *pTop; + + size_t Count; + CSemaphore S; + + +}; + +class LSObjectCollectionIterator; + +/* COLLECTION (map) */ +class LSObjectCollection : public LSContainer +{ +public: + LSObjectCollection(LSTypeDefinition *p_pType, const char *p_SubType): LSContainer("collection") + { + pType=p_pType; + SubType=strdup(p_SubType); + } + virtual ~LSObjectCollection() + { + CLock L(&S,1); + free((void*)SubType); + map::iterator i; + for (i = Map.begin() ; i!=Map.end() ; i++) + { + pType->FreeVariable(i->second->GetObjectData()); + delete i->second; + } + } + + virtual bool Clear() + { + CLock L(&S,1); + map::iterator i; + for (i = Map.begin() ; i!=Map.end() ; i++) + { + pType->FreeVariable(i->second->GetObjectData()); + delete i->second; + } + Map.clear(); + Iterator=Map.end(); + return true; + } + + virtual bool GetFirstItem(LSOBJECT &Dest) + { + CLock L(&S,1); + Iterator=Map.begin(); + if (Iterator!=Map.end()) + { + Dest.Type=GetLSVariableType(); + Dest.Ptr=Iterator->second; + return true; + } + return false; + } + + virtual bool GetCurrentItem(LSOBJECT &Dest) + { + CLock L(&S,1); + if (Iterator!=Map.end()) + { + Dest.Type=GetLSVariableType(); + Dest.Ptr=Iterator->second; + return true; + } + return false; + } + + virtual bool GetNextItem(LSOBJECT &Dest) + { + CLock L(&S,1); + Iterator++; + if (Iterator!=Map.end()) + { + Dest.Type=GetLSVariableType(); + Dest.Ptr=Iterator->second; + return true; + } + return false; + } + + virtual const char *GetFirstKey() + { + CLock L(&S,1); + Iterator=Map.begin(); + if (Iterator!=Map.end()) + { + return Iterator->first.c_str(); + } + return false; + } + + virtual const char * GetCurrentKey() + { + CLock L(&S,1); + if (Iterator!=Map.end()) + { + return Iterator->first.c_str(); + } + return false; + } + + virtual const char *GetNextKey() + { + CLock L(&S,1); + Iterator++; + if (Iterator!=Map.end()) + { + return Iterator->first.c_str(); + } + return false; + } + + virtual bool GetItem(const char *Key, LSOBJECT &Dest) + { + CLock L(&S,1); + map::iterator i=Map.find(Key); + if (i==Map.end()) + return false; + Dest.Type=GetLSVariableType(); + Dest.Ptr=i->second; + return true; + } + +/* + bool CreateItem(const char *Key) + { + CLock L(&S,1); + map::iterator i=Map.find(Key); + if (i==Map.end()) + { + LSOBJECTDATA Val; + if (pType->InitVariable(Val,SubType)) + { + PLSOBJECT pObject=new LSOBJECT; + pObject->VarPtr=Val; + pObject->Type=pType; + Map[Key]=pObject; + return true; + } + } + return false; + } +/**/ + + virtual void SetItem(const char *Key, LSOBJECTDATA &ObjectData) + { + CLock L(&S,1); + map::iterator i=Map.find(Key); + if (i!=Map.end()) + { + // existing + PLSOBJECTDATA pVal = &i->second->GetObjectData(); + pType->FreeVariable(*pVal); + + i->second->SetObjectData(ObjectData); + } + else + { + PLSOBJECT pObject=new LSOBJECT; + pObject->SetObjectData(ObjectData); + pObject->Type=pType; + Map[Key]=pObject; + } + } + + virtual void SetItem(const char *Key, int argc, char *argv[]) + { + CLock L(&S,1); + map::iterator i=Map.find(Key); + if (i!=Map.end()) + { + // existing + PLSOBJECTDATA pVal = &i->second->GetObjectData(); + pType->FreeVariable(*pVal); + if (!pType->InitVariable(*pVal,SubType)) + { + delete i->second; + Map.erase(Key); + return; + } + if (!pType->FromText(*pVal,argc,argv)) + { + pType->FreeVariable(*pVal); + delete i->second; + Map.erase(Key); + return; + } + } + else + { + LSOBJECTDATA Val; + if (!pType->InitVariable(Val,SubType)) + return; + if (!pType->FromText(Val,argc,argv)) + { + pType->FreeVariable(Val); + return; + } + PLSOBJECT pObject=new LSOBJECT; + pObject->SetObjectData(Val); + pObject->Type=pType; + Map[Key]=pObject; + } + } + + virtual void RemoveItem(const char *Key) + { + CLock L(&S,1); + + map::iterator i=Map.find(Key); + if (i!=Map.end()) + { + InvalidateIterators(i); + + // delete existing + pType->FreeVariable(i->second->GetObjectData()); + delete i->second; + Map.erase(Key); + Iterator=Map.end(); + } + } + + LSTypeDefinition *GetLSVariableType(); + inline size_t GetCount() {return Map.size();} + inline LSType *GetType() {return pType;} + inline const char *GetSubType() {return SubType;} + virtual LSIterator *NewIterator(void *PassAlong); + void InvalidateIterators(map::iterator &erasing); + + inline map *GetMap() {return ⤅} + + virtual size_t GetContainerSize() {return GetCount();} + virtual size_t GetContainerUsed() { return GetCount(); } + virtual void OnRemoveType(class LSTypeDefinition *pType); + + unsigned int RemoveItemsByQuery(unsigned int ID, bool remove_MATCHES);// false removes NON-MATCHES + +protected: + LSType *pType; + const char *SubType; + map Map; + map::iterator Iterator; + CSemaphore S; +}; + +class LSObjectCollectionIterator : public LSIterator +{ +public: + LSObjectCollectionIterator(class LSObjectCollection *p_pCollection); + + virtual bool First(); + virtual bool Last(); + virtual bool IsValid(); + virtual bool GetKey(LSOBJECT &Object); + virtual bool GetValue(LSOBJECT &Object); + virtual bool SetValue(int argc, char *argv[]); + virtual bool Jump(int argc, char *argv[]); + virtual bool Next(); + virtual bool Previous(); + + map::iterator Iterator; +}; + + +class LSSetIterator : public LSIterator +{ +public: + LSSetIterator(class LSSet *p_pCollection); + + virtual bool First(); + virtual bool Last(); + virtual bool IsValid(); + virtual bool GetKey(LSOBJECT &Object); + virtual bool GetValue(LSOBJECT &Object); + virtual bool SetValue(int argc, char *argv[]); + virtual bool Jump(int argc, char *argv[]); + virtual bool Next(); + virtual bool Previous(); + + set::iterator Iterator; +}; + +/* SET */ +class LSSet : public LSContainer +{ +public: + LSSet(): LSContainer("set") + { + } + virtual ~LSSet() + { + CLock L(&S,1); + } + + virtual bool Clear() + { + CLock L(&S,1); + Set.clear(); + return true; + } + + virtual bool Contains(const char *Key) + { + CLock L(&S,1); + set::iterator i=Set.find(Key); + return i!=Set.end(); + } + + virtual bool GetFirstKey(utf8string &Dest) + { + CLock L(&S,1); + Iterator=Set.begin(); + if (Iterator!=Set.end()) + { + Dest=*Iterator; + return true; + } + return false; + } + + virtual bool GetCurrentKey(utf8string &Dest) + { + CLock L(&S,1); + if (Iterator!=Set.end()) + { + Dest=*Iterator; + return true; + } + return false; + } + + virtual bool GetNextKey(utf8string &Dest) + { + CLock L(&S,1); + Iterator++; + if (Iterator!=Set.end()) + { + Dest=*Iterator; + return true; + } + return false; + } + + virtual void AddItem(const char *Key) + { + CLock L(&S,1); + Set.insert(Key); + } + + virtual void RemoveItem(const char *Key) + { + CLock L(&S,1); + Set.erase(Key); + } + + inline size_t GetCount() {return Set.size();} + virtual LSIterator *NewIterator(void *PassAlong); + + virtual size_t GetContainerSize() { return GetCount(); } + virtual size_t GetContainerUsed() { return GetCount(); } + virtual void OnRemoveType(class LSTypeDefinition *pType); + + inline set *GetSet() {return &Set;} + +protected: + set Set; + set::iterator Iterator; + CSemaphore S; +}; + +class LSIndexIterator : public LSIterator +{ +public: + LSIndexIterator(class LSIndex *p_pIndex); + + bool AdvanceToValid(); + bool ReverseToValid(); + + virtual bool First(); + virtual bool Last(); + virtual bool IsValid(); + virtual bool GetKey(LSOBJECT &Object); + virtual bool GetValue(LSOBJECT &Object); + virtual bool SetValue(int argc, char *argv[]); + virtual bool Jump(int argc, char *argv[]); + virtual bool Next(); + virtual bool Previous(); + + size_t N; +}; + +class LSIndex : public LSContainer +{ +public: + LSIndex(class LSTypeDefinition *p_pType, const char *p_SubType); + virtual ~LSIndex(); + + virtual unsigned int AddItem(int argc, char *argv[]); + virtual bool SetItem(size_t N, int argc, char *argv[]); + virtual bool DeleteItem(size_t N); + virtual unsigned int GetNextItem(size_t N); + + virtual bool Resize(size_t NewSize); + virtual bool Swap(size_t A, size_t B); + virtual bool Move(size_t From, size_t To); + + virtual bool Clear(); + virtual void Collapse(); + bool ShiftUp(size_t From, size_t count); + + virtual PLSOBJECT GetItem(size_t N); + + inline class LSTypeDefinition *GetType() + { + return pType; + } + inline const char *GetSubType() + { + return SubType; + } + + inline unsigned int AddItem(const char *value) + { + char *argv[]={(char*)value}; + return AddItem(1,argv); + } + unsigned int AddItem(LSOBJECTDATA &value);// to be used only for types that do not require allocation of memory (e.g. int) + inline size_t GetUsed() + { + return Count; + } + inline size_t GetAllocated() + { + return Index.Size; + } + inline bool IsConstant() + { + return bConstant; + } + inline void SetConstant(bool p_bConstant) {bConstant=p_bConstant;} + + virtual size_t GetContainerSize() { return GetAllocated(); } + virtual size_t GetContainerUsed() { return GetUsed(); } + virtual LSIterator *NewIterator(void *PassAlong); + virtual void OnRemoveType(class LSTypeDefinition *pType); + + unsigned int DeleteItemsByQuery(unsigned int ID, bool remove_MATCHES);// false removes NON-MATCHES + CIndex *GetIndex() {return &Index;} + +protected: + CIndex Index; + class LSTypeDefinition *pType; + const char *SubType; + size_t Count; + bool bConstant; +}; + +extern bool InitializeIterator(LSIteratable *pIteratable,void *PassAlong,LSOBJECT &Object); \ No newline at end of file diff --git a/libs/isxdk/include/LavishScript/LSType.h b/libs/isxdk/include/LavishScript/LSType.h new file mode 100644 index 0000000..3e94d1b --- /dev/null +++ b/libs/isxdk/include/LavishScript/LSType.h @@ -0,0 +1,560 @@ +#pragma once +#pragma warning( push ) +#pragma warning( disable : 4505 ) +#ifndef __LSTYPE_H__ +#define __LSTYPE_H__ +#define TypeMember(name) AddMember((DWORD)name,""#name) +#define TypeMethod(name) AddMethod((DWORD)name,""#name) +#include +#include +#include +using namespace std; + +typedef struct _RGBColor +{ + union { + unsigned int ulColor; + struct { + unsigned char Red; + unsigned char Green; + unsigned char Blue; + unsigned char Reserved; + }; + struct { + BYTE B; + BYTE G; + BYTE R; + BYTE A; + }; + DWORD ARGB; + }; +} RGBCOLOR, *PRGBCOLOR; + +typedef struct _LSVarPtr +{ + _LSVarPtr() + { + Int64 = 0; + } + + union + { + __int64 Int64; + double Float64; + unsigned char Array64[8]; + struct + { + union + { + void *Ptr; + float Float; + unsigned int DWord; + unsigned int *DWordPtr; + int Int; + unsigned char Array[4]; + char *CharPtr; + wchar_t *WCharPtr; + __int64 *Int64Ptr; + double *Float64Ptr; + const void *ConstPtr; + const char *ConstCharPtr; + const wchar_t *ConstWCharPtr; + RGBCOLOR RGB; + }; + unsigned int HighDWord; + }; + }; +} LSOBJECTDATA, *PLSOBJECTDATA, LSVARPTR, *PLSVARPTR; + +typedef struct _LSTypeVar +{ + _LSTypeVar() + { + Type = 0; + Int64 = 0; + } + + __inline LSOBJECTDATA &GetObjectData() + { + return *(LSOBJECTDATA*)&Int64; + } + + __inline void SetObjectData(const LSOBJECTDATA &new_data) + { + Int64 = new_data.Int64; + } + + union { + class LSTypeDefinition *Type; + class LSTypeDefinition *ObjectType; + }; + union { +// LSOBJECTDATA VarPtr; +// LSOBJECTDATA ObjectData; + __int64 Int64; + double Float64; + unsigned char Array64[8]; + struct + { + union + { + void *Ptr; + float Float; + unsigned int DWord; + unsigned int *DWordPtr; + int Int; + unsigned char Array[4]; + char *CharPtr; + wchar_t *WCharPtr; + __int64 *Int64Ptr; + double *Float64Ptr; + const void *ConstPtr; + const char *ConstCharPtr; + const wchar_t *ConstWCharPtr; + RGBCOLOR RGB; + }; + unsigned int HighDWord; + }; + }; +} LSOBJECT, *PLSOBJECT, LSTYPEVAR, *PLSTYPEVAR; + +typedef bool(__cdecl *fLSTypeMember)(LSTypeDefinition *pType, LSOBJECTDATA, int argc, char *argv[], LSOBJECT &); +typedef bool(__cdecl *fLSTypeMethod)(LSTypeDefinition *pType, LSOBJECTDATA &, int argc, char *argv[]); +typedef void (__cdecl *fLSGenericEnumCallback)(const char *Name, void *pData); + +typedef struct _LSTypeMember +{ + unsigned int ID; + char *Name; + union { + fLSTypeMember MemberCallback; + fLSTypeMethod MethodCallback; + }; + _LSTypeMember *pPrev; + _LSTypeMember *pNext; +} LSTYPEMEMBER, *PLSTYPEMEMBER, LSTYPEMETHOD, *PLSTYPEMETHOD; + +typedef struct _Point1f +{ + float X; +} POINT1F, *PPOINT1F; + +typedef struct _Point2f : public _Point1f +{ + float Y; +} POINT2F, *PPOINT2F; + +typedef struct _Point3f : public _Point2f +{ + float Z; +} POINT3F, *PPOINT3F; + +typedef struct _Point1i +{ + int X; +} POINT1I, *PPOINT1I; + +typedef struct _Point2i : public _Point1i +{ + int Y; +} POINT2I, *PPOINT2I; + +typedef struct _Point3i : public _Point2i +{ + int Z; +} POINT3I, *PPOINT3I; + +static inline FLOAT GetDistance3D(_Point3f &P1,_Point3f &P2) +{ + FLOAT dX = P1.X - P2.X; + FLOAT dY = P1.Y - P2.Y; + FLOAT dZ = P1.Z - P2.Z; + return sqrtf(dX*dX + dY*dY + dZ*dZ); +} + +static inline FLOAT GetDistance3DNoSqrt(_Point3f &P1,_Point3f &P2) +{ + FLOAT dX = P1.X - P2.X; + FLOAT dY = P1.Y - P2.Y; + FLOAT dZ = P1.Z - P2.Z; + return (dX*dX + dY*dY + dZ*dZ); +} + +static inline FLOAT GetDistance2D(_Point2f &P1,_Point2f &P2) +{ + FLOAT dX = P1.X - P2.X; + FLOAT dY = P1.Y - P2.Y; + return sqrtf(dX*dX + dY*dY); +} + +static inline FLOAT GetDistance2DNoSqrt(_Point2f &P1,_Point2f &P2) +{ + FLOAT dX = P1.X - P2.X; + FLOAT dY = P1.Y - P2.Y; + return (dX*dX + dY*dY); +} + +static inline FLOAT GetDistance2D(_Point2i &P1,_Point2i &P2) +{ + FLOAT dX = (FLOAT)(P1.X - P2.X); + FLOAT dY = (FLOAT)(P1.Y - P2.Y); + return sqrtf(dX*dX + dY*dY); +} + +static inline FLOAT GetDistance2DNoSqrt(_Point2i &P1,_Point2i &P2) +{ + FLOAT dX = (FLOAT)(P1.X - P2.X); + FLOAT dY = (FLOAT)(P1.Y - P2.Y); + return (dX*dX + dY*dY); +} + +static bool DistancePointLine(POINT2F &Point,POINT2F &SegmentStart,POINT2F &SegmentEnd,float &Result) +{ + float SegmentLength= GetDistance2D(SegmentStart,SegmentEnd); + float U= (((Point.X-SegmentStart.X) * (SegmentEnd.X-SegmentStart.X))+ + ((Point.Y-SegmentStart.Y) * (SegmentEnd.Y-SegmentStart.Y)))/ + (SegmentLength*SegmentLength); + if (U<0.0f || U>1.0f) + { + // no intersection + return false; + } + // calculate intersection point + POINT2F Intersection; + Intersection.X = SegmentStart.X + U * ( SegmentEnd.X - SegmentStart.X ); + Intersection.Y = SegmentStart.Y + U * ( SegmentEnd.Y - SegmentStart.Y ); + // and now the distance from the point to the start of the segment + Result = GetDistance2D( Point, Intersection ); + return true; +} + +extern void RegisterTemporaryObject(class CTempObject *); + +class CTempObject +{ +public: + CTempObject() + { + RegisterTemporaryObject(this); + } + virtual ~CTempObject() + { + } + virtual void Delete() + { + delete this; + } +}; + +template +class CTemporaryObject : public CTempObject +{ +public: + T Object; +}; + +class LSBinary +{ +public: + LSBinary(size_t InitialSize = 64); + LSBinary(void *buf, size_t buflen); + ~LSBinary(); + + bool Copy(void *buf, size_t buflen); + size_t Resize(size_t NewSize); + bool Reset(unsigned char Value); + bool Reset(unsigned int Begin, size_t Length, unsigned char Value); + bool Copy(unsigned int Begin, void *buf, size_t buflen); + + inline void *GetBuffer() + { + return pBuffer; + } + inline size_t GetSize() { return Size; } + inline size_t GetUsed() { return Used; } + + inline void SetUsed(size_t NewUsed) { Used = NewUsed; } + +protected: + void *pBuffer; + size_t Size; + size_t Used; +}; + +#define INHERITDIRECT(_inherit_) \ + virtual int GetInheritedMember(LSOBJECTDATA ObjectData, char *Member, int argc, char *argv[], LSOBJECT &Dest)\ + {\ + return _inherit_->GetMemberEx(ObjectData,Member,argc,argv,Dest);\ + }\ + virtual int GetInheritedMethod(LSOBJECTDATA &ObjectData, char *Method, int argc, char *argv[])\ + {\ + return _inherit_->GetMethodEx(ObjectData,Method,argc,argv);\ + }\ + virtual int GetInheritedIndex(LSOBJECTDATA &ObjectData, int argc, char *argv[], LSOBJECT &Dest)\ + {\ + return _inherit_->GetIndex(ObjectData,argc,argv,Dest);\ + } + +#define INHERITINDIRECT(_inherit_,_convertto_,_convertfrom_) \ + virtual int GetInheritedMember(LSOBJECTDATA ObjectData, char *Member, int argc, char *argv[], LSOBJECT &Dest)\ + {\ + LSOBJECTDATA Temp;\ + _convertto_;\ + return _inherit_->GetMemberEx(Temp,Member,argc,argv,Dest);\ + }\ + virtual int GetInheritedIndex(LSOBJECTDATA ObjectData, int argc, char *argv[], LSOBJECT &Dest)\ + {\ + LSOBJECTDATA Temp;\ + _convertto_;\ + return _inherit_->GetIndex(Temp,argc,argv,Dest);\ + }\ + virtual int GetInheritedMethod(LSOBJECTDATA &ObjectData, char *Method, int argc, char *argv[])\ + {\ + LSOBJECTDATA Temp;\ + _convertto_;\ + int Ret=_inherit_->GetMethodEx(Temp,Method,argc,argv);\ + if (Ret>0)\ + {\ + _convertfrom_;\ + }\ + return Ret;\ + } + +class LSTypeDefinition +{ +public: + LSTypeDefinition(char *NewName); + + inline void InitializeMembers(PLSTYPEMEMBER MemberArray) + { + for (unsigned int i = 0 ; MemberArray[i].ID ; i++) + { + AddMember(MemberArray[i].ID,MemberArray[i].Name); + } + } + + virtual ~LSTypeDefinition(); + + virtual bool __declspec(deprecated) FromString(LSOBJECTDATA &ObjectData, char *Source) {return false;} + + virtual bool FromText(LSOBJECTDATA &ObjectData, int argc, char *argv[]);// calls the other FromText by default. + + virtual bool FromText(LSOBJECTDATA &ObjectData, char *Source) + { +#pragma warning( push ) +#pragma warning( disable : 4996 ) + return FromString(ObjectData,Source); +#pragma warning( pop ) + } + + virtual void InitVariable(LSOBJECTDATA &ObjectData) {ObjectData.Int64=0;} + virtual bool InitVariable(LSOBJECTDATA &ObjectData, const char *SubType) {if (SubType && SubType[0]) return false; InitVariable(ObjectData); return true;} + + virtual void FreeVariable(LSOBJECTDATA &ObjectData) {} + + virtual bool __declspec(deprecated) GetMember(LSOBJECTDATA ObjectData, char *Member, int argc, char *argv[], LSOBJECT &Dest) + { + return false; + } + virtual bool __declspec(deprecated) GetMethod(LSOBJECTDATA &ObjectData, char *Method, int argc, char *argv[]) + { + return false; + } + + virtual bool GetMember(LSOBJECTDATA ObjectData, PLSTYPEMEMBER pMember, int argc, char *argv[], LSOBJECT &Dest) + { +#pragma warning( push ) +#pragma warning( disable : 4996 ) + return GetMember(ObjectData,pMember->Name,argc,argv,Dest); +#pragma warning( pop ) + } + virtual bool GetMethod(LSOBJECTDATA &ObjectData, PLSTYPEMETHOD pMethod, int argc, char *argv[]) + { +#pragma warning( push ) +#pragma warning( disable : 4996 ) + return GetMethod(ObjectData,pMethod->Name,argc,argv); +#pragma warning( pop ) + } + + virtual int GetIndex(LSOBJECTDATA ObjectData, int argc, char *argv[], LSOBJECT &Dest) + { + return GetInheritedIndex(ObjectData,argc,argv,Dest); +/* // SAMPLE + // This will let the index automatically access a member called GetIndex + return GetMemberEx(ObjectData,"GetIndex",argc,argv,Dest); +/**/ + + } + + virtual int GetMemberEx(LSOBJECTDATA ObjectData, char *Member, int argc, char *argv[], LSOBJECT &Dest); + virtual int GetMethodEx(LSOBJECTDATA &ObjectData, char *Method, int argc, char *argv[]); + + virtual int GetInheritedIndex(LSOBJECTDATA ObjectData, int argc, char *argv[], LSOBJECT &Dest) + { + return -1; +/* // SAMPLE + // convert ObjectData to inherited type + ObjectData.Ptr=((string*)ObjectData.Ptr)->c_str(); + // try inherited type + return pStringType->GetIndex(ObjectData,argc,argv,Dest); +/**/ + } + + + virtual int GetInheritedMember(LSOBJECTDATA ObjectData, char *Member, int argc, char *argv[], LSOBJECT &Dest) + { + return -1; +/* // SAMPLE + // convert ObjectData to inherited type + ObjectData.Ptr=((string*)ObjectData.Ptr)->c_str(); + // try inherited type + return pStringType->GetMemberEx(ObjectData,Member,argc,argv,Dest); +/**/ + } + virtual int GetInheritedMethod(LSOBJECTDATA &ObjectData, char *Method, int argc, char *argv[]) + { + return -1; +/* + // SAMPLE: Direct conversion + return pStringType->GetMethodEx(ObjectData,argc,argv); + + // SAMPLE: Special conversion required + // make temporary ObjectData for inherited type + LSOBJECTDATA Temp; + Temp.Ptr=((string*)ObjectData.Ptr)->c_str(); + // try inherited type + int Ret=pStringType->GetMethodEx(Temp,Method,argc,argv); + if (Ret>0) + { + // string changed, replace old string + ((string*)ObjectData.Ptr)->assign(Temp.CharPtr); + } + return Ret; +/**/ + } + + + virtual bool ToText(LSOBJECTDATA ObjectData, char *buf, unsigned int buflen) + { +#pragma warning( push ) +#pragma warning( disable : 4996 ) + return ToText(ObjectData,buf); +#pragma warning( pop ) + } + + + virtual bool __declspec(deprecated) ToText(LSOBJECTDATA ObjectData, char *Destination) + { +#pragma warning( push ) +#pragma warning( disable : 4996 ) + return ToString(ObjectData,Destination); +#pragma warning( pop ) + } + + virtual bool __declspec(deprecated) ToString(LSOBJECTDATA ObjectData, char *Destination) + { + return false; + } + + inline char *GetName() {return &TypeName[0];} + inline LSTypeDefinition *GetInheritance() {return pInherits;} + + char *GetMemberName(unsigned int ID); + bool GetMemberID(char *Name, unsigned int &Result); + PLSTYPEMEMBER FindMember(char *Name); + virtual bool InheritedMember(char *Name); + + char *GetMethodName(unsigned int ID); + bool GetMethodID(char *Name, unsigned int &Result); + PLSTYPEMETHOD FindMethod(char *Name); + virtual bool InheritedMethod(char *Name); + + virtual LSTypeDefinition *GetVariableType() + { + return this; + } + + void SetInheritance(LSTypeDefinition *pNewInherit); + + unsigned int RegisterVariable(struct _LSTypeVariable *); + inline struct _LSTypeVariable *GetVariableByID(unsigned int ID) + { + map::iterator i=Variables.find(ID); + if (i!=Variables.end()) + return i->second; + return 0; + } + void UnregisterVariable(unsigned int ID); + + virtual bool AddMember(unsigned int ID, char *Name, fLSTypeMember Callback=0); + virtual bool AddMember(char *Name, fLSTypeMember Callback=0); + virtual bool RemoveMember(char *Name, fLSTypeMember Callback=0); + + virtual bool AddMethod(unsigned int ID, char *Name, fLSTypeMethod Callback=0); + virtual bool AddMethod(char *Name, fLSTypeMethod Callback=0); + virtual bool RemoveMethod(char *Name, fLSTypeMethod Callback=0); + + unsigned int EnumMembers(fLSGenericEnumCallback Callback, void *pData); + unsigned int EnumMethods(fLSGenericEnumCallback Callback, void *pData); + +protected: + char TypeName[32]; + CIndex Members; + map MemberMap; + CIndex Methods; + map MethodMap; + LSTypeDefinition *pInherits; + + unsigned int NextMethodID; + unsigned int NextMemberID; + + unsigned int NextVariableID; + map Variables; + bool bShutdown; +}; + +class CLSObject : public LSOBJECT +{ +public: + CLSObject() + { + Int64=0; + Type=0; + } + ~CLSObject() + { + Reset(); + } + inline void Reset() + { + if (Type) + { + Type->FreeVariable(GetObjectData()); + Type=0; + } + } + bool Initialize(LSTypeDefinition *pType, const char *SubType, int argc=0, char *argv[]=0) + { + if (Type) + Reset(); + if (!pType) + return false; + pType=pType->GetVariableType(); + if (!pType) + return false; + if (!pType->InitVariable(GetObjectData(), SubType)) + return false; + if (!pType->FromText(GetObjectData(), argc, argv)) + { + pType->FreeVariable(GetObjectData()); + return false; + } + Type=pType; + return true; + } +}; + + +#define LSType LSTypeDefinition +#endif +#pragma warning( pop ) diff --git a/libs/isxdk/include/LavishScript/LavishScript.h b/libs/isxdk/include/LavishScript/LavishScript.h new file mode 100644 index 0000000..1702794 --- /dev/null +++ b/libs/isxdk/include/LavishScript/LavishScript.h @@ -0,0 +1,8 @@ +#define MAX_VARSTRING 4096 +#include "LSType.h" +#include "LSSTLTypes.h" + +typedef bool (__cdecl *fLSTopLevelObject)(int argc, char *argv[], LSTYPEVAR &); +typedef int (__cdecl *fLSCommand)(int argc, char *argv[]); +typedef void (__cdecl *fLSGenericEnumCallback)(const char *Name, void *pData); + diff --git a/libs/isxdk/include/Queue.h b/libs/isxdk/include/Queue.h new file mode 100644 index 0000000..53a0650 --- /dev/null +++ b/libs/isxdk/include/Queue.h @@ -0,0 +1,221 @@ +/***************************************************************************** + EQIMBase, the Base C++ classes for handling EQIM + Copyright (C) 2003-2004 Lax + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License, version 2, + as published by the Free Software Foundation. + + This program 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 General Public License for more details. + + Usage of these EQIM clients and derivatives subject you to the rules of + the EQIM network. Access to the network is restricted to paying + subscribers of the online game EverQuest. This software and the EQIM + protocol is provided in good faith to the EverQuest community, and not + intended for malicious purposes. Usage of this software for malicious + purposes is prohibited and any distribution, usage, or mention of + malicious activity can and will be reported to the administrators of the + EQIM network. +******************************************************************************/ + +// Queue.hpp +// +////////////////////////////////////////////////////////////////////// + +#ifndef __QUEUE_HPP__ +#define __QUEUE_HPP__ + +template +class Queue +{ +public: + Queue(); + virtual ~Queue(); + + bool Empty() const; + + QT Pop(); + void Push(const QT&); + + void Remove(const QT&); + + QT& Peek(); + + void Clear(); + + + private: + struct QueueNode + { + QT data; + QueueNode* prev; + }; + + //CCriticalSection S; + CSemaphore S; + QueueNode* head; + QueueNode* tail; +}; + +template +Queue::Queue(void) +{ + head=NULL; + tail=NULL; +} + +template +Queue::~Queue(void) +{ + Clear(); +} + + +template +bool Queue::Empty(void) const +{ + if(tail) + return false; + else + return true; +} + +template +QT Queue::Pop(void) +{ + //CSingleLock L(&S); + //L.Lock(); + CLock L(&S,true); + + QT TempData; + + if(tail) + { + QueueNode* Temp; + + Temp = tail; + TempData = tail->data; + + tail = tail->prev; + if (!tail) + head=0; + delete Temp; + + } + //L.Unlock(); + return TempData; + +} + +template +void Queue::Push(const QT& iData) +{ +// CSingleLock L(&S); +// L.Lock(); + CLock L(&S,true); + + QueueNode* Temp = new QueueNode;//(iData, 0); + Temp->prev=NULL; + Temp->data=iData; + + if (head) + { + //head->Prev(Temp); + head->prev=Temp; + head=head->prev; + } + else + { + head=Temp; + tail=head; + } + //L.Unlock(); +} + +template +QT& Queue::Peek(void) +{ +// CSingleLock L(&S); +// L.Lock(); + CLock L(&S,true); + //L.Unlock(); + return tail->data; +} + +template +void Queue::Remove(const QT& iRemove) +{ +// CSingleLock L(&S); +// L.Lock(); + CLock L(&S,true); + QueueNode* iQueueNode = tail; + QueueNode* Last=0; + while (iQueueNode) + { + if (iQueueNode->data==iRemove) + { + if (head==tail) + { + head=0; + tail=0; + //L.Unlock(); + return; + } + else if (iQueueNode==tail) + { + // ack! gotta go through the whole list :( + iQueueNode=head; + while(iQueueNode) + { + Last=iQueueNode; + iQueueNode=iQueueNode->prev; + } + tail=Last; + //L.Unlock(); + return; + } + if (iQueueNode->prev) + iQueueNode->prev=iQueueNode->prev->prev; + //L.Unlock(); + return; + } + Last=iQueueNode; + iQueueNode=iQueueNode->prev; + } + //L.Unlock(); +} + +template +void Queue::Clear(void) +{ +// CSingleLock L(&S); +// L.Lock(); + CLock L(&S,true); + if(head) + { + QueueNode* Temp; + QueueNode* Index; + + Temp = tail; + Index = tail; + + do + { + Index = Temp->prev; + delete Temp; + + } while(Temp = Index); + + tail = 0; + head = 0; + + } + //L.Unlock(); +} + + + +#endif diff --git a/libs/isxdk/include/Services.h b/libs/isxdk/include/Services.h new file mode 100644 index 0000000..ed42aa3 --- /dev/null +++ b/libs/isxdk/include/Services.h @@ -0,0 +1,462 @@ +#pragma once +#pragma warning( push ) +#pragma warning( disable : 4505 ) + +#define ISXSERVICE_MSG (1000) + +// Services Messages - General (used for all services) +#define ISXSERVICE_CLIENTADDED 1 +#define ISXSERVICE_CLIENTREMOVED 2 +#define ISXSERVICE_DISCONNECTED 3 + +// Service Messages - Service-specific (will be reused for other services) +// System Service "Pulse" +#define PULSE_PULSE (ISXSERVICE_MSG+1) +#define PULSE_PREFRAME (ISXSERVICE_MSG+2) + +// System Service "Console" +#define CONSOLE_OUTPUT (ISXSERVICE_MSG+1) +#define CONSOLE_OUTPUT_WITHCODES (ISXSERVICE_MSG+2) + +// System Service "Memory" +#define MEM_DETOUR ((ISXSERVICE_MSG)+1) +#define MEM_MODIFY ((ISXSERVICE_MSG)+2) +#define MEM_RELEASEDETOUR ((ISXSERVICE_MSG)+3) +#define MEM_RELEASEMODIFY ((ISXSERVICE_MSG)+4) +#define MEM_ISDETOURED ((ISXSERVICE_MSG)+5) +#define MEM_ISMODIFIED ((ISXSERVICE_MSG)+6) +#define MEM_ENABLEPROTECTION ((ISXSERVICE_MSG)+7) +#define MEM_DISABLEPROTECTION ((ISXSERVICE_MSG)+8) +#define MEM_DETOURAPI ((ISXSERVICE_MSG)+9) +#define MEM_RELEASEAPIDETOUR ((ISXSERVICE_MSG)+10) +#define MEM_ISAPIDETOURED ((ISXSERVICE_MSG)+11) + +// Custom Service for memory protection +#define MEMPROTECT_PROTECT ((ISXSERVICE_MSG)+1) +#define MEMPROTECT_UNPROTECT ((ISXSERVICE_MSG)+2) + +// System Service "HTTP" +#define HTTPSERVICE_REQUEST ((ISXSERVICE_MSG)+1) +#define HTTPSERVICE_FAILURE ((ISXSERVICE_MSG)+2) +#define HTTPSERVICE_SUCCESS ((ISXSERVICE_MSG)+3) + +// System Service "Services" +#define SERVICES_ADDED ((ISXSERVICE_MSG)+1) +#define SERVICES_REMOVED ((ISXSERVICE_MSG)+2) + +// System Service "Extensions" +#define EXTENSIONS_ADDED ((ISXSERVICE_MSG)+1) +#define EXTENSIONS_REMOVED ((ISXSERVICE_MSG)+2) + +// System Service "Triggers" +#define TRIGGERS_ADD ((ISXSERVICE_MSG)+1) +#define TRIGGERS_REMOVE ((ISXSERVICE_MSG)+2) +#define TRIGGERS_PROCESS ((ISXSERVICE_MSG)+3) +#define TRIGGERS_GETLINE ((ISXSERVICE_MSG)+4) + +// System Service "Files" +#define FILES_OPEN ((ISXSERVICE_MSG)+1) +#define FILES_TRACKEDREAD ((ISXSERVICE_MSG)+2) +#define FILES_TRACKEDWRITE ((ISXSERVICE_MSG)+3) +#define FILES_TRACKEDCLOSE ((ISXSERVICE_MSG)+4) +#define FILES_OVERLAPPEDREAD ((ISXSERVICE_MSG)+5) +#define FILES_OVERLAPPEDWRITE ((ISXSERVICE_MSG)+6) + + +// System Service "Scripts" +#define SCRIPTS_ADDED ((ISXSERVICE_MSG)+1) +#define SCRIPTS_REMOVED ((ISXSERVICE_MSG)+2) + +// System Service "Software Cursor" +#define SOFTWARECURSOR_ENABLE ((ISXSERVICE_MSG)+1) +#define SOFTWARECURSOR_DISABLE ((ISXSERVICE_MSG)+2) + +// System Service "Script Engines" +#define SCRIPTENGINE_ADD ((ISXSERVICE_MSG)+1) +#define SCRIPTENGINE_REMOVE ((ISXSERVICE_MSG)+2) +#define SCRIPTENGINE_ADDFILEEXT ((ISXSERVICE_MSG)+3) +#define SCRIPTENGINE_REMOVEFILEEXT ((ISXSERVICE_MSG)+4) +#define SCRIPTENGINE_SCRIPTBEGINS ((ISXSERVICE_MSG)+5) +#define SCRIPTENGINE_SCRIPTENDS ((ISXSERVICE_MSG)+6) +#define SCRIPTENGINE_ADDED ((ISXSERVICE_MSG)+7) +#define SCRIPTENGINE_REMOVED ((ISXSERVICE_MSG)+8) + +// System Service "Modules" +#define MODULESERVICE_LOADLIBRARY ((ISXSERVICE_MSG)+1) +#define MODULESERVICE_FREELIBRARY ((ISXSERVICE_MSG)+2) + +// System Service "System" +#define SYSTEMSERVICE_DIAGNOSTICS ((ISXSERVICE_MSG)+1) +#define SYSTEMSERVICE_CRASHLOG ((ISXSERVICE_MSG)+2) + +struct _SystemCrashLog +{ + _EXCEPTION_POINTERS *pExceptionInfo; + const char *Identifier; +}; + +static bool IS_SystemCrashLog(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hSystemService, _EXCEPTION_POINTERS *pExceptionInfo, const char *CrashIdentifier) +{ + _SystemCrashLog Data; + Data.pExceptionInfo=pExceptionInfo; + Data.Identifier=CrashIdentifier; + return pISInterface->ServiceRequest(pClient,hSystemService,SYSTEMSERVICE_CRASHLOG,&Data); +} + + +struct _ModuleServiceLibrary +{ + const char *Library; + HMODULE hModule; +}; + +struct _ScriptEngineScriptBegins +{ + class ISXScriptEngine *pInterface; + const char *ScriptName; +}; +struct _ScriptEngineScriptEnds +{ + class ISXScriptEngine *pInterface; + const char *ScriptName; +}; + +struct _ScriptEngineFileExt +{ + class ISXScriptEngine *pInterface; + const char *Extension; +}; + + +static bool IS_ScriptEngineAdd(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface) +{ + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_ADD,pInterface); +} +static bool IS_ScriptEngineRemove(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface) +{ + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_REMOVE,pInterface); +} +static bool IS_ScriptEngineScriptBegins(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface, const char *Name) +{ + _ScriptEngineScriptBegins Data; + Data.pInterface=pInterface; + Data.ScriptName=Name; + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_SCRIPTBEGINS,&Data); +} +static bool IS_ScriptEngineScriptEnds(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface, const char *Name) +{ + _ScriptEngineScriptBegins Data; + Data.pInterface=pInterface; + Data.ScriptName=Name; + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_SCRIPTENDS,&Data); +} +static bool IS_ScriptEngineAddFileExt(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface, const char *Ext) +{ + _ScriptEngineFileExt Data; + Data.pInterface=pInterface; + Data.Extension=Ext; + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_ADDFILEEXT,&Data); +} +static bool IS_ScriptEngineRemoveFileExt(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hScriptEngineService, class ISXScriptEngine *pInterface, const char *Ext) +{ + _ScriptEngineFileExt Data; + Data.pInterface=pInterface; + Data.Extension=Ext; + return pISInterface->ServiceRequest(pClient,hScriptEngineService,SCRIPTENGINE_REMOVEFILEEXT,&Data); +} + + + +static bool IS_SoftwareCursorEnable(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hSoftwareCursorService, class ISXSoftwareCursorInterface *pInterface) +{ + return pISInterface->ServiceRequest(pClient,hSoftwareCursorService,SOFTWARECURSOR_ENABLE,pInterface); +} + +static bool IS_SoftwareCursorDisable(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hSoftwareCursorService) +{ + return pISInterface->ServiceRequest(pClient,hSoftwareCursorService,SOFTWARECURSOR_DISABLE,0); +} + +struct _FileOpen +{ + // out + const char *FileName; + + // in + bool bTrack; +}; + +struct _FileIO +{ + // out + const char *FileName; + const void *Buffer; + unsigned int Length; + unsigned int Position; +}; + +struct _FileOverlappedIO +{ + // out + HANDLE hFile; + const void *Buffer; + DWORD nLength; + DWORD *nActualTransfer; + LPOVERLAPPED lpOverlapped; +}; + +struct _EventSet +{ + char *Name; + char *Command; // may be NULL +}; + +struct _TriggerAdd +{ + // in + const char *Text; + fBlechCallback Callback; + void *pUserData; + + // out + unsigned int ID; +}; + +struct _TriggerGetLine +{ + // out + const char *Text; +}; + +struct HttpRequest +{ + const char *URL; + void *pData; +}; + +struct HttpFile +{ + const char *URL; + char *pBuffer; + size_t Size; + void *pData; +}; + +static bool IS_HttpRequest(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hHttpService, const char *URL, void *pData) +{ + HttpRequest Temp; + Temp.URL=URL; + Temp.pData=pData; + return pISInterface->ServiceRequest(pClient,hHttpService,HTTPSERVICE_REQUEST,&Temp); +} + +struct MemIs +{ + UINT_PTR Address; + bool Is; +}; + +struct MemProtect +{// this struct is used only by memory protection extensions, and only for MEMPROTECT_PROTECT + UINT_PTR Address; // in + size_t Length; // in + bool Success; // out + const void *OriginalData; // in +}; + +struct MemDetour +{ + UINT_PTR Address; // in + void *Detour; // in + void *Trampoline; // in + bool Success; // out +}; + +struct MemDetourAPI +{ + void *Detour; // in + const char *DLLName; // in + const char *FunctionName; // in + unsigned int FunctionOrdinal; // in + bool Success; // out +}; + +struct MemModify +{ + UINT_PTR Address; // in + void *NewData; // in + size_t Length; // in + bool Reverse; // in + bool Success; // out +}; + +#define ISDetourAPI(_hMemoryService_,_Detour_,_DLLName_,_FunctionName_,_FunctionOrdinal_) IS_DetourAPI(this,pISInterface,_hMemoryService_,_Detour_,_DLLName_,_FunctionName_,_FunctionOrdinal_) +static bool IS_DetourAPI(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, ...) +{ + va_list ap; + int nArgs = 0; + int i = 0; + UINT_PTR Args[5]; + + va_start(ap, hMemoryService); + while (i != -1) + { + if (nArgs < 5) + { + Args[nArgs] = i; + nArgs++; + } + + i = va_arg(ap, int); + } + va_end(ap); + void *Detour; + char *DLLName; + char *FunctionName; + unsigned int FunctionOrdinal; + if (nArgs == 5) + { + Detour = (PBYTE)Args[1]; + DLLName = (char *)Args[2]; + FunctionName = (char *)Args[3]; + FunctionOrdinal = (unsigned int)Args[4]; + } + else + { + return false; + } + + MemDetourAPI data; + data.Detour=Detour; + data.DLLName=DLLName; + data.FunctionName=FunctionName; + data.FunctionOrdinal=FunctionOrdinal; + data.Success=false; + return pISInterface->ServiceRequest(pClient,hMemoryService,MEM_DETOURAPI,&data) && data.Success; +} + +#define ISUnDetourAPI(_hMemoryService_,Address) IS_UnDetourAPI(this,pISInterface,_hMemoryService_,(UINT_PTR)Address) +static inline void IS_UnDetourAPI(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, UINT_PTR Address) +{ + pISInterface->ServiceRequest(pClient,hMemoryService,MEM_RELEASEAPIDETOUR,(void*)Address); +} + +#define ISDetour(_hMemoryService_, Address, Detour, Trampoline) IS_Detour(this,pISInterface,_hMemoryService_,(UINT_PTR)Address,Detour,Trampoline) +static bool IS_Detour(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, UINT_PTR Address,...) +{ + va_list ap; + int nArgs = 0; + int i = 0; + UINT_PTR Args[3]; + + va_start(ap, Address); + while (i != -1) + { + if (nArgs < 3) + { + Args[nArgs] = i; + nArgs++; + } + + i = va_arg(ap, int); + } + va_end(ap); + void *Detour; + void *Trampoline; + if (nArgs == 3) + { + Detour = (PBYTE)Args[1]; + Trampoline = (PBYTE)Args[2]; + } + else + { + return false; + } + + MemDetour data; + data.Address=Address; + data.Detour=Detour; + data.Trampoline=Trampoline; + data.Success=false; + return pISInterface->ServiceRequest(pClient,hMemoryService,MEM_DETOUR,&data) && data.Success; +} +#define MemoryModify(_hMemoryService_,Address,NewData,Length,Reverse) Memory_Modify(this,pISInterface,_hMemoryService_,(UINT_PTR)Address,NewData,Length,Reverse) +static inline bool Memory_Modify(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, UINT_PTR Address, void *NewData, size_t Length, bool Reverse) +{ + MemModify data; + data.Address=Address; + data.NewData=NewData; + data.Length=Length; + data.Reverse=Reverse; + data.Success=false; + return pISInterface->ServiceRequest(pClient,hMemoryService,MEM_MODIFY,&data) && data.Success; +} +#define ISUnDetour(_hMemoryService_,Address) IS_UnDetour(this,pISInterface,_hMemoryService_,(UINT_PTR)Address) +static inline void IS_UnDetour(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, UINT_PTR Address) +{ + pISInterface->ServiceRequest(pClient,hMemoryService,MEM_RELEASEDETOUR,(void*)Address); +} +#define MemoryUnModify(_hMemoryService_,Address) Memory_UnModify(this,pISInterface,_hMemoryService_,(UINT_PTR)Address) +static inline void Memory_UnModify(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMemoryService, UINT_PTR Address) +{ + pISInterface->ServiceRequest(pClient,hMemoryService,MEM_RELEASEMODIFY,(void*)Address); +} + +#define ISAddTrigger(_hTriggerService_,Text,Callback,pUserData) IS_AddTrigger(this,pISInterface,_hTriggerService_,Text,Callback,pUserData) +static inline unsigned int IS_AddTrigger(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hTriggerService, const char *Text, fBlechCallback Callback, void *pUserData=0) +{ + _TriggerAdd data; + data.Callback=Callback; + data.ID=0; + data.pUserData=pUserData; + data.Text=Text; + pISInterface->ServiceRequest(pClient,hTriggerService,TRIGGERS_ADD,&data); + return data.ID; +} + +#define ISRemoveTrigger(_hTriggerService_,ID) IS_RemoveTrigger(this,pISInterface,_hTriggerService_,ID) +static inline void IS_RemoveTrigger(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hTriggerService, unsigned int ID) +{ + pISInterface->ServiceRequest(pClient,hTriggerService,TRIGGERS_REMOVE,(void*)(UINT_PTR)ID); +} + +#define ISCheckTriggers(_hTriggerService_,Text) IS_CheckTriggers(this,pISInterface,_hTriggerService_,Text) +static inline void IS_CheckTriggers(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hTriggerService, const char *Text) +{ + pISInterface->ServiceRequest(pClient,hTriggerService,TRIGGERS_PROCESS,(void*)Text); +} + +#define ISGetTriggerLine(_hTriggerService_) IS_GetTriggerLine(this,pISInterface,_hTriggerService_) +static inline const char *IS_GetTriggerLine(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hTriggerService) +{ + _TriggerGetLine data; + data.Text=0; + if (!pISInterface->ServiceRequest(pClient,hTriggerService,TRIGGERS_GETLINE,&data)) + return ""; + return data.Text; +} + +/* +#define ISSetEvent(_hEventService_,Name,Command) IS_SetEvent(this,pISInterface,_hEventService_,Name,Command) +static inline void IS_SetEvent(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hEventService, char *Name, char *Command) +{ + _EventSet data; + data.Command=Command; + data.Name=Name; + pISInterface->ServiceRequest(pClient,hEventService,EVENTS_SET,&data); +} + +#define ISRemoveEvent(_hEventService_,Name) IS_RemoveEvent(this,pISInterface,_hEventService_,Name) +static inline void IS_RemoveEvent(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hEventService, char *Name) +{ + pISInterface->ServiceRequest(pClient,hEventService,EVENTS_REMOVE,(void*)Name); +} + +#define ISExecuteEvent(_hEventService_,Name) IS_ExecuteEvent(this,pISInterface,_hEventService_,Name) +static inline void IS_ExecuteEvent(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hEventService, char *Name) +{ + pISInterface->ServiceRequest(pClient,hEventService,EVENTS_EXECUTE,(void*)Name); +} +/**/ + +#pragma warning( pop ) diff --git a/libs/isxdk/include/Threading.h b/libs/isxdk/include/Threading.h new file mode 100644 index 0000000..35bea9f --- /dev/null +++ b/libs/isxdk/include/Threading.h @@ -0,0 +1,49 @@ +#pragma once +#ifndef __THREADING_H__ +#define __THREADING_H__ + +//#ifdef WIN32 +#define THREAD DWORD +//typedef DWORD (*PTHREAD_START_ROUTINE)(LPVOID); +//#else +//#define THREAD void* +//typedef void* (*PTHREAD_START_ROUTINE)(void*); +//#endif + +class CPortableSemaphore +{ + //virtual void Initialize()=0; +}; + +class CPortableLock +{ +public: + virtual void SetSemaphore(CPortableSemaphore*)=0; + virtual void Lock()=0; + virtual void Unlock()=0; + virtual bool IsLocked()=0; +}; + +class CPortableThread +{ +public: + virtual bool BeginThread(LPTHREAD_START_ROUTINE function, void* pInfo, bool bWait)=0; + virtual void EndThread()=0; + virtual void AbortThread()=0; + bool bThreading; + bool CloseThread; + bool ThreadReady; + void *Info; +}; + +class CPortableSignal +{ +public: + virtual void Wait(unsigned int Timeout, CPortableLock* unlockme=0)=0; + virtual void Wait(CPortableLock* unlockme=0)=0; + virtual void Release()=0; + virtual void Signal(bool*)=0; +}; + +#endif + diff --git a/libs/isxdk/include/WinThreading.h b/libs/isxdk/include/WinThreading.h new file mode 100644 index 0000000..4922514 --- /dev/null +++ b/libs/isxdk/include/WinThreading.h @@ -0,0 +1,238 @@ +#pragma once +#ifndef __WINTHREADING_H__ +#define __WINTHREADING_H__ +#include +#include +#include "Threading.h" + + +#define CLock CWinLock +#define CSemaphore CWinSemaphore +#define CThread CWindowsThread +#define CSignal CWinSignal + +class CWinSemaphore : public CPortableSemaphore +{ +public: + CRITICAL_SECTION s; + CWinSemaphore() + { + InitializeCriticalSection(&s); + } + + ~CWinSemaphore() + { +// if (s.LockCount>=0) +// { +// DeleteCriticalSection(&s); +// } + DeleteCriticalSection(&s); + }; +}; + +class CWinLock : public CPortableLock +{ +public: + CWinLock() + { + s=NULL; + Locked=false; + }; + CWinLock(CWinSemaphore* sem,bool bLocked=true) + { + s=&sem->s; + if (bLocked && s) + { + EnterCriticalSection(s); + Locked=true; + } + else + Locked=false; + + }; + ~CWinLock() + { + Unlock(); + }; + + void Lock() + { + if (s) + { + EnterCriticalSection(s); + Locked=true; + } + }; + + void Unlock() + { + if (Locked) + { + LeaveCriticalSection(s); + Locked=false; + } + }; + bool IsLocked() + { + return Locked; + }; + void SetSemaphore(CPortableSemaphore* sem) + { + s=&((CWinSemaphore*)sem)->s; + }; +private: + CRITICAL_SECTION *s; + bool Locked; + +}; + +class CWinSignal : public CPortableSignal +{ +public: + CWinSignal(void) + { + InitializeCriticalSection(&waiting); + InitializeCriticalSection(&signaling); + } + ~CWinSignal(void) + { + DeleteCriticalSection(&waiting); + DeleteCriticalSection(&signaling); + } + + void Wait(unsigned int Timeout, CPortableLock* unlockme=NULL) + { + EnterCriticalSection(&waiting); + if (unlockme) + ((CWinLock*)unlockme)->Unlock(); + time_t start=time(0); + int scount=0; + { + while(signaling.OwningThread==0) + { + if ((unsigned int)(time(0)-start)>Timeout) + { + LeaveCriticalSection(&waiting); + return; + } + if (scount++>5) + { + scount=0; + Sleep(1); + } + } + } + } + + + void Wait(CPortableLock* unlockme=NULL) + { + EnterCriticalSection(&waiting); + if (unlockme) + ((CWinLock*)unlockme)->Unlock(); + time_t start=time(0); + int scount=0; + { + while(signaling.OwningThread==0) + { + /* + if (time(0)-start>Timeout) + { + LeaveCriticalSection(&waiting); + return; + } + */ + if (scount++>5) + { + scount=0; + Sleep(1); + } + } + } + } + + + + void Release() + { + LeaveCriticalSection(&waiting); + } + + void Signal(bool* WhileTrue=0) + { + EnterCriticalSection(&signaling); + int scount=0; + while(waiting.OwningThread==0 && (!WhileTrue || *WhileTrue)) + { + if (scount++>5) + { + scount=0; + Sleep(1); + } + } + EnterCriticalSection(&waiting); + LeaveCriticalSection(&signaling); + LeaveCriticalSection(&waiting); + } +private: + CRITICAL_SECTION waiting; + CRITICAL_SECTION signaling; + bool bWaiting; +}; + +static DWORD CWindowsThreadFunction(void *ThreadInstance); + +class CWindowsThread : public CPortableThread +{ +public: + CWinSemaphore Threading; + DWORD ThreadID; + HANDLE hThread; + CWindowsThread() + { + ThreadReady = false; + bThreading = false; + CloseThread=false; + ThreadID=0; + }; + ~CWindowsThread() + { + if (bThreading) + EndThread(); + }; + + bool BeginThread(PTHREAD_START_ROUTINE function, void* pInfo,bool bWait) + { + if (bThreading) + return true; + Info=pInfo; + ThreadReady=false; + CloseThread=false; + hThread=CreateThread(NULL,0,(PTHREAD_START_ROUTINE)function,this,0,&ThreadID); + if (hThread==0) + return false; + if (!bWait) + return true; + while(!ThreadReady) + { + Sleep(0); + } + return true; + }; + + void AbortThread() + { + TerminateThread(hThread,0); + bThreading=false; + + } + + void EndThread() + { + CloseThread=true; + CWinLock L(&Threading,true); + ThreadID=0; + }; +}; +#endif + diff --git a/libs/isxdk/include/utf8string.h b/libs/isxdk/include/utf8string.h new file mode 100644 index 0000000..462906d --- /dev/null +++ b/libs/isxdk/include/utf8string.h @@ -0,0 +1,621 @@ +////////////////////////////////////////////////////////////////////////////////////////////// +// utf8string is designed for Win32. Under POSIX, this will simply be an ascii string, but still +// otherwise work. +// +////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2005 Lavish Software, LLC +// www.lavishsoft.com +// +// LICENSE INFORMATION +// This source file may be used and distributed, commercially or non-commercially, as long as +// this original copyright and license information is left in tact in this source file. +/////////////////////////////////////////////////////////////////////////////////////////////// + +#pragma once +#ifndef __LAVISH_UTF8STRING__ +#define __LAVISH_UTF8STRING__ + +#ifdef ISXDK_VERSION +#ifndef WIN32 +#define WIN32 +#endif +#endif + +#ifdef WIN32 +//#include +//#include +#include +#else +#define strdup strdup +#define strcpy strcpy +#define strncpy strncpy +#define _vstprintf vsprintf +#define _stprintf sprintf +#define strcmp strcmp +#define stricmp strcasecmp +#define strrchr strrchr +#define strlwr strlwr +#define strchr strchr +#endif + +#ifdef __MINGW32_VERSION +#define MINGW_SUCKS +#undef strnbcnt +#define strnbcnt(x,y) _mbsnbcnt((const unsigned char *)x,y) +#undef strnccnt +#define strnccnt(x,y) _mbsnccnt((const unsigned char *)x,y) +#else +#endif + +//#define strlen(utf8) strnbcnt(utf8,0x7fffffff) +#define strbytes strlen + +#define UTF8STRING_INLINE inline +//#define UTF8STRING_INLINE + +#ifdef UTF8STRING_POLYMORPH +#define UTF8STRING_VIRTUAL virtual +#define UTF8STRING_INHERIT : public utf8stringbase +#else +#define UTF8STRING_VIRTUAL UTF8STRING_INLINE +#define UTF8STRING_INHERITBASE +#endif + +#ifdef UTF8STRING_FAST +#error Fast utf8string not yet implemented +#else + +#ifdef UTF8STRING_POLYMORPH +class utf8stringbase +{ +public: + virtual unsigned int Bytes()=0; + virtual unsigned int Characters()=0; + virtual int Compare(const char *utf8)=0; + virtual int CompareNoCase(const char *utf8)=0; + virtual const char *Copy(const char *utf8)=0; + virtual const char *GetString()=0; + + UTF8STRING_INLINE const char *c_str() + { + return GetString(); + } + + UTF8STRING_INLINE char *unsafe_str() + { + return (char*)GetString(); + } +}; +#endif + +class utf8stringcharholder UTF8STRING_INHERITBASE +{ +public: + UTF8STRING_INLINE char *GetProtectedText() const + { + return Text; + } +protected: + + char *Text; +}; + +class constutf8string UTF8STRING_INHERITBASE +{ +public: + static size_t ByteCount(const char *utf8) + { + return strlen(utf8); + } + + UTF8STRING_INLINE constutf8string(const char *utf8) + { + Initialize(utf8); + } + UTF8STRING_INLINE constutf8string(const constutf8string &utf8) + { + Initialize(utf8.GetString()); + } + /* utf8stringbase */ + UTF8STRING_VIRTUAL size_t Bytes() + { + if (!nBytes) + nBytes=strlen(Text); + return nBytes; + } + UTF8STRING_VIRTUAL size_t Characters() + { + if (!nCharacters) + nCharacters=strlen(Text); + return nCharacters; + } + UTF8STRING_VIRTUAL int Compare(const char *utf8) + { + return strcmp(Text,utf8); + } + UTF8STRING_VIRTUAL int CompareNoCase(const char *utf8) + { + return _stricmp(Text,utf8); + } + UTF8STRING_VIRTUAL const char *Copy(const char *utf8) + { + Initialize(utf8); + return utf8; + } + UTF8STRING_VIRTUAL const char *GetString() const + { + return Text; + } + + /* operators */ + constutf8string& operator=(const constutf8string& utf8) + { + Text=utf8.GetText(); + nBytes=utf8.GetBytes(); + nCharacters=utf8.GetCharacters(); + return *this; + } + constutf8string& operator=(const char* utf8) + { + Initialize(utf8); + return *this; + } + + bool operator!( ) const + { + return false; + } + + bool operator==(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())==0; + } + bool operator!=(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())!=0; + } + bool operator<(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())<0; + } + bool operator>(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())>0; + } + bool operator<=(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())<=0; + } + bool operator>=(const utf8stringcharholder& str ) const + { + return _stricmp(Text,str.GetProtectedText())>=0; + } + + bool operator==(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())==0; + } + bool operator!=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())!=0; + } + bool operator<(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())<0; + } + bool operator>(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())>0; + } + bool operator<=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())<=0; + } + bool operator>=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())>=0; + } + + + UTF8STRING_INLINE const char *c_str() const + { + return GetString(); + } + + UTF8STRING_INLINE char *unsafe_str() const + { + return (char*)GetString(); + } +protected: + UTF8STRING_INLINE void Initialize(const char *utf8) + { + Text=utf8; + nBytes=0; + nCharacters=0; + } + UTF8STRING_INLINE const char *GetText() const + { + return Text; + } + UTF8STRING_INLINE size_t GetBytes() const + { + return nBytes; + } + UTF8STRING_INLINE size_t GetCharacters() const + { + return nCharacters; + } + const char *Text; + size_t nBytes; + size_t nCharacters; +}; + +class utf8string : public utf8stringcharholder +{ +public: + virtual void *Realloc(void *Block, size_t Size) + { + return realloc(Block,Size); + } + virtual void *Malloc(size_t Size) + { + return malloc(Size); + } + virtual void Free(void *Block) + { + free(Block); + } + + static size_t ByteCount(const char *utf8) + { + return strlen(utf8); + } + + UTF8STRING_INLINE utf8string() + { + InitializeEmpty(); + } + UTF8STRING_INLINE utf8string(const char *utf8) + { + Initialize(utf8); + } + UTF8STRING_INLINE utf8string(const utf8string &utf8) + { + Initialize(utf8.GetString()); + } + + virtual ~utf8string() + { + ClearText(); + } + + /* utf8stringbase */ + UTF8STRING_VIRTUAL size_t Bytes() const + { + return nBytes; + } + UTF8STRING_VIRTUAL size_t Characters() const + { + return nCharacters; + } + UTF8STRING_VIRTUAL int Compare(const char *utf8) + { + return strcmp(Text,utf8); + } + UTF8STRING_VIRTUAL int CompareNoCase(const char *utf8) + { + return _stricmp(Text,utf8); + } + UTF8STRING_VIRTUAL const char *Copy(const char *utf8) + { + ClearText(); + Initialize(utf8); + return Text; + } + UTF8STRING_VIRTUAL const char *GetString() const + { + return Text; + } + + /* operators */ + utf8string& operator=(const utf8string& utf8) + { + Set(utf8); + return *this; + } + utf8string& operator=(const char* utf8) + { + Set(utf8); + return *this; + } + + utf8string& operator+=(const char *utf8) + { + Append(utf8); + return *this; + } + + UTF8STRING_INLINE void Set(const utf8string& utf8) + { + size_t NewSize=utf8.nBytes+1; + if (nAllocated(const utf8string& str ) const + { + return strcmp(Text,str.GetString())>0; + } + bool operator<=(const utf8string& str ) const + { + return strcmp(Text,str.GetString())<=0; + } + bool operator>=(const utf8string& str ) const + { + return strcmp(Text,str.GetString())>=0; + } + + bool operator==(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())==0; + } + bool operator!=(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())!=0; + } + bool operator<(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())<0; + } + bool operator>(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())>0; + } + bool operator<=(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())<=0; + } + bool operator>=(const constutf8string& str ) const + { + return strcmp(Text,str.GetString())>=0; + } + UTF8STRING_INLINE const char *c_str() const + { + return GetString(); + } + + UTF8STRING_INLINE char *unsafe_str() const + { + return (char*)GetString(); + } +protected: + UTF8STRING_INLINE void ClearText() + { + Free(Text); + } + UTF8STRING_INLINE void Clear() + { + ClearText(); + nAllocated=0; + nBytes=0; + nCharacters=0; + } + UTF8STRING_INLINE void InitializeEmpty() + { + Text=(char*)Malloc(10); + *(unsigned int*)Text=0; +// Text[0]=0; +// Text[1]=0; + nAllocated=10; + nBytes=0; + nCharacters=0; + } + + UTF8STRING_INLINE void Initialize(const char *utf8) + { + if (!utf8) + utf8=""; + nCharacters=strlen(utf8); + nBytes=nCharacters; + //nBytes=strlen(utf8); + nAllocated=nBytes+1; + Text=(char*)Malloc(nAllocated); + memcpy(Text,utf8,nAllocated); + } + + UTF8STRING_INLINE void Resize(size_t newsize) + { + if (newsize>nAllocated) + { + Text=(char*)Realloc(Text,newsize); + nAllocated=newsize; + } + } + + UTF8STRING_INLINE const char *GetText() const + { + return Text; + } + UTF8STRING_INLINE size_t GetAllocated() const + { + return nAllocated; + } + UTF8STRING_INLINE size_t GetBytes() const + { + return nBytes; + } + UTF8STRING_INLINE size_t GetCharacters() const + { + return nCharacters; + } + + + size_t nAllocated; + size_t nBytes; + size_t nCharacters; +}; + +class utf8stringnocase : public utf8string +{ +public: + UTF8STRING_INLINE utf8stringnocase():utf8string() + { + } + UTF8STRING_INLINE utf8stringnocase(const char *utf8):utf8string(utf8) + { + } + UTF8STRING_INLINE utf8stringnocase(const utf8stringnocase &utf8):utf8string(utf8.GetString()) + { + } + + bool operator!( ) const + { + return false; + } + + bool operator==(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())==0; + } + bool operator!=(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())!=0; + } + bool operator<(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())<0; + } + bool operator>(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())>0; + } + bool operator<=(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())<=0; + } + bool operator>=(const utf8string& str ) const + { + return _stricmp(Text,str.GetString())>=0; + } + + bool operator==(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())==0; + } + bool operator!=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())!=0; + } + bool operator<(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())<0; + } + bool operator>(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())>0; + } + bool operator<=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())<=0; + } + bool operator>=(const constutf8string& str ) const + { + return _stricmp(Text,str.GetString())>=0; + } +/* + UTF8STRING_INLINE const char *c_str() const + { + return GetString(); + } + + UTF8STRING_INLINE char *unsafe_str() const + { + return (char*)GetString(); + } + /**/ +}; + + +#endif + +#endif /* __LAVISH_UTF8STRING__ */ diff --git a/libs/isxdk/lib64/vs14/ISUI.lib b/libs/isxdk/lib64/vs14/ISUI.lib new file mode 100644 index 0000000000000000000000000000000000000000..f3fd2569a3b52441b3e5a5c4f59aa021039ac771 GIT binary patch literal 194994 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 a-lg9n*7?au_uh%>`}e5tUzn)==l=tt(T&>x literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs14/ISUI_md.lib b/libs/isxdk/lib64/vs14/ISUI_md.lib new file mode 100644 index 0000000000000000000000000000000000000000..d10eb4fa2eba74f42aa01c84c6328e195b30ff43 GIT binary patch literal 194994 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 S>E1hDegAIt{qqy`|NMVM} literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs14/ISXDK.lib b/libs/isxdk/lib64/vs14/ISXDK.lib new file mode 100644 index 0000000000000000000000000000000000000000..cdec0045b856cf911bc6bd4e921c07a16cbc132c GIT binary patch literal 1080956 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

Hf`Pi+kW_Ps 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�`j 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

w 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 literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs14/ISXDK_md.lib b/libs/isxdk/lib64/vs14/ISXDK_md.lib new file mode 100644 index 0000000000000000000000000000000000000000..009df258b7737a2f1adea01fe29f9c3020ea4467 GIT binary patch literal 1130860 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 z

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%0D3;?B2XFzI1Tgy&`*J02zm}^2k3dA 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 CqZT&+ literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs16/ISUI_md.lib b/libs/isxdk/lib64/vs16/ISUI_md.lib new file mode 100644 index 0000000000000000000000000000000000000000..3c204f765a33bfae8cd79492fbd58443c9172fbc GIT binary patch literal 194994 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 CqZT&+ literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs16/ISXDK.lib b/libs/isxdk/lib64/vs16/ISXDK.lib new file mode 100644 index 0000000000000000000000000000000000000000..942b43986ed85da8df92fe0669c5d71778cce2b7 GIT binary patch literal 782832 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

-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%0A*fkIlN1+eZeeFa%K+}*j$ zM?{RS0acv|qFw=|8&?tycqT!YF+utJ1R8<+(@FSnB0j@~#5d-;iXKtw1avBW_ii%V zVwJ@Q#>O}z9uqvVThwJYvZk-Fu4dOQB>gW$8`_k z<$z-aZiMdRS7Rr;hc@pIsIUh>*WWl4FrXlhIc+#dL_l5d_cGXmrr;-1R~h>je@@Ot zYzpQDLDu05u765-*Gh_-^zu(dRk61o)9b1BF<#?wbFn4&RbPpld#LwDv5?nJ#m!8= z9QPHtufqKs`%c^}4Q4$vgn9i7-1p=DCGMn$qA*votoFdYDux@)a5fOuKPx!d zPAve$I)_s=Sm(3{dxUve{;+=gxFH%mYH++pA#TVQvlx%OI~vaq+voQ{8*v{Pnhiv4 zk{6Br%w^_Mw=XcVCPI9pgT^^CQJV3qQn5~#s5XKzwSrOV33i5J7b|wTVoxgetYR}z zMdaP1tP7h5D7Hv39QkPdeXQ8eAV;eU*rIb6Rl2ZoEnE_whxpPJ^Nzyb-{X#Zv#krG zi)+p*MI?;wMV5UWzvP2m`IZ@pdIdCWsv&H>-j#}tXAZ5HJYV88)q#lSyoh#1bf%G} zWD`-XgCE(VS-d9ksm`fX{HA5gpp#D6Qp0zKe@it*5Ik^`Ig!J5&5xO^Z&auKOa@Xz zrb|o>!R9Nr#=7Fhv=e_HDz;huvCW4uzNoC^(8H<^MV}Iy{lBCyeGwkkjEl6cq{Clx z?`tHEA~0e2-^X*Ym7jiM{D`G}TlUgZO{f!4C5YSK+v)^-q4_uCM;zC;rGQGo5&k`g z$W>sJg84=%s73JQ_cD=h;`Y`;C#Y>*3Y}vc^n#6k>%#K1S+cd9aJ{f=nLrC zK)6fsN=P@@&a`G+YXNbHYm@gouN(Y~DQ+>(c%x>#@dHr}3!K**=nX%}gwq>=zG|?1 z_!(Qg6z-eM^9=YXz{Z}LW_o+PoY-l%#Ee0SeGX3)Orz?tYo-bXs>g2T_2;22b%7Mk zyk6ALyq-4*&GS&BeH4oJkx1-RQrIg|FfwSy7QiP1{~?5&-E_1MHW;Pp!-_W6eBc+} z9Pcp1nK(941t#g}hqipY=`!5a`FLMsP9A$k3b&8%VRV>5js{a`G?-hA)X3U;iyF)~ z%;%0$4Msjwn5DtYLhy+^3?7S4;x^+u@Td3+7ZTs62EN_BJ%7PW>YcjKs4zpaR2W9D ztqQY;iQO~aWBAS8rSu3WUWu-$n_cXzcCbq=7DR^BRWm+8gz^|4=t3@Dj`#9Xml|cr z{l>9OKr96vAye}EBMYbvrLJ;)iaM0KDk$~#^dZ;(P{y<%b)g$mS1n%1FDFx{QzKdy z1iCeisKjI+|8R}g|3M=f0rv*z6c6GKG@~=14b4FHp(b=S?k-3WIf`W)Xgw^{*|@2> zoP&EU?yGSB8aHdsTHLGxGjJb{o6%)vEysN#?vrq@!hIj^pW*&FZgRu@xL?KnChoUz zvp|^n%#Oow&%k{+ZWj2FxR1hp3hpy;x8i1@UxJ$jeHrenafh^~y+mtb-LD3dIa_x?x7xG;;c=FwW$XCIJSXa#BlvBaZRO|}Hu2Jj*#r~lfCKK6r(JgAf zah_t|RqRouy1!B9p0KW%SBhu(Zkct(yi4GE4L;)D71q^OoqGho=X++2_aV?RrdJ7)khD z>J*GW^z_#p3ZFrs@R^4|eQe2&6Aw2h8;5iIba<%4qVNa&m7lOJYV3xcNe zJ>aie2j}MgMQ7}Wd^ew~scc!$JS;uYtd1@7*Yy6?W+bmBJpuYtzb^jj-!>Q3jyy5h zjIoa+OYzw99u}D6GgbcZ$4vl!`iin^m@iabW>wFu{#Nx-vu1t^nhjEgqZ`plGtSK4 z0)WYnk2E7f3!vVE&Z4Y2D`c6#8=FhTNC*5BP}g%wllv?X0P?PJUk+Q&z8;1 zb!LX2eqLh2o|l?6Qx@2GO=q@zl5E^VvIRTZXL4n`c5>zTzUIYHwBG80{4hT}4l~(X zl_1M-Y4t16gY!-A-(!Z2?gA#RkKvNVmpDGz`?L9VC0v3%2$#J33|wXASM=E1UrW?g z1{ZCYOpj1^jMaua28Y7eKzxt%@QzhIPUn*CPK-`N0o$(4F&Waey7&-8ZZZOf%#RdA z3e77yPqUT*7OH-}dFAy;cc?-%Sxz-y8He8Hqp_O7s4khF;BT5Q9fsGwX3olrNlT>kif0LVzVyT6uHSd* zw_EC$R1VxOoA-zpq#jM|+KoeBLr^!NLycR~($H*T%|5ng`FYq>V%SBz&E~lP?N=r) zZ29w2FT{spAg!Qppj~ha11hT0Nk6NuS(I~XjW0NXQgNky&E_!3s^BAx6|)tw8oQ#o zUQQ-stp03XC^oq?8D$|aR748A!4Wq{*mIMY`h8))M34CPHi;bFYi^u1H|V9dU-i7d zm_YN*Gh_8f^V}6hmOUuPXIF#UnW}&B+{FGEo5^I#c2Grt=IsP+l}82SnWF;sn4wxb zwR85fA=kZQ&8H4Q&m=L?*j@fAcLII@0q4!7wjSph0qvX*SoN>?>aYXYCPB6pVGhBK3Xc3k=E40jcjRUr!8mn|2z0n&U*iud7-=3dwF4JM6Ngbt233))cchm zp}1qnoPhz)yiapuYhnPrjw>Su*lkDQ6qK1u`#aw>ti19v@bU`E!2)n{NugUThK);B z>UkUFVE1>!!SR*Y2SwzKo1lPsS6)HxHT>;La^c>Umn90~E-dWZ1{VG`aPX~w_QWt~ z9+FGp-5(4Y>_bz>Jh0b@zyXV>7;9G+6mxol!hIrcR;>$g-;bNJ zmy(F5m^R?P95=-#C05KERa}MmPBmgStAl)>5ooT9i`U}Ukg0bGAZi*@BL~h|T#wGA z;^J!nQInV&QBA_>oHW`QeDI=ywEgr9GKm1+yqM%05%!;PV9g%sl7wXQ1ey zOu7~*WhyF;;O6=TPvgva(-zCm?BFy@h9U9BtT(JT~SFU5`s}g$v4Ize*_zAUD%Rav4a%Djx^REhNkVi=>M|VD#gxK z>;lD}Q|v{>-camK#ipWCOI!}NE}Rgj*fEOTr5L+;B^?hcwo$R)!4{S9UbC*4_qJm1 zDz+~wjrbd7T`_N>Vh1R8sA5MbcD!OIDt3lqX~ll4*zXnFq}V%(JsQRKn}}K5d&0V6 zUK#8ciC?*O!6fGfYhSkU{gZpZv#$NU`+OY~_zxK0`+{rVM2xV9oQYZUp4R>zlCi&6 zpNZf9Qzp24+*;wsw`+xO#Ry-+95-p?xouyF9p3HVu*0j6<6?)O0hid}kHaN)_$zRU z9gcI+?XQ%#;%`s5vhDC_J9hZq@HG%=COwLckGa|%auGYcdBKu-+h&Kq6^U=F9sYKt z7g}E0;b)-rjCk65()i15hyNq89qjNd+u1}nu$>1W!(eY_+0K}di)#y1zCUze!M8*% zhi=!N1>eoQFSak$Qwgt2meTgM9nL-umO{o3uY?`G*MG==&KvyhnU$=dEydiF0Ll(81#}scQ{m69(uk$PISmAGP#R~t>5k9P1+d+!AZ-xJ38?A5-a0K=}t?>8EbH)k} zzLe7n=Q%L!+Y4&FypY2RKaHI(+ir!k``NX^v7j4Q`&PKy?Iu?E^|Zp{^)$h=jtI3T z_&q^~Kn@f9o`5sjHNn5vkqLf%`zCl8wk9~?;9CLx+63Pg6P!v!$OL~MjAHaWatto& zKVkbDcDPyI^a?2LZ$8uh=JN#mO#7S9pMhdtgR#3`1EpHhEO5Xn%{pYZRmXEg0=@d6)LLV6?vl`=esC zzXfC7h`;XE74vpdj5#I#zNuKXV&771j$+Is3GXnZ^3AP3r71}FxuaO(f$^U_P1cP zzXkh|Vs|UHUa^N1dl`1Dy!)zk#k{{L_BX}$hV?7{Mp#$O8?P8w9msd5D>g&17R6R5 zwpy`P#a>eE6~*3C?5~RbDvFt-h*{iw#JXZ$KiDl2zf$Xh{f+%oYSTE%DBZ2-?q^I* zwmT1TuzM5uJ2U>sL6Ut!Q_X1Vz>}HswZyf1#x87_)3}1O(VOaJU#Hz5J=z^`O~&Jb28eRp>=T4`BsRe!xx{;rx&hfJ$+5eh33?ccv|) zOnJpLux|6Z3)4RM{1eb#pm&3!Gu!OHM?W7SYSRBk7n(Q4W?EOwJ3+Bi6njpw7Zqdv zk54~?ed43FmCrQoJb6ui7r%1-vclT*`YF3%$huoi-lNq;cR%eG4ZDD|i-w(O;iB0G zzL*SV&C<_VG`rXVx(GL{#l>Mmna_u%Kv-|mV18#N$rZ=)gkTu4w!Yz*<^{$>#?;)y zK4%A5inraeXL95c|A$91{yDq#bMZn8Ld1e06YE~!k19M5G?h+LrP;cqtIp2H1=nJp$>CV= z`WHX_9%qSQWA(?ju##{_hjpwvCFwOE=~p&Hm!0gV3;i|y{wf}xE(og#7Lz6WRyq0G%%!qk{Q1zBNth+fS>8J7jrm|3=S>d%#Oq!Sd z)&>N46z2mk!mJhSjy-b&OI=RwVL7~p+|T#sz$JBxeDW45PQLde#aNFx1B?q7!>61) z3Y^07KHNQa#2<5o&Y8g!HFL-e#37G!;aGjnQ%?GtI>O;ykPS z&db%uyutYw7)ru*n|Wi0estrFTC58*J~$uX5Q30j>;jsC=h^1D0#Y<%m^EW8Dba0+ zyO3lVAdG`|gF+-DX0DmlMF06k@m=WyXL%o3%vxG%LY6;Kb#qx?u$Y$b@mmah1@1tS zJBP9KwvwF5$B2+7e`N6h8zj#%;>ik>ioAm7gXPh?dT054m3_X(K40(r&bHxwJYQll z5|-<0U1iR|*%tq%hoKp`$AD7m@tK9hXUf_ALH7f#2E}ijahPI;PXMh4od~)DbQ0(p zpgt&ur?3gWms$%t8T5S613|wBIu-P8(1Sq9tM`HtrRkwdPLmPr+xFL(*@j-Q6BWBu z-@Q_?n-#lNvBwm9QZdR536C;EzI!1UN3ct*E9Tvx*iDL|DYgFYQH&Fy{+Lx=_R_pKX6#vD1Ay^Vy zYTqTv)SX~+EV7!T?c}N>GmFbjFa>7KM!@4U3?_e=-V)sWM6E#H_s~8uA>Rk>0gBQz z>d(!f1Mqws=pfMBK^c)dK$%~6f|5r+%nNvwt{9JNwAd``l6{}V-x9^vsK4_Rds{J< zmV}p&e3Eyg)+K5zPv~js<5x~AUzWr%oTY{btTJm(#VOyw28t||(P?R6g%zhEz~IRo zg?6gT1oluIM}|AQqOpS}Q|3c3Ng~lsxl1<=0yozXNcgT=_G~;lr`>!N=y6~pgaK$D=6JP~YNKoKo35402%oRr$dKC`fIQGrC4C^3S~w7NVX4Pir?O*aU)eL`0GzKn`T?(HJAc)i5$>ze zvdK?dusIK#Y&hEq{1V}YPpN?THP;0E4 zx9^debai0Gt|qwsJ6M0k`r8w8I8ZOVXVKpA=-V!c2irYX!SJ>|?*m(ELX|&^{{nm| z4m!``_;QNQX`l&E?7?7~rWv56cs>GjH&8zB0}9JORRuZ|bSx@y?<&T6B-n?F znbCDFp)17-Iy1Aqf>N?3{nmu^yMFqmqSaIk{4I}CY8I_Jn-A&g3V+S$=i$WQd~?~1 z3B$Me>Ak!9tN-3SSk5au6fG>zD?{U2QN8A{5`W9&rBKjoTSs?&)4Z0RJljlYuT76z zP-~Xa(?2F^BRI@jFULghz{9U6q#rV&m7Kn=Wsv?LAK+ATvw(h)SwLUG`Q@`V+{>Jl z4`EVx9gPQ^?9{Ecbwq9J^5`baiHG@MW{b01W87@N74zZ8VQpTbD_VmsTB*lP#VaJ4;Cjq(1o@w1nCgC@#k^X!{vu77*LJom;|#unGX zEzgIc9u}cN98>%@OOM?=W_4UC+^*qaPG{@BA1w%XeC|xh$wWa4-GkX{!dijnrQXKS zLw+8A3l75KOggUOVr%NwL-TEZ9~xsZGGIY*0h|n-A@Ov#H16PpH%8xSX?vi`&j2(K zH!Kk&v}eQ3(wG`Cr9nZl0FTUV11&>N78jQSV!BOF6mn{0F?AwdJOz%=X?gSxvClW# z=Y#C?&+W7LpIQ8}c`oqYL8zv!moADstTz(!D$`58y@3EO%#Jf{!>*u%@jMK4DCq8> z!$B)Rnd)zVvi(MHe(Gq@eL%^CBSBYzjsQK=K3@#_O+544`-8IG^+72?&=;KA3_1=J zyy1-prP4M5GzmHhlx@w;D)Z{YE$Iig}#dCg0snF^)V4R;kz|#n{;J*O+&hVn-^r7&1rR#eRp@-^q%t zRBVl6TpA_eU8&f$is86F8y=;Z_}i%157?NA;IeHuQBgb^|wl~ z7ZsywBk!7S-KWuHM!A?N52~r3KB#00`?}B!t)Gxy?{Asy^Xp{0pjYN;wtP%u$<#Ce&nmZ3(4?TzRI1jzzSXaTI$D-DyX%=Me4EK>-G4 zYZSpaDlW^E1sD>b6k3h|rFdip@LI8Rmbj}jp!{K8u_0t>?``q#LZxC_F9IzBy%-dd z*~28;6q)%_P?q}DClORHVys#6?n8&YTHw36tE21^&H^-;nhbHH*-cocr`O!}wSK?P5 zU(vk6PoD}u%Y1gHu6hWn&vp&rk>?qM98FJ~{Xd_BFS0-BS#CYZz5i!cm2md|l$k&t7Jc!$6?3|! z?=&N)hICvl%2dTFGeO+p{SX2zR5kb&s#pVzmmgzhw=7Mgl_=K$^UB}I>)cCWkqMRh z)L8TT`QB*|mmF)MfdMaOA9e=IF55B2&qbKn-W367x@~)*_9mie#IrS_zJPQ0$Fg#c zg(k!b!nFj{f{O751KSaI4eo<*ABlSz?&Y{o#Qiw#PobWChWlT*S(_<#o&8Y>jR3^D z<7h}#cnnqWsepI|`p{f?RDEcLeGc@YR{NZNiY{wwaFJIi57?=3lm#KVQ)HhM{xhnl zfsO)Q4a$7~4k%gz?+nmmLD3_XN`amWO4|rpS?Vd!3qdJ2Qs7*X8+6J3tb#S!Ut=EY zq+kfuxMJRQiruK#j}&8nFW-oHRH5jKdoL;WmSP-C5r0&v#9zX?VmyGuVik)0OR+9p zv?yC}v95b_PyP`c3TrdVwT%a&JMOpVVWhR81T#E1BxJj>YMNMdL+${N$ zb8p;IQ>|HLOA#Jc4`TyT5f-cxjtPglWUs#F71%F!@aHV=Xq10D@`b_znh&nCu~1eT z_l$hmzFpx#V{||B&LX5d3ELnr$V8Hk#~yO++GWN7>o$mzC2UhgO?c)HB#CQN1@_e6 zAszl=-3{r0+K+h%5;A30J;aB`++h6JA=*#Ed^Zyiup>JT>sHxTzLUf7BAsAyK7&ApMsvLq*(GZMwj$l+Y1pA?49J~^Yc8>UaRk1%P z_AkYF%AWXp!n)!fSE$=}75jr?e^cyz#VBIryR2REZi#ipy?%;09koSxCD$HW@bBI2 zRzuXg9C~lg?T#~hXt5UMtazFIvqF_EThA45Y?N6MK-#-d5y;t5{O0TnOo(rUn4Muc z%x-w{ePCpc;L3x8EJ<2s!B4M_mNFL$SLQ z1KV1E<<=$h0340fNO%?K5cL%FoEPx%=M?VU9pS!d#||VpI|tiHek9olcd}$yxL<|e zdgEs5AIRdW?A?U3ggZ9@Zg<+!P-7rbxDQ2mEY=SBYq0T7!9Lh{m)=4aylDrPnV%`t zOU=*A&2vVem*P2F8zf&+pnt>oKWbZrdGF6B%s+t?{HG(#nLW-vJ(PtZ{;mV$@OOv8 ze6&eRMwm~x&w(%}2lEPqIXk6zW$S?ym%+s{XU$1~F0x=1x}C@e)u8Ms<#Q?MSWuQF zyQ{{5vYToSD7&es4^9DX06hTo1klN#)as!9q{vhJoqFMXt$}oja2JfiT`*>nV2rI` z7br$CFBlsm@kcQ)*m}htQtTPUUQmouMBe?oV)r921Y2)iF^>XYFbaJ6#;b}^;0s29 zFaB7&1dBrS2$rxekq|oKP|6Vp?37b$?9`&wtMMvK*YcVzPt;caqi9u&d49NNw})yg z*VPtH+B}7(?14mK^;Tgl;xleZL+jVCN&lm^bzWKBgyC;w?V!W%{q!)5QT(+TiX#UX z4uP)8F$!z0{`yU106q(U7_6vmE$iy9dIwhP-y$uTV|Q@*)HR7QR3Ckgg>a&fnSS?h zP36;#JI`N>AS(_?=Re@L=06P&RAHkvTQ=g?rZ;LZ@KO2x@%_T_!8bPgTORN$A6@n? zE#%rX;?16)$_JX8{WM2I4k)Rqe4?>yP2Q7!>j5yM{iHc?U?^Nsx>|N9>Yp<4uB=YB zbm#Up=u9$x{)&f9NNO>tIb~qS?C-~X^e*8T0)*21o?kgG+Hy9=J|Hh=7&F|AqnJnN z&$P=8a3Q`WW_ch){{csMio{P*GCkn)M$l7SAsUQ@ELb?d`H-bX7`8JOvLh4Zt&Ob2 z3bX97kR8n{1MzFbo7lJ{+(TGm6yrnjRW_J74KZ?dqzlA(FnrR)?_#HsU_+IR=#-5K z55t?=nK!SBtcm19sg^f!L3pW;H00l;V<=3^L^$}(ezL&O#?TI76* zLR(DCS!nhHPve#>U7^WfWLQ_Z{fg)l5f8mnxY#ieyfSfNqn)V5v6#F0Gmb!~|7nOz z;J-xuFP^h}Ryf%{-rU=~IohOxYw4Dn=OIY+fC#6OwH?`EbrY#M*?jLneJcw26~u3$ z`HfvA@0bt=ncw=L1qk-);n!vIW)XhNgE=7k@kl-{!!h7749a)$rg#GoyD`Nx&;g6y zjXTxU13E05Ak6`F^JO4Ym{^%~F_Tx(l}4xFJHd3OU`vZq7N@FXimK<}p6gNwSU*lfTEIsBezr;PEnVU>>Fj!ZG0G+|Qz_4V6of(0pkqKE0G$Mi zF_;u9<71#FgFXq$F)Z+J>JrdrKyLtj9`rWQmp~~7UIu*x^tYf-fxZIzJJ44_e-HY5 z&^JK;1j@Mm1r$=$dmA(f`VJ^L=RHtXt@lCq0Q~@TANxDS%RlgZG3aJcDl&IM{!0fJ zT{12w*ev_2bb1Naq}Vz7?)i#Q5fgvcDYj9u#}#`~F{V(y`>|r5Db@|~l<>M+7fusV zY+uC=QH+8~!mC$op<>iaB)nF|m?wf^sKCC9Y1|gupxBd&J*(J9ihZnD0aPRjubXwn zya9@#d&Pd^n~Fh2wb(Sp4pD5SVyhK9PqFVRc2-{S-E*uf=3S=PRf=&vyu|Ny#r~?; zdy0JkZV-Re5a^0wd_KUE)`gj0Q2lUXQf>O_mi=lfpK9I{vrC}(Jp$#awsK?BKxlkT zJ9Ea#0qNfB4p@^|2Q3RbBS&h|V=E45?Y%L3Mi*P~;h_P_iQorb6L6o@o;Gs)oHnXR zw%Q?T$Uz93UBw&%4H~?NSFH__`3c?a(imsvdS(2|iA5Q$VR*ZyoDs7fw-qem?ZbG zl(A@yrxu&TJQu)2a4}yg?U*M=SrDVoDLT&qO@OWi<#5`Cpo2g!2Bq}71at)GrJz-y zmxGQ21wWb@W_+e}xfOgP(uJ;=H$yRgQ830y{4G-Kbj8k8jJm7%yF{@&6uV0?N>B0k zoMNvj_J(4MkfGvlsdZ(YRWuA>RfrW)JIsYz=Uvj%K5*an@C3H$OAc;sT-b1o(RXuB zUCVS^1--NpFRSa*J(nZXc}0a-_Guhn-_(pnSj`KU$SR!-Yj&m&%N=xg=DpE+Co{F_ zie>9chLN3{+;5Y=*qBxXSpv$udJ|%Tw9MiUqyLJ|jiAiKM?lFY@%(^I=!%&$yaZcl ze~o!;W(2!Pv2}_)s8|)sP5g0$Rl>sv#fYM07useVRWJv+Y*|Y-f@w5Dr$_997siB& zygxi4PEe)5{T&zi^!nw}L6oz=cQ6(PGq!_*E;1I+)(UtB(>XZ;v1)q-1zUxmLIvvs zYPVqP@I%{zW$!yQFmo+Lmr$lR-7RY7QMjnN6pHzVE{GKK?m=7BF@Pcw=)$f^_)V~5 ztSjcR&I@+7V$_uc`;lVkk+&F2PQn|Z*l5MtFMfU{tN2-aIx7CZAp_)Ux5j^A#m_l( zQv64^%r{L)re5!WId;M7Jp8(-UMfCy9JzKdgF7?uz|QM0hCetBC&M3%6c^X=8!fn} zMl>RAnI$Y0+G7g`CNp$51zlBwYD|2xvRUp2rEJnh(a!M5>xK6ei@5y8vXkuov4eT8=V&;P~O$UHdoKv5aI!>3^ z6oS#F5R7AXf^jTOu$vTP?g_R|u?H1fFCv-Qd;{)|PGgUjz=OF^XZ6^$QKJrNX#7gg zQe!zL-91wu1c#;F=GmiFAQgo@(=hY@|!3i3`Ro6YL)AihDm-4C1bwrxXF18S$Crc z$=NpMNF?gmnVEq-kvLf!H30FW+;X!D@vv9Wu92NXM=nv&$=NoUBbQ{ttlLmAU0~KM zodm{vifP>+6m`L?0wohy0~98vD~8UP06W&YVw_cC{c&tS{JpK%yNdY_S4Z)XSsn2k zJcNg?y3q$N`h3rAYJ#pamurJ8&v~p+H*`C0noJ&{nM{`qqX@PD9tAtYy5ijB(_+kI@yARSf8cm53VXXebuTfm zrPyEjz-w@@28?) zhNB1;0b(H1dgH4ZwT^IbF%M8s$f?Z6330T|%olXX7{jm!DC33^ep8^^Yk|@wT}Og7 z!IxmCT36i6oD%E`#ja6*Yy{-pI~3!Tcfl|%!-i*OO$HMt$0lpnjKxIClQ=Q)J<~Js zzB#J7zaH|uhhJHj!~v4&r+AvP`SGutaArZ$46`IL7L+x%Qj_jclODlInpjzbA)AsE z_Ni?y!07iT4A?AB)>J-Jw3;y_&hsBy^8MCX7@R7s9l11$vnRP^rAO_^;VlJzYvm^V zcp}!s7fu;j(Xw9<)U%r~Bvj<5e`CI|6GwXHXEv~e*@9E3(;H1x->Yd&`sqHkBO8+~ z`N5{5NqrJ2T8(WI5I7FwTplet{T4hRiQ}1XB@t{AfR#$-_qbpA zanb4xCK;14URL6@On<1l1bHwy`Ovr$gb?vt$02nAJtApEchpPMuH^X@P22jch836rFyLf#s=X`-jHz^G_od z`1%tfOAtcQ-8lCm{p^|5C5RV1R3lPPJXBQ@F+SdU6k(X?A0p9@OYGsR6_eZ;Hj1Z% z==YN7&q$i&Bsb+D6@KgCc%2D|8&<)&7x2s%`2AHH;oQ-l_lJip>zyhnXtUMan4+^(65JVYj?)Sjz;3r zGLTWsE;c>JmoIfH+r!5pf}F6-FC2O;=<)RT*R3u_2!jg9sJSL z)ptRdGz*@>jVV2m9kJZ|8hrD9BYNPPJ>za5m>MIP zJrjjp5oq_WL00H+9s^~GMsc%qEr#A{!6IfW25evv8HN&M!0y(1t0myI@p6PK-OGDA zrLhZsF3iK1|BOR*C&h=x=f!>e9gKS*4%(f^m)f!y%Y~8IWFk{*QnR}g>HvN;@3b4^ zLlEY!8s@I%=sO-Ao1Y&fFsrN?=FJci+!2Eb=>t=MVu9f?ro8EjGGUWZYgLX=rYi*pesPp^`ANs6bCP)s1|hx zJrlGDlnr?jl--@ZK(7YH=xgeGpxc46a|62>r)~w^9`trl%)?Cm7<5O_pMhdFX3FT} zp#Q}408nyM8E8*XKJR6p*>i^RsTBLo27`_TEeGWaH?AsVL2*?fh2t<#N{8J+vHIMs zD#WUDZ!bKv3k4I%Q{M*N2b9|j?F)JW=zgH9Ku3Un2b8M~&jcL>dNwFV#ZqfQ$AEGJ z5fU1yWX+S!%=oMct%{z zv@V3{O~vyJ(1Ssb2AvKHbKE-=v<37q&=sIZfSwHcEzpZWXM$byI2J{(i35I>nw+>^a5W zP>d>%yo;97hL>+$F^}g1$anWsY`S7I6kD#?Ns3*k80RC&Hy%@r8SuZjP?%%P4Y(QJFgR*0^4R+8|DB}+7psZwk9y{nS3_r^bVvuT21VMgYJIDl| z7q)}4KJj_%p!XQ-kR8+}&@aIbdKcgAlpWNjTspFY-eGFCZU?m+CRN6;9mMb$Q{HrU z&JGG}9&#LuEeM5q9rOsZ@`vmoR`8G=MDyWmGw5qG=zrM^+5>H`m_c;Ku-&TX33iut z#k_TjJ*e30iv3Bkj}-e@v2HLzBs`3Z7+1{9Zx?K+Vl;FFJ4&$?ik+<3m5N=f80Jpd zcWL}El$iIfVjn721sNjWfKhDy)hPzU)?ybZMnhJ@yI!&HEB1HAK2aTspFx-e+pIZaK9ZW_y+s!(&W&)4gq$6FDvjfyKwX4lE~D{*dLw z3LdhYz8*n>Qu_4>(*O1d(h#)QVmi?k^Ztm&S+GA_SIqlBv41Gm8)Yy4N~|m9l`A$( zF^)EhzbeIOCJ9C}i7t#>DR!=6w?s(wo$Pd#%XPM17XaFzaiEY<7k`3 zFwSQEVPwr>XDIfNVvj2Jf?_W#HWb>Ad}DX(ih18utXi>C6gy3^^A)>DF^&;QctzF~ z^JXbFSFukOOz``!nIzYY$|5*JM;`4vAH z)9H3N&g#H)D#AP$xwhSOYH6N7LTsi6*h5YAff3^KvDF@v%` z@p;Uk{)~0V3~CeT7i0#xQ{Hx#?`~}xU7J$r$OzhrVQ$?BYB$XGj39=`c=D#Zb4C#P zjD;1v%^VJflma7&RX=0|v3h44L0^v^eQg5$uTP?DLAxs^5M42k6DOvCU^NPKs*ie*;gvS{-;_pGlIF2Nk-DmwIEEC&O9i5VX(NB-$zUt{NIA<#A zS3cabb8Tzan)JHb)=5#^$!f0U;2vsN+km$=tU4j;wIpj>XC(c~Ny(Pt+SXagP4U`R z?8e@;C9k%%e+||X)uf-r5)!N|;gFnJ$Wzq+bd)uhz8ny(U4t9DXV$Kn2A??6Ze!7E zjxFL%t~~LIPJabY@PTDTPqiFLFIf81%7ryvuwKN+n-b-8o?q!lTZ(EC|0(H5Yg(gI zTDxp2$IpIcw53OFD|Y1z(4O#=%sl4RrXMirtKsS*KgvZT)>)gz?krVUW@1R@t5~xV zH92KJ+nt}S!J?YCX!i40#0IU`WEXG)~Mj1 zzm_SoX>|F2?_Kj#kD`dVwq`@;uyaf{+`c*V7|7= z-f%(-nNY4KVhW=z1xVATd`Ttvgb^8wWn?V8zF201#aBQArje9x&^;z-!yg+`;yI%@ zhNOQR^e9YJm#ec%eA|^SH4RPmjm@*nIu5QScUHSlz2a&Ou5`sdZe7akIt8jEa&2$c zFJ6ruY@qhlE|K$xChN}&&DxaHjoLp8$8G6ikvjDv8{r>}=VBA&qAuJfhp#{j_v`1( zGm99wmIYb`t~p(X;alx44&ZmW1qf%pb5lGUNS#@FGOKCf(Tljr3KQkS=QYOX3M?6! zVV3c5*~l5dDZX>R%>^uc`vUWJpGbG_b?-y3f142Y4lQ=bTUn0v61vu*um@H+6n4++ zh9gpAaK={@7GfO*cXr{rnZWAN{9=w%wxbkuQAf%|;j>7-_jIJ){9q>UW?nkfyi|u2 z1}`PBoeCFF?Bm3fizgC!sUOD+i_6CaPqS$+hfQnr~#BL(k4YAkQ zTcSo|ud#QHy+;#Ej2e6FEgHZ1?VR0vxLi>4zVH8gzwi0)^PIbL=I+eS&hFVWv%6vd{P1wIN%8)TNqDJ214OO zTC`q5$)`qqX95Gcv&f$S3g`>s=)N$)82v=}idOTZe@LJhkJQ%`;{nEQP59abyEWyd zcs#`gC_YAU5XH2xBknVbu}f1Oif2;XkYeo4)Rf{m6gQ`M9>uLFo=+u= z6t~syqxJhf`aR4T{2x#87K-uwLJq9`-%0UGig!`GhT`26qwe-m{GQ_d6w{Y98ja7! zHKiDIohZg$eCS)D7km{_i~3+T=m42<_=Ao^AHcXp3b#bz_9)x|g~Q96`Q1@CED>TH zmIyJw3?v`pvgnXmtEg~Q6%Jp|a5}UKriGEmIB17)_$q>N&l>&cj8AC=Z3hC^)Apqi_`z?rVjcpm4Jl zZob0#QcZCl`E*EaQ~tjO9jw0pHR%5D7<5>%Ha-P|uCo|@q<%pAScC2#uIsnA`V4FP zKi2BYRy;+kZ$G`i$c~ZkFAOk#$m#>hhpfINOQG$pKAp)wwE7%V{}ZbZi>N=|>eH97 zi;u=X$?8j@k59GwuvGjXT74k>u+^7r(LQALIV{?zSbbatAF}$AWCLUSU$^>@ITR$V zKEncfY4za=va|Zo{_L#2|26v9$oro(`btng%|;&}v$mf4CB|W|55^r*xT6a9hr-=c zI5RaTrltLFblR*6ms8k#`74rM&ULn+-`;2uW-RsQ_Rn*L;q{^{qHDVlHtn#`B6Nqwb_$`(bw%?F#7(} ztC;QWL@Z|1r|>`4P8`u9MLThm;P^>)B1k@DCnj0=X>TX$O#Y#r=$QJS*ojy+`tf$6 zzF_y$?ZhPd_*6R)3uFJGoyaSIKQua+Y|%bsCps+Jr`U;H1s}2#lVtPnu@mL8VQDAg z3DalFrJaZ;$j(kg`?IqX#R}s89UY_f6~+1Z37=05T2+Amjd0 zxc3SN1CZ0f0OWL46fQ{NF!90Z8Y)~5h3lnolN4^6!fjKyT?%(n;jrSB^L?Xme=A%% zGUqtoj5=i2dMI2kg~JFmr;ArOOzkobQ@fnUT7}!Fa8@$iI9;d?(VqVb*GA#KP`G%7 z8>?^=74C+@-B!3~3inFk`cqADzJqnhOp~b9d3H}kavHONn62Y!Oqyt<=|c-oW752C zb@#oP%ClDT>O-@-G;hf`p6O$lxQn%T*+{MS8`fb+9ia(bn0Vpvv7ua5;JYK^*hdd?#SyQ)V zdwr>C4Qym319XFFjWiSw){)e3;{cwb7-F2J*pp&v#&J;JIf^lD@-xN06knpa5XHYx zOp`0x4T{T9{42$@i?4Q>;vgL#LNR$padq{34ExuhO!&bD#G4^84if;3!#jtzFAY{%f5 zq#X;h@V~7g;(1zQEb`-bKr`Z+*uv+)P7dD=L&}zd`^enm1)ttGA@)B;_(VKUckp2Iw!R;^`&wRj7BCc zRnwQs>1bhc>M%*0tex4C{zD)aQY=IfHy=H_nAFZ}^f7j3%a5@$TRL9Fg+@oFI)!Hc zX*(0Tv9~jCksXN4|DYIR+@=`IY3@>t=lUMSurnW0>`U<@ieYCyrWkf6Ia6_EDSkq6 zAjPy=HZEAl!@hh@_YL%W*qIo$=0*pI?M%kO&SV_yOvd3g&p6nbj60`rB}sLRgPqCg z{^O0#k*#TLbbtN}uXW?T3Q0dQ5(g;QzBDqn%w%m%ZkZpjHMwOvv^77iW&TrJ^S_~C zVtF(-Oh9aFG7gQ9acFvsyQpxmH5mt6lhdI$WE^@!#{I_|rXzdP*f25h#^Jxu-ZZx5 zWbI9E%O9{exh*@iH$SZ{|6_aezo9V~P>mT7+nbDoy~#M(n~a0K$vD`XjDx+&IM|zv zgT2YP|9E3|WOEuDGrqn0r;YhjY))gtOxEV)hWP=TlN+W(oAc8e=0CPM{~H=6KHBA8 z77*K$uy3u_nAAuJ*$ zCSpKX&&YmZbo^ka*v?c&KE10X(O~_wRgxx(agT+_j{!kzVF zwD|RVRY57o92c5_#bft$4ZLD;Uuh^u*jI0s2HW8 zEVOJJ8Zwra_~;>74PoHQNP@g!VSXa=ux`Hk#1pzW^Lx|>uP!LK5$gIsEh|@t; zoX(+woM~LvMN6uneneI-1qC&n+}As z4twVnW5Q=;V|w8LCegwUxRlfG+$C1lo$omeu~vGScGLr)5{`$`#vF8P&f&DyN+=#+q=>nsCs1>aMlO9&4rB4ilBLj&&&v2`U}3rmg#^OMYL``M*@X~wcRU{ z9Od8gRK&ZaZWk?|Mm$t2j6~jS6IfWfRjo1*#()TMpPdA>JX?9zbMrA3@@z~W43(yjX^PRO zG{xN9@>^W%xaG6By2-vCPj*K7wh2Pe!VOvz9M(P}I--4-*a1Qo%yQNj89O^&qm(Ff zU6QGUkjIC*&#KJr%xg!j;L8Vl5e17ISZlIlm=;c1(~ZQYemS!ZaJY z2+Z}lYQFSQP9`dptJan-u0$s~S_#3MB(>#Tjo!&5kl; z?w$o9i?e=sk=dK1NaKU=0`>CN@6KQ3)uYm86s4);l+($Zo_AHfbt8Iri|j!EvQ9dP zR1K&VnzaDBjN<pT5E9rF??lRSv$$q2$4pT5dy@ z!K7D;*mAMB1ZEU|A z32n;9a=W3jaA-6=i;W_C_vs$1KXJ7G6OdX?2T!1_!9GF`E(K+s!9?*DWc-8CF%B?M z+R{gGXeVf>P+%>(mJkETgW3l()bcaBAUdAJSgKppFBy726wffgVQSEUP244!9n zOKB4siDk;s!{zNANExDAHLRnt5(?cW4Mn5d#92-a2!+Zb6nBfmHFxia&FCq{sd4|N zE}qVk3+wJ*v0~-!5k1;))|#K!=Xy%lLQf zSh6aqzO8p}5)CJK;?c)FY%k;ecEdf);wN<9S>X5w?<|-%Fz?&w_!Sm9#);sS6z8LO z6~!efUQKZT#cL?8Oz~QZ11VldaZQRhQjCsxJMJmQJ!5I*74DJ3Vc`j<%Roj3(`L~jv(`)Du-gEq8=-Jx6mGe~ ztx`B|s#oThL5Iv*ZiUOQa0dv&=5C(aPdY?4JU#SGJ6ng$+ERsEp>UfO4wezicT(Zb zDxAJcLU-CF0b9o5BvoIzZ(OO+gwvr3kF5z;tOc?_`YD9W(vXCo>n3PHAc?(zfBKNIoJw%W6$B2!npVl` z+nd(t(Akyrk-a*%^iJsquqP{BjcrWJe`y1U{W$(IHV@VUi-R!JTPp?8go-s`H_m4l ze-g#+dvxrpH^t&;*Ywzq!R~ZdZ2RzowNlPLO@yTNtaN~D+#r&ys9v7Xgc@WXpO>aF zowNEQ9x-b|HetykZR{`BF@5Q1&axDFg&eHq4n5p~=}H2p9lnnM<7uun=!jaJUrPH# z5bb9;4wd!fIp`5l| zCun~M+T=o>9*Z3%SY_UvANGIXKcC4$>Lp~O9%UF&i#!)t^Chhb`>kZ%m*>+yXTI9GLB+oAE;!gux7q1d*yp!AH0_|BeNM;1(cz4AQH+y~IT*%r z<#C@qBBJGH&c+Faq=(+{F3;T~d-qOsNKTU7pFe#uOwp2JQ|L$>nJH|OZ^`s_xD{Gn z@#=+Tn^zRb#~Ckc7b+;(DRm+T&@rYWh0W&o6~;v)qVN?IfliOKD&pA6Mr6r&5uU~a zXorA|giTMI6=c-P8q9@>q&ZXEGdCBD+0*1r2X2<95Bxn`$-K#y-s0CIMyl`^<4GVvCIV8aM}qCy{I&`Tke5EgqYycIZiAy^3Ahl~52 zWX;gG&17-3)v6M`&B{1Vf{{s19}d^^Hdb#HUsNWvKuUJ@g~n=o+aE|EpA@Ygu@@{bVj7^Mp03*>SH{V3ojxZ{|)9S z1DYOQ%NY#J>w>v!d>-;JjObmC(b-5oJ+;wVgY`r8z-**+uxq8!C1WGeWn^KB&jr)e z9WIlu4>H+t`mK-}mL%JosT1+aXehxkq51f_r2TzHJl6>0W&ZgLbZ0^55d5v?Ldy(bQu87)^~V)W&_?Q(`)9HQm@Gc!(M#$LrYUz$ z@?(tI5S=_v_~a$XqQ=MpI-~^xAMfN#9Z)fP7|PIa$d}YR?$tJmE}HxY3Ssp-b`-^i z!~2aujdLrhkgv#NvajYiN{H51(keWu+Q>Q3X)|) zY&DeYJsO!QD{ZZk*RwV?D--3)`>fy`XDVX`+C?TijlmS67D9izd)B0sbds=JYJC%y zL=TFr!(u|Tu2g%iwQ#Z!&=bI&hH(XVn$tPa7#>1ls!3aE?)`mJf+ecS>+I@w4q(f%yt-?{qB`C}q zKGI-XygZqTy=%RXfvlEVXoq zHl=4a6%v*xRC`4q0C!UZUtRpCMvj`j`I`F*KyvlVW> z!mU=g^$Pcv{3Moz8n=LWI!gDAsG*S%apabJ=@n$9}5xvw?h*ll`dwBfr#)7E@x z1;1*-KPKmoxDa3KuwCwgAS7+@0c%2ekw+ojXHLu_mWBz4M>V+fL%akV8b2U8OOs2v zH>A=P>C+$lH~I7-l@9dzA*52SJ|(zFesyU}zL12oAqhPDRCmk}+9W2=Bf9Vw~jtg+nJPA4^aP%Ym_0goJj!vIp>RE-7l#1Ry zICfskMXwPKDf{dHj*-}+iJX4HQMma34&J^gj1Bx-`0MBM8jC<92}y<%zAKZ=a6(pL zDq&@aaHg~j!l0Q?7C~~u3Hg<^n_tw>LNc;!2Fz5dI8%H+&rljE$V(=j7%1?t_~tSW z6y$;hs~=+ZuMZSNknozejn*`nwF+d>eQq~Uu!}?@w>KXQB%?p_vk^|tKI%Q!jxsvbqXI&f7_34DDgqpRAJoSZ4zI!CT5{FlRmq)j4MmD_OK zQ9DA3lhgv5%XN{x%~jPZ7OG)`rrMGcv$WAmaOBM)_MS>Uf) z+)QpcEg7i^nsU(pUUu$klF~!@B}D0G3inb^U~n%nxa%iUxQgCbPocY)Jhn)qbRtDH zC+S)yZFsH7v$FNf-Kn8jEP-;w>M7l##7UEUZlA=5{qWGaiVuYrgE2-^hyBi;bG$08iu zqatvR*CForPz?VvAMt>H342ERm-)y5V*e75SsX;gILu8lZk7&tYM7;D+;)ZAt#HQ_ z?v%p$QeMoDUUxbz%ELIC^w)903TIU~%y4qL77DjV;SMNVEAj$49rj=XMC$<+ZkWQ2 zSGdUvhgE@0dqv^yD%?Yb8%A6?-6$P0Ym*gjy271Sxbq5!rKwDNOW~*B_rEudE&VxKd=9gNB%vu(O%b{?c6|TF&^;fvT3YUsJL+0nHLuRdz!WC1vIto`` z;aV$Pn8LyLV}9`c0I7YgDQ4bC#GDpSQ7@(4Bu07nS`%Z&6?1Z?(6&ArpBv{ z*fl`+;)D~I-kQ+d&zexzUH{XX)@tGp)<^eA_lT+4Q-Z@|EBSCMLK3Q4$&D)}%2Y5^ zcyYFwSn}emW2#w&7pKp;-Xc|yK>9BFW2-MBJn5uh>7F`>zuW)3&~a zjWf1(hf<~Bnc1^U`e~W?sw|0@g;$WnNn2hoh4(sk*rtIO@m`OjH%W3{RyO5j(JPO_ zoJ5ndUyyE0@jhf~)FHEjOc9=u&6>#~XJjpYz9!6lc%+7}g`;#RC&#`P#>O#unOkHu z-N{R9;S}R!N@5^mRsmz!r9?V6=hB*qQku0$r##wMPC4yR-6q*rZrW7XKLDUzcj5Ob~Y0y z4>>QIg6_4=T@wf?E<7 z6H@?WLfTCtT@WiH%90<@n*NhbTgG_|rKn9U2*)|St%9j5y=mI{ znH!NI4W^hiU-C9>Q=+>BKE_G2cOoCG?&8l@LK`v3}`ZtM_#ZYusa@-To;>oKR6$T#w zYeD4PFY|U>P^n_XL594_LCrboc#9gIAyhCNbz$cuX7C`qFFA?cc1~iFMuc7^zmVyP za1!+d1}70~SNueZEaGLNr?7JpJBSn}(o9NycWfd@aT+?Dw55!WVGlgXX-moeqk&d)-$4*vYsPKV^_hHaTAO0_P~Y z@HXmC*8sW((lv;#!F1vEiuVZK8|Wj@4d6Y2x0(lO2dxUVjR&g^T`lQCH;tYaC7Djw zbGly8m67^W^wj8AE6^28S53OmQxB(0E=Pv#VCSmBKCro}X|xL7*mVsdnEsK=dIJT9 ze_%hwQNtkLg`Qgua7|%#z%^Y*F_W``fJ@ zE=P8R19V#(+UQW~{vflF#+AKG2+bIYN`sdvz64q6ymnaEhyB`NEOml^2zq%LeZ_OE z`Oodw4(l}{@RH8xre6Y`OZ=kb*AAy6-M~%P1+#P0VdP^p3bMf^M^kg?lCKj5u&o`I zP0MJRifTwb)W?Vubzp}R6+k$L-ndUnsy9x^{!B%uM~DmWaP6>OWZN2AxJy`8hCv-X z(D0GDAc=kC^k`2W@lR4%JA8q1H^oP*30cQ$han@a9gdb0vdOF+P9i9(WrPsawsu%* z+&J|o1U1DUO1yR$?2>rP#|1mv+F?h1fox$i_BFV1bx9|txEcD|VOlPoFO$WmBz$GP z&Dis>a8AXp_>-PDw|yScr`)h|8kQe$oo!T6W%cqLL?G zLEMchu#FZ$MnK9dh>Osx##!^#>{k$49Mdank0Tcm?rHp&myoi20u+D~K80-{SI-D~QLDW1WXYmyUHjJ^DlG!pk0w z6)h8;2AUw=r|7wVp^KI+YiKIe8)~RSJZJUj!g~=NDqc&FWfont>6%N|Q@S$Kn+I>7 z0J_T3g^m^->oB@j(j`|9!|E|O(B(-)ST;5XnpY2tp&sM%Vc2YOR2}4aeAM#c8I%q_ zv2%X4*VD zWY&IEIC#!1-&KYCUE%&zxTgxYl(fkFR_Ksf+pKWg6s{q8wVbZ04wNCZ!zsph0!JtjKj?tW_+Q7h*CDgESmBl`oUSNr45gh-q@m%2scxqs2#o-J z?)MfT{p_L*1EShTbf=w+tYf?9>u*iCMEelkrj&HBdiQ*Op|r&jeYs8RtbGNJ zb{e8Dm4_X65=lnv+JZfi(pq=Z^mX~Lwx74&o12m$6BjL*ARGo}Ym|qn&nsc4^463J z72Sxg(^#$~LR?tyo~&mv8jr1J$nLD(r(?%R{^}6669->mIpF>7D-h+#fm55KFa>WW zA=hzYqR{|REN5&^!BP&RN&wRou1r$mzYF(jO2-}&k`raExrGWrNfntb2SB&A!Zp<5X z$;-}Z|9XNEW~I{NpsTqQ`%*lQV$}6Qijn4kYQlhMk&wcH8{;}DTsMUqr*M-LZmz;D zRJdIVw@=~DD%{TshxW{}+*ddZIWP`2%(7flxEl)Rl+IO4*Dg(T>TpW~&yqw=0n*Fx zKs?U$qcP-85SBZcG$%J_&CTCg(D=*b6hBlH41r<_Q_IE?QP#0zk_|V5h z&zq((1ge=y@~Lbi&>krYhCqRLHc6I3K93a@L!kOD#eAM93Wh+j;)D6%b0sbhL!esA zR4z`M%TT(d;46Ol=eeR_2o#%b6uPqT9LexfQ7{CG9Vt@0Rul|@Vjoi&YLi}MD*UA= z7y<>h03j`>bJx-}p)HsKJhXKFX&zakJ;Om}Y(4K3HAA32DX4S1I%}>saBri)9jCJ> zh@M@Y0(?tQyOqHa@AJ%CPa-8DA#}cpb6`op(>91HQzoYQRp;wWUD2n=48GVtM+QeS zUl+Wypj8+i2;_p#;7nrg!-pabxa5?qDE?b%mm$#H7AeD#3i&=3x6b*rEOyTX5IBthJdQF)0bYIc=!xCWeBz2?| zj1tgb31LYLF;!`zkz2YKDHBOx5hzHIHaQ85Jyss@(}R=Bfg$9OPB1Z27r%H@2aH_usEl8a(Cu8Db*4^!gz`?Ys{J%0YW`^ zD)tP4{pW(8lc8RXE!?6g7y?Cm8^us&Y^>MRih?0fbV)){kO{?a8b!enD53;Kmb|1& z+6XZ9BhPCdCsXZmjdlqK34WkXTPf?)oeW-zA4A~RNASy?$%R^0TFoT@IwEsW{BjS- zX@O@5{Fw@=PU|TVIpRNv`J<~N{s@vca%T#(8(S{S8+)aCO zz5v$S{`W%tpIC z-$<>w28id0#;`e{^qkg9LEz6+NVStL865G)=hh|~A|)LYe+0=JxidxLT$nfb-av9a zIO2_U3gFE_@`a8$b>bYDFL-`$(6J-F^8{b6I24LM~V*K~@!>M+X!> zih?0fEEg16a>EXzIZx7ix=CrSNjof%QY5a&(gv9`Dt-)s-x}tJXRkwA>dMkkS7y8bVSgKM6emN9B zhQROe2TPSxQ85In6N1WH*vwv3S7{T~6(z8HP5dI#11~y%0g%6-I5Py!=R`_BJ%vbp zMW86HhG9jrzGz%U(*o)F(GFA7CTnV}v-3*L$=ykFua3XuUY!i*R=F^QTy6+PS@N2x zO=Qx1PJ2C~mUhy-%RM?(xSQT{Xc`(W-p@BhF4+lsBr(U+>Lag`F}I;UiYOTwf{gSEvzM`ek`ar{619C*ANibViO#3hM}R?F z#grrrL6V{(GpDR(Eo-cYmX%DwtYiviB~vh~f5vN+K#RtY9*Qdt41t6H2RUGfRE83Y z14H0Yo;ld{w?=Qiq@rR7R8^UZrZK!oaxdCX#LM4u4f!;~j~+@XN`^ogEGUI1--I3v z3X%fjFISX{-#64DlJ1O?Ic0vo!P8q?%<_mCXXpIS*@8T z`8-N@&E_!UO~~U?upnskoiv1CwDhpnncvO~f%^=R(odwNABeO-peU`jSU`ri^G~D% z;;`S@*~2-}V0K~2fZ}p08-|e062U2@uD-lM4doRFhQQ$m=8!^Dsi3GB0@XS}l~PmT zv}h^}p{X#HeN%D7e+%;`8U$lgvB|&?nhNu^Zz_)X?&Q*@&{XKN1HCdCLTUHgsOZ6v zQw9MLO%L>uf=)E1_}`1AKUQjWswH>>iE$^6~&Dq z&|m`Iq=h2|n%^~X>l~b9O2Sxt7*qri+6I>kZR5E}3;Z+u=pj&XWe8lch`>;;SK`*0z6BEb(D?`CD5jmngO^~F zI3Fis!H+Purj`L8DX{bmA)mhlV?UV$I&=}llvYb6Aj2bklpkRaXXmfjan`E`-G&S` zR4xo57qeiL(i4n@J~9L=4h(^V7jsDA39hNA7y?yBL6y=I%xR%LhEPjPW&Z>_;-8)Q z6Agm#3AV|=5T0P>8%Gsm?Cc%!&BLWl;R&v#O3M&R>t~}%<_Z2xQ85In;({vW=dq$l zLy2h-r7c($H-^BCtXX5bts-un13qFp1mE>@n{8psLJLuOFoZk;Mas@H71}J;&9GC5 zt@x5ohqwgNys4O6Xv7n!kbR=xaVgG+~$jven^Udx?3htlvZ0I zAY0x2{NcLOlMpdO#6epn*rY7+R*{AhCz80Cl9(ZI+aOZn0f0-BwuP)I=93*FkkT8ESaj5iD_O6zQzu%hJm7$DkVe6nVRN~yRdIGUPSNH8sUE^rCJZ5y!h(;H!syLLC<=x^QIaWA==<9#DuzH+mZ|XG z)-9M|T`ENF6$L|}z$d!NH-Qd{f+0{;Pmv;0Q7{AwtDyL_3ZyQTLs^n(g)E>M(KYbBshtH4ew6NZq<=Yo&@3O2nnq5tV~)L=ZC51~L!kJQDGa@i zaeYlUMZpj#hTHPc4X=uXm7%+$UCoN(&c`7T$ujMSX+#BGW*y3Ahlh&Ca z5g^l#N~Y}svb8=oO5Dn7&)`sr!3Z-AMtEpx8}VSouR0qT670%|P8-Q8NVU1A>5{<_Z+taj zTbUsFlFoH*iF07S;F%d3(}N?vr@6#-?XRmOp*U8Rlp*BwGgBF!zJdmdK8k`NP+T$O zmVZEiO$cav0Fc5;DfZFDqJ7r~Dn`l%8#gc84CiLf4)o@@k3 zfjdqISr|gOnF6VL(j|i<-q^z5)`lcsl-8ENEeGZcp2H;4(l4P<@?M)IY4QWA>`)E5@n^C z<$bjJx`PKjCBSQ%q=fc3J)RAQV6`$OQk|qr21j`muxXU?K#;tV6H}nJ7(#x`8+?s( z_KtYd8MlTuDfvR9oH}t1dTFUo!!ai^IO6Ls_&ODH(~8mC(M->hoHQ6E$tWJEG|CWi zD=#Qhww{7T8Za_iPlFUUhQO_=Na=^92$1?SfugipZ2{TdUuUV@9~gwvlMpdO$fK@c zV{auIXZi;#$ru7vW2VAel3I*DsSr+oXm#+Thc6T*L!fLaD8+j&mV0DLfqyw2+5JsWe8>I=8(#0 z(+yEn41uZ_Q#qJ)8EMEbPEj%h%6?3l+D%JM^ZKd%J+7sS=JixX4V3YUk|CjWL7Cgz zMe}|}eSrS%kW{D*PK(-L2))4a7=l*DiOhN+wwLQZo9vky@YSCkBaaRF|&X+im+}bC} z4clxLrr?2|JISH*15vKT@vg2b+We;~#R2S^1+C_Bm zjfjbf7~tD8vY&7F$ex{IJKIwyx<@lPOHBBar8}bFben8I`aeY~6#lt@(5(J)sIubK zf|`*?VM3%Z5-E&D3ZyTa0|SYS4yYzVJn*)FFMM%_-ozM?^?i{I{y8UvHvSJ-W!Rm* zpiYttYDtEaa(SY1IgxBGs(zE?B6C2TQZBDlE{8=fbV_jv+BVELHY&=udsNR(TJKo; z^1GAm-pKeva6i>Vt`l=^pxBDRiI=Pj$d{P>A)pU&OZ5NLk7SK){}b12A~p_g7Awx1 z1TE@|A=EfSz6v7Xqr*DI8M{!hI_?VyoF53tmmnNakh09D6sJ7YAemEM0e!SE{~smX zqqI>t9N*Zv^B=C4VQNk_5dKP7EmBTv=0&K)Jo8MfonjJv%s|=NE1*v z0VV;VYjY7$G(oNc>Q9iHfZ_;BC7{s+xeI6lLG=2dJZ2E&A)xsL(V7s#EhQ+efL0Tf zUO<}(@)6K3g0cwc5J8y*bdn$(kmw}VuVxp}HNw$nHH5oOP!0hRkZic7bZFn|lO_2d z_~TC{RXI@tFUqsLfHD(QSwOx7vCMu7Dyg9I3JO$^RY46D)Ivew3hGQy1(8QIK@|l= zz(;y|(Of`i8Z87APEbn$ z{i{ub82wvAkrcJjO~~v^Ikp!Nv=Jd7XrrBgpp6a!3M7cW6{Q9QZFCe6w9!dG&_-tg zg%i|8K>uypsF^pjm1J{Uy^>dfS`?;0)jSX2?*MlBcMQn<_ZYfm?t1;W4?f(jRgVp~|bt)th@4k5QMNxe}((CsP#LAUD#1l?{BP#{5@1O(kK z6%cg0OhC}>_W}whXt{u(TWsLwBtDq>K|uWpw^BfH1g#d(XoA)XD1UFwm#!{7J4E)^ zy3orlg0`sAJsz!ZL`;{6cHJZC@7S^d#P!30im$Olg?eg6uYZ&HI1`RKS(17%asoxm zME}ZEZIWQ68y6^(7-E|n$GIBwFeFO^B5!swA#FP)ErtVZ((1D`f)W&wiT)L6!%t`N zFDX~E$uDI|Nq(EN%W_B>1M4Ipq+wSa^7mBoV_?E2zYXG#_IoAzHwjZ6L0?M|50ryT z=f;yZfAk-lSEIw3+J!!+e-jNQAXCy@ya~-my zKN5unA{AlQU)t6SMRQc?jI1$D$l`B)V!5jjHz-wOyTz{rZR9E75PTCUL`Dkc`4 zZD>^cZVt=gf^I&B4&LZ?(v78nI(fh7%iCKn*hevuyvdPqPhC`7c{hS zlL66@!I2%i^z4F7H9x8zk2qv^JP9_X;<1=09*g<0#XBo>jAih4^xC@O}092YgT zapM6!KB`Q29P+rI1e;QsST>Z2W&7ANJrTK}OwR>`GGV|dxiW?52A;!$ITNuAX!@@l zGLk9&693{sv=vo~ol;R*WE7P}mNb&DqZraS(T_>Y?_g0K8;fYdG0`$QLl%(= zW#-c3#c8W**;rDlYAyvz&!za-(&rL6qgCe-5Lz|Hx{T!@6a~CELmM~j6WJ#+#inhf zBt}|(huj29!;hax1r2ax|8xy-NuU8P$;WD-xX2kAC?z0h0OMQ6auA9FYoKv#MEh=^ zqybv1>3|#awEdP7ss0rWa7my6F3HDgpo+*D8VD2+G=MR!w0f#R>NG}61(4rl3ktyus-Xb-4@aq9xBEKHM%l3MZa;5Zo z;4(oMT&9oJ#Q-4#bTL>!&; zGDc3UZ%@Swkd0RW<>POsr{rGIMy`;rgyIRv#uJS{za3A*o6g8a)SYMXdS45-cMp$Z}c90?5V(pURg?S|&$p$BZn6zON~sfNVS+Ju`{k(1|#4 zIm@VW0Z35k;XtNJiU%O( zQCrK9VdU>`hP2pPvHHx^QMLNa^4*8`Sa8KQp%Hz%^zPgyq$jy$zKx?J+DEqOUpAmk zqsZ=&G{Q+x-`=Ilwh3w6BDhZR=nn0)$9XUN4@;N7h(}n5gl@Ix?zT)@IPG-4CnFBL zt1oaLkgZwA%Mf7Vk*DbDH(A9e5 zBbPmFvwH8VBJ~DuPuI0nr>reYWY~8l{pJ%@D`i|ez24G%-Qz}F>N;WV^mVh_^xm>~ z%*2u%S8oW6clCd;rIu-B*V~mAHe55Y&aG4X+Z2o|{9;OxZn!AkXz}T5C8DBC)->+(!_Sp{U@3NQovB*9^SW#<^8Xs6-yXU>>Qu*u zPh8F4bWOWs$JB(aFYn|UySY&Ax$|F5tuxB|Y1JRTv!pMY=gQAF=dJH<$+#1?Yvmd+g_IcS^6<*f4-@qrq z>i1pQqZ>EA>F3}4=g({O-RNPxl)d21$2n_Wsw?k3d#&8s<^1Q@+dSRBV8Xt_L$>9< zl|Nm*TD^kypXgh-QUA_))&)l`edgA8-gvFro4=;kx_^A}sUB5EG~AoL%jlS#%U(ZN z=hJxKk(s7;U(Os@Bi+Q%zt%?N(JHk!y*f0$T>jYw+(wPaTeVP`*l+ju(M-1kZ@)F4 z?Dl8h#)B(VGIiL#b5?`LS8nVc8dK`HY5(=>3ELK4d|GPB*DJjnKFqwMNr|mao!8tc z^)_Hop4r7(me}gGzWTyvgB!l6c%<#ZCU3_6_AqGrxP8MyJs!D6EZ31>XO>Yk0S*=CM|BKcin&X>R2mR&!^bHp_l`H*yYI$Gc$nOV_Ke}*6 z-cRlsnax@x_URh$_02jiJ3s4egE4E?ox1mW&u>?UdY7r1smHjYqn;mGl0)9VHfK)z z?e01k<^7Ff%fD*cB}4K48&_BRds17i_NnES6OKP#An!|8Shl$9pNA^mxYi;rI_HcW z)ru4?^s-(2>qR4K)OlAYBu$G>>w9!`Tf1fYyAgZ4$IqWI>fE;r{oQ?MNxfEj5mCBOQM)5n1AzTj}w6Y8L2qU;h8~{5fYgZ9I12f#1?)bEfs*B=M5&>ej4YQ(9ff z6ga})s`}ctDC4-O>J0{@zrFhGnEK;VKiK$p|5|e`Efc(_#MInAJ$1J)E|f0+ zAgIy7<5`;b$u#}qPS3)%E0!_Jj%HT6pC?sszZ zdNQcd`?GQBO7+`yf+FCB?j#@|Gw;Kj+Hxxmuqn&b7+MH6H2cbu=I!f z6GQX7oKbY=MgQ(OW*7Ty{pyByMqOAo+hu09I!k)ayg%T`l{zub0ci()(ebZ3`F}cp zZEv|RHs5}{)OT8!vRT@M-p*0)`0iP?@_lo*Vy~B4TAzTm^1e@+<~0__?tUxpqkg!$ zdQJbHn>HS~fB*67FJtp|G!^|hAj4-)M?O2*fBo=m#|AY$YzhAL%WMH@LOgEv7&q(J z7uB}4^Zjn`i@^A9Zw=fBjnx+Rx1Me1y*vj{>zXZ;x{sSny%{C&lWd(e^gV zzoPw%Uak7nS)P0Gx3TM_9|FKk&*Vj#D>p!^ccJy?Q>C+E(8lNkugEnK(j74{!9ozoZ$UIlJ=PiBcuMXq6D{fe>h;6T@oZnEPagSxD3^yN?tbcUA*X#0CFQ#$L7}TI@`;m38+&(ke)bFz+ z#~WR%Fy6b$Z@=`3&+4mnc;Z|tpkd*!-|hFjKdQad=YZ?I9xtf%)3MzFOHn=Q~fG*<)tCdhII|yX&{>@u(e*XY}~`%7FsI*Y>+{Gj9Ko*kAL!xxDB> zK-AT5Cw|d$_h+-;Rvmj{&D3{;e~g{I|I7Sa3O+3NYrkJgY&l-8wny;3XPZi<>bv4x zhp3&s)BA)@cIw_~V$Gn9udlR`_4nNmsWUgq)4JQl5t#~I-Z)@e^)53X9ZKKBRsKJs z<%LseU#?1ZyLRKB7Pt9k@P_UIJ5Mh6`g82l_)04;H9xUuSVZ`&@0vt($X}}TvdEH4 zPZk=mXzTXiW!}DZ)BTh$qRhO0UX4~pgnP>VAV-bZOsQ%V>0SG9%|bo8pWhkvrrgtZ z6@p&N=YQ$3IX`xq-KDX-_q|%WL*F5}Ps;l|PtJVXch^_bMtt6S;nI!gkEiSU+k-z+ zrJr-W+So>OOzqm=|MSJPX?+(SxVyrqd}N+x>m~m3`-ykGef(zFvC8@7e9Oa z*Q1Yy4(Z+Kr9FPcx4Zu8Jjm?_iT58{@?!H|yN|4@&}>TZp&HF^*YEnS*Noe@hZHKj zz0=HxEr-p>TF(DLKy&{|zg-BpmFH*q|Av^nVIGg`y!mb6!iK-yId#*c>aC5ZOkOQz zzxQI$z*^UuRmv~#uPnNJWXg$_&E@^DL6&iUHm!3+-oJ9~bgN^~h&uBA^{CFi1@l+G zF?CRt?W?-PTxfLa{n@W}d7SAxWMPT&@ezf7Pt~{ZyG@_wjKDYLZ?dk zi{@@x{p^&XV|p*S{`KH&t@CV-49eVo*%9|8^IjD#@My=3I6hrpWUXN%Mm+t-}#DV zT$XKKe4_KJ+*x}@HQc-5^!W462i&gazaG*x$CK}J_NwWdwYSuF^>O2~5AE!8FaPxL zS!M6#Tr|Nty;k}CKfM^<)wx}twAl`h{-W=;7w1;}IIhb z>Up!8=k0NGoV>5#w9?~7rYha*Ok46g_tSfq8Z6DVeb|8tdFB0$zdVW!OE><4yq`UB zNy!Df`&HQ#KCN<#HH8niZrQ~2>&3J`%KJSN^8Q_Q*u?_!zM83F=&}_ft@8fKn^cWn zy6(|tJt!ME?U%7>J8dp7|K^l~A@Y9p(WP^i<;e6{-WOPZEuh|mqTA$spC<2)jGx}; zP5zK+k1n>a)?{g=iSrKZOykw@^FimkN2f`D?)$^vAE@RxTi%yRQ#bRP%6_kF=5Al` z?TKGEL|xn5YTbaavu`&?7Y<*%FW_)cuT95NkIOLZRqlX!8S-}j>Sp-;!OeTWvZQyP zUFuBJ=k@`7CST~8vsae7RcgI$Skw{u|9#hkX$lM~_RXjMf3f?f z`6uf##!E@KA+270j4tvM#YhBjAS=$*em#sTL z`v)m+=K20b`Y&+}&K%QZ)~n!(PpkZKwD5v+GbT4*)I4L6ghiZ^{f_-zW89*Qt(h)2K>Q+Fz9SJ0`teTdT_AAep|zqK6)tp8VQK>Z|e9 zqtynb-ttJ^$GlrRwAZRKeS@-JdNG@d~-x!=J;>$HsFV0g3tm`~?!CvdigWjnxj@dG%ZHG2b zZg*=c^O5C{^(ym~_f;A+YEy4viQsB~uUPspxR__{&3pZ;mYO{HQrCnD!!oBHpD?n- z<+(4nN1e;?s^aA-H(sn-T-5SY&)U^02TkhJBE3(o_dCn}Jhc1sw)w|zJymna?Od|m z#audgszbk#ZUZZCc$0J2vlW>RZ(4Tb@ZAjqn_akHp-S=7KV};_u3oOeyE;CdIWKsv z*Yl-^BEN1}{Cw4WUODm?tDJ9+{e889duOIjIyz?E zhESizgnNVntnphgR2`s|lNYBpV*<&J&&MMFG#Ouut{?bI=y zhfjWZq@b*atv_^|y{Y!majTAJdy#2Qv(&{e=h+xBeB&jlw-L4H&6{I6)AY>J3r+Xe z^u8tO^1dq;yLa}+TwSyO*8B0*sl_Yg-uU+CKW=6#m$BHsmbt$ReV&Aqu(^FcRZWq|7K0Bf3D`IPf9w;e`a)+YsbGY^-}U*K3e!*Y-?mviukFG9maQwYjeUMG=l0qs)@1s%pS(B4dJM0+WmR#h zC;5CIc-!}v$s>I_G*9DO;X$@93oQAyUCwN)y7kGMrCZli%Tvvn{=<&CcMk`j>~iw(pD}~p|2p>e@x}K>Rmduz zkChi<_rykhn{!F(_YYV6db#kGl~d3f=z6O`Pi8gv zdFu8FL5EJ}PoE|tcfC{sO;HI_v5~OQ+dzawH~GVypDKr_rb+E zl@1rJcByBLS>2Z2$o}=YLuInfESa%MuemwW+_b#XzI#5f=@e7O$OZ}LD?I8Z+l{>* z2V5@r+s-U2>dNQ5YbDExdsWgNm3ljuf0E0ZlMPJ&svJ`9A|870Va-V4ukY-OF^Fb+hn+rMO)}>ywMfUr94v!mM zc}uT1_U{Leugq8fJnlZ_-J=ekJI6e0cc%5eowL{fy-w;^_Fwk*b(b$`TB+yhADjpG z7+<3JkWhR5hL#TLwSHoS)EUjIxY1$Y*yFD+QaBkvRy8kaB<=An=yl>9_9N@-pll|-IjB? z6`Sh21LHhbHGP-Ev)v{6ez7mt=;^mNt$4ZXt;|Q-5At623-@8-@Cb;DKquyvJSHT#UvQ4f17n^)A3f>pi)|HNR+w@4+`iPaS5@MbPS-+XHAWwL!u&4cY7Pub$Fz~x3mZe_HZ?ztHbzJ-O`?|I7 zUF%8H>sMBF(P z-mT`H-Bw|L%io?Y`=Zx@lM8(QX}ghnly-wqV;X$TulZTcs+G2l(;G=aV{q~VAFWdPqUMBBlJCb(y(&shb?`t~V z#rf3jc7G0>K63EG1ru`~{%P)%5mCWAw*R=}e7axHc3D0*c74MiFU9TsYdQJuS_kre?RDt5`ha{BTT=PKisfk!}1wUHh+EgkL`PRU3|ZHe(N*x z`H=5rSx#w>$@V9oFPaV&Va|kcCpNBab|q)`SwA#cV0|d>Wo!zMsx;(|bxg&}fB9s; zaCqNO&YoH84lg_TvraE#zN%95*yS&RiVU`Vzq0k}sGXKEeqJ|z`u*IBkPUTT^jL2B zw(GdG^8d~I8~QaHeLnSs#z(shZ8+)Yq5;QqJgGG7>z)Cgv)`{9I78ms$5M`Be|=Xv zKDyRHdEfK$yr|iSi(ZlGht-arwXku$9R)j14*6#;|l&Dy3 zR@3KKhj-jsuVdF-<32kXIwZ2>7ya*^nzEr?_g_T(ql8wXO}XXAa#nt#;Jg zpMP8TMfUH!w|Td5F5o{q&;5#5M+N=9KEwS%k2a+8Ute|ii5g{AyJVIB=Wo^OV!q?w zpS|+g;k93GKBMJnd+g735or#||3~HRRd-yO%0W`!r>5PScgtnDul&E-gSZ>crcx!6 z$rvm~%Bu|kCmv4_MHoW_X@+~#ZWpU-1*8Csh*EG9d$g@UH z=aQ38mgCj6@KX`D54Zmizi2Jwmoy^=t@%*8EuN=J)+qDkHy=vpSF={Ogqqh!e@MO& zH%bp*F!aIL52dSE$UM_KU_zr0>Cg9Wmo0nF=E(k`bSE!Y-ajhcY3qm5RcQSvjmPc4 zUp|y>`2S(=I^d(Iw)d_PRwN_})nS9oigqS~A?l*A<+<^KU;t_s3D?{U2|6+%FUFjl6cvD-|B}$;?+mAbE9pB{&~mummJscmF%4U&#e37+m9yXx7gwMacy&kFM0ot z32#04({@)> zcKeb?J}Oz>IpdfwpRBlLpNk%Oa$J)?hxIx4kF{I>>xBJ3?fb%$XEa~+`{Qe>j^5$( zZQhuz$I0B1%86C&%SuN~+B}R;V9E&Pj*S-Aw$I9%8xGH8%jC-P_7h9#C%MYfzO)+d ze4ZRdFL(z^M%aDhm-5}dG&*L|xXhvW7v8|15iUIkp0=-c@@M<%(&E};^#|TjnGx2v z`U{w05r%f*)4WI-S)ul|(W$kW6Y+tlgv|(7@%|H+4|z}NyYax|zd-9b5Ze|hur&&y z&Gmy%Y|99v4yxWYb@P{fKk$S!z%&6r&EOku@Mbvpbp7C6s~KT@Mje)|{L%a1(ZBf3 zjb}^3yaVR#;TvvEJU?)oljG;`VH4qj*Rg)!Rw2N&gMhW4rk)?TofI(moHneBmid_z zd_UU|<`*am-V=%2)}9|MaYpzo_(VT9ZnaYf-w(cLJ0rXj;=wyoack!J!5YX2m*Xe= z`|j&iSNndpBh1zi&+hOIw{1N?SmKOufB3|#TygcCkaBDxZl3Xt6B*(8VAlEB-t&WZ zaAky{FvNcG;)O-NAAGuOMz|07!EEBz!t=8eSTn-c!6&w)=(VRV@cryen2Vv{x?DRs zex|}+mAMT3Z4bp$Jm=)geatSfHzSOh#1ilO&HEEvjOrJy2!qdV$2=FUJNR@zo?QuZ z3^>8ohFdEq9_6PsSZ#eZyRqyA-w(c;CnMYfgmj);dw#IQ8R5g>6JvgV=bE;@AG|9# zBaCl!#ah8_ch657ux5k{;1lcp!`-s3@crybnCF~wwekGyMVM~v=hpcjLe*hpZu@}{ zLCek0UY;MkJ2oR+$bJrAcsqm@>t}DmU^~=#&h-3X&&voWjtB2jmGSK3`N6w2Gr~on zg(J}^51g~mj|cCX%m|+W!;pSWS3Ad#YKQw1Mz^um&88maV-66Q>l(G`;A0LHnC@Hr zlGn{S z7|+QUKeXQWlS7#4j-SIlKe>d#JY#9*-dhg8hKMa!9%063*tgi`dVcZ=gS`ydomwpl zm?snv<_7Si+fTmd2S*;5lfWmItII{#RjY4q`{_xTH{nzJDfImGA`G@7Y(ICNen30F zT)hc{LORdAJU@L1b02)-tm3hs&mQ5&1BY0Mxjz(Kx5GZ3pT30o0X{LFF&nx<=f)Dc zt_IA@cj%;;TvxKJwF4%nh|~+V#aZ5 z&}qHlU>@sd5MgS!!Z_46(DO5xFz5s8eZ}TawDt3R1YtgePmCG2!JeNXV9f|8_A`_) zYvEJZ`w-91Fv9E(pBT@Dg%3CP zgmLpT!Se%$5UBUWd9EPLi}0!IYoh0;G6g?XgmL4k^!%J4{9N_xZ{Rq#-r+Caocl^=Vww1exNBpJli_`Vv^@)N(z2(6v_zy0iU{D zQ#?P@2vdlk@UL<0&ae38I*~9fARawtPV@Ynl!Bk>glX;gImz>LGGS)HC)U!21!raY z$EH&VgX35W_=elbo}U?D%?M+gM?a^G-vTNJ2x1(Y34g1#6g+0&HpBCCDp)hZJAo6N z19bRnr`vo#rx6C}9rcktsmpD=FOXM6EnAhfV9T#VA1Ll~Tm<96jO zceU}g=E5F0#z8!~U(9i|l%IKo!J5U)MVlPg)c12CVdev1Tlj|CJkQTXV9f|GqP_53 zsW~P2zMqQ;gZ)AumoM`CTtXN;%0sn=e!p@SbZ(5yJ-%N`7&o3vJU=kShj_G3$>VQ) z?vrV2iByI}9fyZC=hm~POR z+rc;7uJQa_3)YNqHv1X=SjP9hpX&(Y`nlHgb3I{TqEDq6*L^Z{xY%;tKp6LUalPl~ zM#8j&PuzYx_L&X7pPOKhT64gDirbBzpPRv&5#EvZ!UHguE`P-La|>bIcy9Lm{EIL; zp6n}n^zr@NN|+u{TpiE9JU=k3Lp*T8K--nm4}8`4gS{^!`~`e!Keu^)ZYK=3cg*gA zf4v9&0(+XSM#uY2 z)BT?J{X9;X55W%vOWR|fpC<^D*w2%MX$N`M@jT)Ac`5}zs|fRn6VFqgpQj0<$FT#l zZ{NeO_h(c*;79kbr#(N<5=Pfo?{~U>>gVSZQD{OQND znlNtvdfxN%0$~Q>C;VHy@)PK%Pyo@tUL?#aFzbH$g6HQY!t{VojOVA4x98;WV&3hd4Ap? z42}or=j_YcjPm_p56uWepr*dw@cgVHOkzK85#|%e&l=Cq+bQ^Y$Mf^H=jUC*Bp#pN zBTO48xb9!?dVby~OlSDS?ZM5e&QzIlkArJr51i+MpY0I@+xwoMbzsd1e+G4dWAy8z z-#f|A^9O{P37xAye8X*>=Vv`wGr}F&&xXC`jQ0I}NSH;?x!S`w+}3-3J_2h-IE(he zwaENG0**Ty2!s7X=jS8O&&PyGoM)`@jPP3UqsPOKJwGr^0A?%r#O>eH&uQi7`7_uf z$LCKyKc5rkR?g2szhpr&;1AK?zaUH_$a5il!|ij=&zE3TYo}OWU54hskQVC)h7!Qs z>E!uK&(GI{=>ng)t!~)_BxC)21AAcI2FyCoUweMOCCq;41UC3}QE%VRcd!Sp3xgl* zhq!&~`GILSV0HlvmaAfEhoAjCV^7Zr{{rn z2wJ+{fAsu-JZKGoPh{tR7uwY?*Dr)Q+sV(*o}XU{Q^0;!c3cIG7YHJr-w5+CnDu!0 ztLNu;!XzH&{~(Mz&j0TDfx{J)EAcr0Z^F3a{GXnmzX+3foX3Kydm(hW{_^~U3DXF? z;dbx0{h{h&>uWQ@K!-8oe3)i%?))%=Fh>FgzJw-6-`d~LGraN-;u#H}y57}H(Dk#q z@H6YP<#0elkM6j-h398;FP_GPfv!y3F@49a^vl(RFz&ivW6#f)glWruetErWhVQ2- zVTQq{?q6GaezqdaS>Ok=d(z&Y!2u0SqFh@O<{kKK!FpSHezq}w5Yq069s&Km8DTzz z4%nLgY~%T9P8dBOJ9O=Xr~Bo?Gp39%&N^Tyqpi8;XFI}l;Qd{uZ+*94uI&kf-gG-*WAFf(CL$mFU!V9^Mk9M8DSmI1K)lI2YfJzez6x}s+@TC^!&6XOyYPl3FF4o*7LJBVcJ3j@FjHG zZrAql{ph%n758dx_DTt{k87@SS%cnIZ=luK-o&_lYlW0HP2!rbY`gqaR^MhCUGs0bgiP@d> z_Sy@5KZg+J5BSvc%`+@Ttp{?`h%4lM!}v=wg&s&lI$J5ymZ7 zPfx42r{!XlRv*IPu@b(7%1e%c5f;C>V-((W)tjCuAo}Yn)NgU50!W;viI-Y@^ADn5}G4u9$ z=RD!Za|B`Bxx`@4&k(}sW0P8229qe)P{QDhLdP@2^MfG>Izf}f*3KchT9SexoTEBF%H>Y%$}*u!sbdp?#hZu>dL z^K%?w;DAKzTT2g}<@<>c#+?Hk=lK~;7+qg#jszwVPcdOW1gmb(qdh-k2y-!DaO-#L zm>NHx62c5~#?>*NpHjjkjwkBHQ|kE{OBh^}fiIyaj(zY||JXf_FxW!$Ty(7GXFOqa zJi+~jV< z^D~(+Fd?RxA6t17EC_)~)YlZkYz?0}hm$=&Qwf7>u*kmb@tjN;9I14_ znC|&Gg)nepMt&x3an#PfpBaR~8HLWzDW0F1gy{u-aQkzM`EY0jlgQ7ho}ZbXpVJ7V zb>^J@_-DSK(+SfCJ~i$%&(9fzX$ha$W2UrueXZ~3Ou|fsPO%SQa67~Ea~5Ir+QrIc zEhBz?%_0o0@aTBX^8B1l7_BpU%(7qnc+MdVW>U}V&i4GAOBfggsa$3E=^2&V4$mXZ zoltPSCUdUmXEtH3r&7ZU&~AST7Wu#=>g#;M%yin}Y|qaHgwbPE@Ns7jVQ@wPU6r;A zJU?>@vw-(6`QeQ_{CMUO#*JsL=jTGgEQ3$@FEr|__uBe?E+R}L804}4;C7+s=VHR> z_FVGTH@EnHE+NdT@TvRz#h#x_2_y4^Ez+&8%Ls!bu+Gn=o}bGJvj;^B_dcDp8&rI( zpDPH1M>^f#FZcXhDg3nP{_aD*pQ{Li8PIE|S9*Tt69$q?d0v{g_c-6r)r3KSF4ug| z&jP~e`~)ADuOZA@(1I$XZGq=!Az`q+!F>dENNj$tRT%ix{dA${=Q_gZHMFZ{ zPT0lwb3I|){&uxTR>iD_U^Rp-gKerQRy5nb&=Vvit zPR6Q+t!a;I0UcZKcM#@m7{qmc7JGi~Ou^4xgjwYHxzqErBn3Zr6K1XBXNl)$DPe}I zVukK|ap-}5x$Yqh&Np=bTI%_^Hw8a9TEhLkj-PuyKd7R9zlf@fDCkeA1V6a!6IpfC1d_PYS z=3&Rrlb)YdDfoGsFiRajt2{r?5C&I5aExwt%*QwR@jOeIZZHyb0t{}?cz&K!7$_8u zt65XG?Cbk^o-qBPG504gq0n=lpVfrP0za6;fme)x^8(D2dwhR^Fn_>7=WzD3+Vk@w zVfq0Tk4<;%zM`Y==Ow~i3W4V<0~hi}Bqz+J>I1 zqpk@p@V@&pjR+AdQd3)9Rx+_lSrG$OKojJW#Q*w zfHDTXBlH2A+8b7eDom)xSoUHI##|PDG0;yQV>%etShfr{mh;$>Wh~3sGRauhu|;XU z9;meySaEwitjpe!El(QDNVcppmJ`^LYqXZLTPF<|M-!C0L&ZvZgcU z;INMQVz$gTmc?voZY|GV+L1XE}3vIU;%kg;W6}CIW+E2yqWC)#LwC1u!9aFMk zlnpD0^SQ*qsFD9o&+-Rbb~m2)dq!U@7)uOl!l+VM||Q8OfI8!#ZPUv1OsL+{>1ijb+fDA=;K2%TsJwX)HN= zDa=jAa!^}kS!^tyvL$NbX`HDrs&;w@mTPau^fIi&*fQRDjOj>a;AEiW0?*=+gUSXQ!Swqbq3mOYGR z+kHZ`^*5F*wv0BGVQiUTJWpbaD(R@el3vP~HHP&9TXKwNcqJ-rBaEdpTlO)mRnR>9o9BV9%vXrHbu@tc7Mq{aD%f80* zm2BC;SXQy+1;g4rTY3J~SPI#4u3??TmfehHFo;$Hc)hW)w z!wTYjj%G}zVV%jAe;LaSY&jsTd-tPk+1Xguv*i`T+5uJ)aQo9(da~t$u=Z2QmOYK- z61EI9mb=+9##mls%hAU3m`)+uCK}7BY*A&uFtF?k8Ix~3zrdD}#Sbd5$gL z8p{`KImNJ=bW;IdY%Fcr($!cFXUja}=Sa3(WGvNexzMoYvgK)mS;3Z*jpakOJYXzM zx~q5|GL{3`(%pDImMue!q-SSGOLKx4UzEhCNP%f5P7%@F#(p7@cTVGnE!v%yK5gvsnl%6D!rjgTWPB zYNEBuud=`@XpEoC{sX!Hc|)##nd%G!esNI5>^x$lg-nF z5dL3bwChRQLdU!|@Ymy7osU(Hg)rLz=1C7@EC#d6!x&2k4Ei|umka+Wo{l;~W9f{T zBf!Tq+D{iUDA`ZMH@l~YtP0q-?OyPER&7xwS|vxq0lATV&a*u z{TS9{Z84as+LE2k`t7uz4&Asd4Ad5*wM<(~%v)+dM(cfzF_uTPB|8gjp8;c?wXl|B z0nDv{`P{=8i}8&2T~G}g%jMeA9UE&$_-noOL#@NH5as~DT;pMk#gsimc_6wT6=WQw?3MEgf{P#AK?Lpws%jwq$qY*0I`XX-C-3h-D&NqAl57p)RnNM;Jd{xh{;Q zqgKy1nC=|(bHxv?FEhLpfSH{OK06$ z&ebd&0BGAyTTHq7YKzIwaoS=qW!iJLPHU#Nn3!MjEPrZCXU)Q~L$-~9o@JtD>5xPD z8l&CNeZI2QZKpA&6xb68V^}|Hi)nQ@ZpwH{G{%&4CvEAV8wXBF6-$RWLt9K;oMAlc z+POkwjQS}Cqdj*u77d!GS)I5+g)Y*T?z&(X8kWYKtT8%38t*7(Gp^z;X*p5*p?MVS z4*jSxI-F3kXW2@#OvYAdOlMv8X4=wGJ8I%tnrcf|EZ0NuZ);=G`7sunvz5dCZ8fHg zu6SeVp!3s6W2iUbN#Yj9qT^AP_EYVfHQs`9skZ|FIP`4a*URnQ5zYFe4W7k`m{9vF z%X*tw7$=^W&HcK66U%DDEW(6bt#^opIl=AvTh{!bo=lE^WiyK~LhD_j6&m)*Q?)-~0Ka_MW0IPlrxp7GZ?e`-Vm3dg8tbmh~@Y5k_dO^~$B5B#+83FpDrk zYn{;Q&}+=gmh}s>2qU!c4hZ!N5nZktQ?51x&=#V*BxHT9H!NK)%j(T6!U(Moy>h81 z+oJ})VFWkAh;n@-w6I*3buF_9BeXUc7J9|{nqeM7@_qIv0A85LeC64=p%LK9vWU?7GZ?ew?YfYD9g$kteg=>Xnkk2 zutoiKLjTh(Yc8`0BecF3TK&&l^{i!m$1K7KtsjVmBROhK-+b4*ENj>iDnh~ttsjL} zuYtEsv#fiWMHr#=lPK5FJ+FDnvRV#NT7(f=KMSpwJDu^6Wu3?@!U(NjOu66$Db(oT zZLU>MfJc>gm_-<&^{dd@rEPYZW&O@9!U(P3h_yL*hA*K3Q#xE>S-T8HMYz)qF@p6w zu`uhnt?FF3Th~>I*r*#F>Oq)NNS%eYg`jc2&0|WJTe(sIiEo%m| z2qU!qO{^_hYh~LNA6wRS%p#0n{Y5N1%EOn?@q7I8on@_J7GVSni(`M)d+3C=t1RmW zW)ViP!o+g3agxbKt6?Ay8(~B?HY1js4a+KI7GZ=I-sPvBVFF)5m<`LC$SlGLRwH7$ z*|02VCbSVour?=_ZX1{l%X*esgb}PQh~>_0)RQ7mLhz?z0SvwC` z5fVmdHSx66FK7_og;|6VT3ZUOd!oNiv8<8IB8<>#>S?twwLFbkgb`X>2`!wnS=Qyu zB8<@5npij<;&$_?gT7R6;KIM|WfozC);2=xx;HwUVp(gLMHr#g%+tEWlx1y*TPOv530*O3iyzyW`r7kIES*|Il=I%5g;w>;H_o-JzRV(w(87Dg?P#;2 z&3@f2tD0Ga5v*N^wIjrVXJUUmxn{CuUCk`Q2v#d%HOBB^JMEffA6wRHW)ViPb|se1 z#^fWqZ>ioLgFb#`7GXr@@j1Qf+yO_o4@cINS=R0&kqf^KMU2qejacpx*0S=MMHs=_ zomiL&+zJ~_n`v2P%p#0n?Ln-Tz`*0zadR4`t zEW!w_gNUWi0&YL#vm(pd0T)eSBaG0(YZx|%XLYVV!?GqYi!eg#U}EX|+GF+X-PH3% zQR6XY5k_d?@0hF>p3z&@Hh3WtHo^$4Y+~v9${hG*AIloSEW!w_4npgKhko4MvaV$o zVT4vkV(I#tzhV0;Eb9wq5k_d?^&4BRW?!xiTUJ+G&WDXKLaQ^ebbYPjpghmtY?@-7@>72v2;6p=&d`$>N&s|Tccw9gy(%BMridA zTKh*j-)>nwm_-<&b(qlV|HF^1uQA7z8fFnjXdN!JmQI?mnPn|w7GZ=|j$vU5a23lw zY5q565k_d`8WxT=@Bg+wVp$!=pr=rXFhVPjSZ)s0Gky_W#w@}Jt$d;NLBWqbEbCfk z5k_bg2rbOvwI+veGK(-mt59eiIda>tEvt12#tAb6#0agPhK2hvhw9m?_*aBkgb`Z3 z3`^(GvMys5VT4w1Vqp&9OK8gYsfVj)*PzyFW)Vhc^$}W2x0-U3W$j#wTzG~JVuV%^ zvGf@|&MGY{!YslFR$pS_{4fmv-miHx*RpP97GVUdAF=Sv7q?|AzUpULzcY(4g4Lf` zdbHW?i@Q%#PaZ%Yz3>t!Y=jZn7(gsN`@)%nWu43{!U(N_#L5JZ@Fn!z!u`Xinih38 zvj`)!1_`Y*_v?3%W$io`KjgBUnR;W!hom+_vgnQHWl`EW(Iv3^Q8T=AYi@rdgJ? z<9OtTLWB`o!-?f)!?LC@i!g#Uf>>@lw5)fSMHs<4l32P$y)mWz7naq#Ohrf-!5T@d zHn1Dp{2f1je~5Y#6yg^#i!dS^M-fZ6!(roZI>EBGKOVWE5MhMYC}O$o@NCl#r!b2! zLhERuHK4fUB+FXOEW!w_V~FKu-m>sb>$nj{u#P2`+YT)YpYMblVFc?q6Cv)uy5(7W zTh=?wB8*@~h~>6J_1-S@(YYKyVGKr$$i`@+h3#;9*=-kD)_Ke#jL<43mYWUBTFWfL z2-X;4x$V%hx=o}2Lxd5m5@P9gcyaq1n_1SS%p#0nl@hBBIMwY?JxL5zzG4<(L^h(t z((Q0@|CX0pR__Yr!f1jRp*5CRI9tYT__CKCy~?!1YnVkCp*2ou&7C)Rk!8KhEW!w_ z@t&4?yA~?9s>DxtC$x&tIcqBuT038!bG&7ZWENqB*71ggUh!zI-Xe{EUBWEFh;mIZ zENoGDoyfADWENqBRyncs`r%jdRyDD%4-ij$Fhbqi!ef~Mrb|SYu}}oHJ4e05n8oE>-KGT-`}#H zWfozC)+C`-dd}kcmbFE-Di>jd)?{K~ec{&Z%>`Sjr)}V0dCVe=(3&E&a9z~0ZmB^o z%o-6Rw5A#@%;AO)j{eZHnoS~7h%iEHn$S99%A$8 zMHr!VlF&NnvBQtBtX|U;i!efKIXghgsGsc;gRjgb`XZgw`8}_Iu5;Hk_hZgb`XZ4GR(PM4FDi)tvbboT*rZ z5n87j7S{5rE}g!!tj4D)7GZ?eX~fd2BC{5r^txp|bh=^@MrfTbwE8U^zKdl|J5#X; zBec#SmaebNcS`zMR>xV2MHr!VrqHTb_-L7BeR;NG5k_d8Wmt$9enQ!D_4F$I>*jOu zGZZ3>(3)jfn8WdxJhRZU+Rr9Zh%iFyY+|*6-S8!}^COo|Q*Zr7{L=IB6YlRtjLoE$i@06pJuIYYws8S&Dl05#oDZ zs#t^(T62Zgx}%moVp$uQMHrzq&#=%h_Dc2KIsEIa%kUFcoDn0mE;KCND=q8s%N2_- zLhB-8xxLb|!dEI5VT9JjLJNDPW#wL_ScDN;mk`VCm6kPQzG4wZXk99_uvc2vgI6mS zVT9IYhJ^_1mFn4a_}8Bc@DrX|ix{DGxnb#EX<1t?BvOblLhA~{LIlqAPB87T#kGn> z7@>8gVWHNnV`qge>u_cfMrd6{EVs??ZnVZRi!efKzR((!*Bc(Su(=8>G@n_75n5Lh z3+oHMgq|PQbwGc^dXZU#5n2m`)?B!g(6V3|j5fjut!s#dF@@nD-pyiJ+gztugb}QT z#KQdHR(agK%Pgxsvj`(t*Afdy0Nk*?#+h;rVisXUxvn!TU0;?}!z{uGt?P+}ImB(w zmM!0CZL}_B7GZ?e4MOXOdkSY+)(U13MrhqgEbPnhB{b{jC${NpwBBbHVT9IA#M0y8 zovrpf$+AM%W7P2cOvDJSn~CMtmu0nK7GVVI7Gml8nm_)HK9*I$EW!xZzlf#F6|HFe z)$wMQGL~6{5#_p-Sh`#rhFrhSvgR|3Fhc7#V!1~>%X*1fgb}Po#Bz^%mbK*#Du;v- ztlNpD*D4G8kN&r1^=1}f1Zy#|^ay}gZx@2}*M?K4Gb&FyVMrhq5wD72BS=;?fu?Qoy?j@Fc)U&K6 zw<;E4gw`^lg-1Qh`iohF5nA^d7W&1b-eOZWxXw-~0C*Q7Egb`XR3=6gJsApN%Gm9`nYbCMVBT+A-wTfAU5n2xjt=~pnS72G6 zFpDrk>p^0c=d? zh;ltbEZvuDK6&gc%c^1)VT9JB#L^=h-brX#7c+}6g7p}&aE!v^GTv8dSu2=D7{Pj+ zSeQfHMzpqe>OC2qUys2`#)Iz_M;-7GZ?e)1KDvrd;cpMHr#=jHhK;d)%qAK^UR+ zEV1-z&(pi@GHtdQ0Y)*4Fhc7&p;fu|(M-#_fLVkQTF)C6MuQ{31XHd@m_-<&wc4=s z2w+*CF^e!l>jh$M3p(&6blNYOhpTr*q4M^3;V0Y?j~Jo#qR=WG)ntxk^s4aup7Q(C6P8=n zAxl&?2qUub8nJXw`7QIok1gvoW)Vhcy)Lw{SMFnK`DtbmMrgeuw6IrN)^E%rjL>>h zXko8>&1mg^w<;H5gw`6NwP0BOR+d%DEW!w_w>+)CjMml6B8<>_+taeFHOwN6(0Yeh zZm*ncdS#2Hs$7H-TJH+2$8KtRh-LL*7GZ?edxnL6u~$}_a-GC1!U(PR4NLb*%esMC zgb`Y6iRJc6^`o8^!MzGcs%k7nx zHI-R}5v&i1<@QR;TFxxO2-Zi$a(ks^{lF~3h-_>imfI^WtH-@68-x*B9}~;Xd=Jy2 zPG=Tjgw`iQ3o~z7Pce%yLhDmvxtX`Drpr`>gb}RIh~;M9vIaAYFoN|tvE0mC)_i6W zMzFphmYaFY`hZ!45!v{XSZ?MmtMh%TT!ax?UlFSf?1nF)`LB-O??sdOS-f8A?sE$bR)5k_eJTWGaBWca?8)oGQ|B8<@bi` zI7?|`a`-f}2qUyG3C?}6Pi%j)Wo`Sk(jtt|!q-6BU$x*0jCyx4;zuxxFhXlHp|yVK zxFX9shgpOXS{XtMXGAZUa;;z%VT4vAp@sLETUO{9RW8B^t<62HUyW8Fvj`)!wh&s) zAcvN99Fo&`!a60vUIK)H(p{EVT4u_p|xS^k*8VKw$CbGgb`X>5~~gDhDH+V zzO>aV>Ydt%AIL1i2(6|<3-5!qtaF$}7@>vFyqCYAv8>0KMHs=_npp0LZCRn`Fiv<{ z0%8Pf8^gl=(G?HYSXKeE2qRd{h^2c9w%)!b^D~)67?F+U#L~w~{JoxK-OVh*2(4{B zE%l~OjQ1mE5k_cjC$#Vion^It9=V|qVT9K9hK2ia-dko`?+|7YMriF|Sn!3`qb%zz zW)VhcwIG(xA&xegMr%2<2qUz16k7OuSj*bLEW!w_orD&S0IwLW?N?)2;rCyN5n4M7 zEgS(Xt1q(%BeYt2T7Md?Q<+5=p|y*rWmzkjMHr#gidbzRdfhA4o8_@QKQN0hLTgu{ zg}u_U_Id%i@U$$%2(8w{+7kAm7M{^t)*xmPMzD4xmfI^WYX-9jBUrl|7RG|T(z5Ph z7GVTy4`S&Sg}rj1>6ITbi!dS^ZHVReO3T{nMbr<42qU!iG%VbYJ!PV)zG9tp|!uz!ZE6qspWlMR^=j$&^kb9;R>f^9my=h2(1H!7Pj8)OfAo17GZ?eK|%|E zD{Wazm_-<&)m~`fc=)_2*E`H2jL)Eo-M&R5l1Bw6Z*{pN-ZaW)VhcWecqy zZ(P2_vd&``VT4u(Pit3`!zYu4)Uh*Iyq;oNKQW6iLaUQuVaag>C^6;Q`&E?< z!U(O-h6P_}1hA}u%p#1?>Ow4>>EQ^lzO+^Ios8CGW)Vhcbro9Qt{wl0Wi4VBVT4vU zV!0!LWvyctVFatY(ZUEH|NNYTEo+z8zyup%1nUrD=@HIwXh%iE{7qKvhsCC$F_d8ncnMD|()mvyS?_05*)jEb* zgb`YO3=5;dapMY8U*|H5FhZ-yurR`!l?UWm))HnBMridVmOfVEG369fUu&2}7@^fq zXyI?NEbC8Z5k_eBH!LjI@I^!S=xVguyoomW{TE_{)&RqTFZ6sH%PL?NVT9H|V&Qm* ztZz=)>LtsHGK(-mYmm@-`ILh;v#fKNMHrzqm{_`P{Jzi37M688vj`)!ju2W`%&5H9 zvR+~qVT9HYqXoqZJ+RNj=JQP3_>ozJ5n4lqR_K)0H(1tAYtU0DL>Qqpj9A#0;Y;Y% zZLcb}tS-zVjL;e`v}Qd2=pxG+$t=PMtr5i1IsD?{e!E%LiOeF5&^l6Rb?LPIPL?&F zS%eW$98XkuCYm_-<&b*#`j>D;%bSym;p2qUzPBbKhO z>tEaYe9O9sS%eW<5ur8gj@jQ@)-q-hMre&TT9~ct_M33kg=XA%n^}YrTE#-^hi6B& zwXE>l=qVH;jL;fGtk$p(zJyNwHS zXIfS*vj`)!qC#u#F+0CtSywTOFhXlAv2=a4+_Sk;u1A?g7@;*zXdOHMxNcVKQ)UrH zXpJ{onB%Sse!lQz)4#TT2W@cw6Jmr`nb3M{_P>v^tUP8BMra*xwDg&8chfdbU>0G7 z)&!x2XTFwoE3*hAw91L4XL`84VObwAi!g#Uky!3b&$4!VS7n1Rf>l8*J@3Uk7A)&H zW)ViPDv6~>HazpStSgvB7?F)CV(FP4p7~nVI%W|@Xq{kKSO%P>bThTw?mbm5!U(Nu z!-6mL%R9>&!7RcEtr}us>&5NoAy0g8qN(N6nMD|(RV%bsy!UghW!=Xt!U(NN#L~TT z;fd!QZdqS2i!efKve2qtIP5^n+UtE4H(`X<6jLtv5<0Te!sjh(B(n%3w5AHJ>Ag>z zU|AP1i!efKnqgrySYJPy`g)vMgb`XN8Wu)4^5)XxEbDh>5k_d8WLR3O*l1<1MO!FD z7@;-Yuuu!nvMp=KTI9g5e-R_JP9~Oa8~9YWtxVgfUQ479VT9HxLhIPs!!EI`mCPcH z(3&B%md?H7!xg4no3B$^gb`XZh1M=p)-1NHgPBDbp>-;;T7pyf5}LgAyK60LB(n%3 zv`!OR6Ha*NB+ELTS%eWM|ie;@~7GZ?enZ#-X zWx^3Vblq3|o0%Lo`T$Mv&IQB>t+Rv{)|X{nyk4;gBeZ4_OOM!iZf;p^KT<5h2-exe zaz|{-x@Uu85k|1iAr^elw%>#mCs@{iPn4A~f^{yj+}7K~WaIr$6^k$;8|M*AkJ#7! z`Q&bv_4a3qMHrzq+tX@lwBT_;v=K&Vo$qN`R);SYi!eg#0-<&4{6q4$Hd^O@rC5X! zT62UJKK;yLeWO@}5n6MJrF+V{zD-}Ttl8fw7GZ?eJfU^RkGH>NS?B+tScDN;7n*Xx zm(Wpj7O%Ff3w}~8!U(O4gx2N-8xFLrIlm|tVT9Jj#M0&3;^wj)ENkv>ibWWqb&1eA z<>q-CENk8$ibWWqbt$p*%mLSXw>9;3;lCA&Fhc7xp@qMov8)~GUS|0H7h;6g<%WfR z@krFjXk8W#lNe!y))j^YUqbjS0?TT-nPL$}XkAGxT`pYT*urRC&Md+Rt*e9a*n``7z{1!OBUuZG zwLPKWnT&@vhV?G3bscLVMzXF+p!GCsAx5$mCSa{)7GfmpT4L?U5#HWxznyG^n>A9| zKn$?xeF2$M5qcf5TEjP88vCt1vk)U$*Bcgm34OP8)qa*Wm|2Jc7A8Kk8l^%v5bI$0 zhS9XTVAK%&1k;kPzAFO4@>IYf-qy2Y>%@!jy1!z`;8vk)V-{$*HxxkfV!F-rd$wtxWoaoY2( zo#KP@&C#A*jR`buH71|c8D0sTAqN_ zg;|J^toswN1~CgUlC>fMtA<&Kk*t*oSm!beF_QHFv4Y#-^~^$yWIaf%xsYFdRI}~y zNoFBNvK}H9e9(6I;)@SKgxcN!7H)`vNX1kXeY4tX0Iq^Bt9C_yP#E-ODV*NY>ND(nspvlh-(H<2hy_MzWqUEcg;ruFsi; z7|D8;Sh`#%H{LtnMwqdsiW)JJ^_*ep(pc6m%tDN0Jx?rMuF*UEvBI(rW)@;3Yqep) zmzZ)5WENs1>jh%za;@(@(fiKVk4`|`8QLX2d+V_5Jdrfq!7 zEW`lI$;P|H+LyDDJN=PM5uvuN@kMR0Ax3JwM=YHU*;Dpo7GfmpePRXolze6(MzYot zOJ_s&l%tu27|B{^Snwq#8z(ahF~D-N@quAs$@lncJlsR8vjK~yn2Zo&q}F<3>1@ch zaR;*yBUv93E4Xbu!7Ri`)lb1LXX68AAx5%(C01}YzF`((BY?FkG-tUK}is}Z5L*33eT)cS*1IvaA_=*TR@NYV|vi?mh zoeeo|9K|feNY-D51z%#aF^O4-0hW^ue1%O$xGgX+8%@@YS!N@g%`C)7tuV2IvvDJ{ z5F=Te8J3@o`MOF;Z&_V(Dzi`NpoyLX2cJCRXr#<6veXMzWd^E0eP!=NkpgLX2c>X;^+XMl%aB zz;d$Dlvw+4HbOTphpP{|=1yc5Vx-nq#0t*FrOZN%WNl5X;A|{r7Gfl88)9V!X5&d_ zAx5&A8J3@okC}xSU^&@nPAr{`b56NB6A@|)Z>!n{Vx-o##0t*FZp=cAWNk;R;B0he z7Gfl8dtzkHPi z#{JAfjAZRZtl(_C%Pho5*3QJr49rFdU#|@tVkE1jVfooOkXeWUmXnQL3=92cJRSNK z5o#-B7Gk7UD`Ev_<2Ys^MzVG#R&X|InS~h1YE7(62npko|hU{>3cB z0L#h7?!?kP<-JR9aL(u-V-{kh)*i$P&c^%9LX2d!Ay#lUer6V8Bx_G%Wd>%W`Sz-9 zAV#wGGAutES+W-xvgTl%N+%Oc7#7in!h6v(2UeZt0$IK6xT*Wk+O=(#pPwC zk*ebA;)zk%5viyws~B4e|ErGHPO7ee7)F*yE5_B1k3_4hL63qapZSHL5Q#u+#pUR? ztTIwnT~<*$Hd0wtTLz_soyuHNIdNiTMPzb~+8>J4ROoLMP;_cZlqis#s%eTAvBuIU zB&>28lqSmzO|yD?68pn;iofj)0Mnh$-WXYjeGw`H-soLfoGd>Fw>! zqeK>w<4DhhyR*g=m%8=j1s3TYgTTnJUbOp!yOsOu>f&jUis+Pxst_jyRDx`B5ePDA z$VukOO(w@2*P|DHa%5!K`0C0jk@%59%fiAiuC_WF<mGX zh0${8$Fa1WAyGAoOsXB*jWd?3o1hsUat6c)sqv&2R7h^D4;o)o_lw;{eGmFptle!o z3HCX>3K(W;qPZq$-ES;A5YfM~WI}Gik!2P1h1k@dpT^s26$I8=4fU{quvbdTYY{zFF;R}ZeO&dt?skvS|n6=M$a?(zCS zV(ZG)JnWMYM;TUO9Nm#I;bI0-pn2iqkq5chrRpHrJ6by+I&n<2I!>68fw4K&`Qi96 zr=Xil?UTIKj;}0@>n*0#m@w@SOObXs7#)Vdg~-*;8Y;SY{yEs9iqh!RIEC%wW-e)5 zSO+~*a^>bMVKL*oOI`~_72~6DIEj`vR0)m4gw0LlEQNwPUK2FCK1s?utTN#M;npL@ zM8}LYIoMu?RVEq1VueJH7zi`#fR=`b0TYzzK1GFbpft`GLO!Svy~-*|f607URKxq^nUQwNz3w73zR~o+!sFI^p;ovSR z2T&@voyH&7FjvWa*V*-u=)}s&dfbn9Y_GF-3Or$Rh)qh&7^Cx&JIdrCp}Uw!6MEA{ zZ!m{FD<(};<3LT^*472vXnrBYIWl)tHWo^;Fo<+mIoUax1?s2*zH|%L$8Vk!;w%*g zjNuiNYG4YToDk`U3_kBj4Cl_tD;snslAM4=hhm3vqSbi%kdql1hNm!a<`)?T^LTwi z2!Ge(gs})tFUzAfHR!e;Zr}t|oRNaps^YTh+|0~^{Q7w=QYW?`keQXoXSw!VH_{K! z`s*4xoHavwBmJu@Yhg)AXE*}uO1V$~N_V6N&S%S`ky;paYtY)j#iBJSTOJ&ejdVq2 zX|&-bsWWlOhx}tp-g7Ffr@%s{uIB$>o&Ud8IrJ0NrYBXDjE~|%fm+dxz?{397Lp9& zKa`H)ks=NS*4b*JS-7snO|__^CR$w!i@VS#bUFS*QR=y!4r8PCQ!^TrmE!V(`Ew(R zsxb){{qlx)RO!#j%gKaePCbtjf1`tq9g^|9B{LIpQRl;qUf}=7rjSla63=3S&n%#| z)8vFF0Z;>W(Hr)eV{tH>XAT|X&m8E4w2sIBgqmp`))RTE|Is>;cg_$+i=$fN=|>_@ zZk%;HwkGl(8)w3SFp(n;(;Vj->PVPK(+z&39NWm#1>^dNN!Yz&XEO@35GHa=2uM5C~kY zZsWxRJsq)^4Mu1qt+VGw24>TFDPBmhU_9TWK~L)poi-6pawPye8+gNAF-s_^pw-1P z-zlHPDk;7eAa#|j1JGBxVgr;}_ndHzm@KJ;U?YQx3a8LyMeR(O7Yj)(Gx6~OhZ?wm zq)(XL^21#Lc!os>nOM8(x8j)NK@uEWaK_+fG|f{@Pb%plC6)nykJPj0)KBzcy||-S z@F60W;p(P-D2VkEs|)+h*h6#QSOUv7$j~0^+YP3{hVVopfkSmHflF-C5;P0* z0K?P~lcJNNb{Io_Jf(tON_*5O+^ej*2Cv)3fKf?ZNAF*pcz;pN2)r*TkqcO5>=(tW z;ejH&3>$lq6TD8smHd=Ba19_K$F3HKa{5l1SQXE=iyNpeY6r%ERXMmiI=QTJ60Xh0 z#ZV;%?6q|j=^02j0LUL*bEj+Fd_9C5s>8IZQ?$F+{V}|O(J7|>S;E|wAqH!d!U20w zg7h>94ARZYvpBK6scf)1E!xz{HATbv;C`uYpq!l7qhBYbGU1PsvTq(6WW>zt3o?Ef#>NF` zkZEYWixq#aYEP5(K?;xAe&466g`y9M5C=YcvY09sr^;}z zk{(pVL>cb+rG+tlN+y6_qlvTEwv#vj(=-D1Cut2SG61Ge!~z%rb)E#JC&q5xY&x7% zumC?axHQOE7%=|TX{5tbdM{AfnBwo2Cv<>I>vYcG6HKsa6&UZh4Q!+8o+4_cd8L!_ zUb|tH`t+anNtRkc7!sWfOVgG_VEil?^Z<02jdNmTY(Mid`2FE8+@`wMYkhxbF{|30)wtdy3qQ zs16W=hzyMMb3y8gfbR)$cpQg{#*Fy@b4`SQg2AOxtxR!;PJxU6rkr|D7P=h(cSOe7 zRZt#z1M8%f{9Ycf@cuf<+)PD1#q=?6gaT>}3@l6>)op zQ&0NA2Is}B8V*%ILUA)dclm*?!3@XS14ZEKPCz*pIW8c+R8IIEMxya3@K#1TmFCG9 zCYXOt6LgcI1LgY>p>PRqdUWtf?|5V^wh!z;sv_dv?&zSQ!0KK{+aJwH?#wEj6qycc ze~Sh!L*2#%SMli9X_IwzsR$`?#*BKU_Sd~9%>{wjk)<09# zLE|m${$)u*K?re&g3L%yyt5OoOR3vB#k~#cPA&f~pHxqyu(0m&INh73Qq^%au!muW z#Wk~rI;U1ECfP}Df=V@PN)O+dlWIKx$FwNCa9D>F$GS)}d$DvUf`G&XqSGw1y9ANq zC4E&<`uufrN;lIca-C+5>JV{2?$Yv7kDNkRsmE>Cd|#B)4C<2n28p2_wbUT`P7ab( zXT!;vddEW?4b|W~rBQsN*1CVtXjr+SX$|rXs|^p0fSMj|9-08dOddXC!akcKQU$-n zO|c#l4LeSQQk{xE@erq0=wKdJAL)i`g-&#;6WSOva|WdL`~Yal;ssj50AhF;NnT;wd(m6 z2<4|JI62dkIXo381$JguZcbJXUBu<-CgoFw7d)5C?bIjFBgaCu7x*Eghfn^KHEgMM z`8ix2q#9Hy;m^fl3l(#6rsv`KbGG1eB=jCrj&z)-c`D}xC;72!q2|oSZ|{CNr7OP6 zflsi~=bIHT)tv1a6Z{P~JR~WIb4fZWKf6A?$dXg*MGF7_(u*9agsrb`ZM%cXT51Jn z{H9-L)bH0BPPI)!?F4lSCp1Vt2=?I_fY<$0Dl4I86rLVAgU%>G6|lPnvm_6_GVYS$jKhQv$ujN|ql~lE zpLAtBr$I3?sXipjh@?!=5-C12OADk5k8z*yQCl&-6Jw3zIFIKt&f@LY4sZfokMnw( zE5bUi)@vwtI=qebbTA$7M)MC(LMyAt%*xE!XbNgX+n5Tf4A~pK3>#BHm7&8%FT=)E z(48SC+b$ZbsX3nD>!uuMZ%I{^dgmrQLM)J8R@I>fpDK_U4`AfuKVr_rkO1NYk^n`a z45!2QfZ{5MDFN1rJOL^&{GjL91r{O@7^f(K*n|ZNWW*^}AXXQSp1kKjf=?GI-fm5g z`=mbYAU;65z}pY}r|)TgoV{_$c$P<3wBkCj2<;^CgZs3jBq;4H(PRF!tArTGQJhBt zI&R`25GB1~uhM@PI^}p+pZ+%yi0= z$dwaXBA5=V9uHX5QP;I)mo#0h1*h7M&JV z9~U|dCtGo1QPa2>>2zsYPG8-q;{^)Sh3oCdo*dNMRqV-7y&c*!l6t$+dAAQbNRoNF zhgeP-7b@tqRtBGRDPXB z(y#kEOQlowbr#VzubJ=Wm|0|8kOUG$Cb(fCc^s6o%@9ETBI(~J<>CT<7Nu=Xgoq58q zlGNk#8_cf`xK7WK*T=ECk)<@2D2)fwOX+mUS~}II+H19x@mc^*#uEH6OfMd*pPkWf z!?aTRM77KTm)+B+s>W3(s=E+Xr;@7W&@`#;LQ|SlcVQ__s=JVsCe>XyN|UOaQj+Hc z)$4AVztLl*H_|%{bidn_Wq4x5Mtf5PzK2oWeY7dh8#T{nMBkL>jhbh3_}i4{jhbiG zo?))ADbE`<&t_t^DbE`<&t?|7DbE`<&t}TLDbE`<&*uDQQ=T_!p7qIKq>fMatlwFp z`-B4fLupvXO7Mh|hEN0rd?+jY;QR0T_APySxvAd%UT;m~6IPgbZmPMzS){w60)i0{$@32PHQ&R+~2I`%*1ljTSEVXZwWQi#7(vEpR5Jl88*GMm7YXdx1ZtD zquq3a-jvCDXVTtivniSNPG;=gMVnGu@08kGsx~FF-pMpaAb1MOKlH8P@(~jM>@?`+ zka%@H_;FaUHoMW^0Im=7|F!Yy1lIAqG&r+$SPoC*Xk)E%C(?9_5cFoH4)|gYUAvo- z$4{f5qyOHnTi>bs!% z4^N*t?ACof>;E%@<}!BBd%)9rpMiQhb_aZ)(eRG)Ai60P=6L}0s+!o}jPsM3#SeIs z19eNImyMaX*x;zdFDO?JYF1C6jSS4rcIGu{af}c=WXV4K8H1K5EP;ESHJo6&a}pg4 zF!K1)H>r;YA@}hRl(aYy;|88$Eu-|ImEsG;Q(-$B#B#@( zF9(2(E12k-7nue<>^gY2oi*aKUV|Li8D2bu2?6K+F)jiN6A$AAlgL%Ie09Wd z`@V*>V~*EzQ_$9VireLq`be$krszh8BU6yhJN4q!V0td%Rc3l#64z^bzT#DJdR}yT zzq#(I>lep3vlAh68}d_XM4{7XaQq8_5Wxw?RfJ)T0lL@q_Nmjw-F-Q5_g@v z;(TbM{LDD{sOqkgsP7HASYD@WxFH2D+|G2M zzjg+|WaC9$t~_kYa=KYoZ8^OQ9hs7D$=C*~dH`WO8wNE@W0cDx{`t zVpVxGQai0GT7%X)oQ-&04UdL7c_Xs2bNe{w9{)`tsV)x>bp3A%O7)QcvY^a?{=Y9% za9sRv3d(dnSpSV(e+XO(js~z>#yziumRVmbafN&j{cKM|a_O+(9K zUhj(51`bYO_eQm(Snb#hD}s^6RW3KE_%ugO4<2a?rb*P2+*||X;&;p>V6QJG!N=)- zNmyQwOM=%0<}MR}cA9%)kandm+Qn9JV1xGL3`#qbSAGCrm&bR_kllrqCjw+q&VXc4qoI> zy<&uKuZsQ2Ð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

0`#*9EGRlY{;~ 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�WkJ`fID0=52;_G{&Q$&c(PTnbeN}NcEc> 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 ImirC*e^b_k1^@s6 literal 0 HcmV?d00001 diff --git a/libs/isxdk/lib64/vs16/ISXDK_md.lib b/libs/isxdk/lib64/vs16/ISXDK_md.lib new file mode 100644 index 0000000000000000000000000000000000000000..6ec5ba72c44b0d9b38fd3c4f4558a03824dbfdc7 GIT binary patch literal 782860 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¬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 + { + case RetrieveData: + // Handle the "RetrieveData" member + { + // use argc and argv if you need to process parameters + // return true if you set Dest to a new, valid object. otherwise, return false. + return false; + } + } + + return false; +} + +bool MrType::GetMethod(LSOBJECTDATA &ObjectData, PLSTYPEMETHOD pMethod, int argc, char *argv[]) +{ + // The GetMethod function is used when a data sequence access a method of an object of this type. + // Its job is to take the method name (such as PerformAction), and perform the requested action. + // Unlike members, methods do not result in a new object -- they may make changes to the original + // object, but always result in the same object (return true), or no object if the object was deleted + // (return false). + + // ObjectData here is passed by reference, so that you may modify the value stored if necessary. 32-bit + // (or less) integer types, for example, use a value directly in the ObjectData, rather than a pointer + // to an object. + + // ObjectData is the object, or a pointer to the object. Validate the object here. + if (!ObjectData.Ptr) + return false; + + // Based on the method ID, execute the desired method + switch((MrTypeMethods)pMethod->ID) + { + case PerformAction: + // Handle the "PerformAction" member + { + // use argc and argv if you need to process parameters + // return true if the object is still valid. return false if not. + return true; + } + } + + return false; +} diff --git a/src/DataTypes.h b/src/DataTypes.h new file mode 100644 index 0000000..5445231 --- /dev/null +++ b/src/DataTypes.h @@ -0,0 +1,32 @@ +#pragma once +#include "DataTypeList.h" + +// custom data type declarations + +class MrType : public LSTypeDefinition +{ +public: + // All data members (retrieving data) should be listed in this enumeration + enum MrTypeMembers + { + RetrieveData, + }; + // All data methods (performing actions on or with the object) should be listed in this enumeration + enum MrTypeMethods + { + PerformAction, + }; + + MrType() : LSType("mr") + { + // Use the TypeMember macro to activate each member, or use AddMember + TypeMember(RetrieveData); + + // Use the TypeMethod macro to activate each member, or use AddMethod + TypeMethod(PerformAction); + } + + virtual bool GetMember(LSOBJECTDATA ObjectData, PLSTYPEMEMBER Member, int argc, char *argv[], LSOBJECT &Object); + virtual bool GetMethod(LSOBJECTDATA &ObjectData, PLSTYPEMETHOD pMethod, int argc, char *argv[]); + virtual bool ToText(LSOBJECTDATA ObjectData, char *buf, unsigned int buflen); +}; diff --git a/src/ISXMr.cpp b/src/ISXMr.cpp new file mode 100644 index 0000000..f835823 --- /dev/null +++ b/src/ISXMr.cpp @@ -0,0 +1,417 @@ +// +// ISXMr +// + +// Version guideline: YYYYMMDD +// Add lettering to the end to indicate a new version on the same date, such as 20060305a, 20060305b, etc +// You can also use a standard version numbering system such as 1.00, 1.01, etc. +// Be aware that for the versioning system, this text is simply compared to another version text from the +// same extension to check for new versions -- if this version text comes before the compared text (in a +// dictionary), then an update is available. Equal text means the version is up to date. After means this +// is newer than the compared version. With that said, use whatever version numbering system you'd like. +#define EXTENSION_VERSION "20060617" + +#include "ISXMr.h" + +#include "isxeq2/Character.h" +#pragma comment(lib,"isxdk.lib") +// The mandatory pre-setup function. Our name is "ISXMr", and the class is ISXMr. +// This sets up a "ModulePath" variable which contains the path to this module in case we want it, +// and a "PluginLog" variable, which contains the path and filename of what we should use for our +// debug logging if we need it. It also sets up a variable "pExtension" which is the pointer to +// our instanced class. +ISXPreSetup("ISXMr",ISXMr); + +// Basic LavishScript datatypes, these get retrieved on startup by our initialize function, so we can +// use them in our Top-Level Objects or custom datatypes +LSType *pStringType=0; +LSType *pIntType=0; +LSType *pUintType=0; +LSType *pBoolType=0; +LSType *pFloatType=0; +LSType *pTimeType=0; +LSType *pByteType=0; +LSType *pIntPtrType=0; +LSType *pBoolPtrType=0; +LSType *pFloatPtrType=0; +LSType *pBytePtrType=0; + +ISInterface *pISInterface=0; +HISXSERVICE hPulseService; +HISXSERVICE hMemoryService; +HISXSERVICE hHTTPService; +HISXSERVICE hTriggerService; +HISXSERVICE hSystemService; + +char Mr_Version[]=EXTENSION_VERSION; + +// Forward declarations of callbacks +void __cdecl PulseService(bool Broadcast, unsigned int MSG, void *lpData); +void __cdecl MemoryService(bool Broadcast, unsigned int MSG, void *lpData); +void __cdecl TriggerService(bool Broadcast, unsigned int MSG, void *lpData); +void __cdecl HTTPService(bool Broadcast, unsigned int MSG, void *lpData); +void __cdecl SystemService(bool Broadcast, unsigned int MSG, void *lpData); + + +// The constructor of our class. General initialization cannot be done yet, because we're not given +// the pointer to the Inner Space interface until it is ready for us to initialize. Just set the +// pointer we have to the interface to 0. Initialize data members, too. +ISXMr::ISXMr(void) +{ +} + +// Free any remaining resources in the destructor. This is called when the DLL is unloaded, but +// Inner Space calls the "Shutdown" function first. Most if not all of the shutdown process should +// be done in Shutdown. +ISXMr::~ISXMr(void) +{ +} + +// Initialize is called by Inner Space when the extension should initialize. +bool ISXMr::Initialize(ISInterface *p_ISInterface) +{ + /* + * Most of the functionality in Initialize is completely optional and could be removed or + * changed if so desired. The defaults are simply a suggestion that can be easily followed. + */ + + __try // exception handling. See __except below. + { + // Keep a global copy of the ISInterface pointer, which is for calling Inner Space API + pISInterface=p_ISInterface; + + // Register the extension to make launching and updating the extension easy + RegisterExtension(); + + // retrieve basic LavishScript data types for use in ISXMr data types + pStringType=pISInterface->FindLSType("string"); + pIntType=pISInterface->FindLSType("int"); + pUintType=pISInterface->FindLSType("uint"); + pBoolType=pISInterface->FindLSType("bool"); + pFloatType=pISInterface->FindLSType("float"); + pTimeType=pISInterface->FindLSType("time"); + pByteType=pISInterface->FindLSType("byte"); + pIntPtrType=pISInterface->FindLSType("intptr"); + pBoolPtrType=pISInterface->FindLSType("boolptr"); + pFloatPtrType=pISInterface->FindLSType("floatptr"); + pBytePtrType=pISInterface->FindLSType("byteptr"); + + // Connect to commonly used Inner Space services + ConnectServices(); + + // Register LavishScript extensions (commands, aliases, data types, objects) + RegisterCommands(); + RegisterAliases(); + RegisterDataTypes(); + RegisterTopLevelObjects(); + + // Register (create) our own services + RegisterServices(); + + // Register any text triggers built into ISXMr + RegisterTriggers(); + + printf("ISXMr version %s Loaded",Mr_Version); + return true; + } + + // Exception handling sample. Exception handling should at LEAST be used in functions that + // are suspected of causing user crashes. This will help users report the crash and hopefully + // enable the extension developer to locate and fix the crash condition. + __except(EzCrashFilter(GetExceptionInformation(),"Crash in initialize routine")) + { + TerminateProcess(GetCurrentProcess(),0); + return 0; + } + /* + * EzCrashFilter takes printf-style formatting after the first parameter. The above + * could look something like this: + __except(EzCrashFilter(GetExceptionInformation(),"Crash in initialize routine (%s:%d)",__FILE__,__LINE__)) + { + TerminateProcess(GetCurrentProcess(),0); + return 0; + } + * of course, the FILE and LINE macros would be the location of the exception handler, not the + * actual crash, but you should get the idea that extra parameters can be used as if EzCrashFilter + * was printf. + * + * EzCrashFilter will automatically produce a crash log (CrashLog.txt) and open it in notepad for + * non-breakpoint exceptions (and hopefully the user will report the crash to the extension developer). + * Your exception handler (the part within the {} under __except) should simply terminate the process + * and return from the function as in the sample. The return will not be hit, but the compiler will + * whine without it because it doesn't automatically know that the function will not return. + */ + +} + +// shutdown sequence +void ISXMr::Shutdown() +{ + // Disconnect from services we connected to + DisconnectServices(); + + // Unregister (destroy) services we created + UnRegisterServices(); + + // Remove LavishScript extensions (commands, aliases, data types, objects) + UnRegisterTopLevelObjects(); + UnRegisterDataTypes(); + UnRegisterAliases(); + UnRegisterCommands(); +} + +/* + * Note that Initialize and Shutdown are the only two REQUIRED functions in your ISXInterface class. + * All others are for suggested breakdown of routines, and for example purposes. + */ + +void ISXMr::RegisterExtension() +{ + // add this extension to, or update this extension's info in, InnerSpace.xml. + // This accomplishes a few things. A) The extension can be loaded by name (ISXMr) + // no matter where it resides on the system. B) A script or extension can + // check a repository to determine if there is an update available (and update + // if necessary) + + unsigned int ExtensionSetGUID=pISInterface->GetExtensionSetGUID("ISXMr"); + if (!ExtensionSetGUID) + { + ExtensionSetGUID=pISInterface->CreateExtensionSet("ISXMr"); + if (!ExtensionSetGUID) + return; + } + pISInterface->SetSetting(ExtensionSetGUID,"Filename",ModuleFileName); + pISInterface->SetSetting(ExtensionSetGUID,"Path",ModulePath); + pISInterface->SetSetting(ExtensionSetGUID,"Version",Mr_Version); +} + +void ISXMr::ConnectServices() +{ + // connect to any services. Here we connect to "Pulse" which receives a + // message every frame (after the frame is displayed) and "Memory" which + // wraps "detours" and memory modifications + hPulseService=pISInterface->ConnectService(this,"Pulse",PulseService); + hMemoryService=pISInterface->ConnectService(this,"Memory",MemoryService); + + // The HTTP service handles URL retrieval + hHTTPService=pISInterface->ConnectService(this,"HTTP",HTTPService); + + // The Triggers service handles trigger-related functions, including the + // ability to pass text TO the trigger parser, as well as the ability to + // add triggers. + hTriggerService=pISInterface->ConnectService(this,"Triggers",TriggerService); + + // The System service provides general system-related services, including + // a diagnostics message that allows the extension to insert diagnostic + // information for the "diagnostics" command, and extension crash logs. + hSystemService=pISInterface->ConnectService(this,"System",SystemService); +} +void ISXMr::RegisterCommands() +{ + // add any commands +// pISInterface->AddCommand("ISXMr",CMD_ISXMr,true,false); +#define COMMAND(name,cmd,parse,hide) pISInterface->AddCommand(name,cmd,parse,hide); +#include "Commands.h" +#undef COMMAND +} + +void ISXMr::RegisterAliases() +{ + // add any aliases +} + +void ISXMr::RegisterDataTypes() +{ + // add any datatypes + // pMyType = new MyType; + // pISInterface->AddLSType(*pMyType); + + +#define DATATYPE(_class_,_variable_,_inherits_) _variable_ = new _class_; pISInterface->AddLSType(*_variable_); _variable_->SetInheritance(_inherits_); +#include "DataTypeList.h" +#undef DATATYPE +} + +void ISXMr::RegisterTopLevelObjects() +{ + // add any Top-Level Objects + //pISInterface->AddTopLevelObject("ISXMr",TLO_ISXMr); +#define TOPLEVELOBJECT(name,funcname) pISInterface->AddTopLevelObject(name,funcname); +#include "TopLevelObjects.h" +#undef TOPLEVELOBJECT +} + +void ISXMr::RegisterServices() +{ + // register any services. Here we demonstrate a service that does not use a + // callback + // set up a 1-way service (broadcast only) +// hISXMrService=pISInterface->RegisterService(this,"ISXMr Service",0); + // broadcast a message, which is worthless at this point because nobody will receive it + // (nobody has had a chance to connect) +// pISInterface->ServiceBroadcast(this,hISXMrService,ISXSERVICE_MSG+1,0); + +#define SERVICE(_name_,_callback_,_variable_) _variable_=pISInterface->RegisterService(this,_name_,_callback_); +#include "Services.h" +#undef SERVICE +} + +void ISXMr::RegisterTriggers() +{ + // add any Triggers +} + +void ISXMr::DisconnectServices() +{ + // gracefully disconnect from services + if (hPulseService) + pISInterface->DisconnectService(this,hPulseService); + if (hMemoryService) + { + pISInterface->DisconnectService(this,hMemoryService); + // memory modifications are automatically undone when disconnecting + // also, since this service accepts messages from clients we should reset our handle to + // 0 to make sure we dont try to continue using it + hMemoryService=0; + } + if (hHTTPService) + { + pISInterface->DisconnectService(this,hHTTPService); + } + if (hTriggerService) + { + pISInterface->DisconnectService(this,hTriggerService); + } + if (hSystemService) + { + pISInterface->DisconnectService(this,hSystemService); + } +} + +void ISXMr::UnRegisterCommands() +{ + // remove commands +// pISInterface->RemoveCommand("ISXMr"); +#define COMMAND(name,cmd,parse,hide) pISInterface->RemoveCommand(name); +#include "Commands.h" +#undef COMMAND +} +void ISXMr::UnRegisterAliases() +{ + // remove aliases +} +void ISXMr::UnRegisterDataTypes() +{ + // remove data types +#define DATATYPE(_class_,_variable_,_inherits_) pISInterface->RemoveLSType(*_variable_); delete _variable_; +#include "DataTypeList.h" +#undef DATATYPE + +} +void ISXMr::UnRegisterTopLevelObjects() +{ + // remove Top-Level Objects +// pISInterface->RemoveTopLevelObject("ISXMr"); +#define TOPLEVELOBJECT(name,funcname) pISInterface->RemoveTopLevelObject(name); +#include "TopLevelObjects.h" +#undef TOPLEVELOBJECT +} +void ISXMr::UnRegisterServices() +{ + // shutdown our own services +// if (hISXMrService) +// pISInterface->ShutdownService(this,hISXMrService); + +#define SERVICE(_name_,_callback_,_variable_) _variable_=pISInterface->ShutdownService(this,_variable_); +#include "Services.h" +#undef SERVICE +} + +int frameCount = 0; + +void __cdecl PulseService(bool Broadcast, unsigned int MSG, void *lpData) +{ + if (MSG==PULSE_PULSE) + { + /* + * "OnPulse" + * This message is received by the extension before each frame is + * displayed by the game. This is the place to put any repeating + * tasks. + */ + if(frameCount++ > 80) { + frameCount = 0; + const auto me = pISInterface->IsTopLevelObject("Me"); + if(me != nullptr) { + LSOBJECT response; + me(0, nullptr, response); + Character c(response); + printf("------------------------------------"); + printf("ID: %u", c.GetId()); + printf("Name: %s", c.GetName()); + printf("Race: %s", c.GetRace()); + printf("Archetype: %s", c.GetArchetype()); + printf("Class: %s", c.GetClass()); + printf("SubClass: %s", c.GetSubClass()); + printf("TSArchetype: %s", c.GetTradeskillArchtype()); + printf("TSClass: %s", c.GetTradeskillClass()); + printf("TSSubClass: %s", c.GetTradeskillSubClass()); + printf("Gender: %s", c.GetGender()); + printf("------------------------------------"); + } + // if(pISInterface->IsExtensionLoaded("ISXEq2")) { + // printf("Loaded"); + // } else { + // printf("Not loaded"); + // } + + } + + } +} + +void __cdecl MemoryService(bool Broadcast, unsigned int MSG, void *lpData) +{ + // no messages are currently associated with this service (other than + // system messages such as client disconnect), so do nothing. +} + +void __cdecl TriggerService(bool Broadcast, unsigned int MSG, void *lpData) +{ + // no messages are currently associated with this service (other than + // system messages such as client disconnect), so do nothing. +} + +void __cdecl SystemService(bool Broadcast, unsigned int MSG, void *lpData) +{ + if (MSG==SYSTEMSERVICE_DIAGNOSTICS) + { + // Diagnostics sample + /* + FILE *file=(FILE*)lpData; + fprintf(file,"ISXMr version %s\n",EXTENSION_VERSION); + fprintf(file,"------------------------------------\n",EXTENSION_VERSION); + fprintf(file,"Any ISXMr diagnostic information here\n"); + fprintf(file,"\n");// extra spacing for making the crash log look nice + /**/ + } +} + +void __cdecl HTTPService(bool Broadcast, unsigned int MSG, void *lpData) +{ + switch(MSG) + { +#define pReq ((HttpFile*)lpData) + case HTTPSERVICE_FAILURE: + // HTTP request failed to retrieve document + printf("ISXMr URL %s failed",pReq->URL); + break; + case HTTPSERVICE_SUCCESS: + // HTTP request successfully retrieved document + printf("ISXMr URL %s -- %d bytes",pReq->URL,pReq->Size); + // Retrieved data buffer is pReq->pBuffer and is null-terminated + break; +#undef pReq + } +} + diff --git a/src/ISXMr.h b/src/ISXMr.h new file mode 100644 index 0000000..d43f72f --- /dev/null +++ b/src/ISXMr.h @@ -0,0 +1,96 @@ +#pragma once +#include +#include + + +class ISXMr : + public ISXInterface +{ +public: + ISXMr(void); + ~ISXMr(void); + + virtual bool Initialize(ISInterface *p_ISInterface); + virtual void Shutdown(); + + void RegisterExtension(); + + void ConnectServices(); + void RegisterCommands(); + void RegisterAliases(); + void RegisterDataTypes(); + void RegisterTopLevelObjects(); + void RegisterServices(); + void RegisterTriggers(); + + void DisconnectServices(); + void UnRegisterCommands(); + void UnRegisterAliases(); + void UnRegisterDataTypes(); + void UnRegisterTopLevelObjects(); + void UnRegisterServices(); + +}; + +extern ISInterface *pISInterface; +extern HISXSERVICE hPulseService; +extern HISXSERVICE hMemoryService; +extern HISXSERVICE hHTTPService; +extern HISXSERVICE hTriggerService; +extern HISXSERVICE hSystemService; + +extern ISXMr *pExtension; +#define printf pISInterface->Printf + +#define EzDetour(Address, Detour, Trampoline) IS_Detour(pExtension,pISInterface,hMemoryService,(unsigned int)Address,Detour,Trampoline) +#define EzUnDetour(Address) IS_UnDetour(pExtension,pISInterface,hMemoryService,(unsigned int)Address) +#define EzDetourAPI(_Detour_,_DLLName_,_FunctionName_,_FunctionOrdinal_) IS_DetourAPI(pExtension,pISInterface,hMemoryService,_Detour_,_DLLName_,_FunctionName_,_FunctionOrdinal_) +#define EzUnDetourAPI(Address) IS_UnDetourAPI(pExtension,pISInterface,hMemoryService,(unsigned int)Address) + +#define EzModify(Address,NewData,Length,Reverse) Memory_Modify(pExtension,pISInterface,hMemoryService,(unsigned int)Address,NewData,Length,Reverse) +#define EzUnModify(Address) Memory_UnModify(pExtension,pISInterface,hMemoryService,(unsigned int)Address) + +#define EzHttpRequest(_URL_,_pData_) IS_HttpRequest(pExtension,pISInterface,hHTTPService,_URL_,_pData_) + +#define EzAddTrigger(Text,Callback,pUserData) IS_AddTrigger(pExtension,pISInterface,hTriggerService,Text,Callback,pUserData) +#define EzRemoveTrigger(ID) IS_RemoveTrigger(pExtension,pISInterface,hTriggerService,ID) +#define EzCheckTriggers(Text) IS_CheckTriggers(pExtension,pISInterface,hTriggerService,Text) + +static LONG EzCrashFilter(_EXCEPTION_POINTERS *pExceptionInfo,const char *szIdentifier,...) +{ + unsigned int Code=pExceptionInfo->ExceptionRecord->ExceptionCode; + if (Code==EXCEPTION_BREAKPOINT || Code==EXCEPTION_SINGLE_STEP) + return EXCEPTION_CONTINUE_SEARCH; + + char szOutput[4096]; + szOutput[0]=0; + va_list vaList; + + va_start( vaList, szIdentifier ); + vsprintf_s(szOutput,szIdentifier, vaList); + + IS_SystemCrashLog(pExtension,pISInterface,hSystemService,pExceptionInfo,szOutput); + + return EXCEPTION_EXECUTE_HANDLER; +} + +extern LSType *pStringType; +extern LSType *pIntType; +extern LSType *pUintType; +extern LSType *pBoolType; +extern LSType *pFloatType; +extern LSType *pTimeType; +extern LSType *pByteType; +extern LSType *pIntPtrType; +extern LSType *pBoolPtrType; +extern LSType *pFloatPtrType; +extern LSType *pBytePtrType; + + +extern char Mr_Version[]; + +#include "Commands.h" +#include "DataTypes.h" +#include "TopLevelObjects.h" +#include "Services.h" + diff --git a/src/ISXMrServices.h b/src/ISXMrServices.h new file mode 100644 index 0000000..7e32c11 --- /dev/null +++ b/src/ISXMrServices.h @@ -0,0 +1,91 @@ +#pragma once +/********************************************************************** + ISXMrServices.h is a redistributable file that can be used + by other extensions to access the services provided by ISXMr. + It should contain all information for any message that can be sent to + clients from the master (individually or broadcast), or to the master + from clients. + + All "in/out" information is relative to the client. If it says "in" + it means the client feeds information in. If it says "out" it means + the client pulls information out. + **********************************************************************/ + +// ----- "Mr Service" messages ------------------------------ +// Note: ISXSERVICE_MSG defines the starting point for service-specific +// message numbers. Numbers below ISXSERVICE_MSG are reserved for +// future system use. +// These message numbers are PER SERVICE, so you can and should +// reuse numbers for different services + +/* in (requests) */ +#define Mr_FOO (ISXSERVICE_MSG+1) +// add all requests + +/* out (notifications) */ +#define Mr_BAR (ISXSERVICE_MSG+2) +// add all notifications + +// ----- "Mr Service" request structures --------------------- +// These structures are sent as the "lpData" in requests or notifications. + +/* + * All structures are essentially used to build a function call. Our first + * example handles a call to this function: + bool MrFooFunction(const char *Name, unsigned int Age,float Height); + * This function has 3 parameters, and 1 return value. The structure used will + * reflect exactly this. + * + * Note that because services are all executed in-process, data does not need to + * be serialized, as it would with using network sockets and such -- in other words, + * it is safe to pass original pointers. + */ + +// Mr_FOO +struct MrRequest_Foo +{ + /* in */ const char *Name; // Parameter 1 + /* in */ unsigned int Age; // Parameter 2 + /* int */ float Height; // Parameter 3 + + /* out */ bool Success; // Return value +}; + +// ----- "Mr Service" Helper Functions ----------------------- +// Put any helper functions for REQUESTS here. Notifications (in contrast) are done by +// the service master, and do not need redistributable helper functions. + +/* + * This function sets up the actual service request. It follows the same form as the function we + * are calling, but takes additional parameters to set up the remote service request. This will + * be used by our EzFoo macro, which will hide the service portion from developers wishing to use + * the remote function. + */ +static inline bool MrFoo(ISXInterface *pClient, ISInterface *pISInterface, HISXSERVICE hMrService, const char *Name, unsigned int Age, float Height) +{ + // set up lpData + MrRequest_Foo RemoteFunctionCall; + RemoteFunctionCall.Name=Name; + RemoteFunctionCall.Age=Age; + RemoteFunctionCall.Height=Height; + RemoteFunctionCall.Success=false; + // return true if a) the service request was sent correctly and b) the service set Success to true, indicating + // that the Foo operation was successfully completed + return pISInterface->ServiceRequest(pClient,hMrService,Mr_FOO,&RemoteFunctionCall) && RemoteFunctionCall.Success; +} +// Most extensions will opt to use the default naming conventions, with a global pISInterface and pExtension, +// and your service handle name. This means you can make an "easy" macro to call MrFoo for them, +// and they can just use EzFoo as if they were calling the actual remote function: +#define EzFoo(_name_,_age_,_height_) MrFoo(pExtension,pISInterface,hMrService,_name_,_age_,_height_) +// Note that EzFoo is now used exactly the same as bool MrFooFunction(const char *Name, unsigned int Age,float Height) + +// ----- "Mr Service" notification structures --------------------- +// The following structures are for use in Mr Service notification handlers +// Mr_BAR +// NOTE: For structures that have only one data item, we dont really need a structure. But to make things +// easy to use and understand, it's perfectly fine and compiles to the same machine code anyway. +struct MrNotification_Bar +{ + /* out */ const char *Text; +}; + diff --git a/src/LGUIMrFrame.cpp b/src/LGUIMrFrame.cpp new file mode 100644 index 0000000..b50341e --- /dev/null +++ b/src/LGUIMrFrame.cpp @@ -0,0 +1,50 @@ +#include "ISXMr.h" +#include "LGUIMrFrame.h" + +LGUIFactory MrFrameFactory("mrframe"); + +LGUIMrFrame::LGUIMrFrame(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name):LGUIFrame(p_Factory,p_pParent,p_Name) +{ + pText=0; + Count=0; +} +LGUIMrFrame::~LGUIMrFrame(void) +{ +} +bool LGUIMrFrame::IsTypeOf(char *TestFactory) +{ + return (!_stricmp(TestFactory,"mrframe")) || LGUIFrame::IsTypeOf(TestFactory); +} +bool LGUIMrFrame::FromXML(class XMLNode *pXML, class XMLNode *pTemplate) +{ + if (!pTemplate) + pTemplate=g_UIManager.FindTemplate(XMLHelper::GetStringAttribute(pXML,"Template")); + if (!pTemplate) + pTemplate=g_UIManager.FindTemplate("mrframe"); + if (!LGUIFrame::FromXML(pXML,pTemplate)) + return false; + + // custom xml properties + return true; +} + +void LGUIMrFrame::OnCreate() +{ + // All children of this element are guaranteed to have been created now. + pText = (LGUIText*)FindUsableChild("Output","text"); +} + +void LGUIMrFrame::Render() +{ + Count++; + if (pText) + { + char Temp[256]; + sprintf_s(Temp,"This frame has been rendered %d times.",Count); + pText->SetText(Temp); + } + + LGUIFrame::Render(); +} + + diff --git a/src/LGUIMrFrame.h b/src/LGUIMrFrame.h new file mode 100644 index 0000000..6a2dd24 --- /dev/null +++ b/src/LGUIMrFrame.h @@ -0,0 +1,19 @@ +#pragma once + +class LGUIMrFrame : + public LGUIFrame +{ +public: + LGUIMrFrame(const char *p_Factory, LGUIElement *p_pParent, const char *p_Name); + ~LGUIMrFrame(void); + bool IsTypeOf(char *TestFactory); + bool FromXML(class XMLNode *pXML, class XMLNode *pTemplate=0); + void OnCreate(); + void Render(); + + LGUIText *pText; + unsigned int Count; +}; + +extern LGUIFactory MrFrameFactory; + diff --git a/src/Services.cpp b/src/Services.cpp new file mode 100644 index 0000000..cef06a8 --- /dev/null +++ b/src/Services.cpp @@ -0,0 +1,76 @@ +#include "ISXMr.h" +#include "ISXMrServices.h" + +#define SERVICE(_name_,_callback_,_variable_) HISXSERVICE _variable_=0; +#include "Services.h" +#undef SERVICE + +bool MrFooFunction(const char *Name, unsigned int Age,float Height) +{ + printf("Foo: %s. Age %d. Height: %fcm",Name,Age,Height); + return true; +} + +void __cdecl MrService(ISXInterface *pClient, unsigned int MSG, void *lpData) +{ + switch(MSG) + { + case ISXSERVICE_CLIENTADDED: + // This message indicates that a new client has been added to the service + // pClient is 0, because this message is a system message from Inner Space + // lpData is an ISXInterface* that is the pointer to the new client + { + // use lpData as the actual type, not as void *. We can make a new + // variable to do this: + ISXInterface *pNewClient=(ISXInterface *)lpData; + + printf("MrService client added: %X",pNewClient); + // You may use the client pointer (pNewClient here) as an ID to track client-specific + // information. Some services such as the memory service do this to automatically + // remove memory modifications made by an extension when that extension is unloaded. + } + break; + case ISXSERVICE_CLIENTREMOVED: + // This message indicates that a client has been removed from the service + // pClient is 0, because this message is a system message from Inner Space + // lpData is an ISXInterface* that is the pointer to the removed client + { + // use lpData as the actual type, not as void *. We can make a new + // variable to do this: + ISXInterface *pRemovedClient=(ISXInterface *)lpData; + + printf("MrService client removed: %X",pRemovedClient); + } + break; + case Mr_FOO: + // This is a custom service request defined in ISXMrServices.h + // pClient is a valid pointer to the client that sent this request + // lpData is a MrRequest_Foo* as sent by the client + { + MrRequest_Foo *pFoo=(MrRequest_Foo*)lpData; + + /* + * As described in ISXMrServices.h, pFoo is simply a remote call + * to MrFooFunction, and has all of the parameters and the outgoing + * return value ready to go. + */ + pFoo->Success=MrFooFunction(pFoo->Name,pFoo->Age,pFoo->Height); + + /* + * That's it! In many cases, the functionality provided by the service will + * be something that should be per-client to automatically handle cleanup. + * In such cases, it would be prudent to pass the pClient to the function call + * for proper handling. + */ + } + break; + } +} + + +/* + * How to broadcast an outgoing service message (called a notification): + MrNotification_Bar Bar; + Bar.Text="Some text to pass as part of the notification"; + pFoo->Success=pISInterface->ServiceBroadcast(pExtension,hMrService,Mr_BAR,&Bar); + */ \ No newline at end of file diff --git a/src/Services.h b/src/Services.h new file mode 100644 index 0000000..e1b95c3 --- /dev/null +++ b/src/Services.h @@ -0,0 +1,25 @@ +#ifndef SERVICE +#define SERVICE_SELF +#define SERVICE(_name_,_callback_,_variable_) extern HISXSERVICE _variable_;extern void __cdecl _callback_(ISXInterface *pClient, unsigned int MSG, void *lpData); +#endif +// ---------------------------------------------------- +// services + +SERVICE("Mr Service",MrService,hMrService); + + + + + + + + + + + + +// ---------------------------------------------------- +#ifdef SERVICE_SELF +#undef SERVICE_SELF +#undef SERVICE +#endif \ No newline at end of file diff --git a/src/TopLevelObjects.cpp b/src/TopLevelObjects.cpp new file mode 100644 index 0000000..cf054da --- /dev/null +++ b/src/TopLevelObjects.cpp @@ -0,0 +1,22 @@ +#include "ISXMr.h" + +// A LavishScript Top-Level Object is similar to a global C++ object. The main difference is that +// a TLO can give ANY data type it wants; it is not limited to a single type. You may wish to give +// a different type depending on the index (parameters, dimensions, etc) for example. Usually, though, +// you simply give one specific type. + +bool __cdecl TLO_Mr(int argc, char *argv[], LSTYPEVAR &Dest) +{ + // argc and argv are used if the object access uses an index, such as Mr[1] or + // Mr[my coat,1,seventeen]. argc is the number of parameters (or dimensions) separated + // by commas, and does NOT include the name of the object. + + // LSTYPEVAR, used for Dest, is a VarPtr with a Type. Type should be set to a pointer to a data type, + // such as Dest.Type=pIntType for integers. Do not set the Type or return true if the data retrieval + // fails (there is no object). For example, if the requested data is a string, and the string does + // not exist, return false and do not set the type. + + Dest.DWord=1; + Dest.Type=pMrType; + return true; +} diff --git a/src/TopLevelObjects.h b/src/TopLevelObjects.h new file mode 100644 index 0000000..84a3926 --- /dev/null +++ b/src/TopLevelObjects.h @@ -0,0 +1,31 @@ +#ifndef TOPLEVELOBJECT +#define TOPLEVELOBJECT_SELF +#define TOPLEVELOBJECT(name,funcname) extern bool funcname(int argc, char *argv[], LSTYPEVAR &Ret); +#endif + +// ---------------------------------------------------- +// Top-Level Objects + +TOPLEVELOBJECT("Mr",TLO_Mr); + + + + + + + + + + + + + + + + + +// ---------------------------------------------------- +#ifdef TOPLEVELOBJECT_SELF +#undef TOPLEVELOBJECT_SELF +#undef TOPLEVELOBJECT +#endif \ No newline at end of file diff --git a/src/isxeq2/Actor.cpp b/src/isxeq2/Actor.cpp new file mode 100644 index 0000000..15a39c4 --- /dev/null +++ b/src/isxeq2/Actor.cpp @@ -0,0 +1,139 @@ +// +// Created by marob on 12/20/2023. +// + +#include "Actor.h" + +u_long Actor::GetId() { + return {static_cast(this->GetMemberResponse("ID").Int64)}; +} + +std::string Actor::GetName() { + return {this->GetMemberResponse("Name").CharPtr}; + +} + +std::string Actor::GetLastName() { + return { this->GetMemberResponse("LastName").CharPtr }; +} + +int Actor::GetHealthPercentage() { + return this->GetMemberResponse("Health").Int; +} + +int Actor::GetPowerPercentage() { + return this->GetMemberResponse("Power").Int; +} + +int Actor::GetLevel() { + return this->GetMemberResponse("Level").Int; +} + +int Actor::GetEffectiveLevel() { + return this->GetMemberResponse("EffectiveLevel").Int; +} + +u_int Actor::GetTintFlags() { + return this->GetMemberResponse("TintFlags").Int; +} + +std::string Actor::GetVisualVariant() { + return { this->GetMemberResponse("VisualVariant").CharPtr }; +} + +std::string Actor::GetMood() { + return { this->GetMemberResponse("Mood").CharPtr }; +} + +std::string Actor::GetCurrentAnimation() { + return { this->GetMemberResponse("CurrentAnimation").CharPtr }; +} + +std::string Actor::GetOverlay() { + return { this->GetMemberResponse("Overlay").CharPtr }; +} + +std::string Actor::GetAura() { + return { this->GetMemberResponse("Aura").CharPtr }; +} + +std::string Actor::GetGuild() { + return { this->GetMemberResponse("Guild").CharPtr }; +} + +std::string Actor::GetType() { + return { this->GetMemberResponse("Type").CharPtr }; +} + +std::string Actor::GetSuffixTitle() { + return { this->GetMemberResponse("SuffixTitle").CharPtr }; +} + +std::string Actor::GetConColor() { + return { this->GetMemberResponse("ConColor").CharPtr }; +} + +std::string Actor::GetRawConColor() { + // TODO: Modify to accept a parameter & pass in the string 'raw' + return { this->GetMemberResponse("RawConColor").CharPtr }; +} + +std::string Actor::GetFactionStanding() { + return { this->GetMemberResponse("FactionStanding").CharPtr }; +} + +int Actor::GetFaction() { + return this->GetMemberResponse("Faction").Int; +} + +Actor Actor::GetTarget() { + return Actor(this->GetMemberResponse("Target")); +} + +Actor Actor::GetPet() { + return Actor(this->GetMemberResponse("Pet")); +} + +int Actor::GetThreatToPet() { + return this->GetMemberResponse("ThreatToPet").Int; +} + +int Actor::GetThreatToMe() { + return this->GetMemberResponse("GetThreatToMe").Int; +} + +int Actor::GetThreatToNext() { + return this->GetMemberResponse("GetThreatToNext").Int; +} + +float Actor::GetDistance() { + return this->GetMemberResponse("Distance").Float; +} + +float Actor::GetDistance2d() { + return this->GetMemberResponse("Distance2D").Float; +} + +float Actor::GetX() { + return this->GetMemberResponse("X").Float; +} + +float Actor::GetY() { + return this->GetMemberResponse("Y").Float; +} + +float Actor::GetZ() { + return this->GetMemberResponse("Z").Float; +} + +std::string Actor::GetRace() { + return {this->GetMemberResponse("Race").CharPtr}; +} + +std::string Actor::GetClass() { + return {this->GetMemberResponse("Class").CharPtr}; +} + +std::string Actor::GetGender() { + return {this->GetMemberResponse("Gender").CharPtr}; +} \ No newline at end of file diff --git a/src/isxeq2/Actor.h b/src/isxeq2/Actor.h new file mode 100644 index 0000000..2bf13d2 --- /dev/null +++ b/src/isxeq2/Actor.h @@ -0,0 +1,65 @@ +// +// Created by marob on 12/20/2023. +// + +#ifndef ACTOR_H +#define ACTOR_H +#include + +#include "LSObject.h" + + +class Actor : public LSObject { +public: + explicit Actor(const LSOBJECT &obj) : LSObject(obj), lsObject(obj) { + } + + // General + u_long GetId(); + std::string GetName(); + std::string GetLastName(); + int GetHealthPercentage(); + int GetPowerPercentage(); + int GetLevel(); + int GetEffectiveLevel(); + u_int GetTintFlags(); + std::string GetVisualVariant(); + std::string GetMood(); + std::string GetCurrentAnimation(); + std::string GetOverlay(); + std::string GetAura(); + std::string GetGender(); + std::string GetRace(); + std::string GetClass(); + std::string GetGuild(); + std::string GetType(); + std::string GetSuffixTitle(); + std::string GetConColor(); + std::string GetRawConColor(); + std::string GetFactionStanding(); + int GetFaction(); + Actor GetTarget(); + Actor GetPet(); + + // Threat + int GetThreatToPet(); + int GetThreatToMe(); + int GetThreatToNext(); + + // Location + float GetDistance(); // Note: This is the distance using three dimensions, which is what the EQ2 client primarily uses for determining ability ranges, etc. + float GetDistance2d(); + float GetX(); + float GetY(); + float GetZ(); + + + + +private: + LSOBJECT lsObject; +}; + + + +#endif //ACTOR_H diff --git a/src/isxeq2/Character.cpp b/src/isxeq2/Character.cpp new file mode 100644 index 0000000..c4c88d7 --- /dev/null +++ b/src/isxeq2/Character.cpp @@ -0,0 +1,39 @@ +// +// Created by marob on 12/20/2023. +// + +#include "Character.h" + +std::string Character::GetArchetype() { + const auto response = this->GetMemberResponse("Archetype"); + + return {response.CharPtr}; +} + +std::string Character::GetSubClass() { + const auto response = this->GetMemberResponse("SubClass"); + + return {response.CharPtr}; +} + +std::string Character::GetTradeskillArchtype() { + const auto response = this->GetMemberResponse("TSArchetype"); + + return {response.CharPtr}; +} + +std::string Character::GetTradeskillClass() { + const auto response = this->GetMemberResponse("TSClass"); + + return {response.CharPtr}; +} + +std::string Character::GetTradeskillSubClass() { + const auto response = this->GetMemberResponse("TSSubClass"); + + return {response.CharPtr}; +} + + + + diff --git a/src/isxeq2/Character.h b/src/isxeq2/Character.h new file mode 100644 index 0000000..7063644 --- /dev/null +++ b/src/isxeq2/Character.h @@ -0,0 +1,31 @@ +// +// Created by marob on 12/20/2023. +// + +#ifndef CHARACTER_H +#define CHARACTER_H + +#include +#include + +#include "Actor.h" + +class Character : public Actor { +public: + explicit Character(const LSOBJECT &obj) : Actor(obj), lsObject(obj) { } + + std::string GetArchetype(); + std::string GetSubClass(); + std::string GetTradeskillArchtype(); + std::string GetTradeskillClass(); + std::string GetTradeskillSubClass(); + + +private: + LSOBJECT lsObject; + +}; + + + +#endif //CHARACTER_H diff --git a/src/isxeq2/LSObject.cpp b/src/isxeq2/LSObject.cpp new file mode 100644 index 0000000..479700b --- /dev/null +++ b/src/isxeq2/LSObject.cpp @@ -0,0 +1,19 @@ +// +// Created by marob on 12/20/2023. +// + +#include "LSObject.h" + +LSOBJECT LSObject::GetMemberResponse(const std::string &memberName) { + LSOBJECT response; + + this->lsObject.Type->GetMemberEx( + this->lsObject.GetObjectData(), + const_cast(memberName.c_str()), + 0, + nullptr, + response + ); + + return response; +} \ No newline at end of file diff --git a/src/isxeq2/LSObject.h b/src/isxeq2/LSObject.h new file mode 100644 index 0000000..bca93b0 --- /dev/null +++ b/src/isxeq2/LSObject.h @@ -0,0 +1,21 @@ +// +// Created by marob on 12/20/2023. +// + +#ifndef LSOBJECT_H +#define LSOBJECT_H +#include + + +class LSObject { +public: + explicit LSObject (const LSOBJECT &obj) : lsObject(obj) {} +protected: + LSOBJECT GetMemberResponse(const std::string &memberName); +private: + LSOBJECT lsObject; +}; + + + +#endif //LSOBJECT_H