Inner Space Extension Development Kit (ISXDK)
              Library Version 34
     (c) 2004-2014 Lavish Software, LLC
---------------------------------------------

Changelog
--------------------------------

Version 34
- x64 libs now available under lib64/
- All char * instances that should be treated as const are now marked const
- Various usages of int and unsigned int are now size_t
- Added to ISInterface:
  * char *GetLogsPath(const char *extension_subdir, char *buffer, size_t buflen)
  * char *GetSettingsPath(char *buffer, size_t buflen)
  * char *GetNETProgramsPath(char *buffer, size_t buflen)
  * char *GetExtensionsPath(char *buffer, size_t buflen)
  * char *GetInterfacePath(char *buffer, size_t buflen)
  * char *GetLavishScriptModulesPath(char *buffer, size_t buflen);
  * char *GetScreenshotsPath(char *buffer, size_t buflen)
  * char *GetScriptsPath(char *buffer, size_t buflen)
- Added to ISXInterface:
  * bool RequestShutdown() -- This is called to request permission to call Shutdown().
    To prevent the Shutdown() and subsequent FreeLibrary on this unload attempt, simply return false.

Version 33
- Visual Studio 2013 libs
- LSOBJECTDATA is now 64-bit instead of 32-bit, and includes a constructor to initialize to 0
- LSOBJECTDATA no longer has VarPtr and ObjectData union members. Use GetObjectData() and
  SetObjectData()

Version 32a
- LavishScript 2.0 support now built into ISInterface:
  * bool GetLavishScript2Environment(unsigned int LS2MODULE_SDK_VERSION, void **ppEnvironment)
  * To use the LS2 Environment, you will need the ls2module development kit!
  * Call the static ILS2Module::AttachEnvironment before instantiating any LS2 objects
  * Specifically embedding one or more LS2 Modules into your IS extension is optional; Types can be
    implemented by your IS extension by accessing the Environment. However, it is possible to
	register any number of Modules by providing loaders, as opposed to only loading DLL files.

Version 32
- Visual Studio 2010 are now provided. Visual Studio 2008 libs are no longer provided.
- GetArgs now requires a buflen parameter

Version 31
- Visual Studio 2008 libs are now provided (vs90). Unfortunately due to incompatibilities with our
  own libraries, Visual Studio 2003-2005 libs are no longer provided.

Version 30c
- Misc fixes

Version 30b
- LSSTLTypes now use virtual functions

Version 30a
- Support for LavishScript queries added (Requires IS build 4412 or later)
	virtual unsigned int CreateQuery(const char *Text)=0;
	virtual bool RetrieveQueryExpression(unsigned int ID,char *buf, unsigned int buflen)=0;
	virtual bool QueryEvaluate(unsigned int ID,LSOBJECT &Object, bool &bResult)=0;
	virtual bool FreeQuery(unsigned int ID)=0;
  QueryEvaluate determines if an LSOBJECT matches a query

Version 30
- CIndex resizing issue fixed by adding some virtual functions

Version 29f
- LavishGUI API version 11 -- fixed heap corruption/Windows Vista crashes  

Version 29e
- LavishScript additions for object persistence, used for .NET:
	virtual unsigned int RegisterPersistentClass(const char *Name)=0;
	virtual void InvalidatePersistentClass(unsigned int Class)=0;
	virtual void InvalidatePersistentObject(unsigned int Class, unsigned int Value)=0;
	virtual void SetPersistentClass(LSTypeDefinition *pType,unsigned int Class)=0;
  To support persistent objects, first register a persistent class, give it a name related to
  your extension. The ID is permanent for the duration of the session and cannot be unregistered.
  You probably do not need to register multiple persistent classes, unless you are implementing
  a persistent *value type* as opposed to reference types. For each LavishScript object type (defined
  by a LSTypeDefinition) that will use your persistent class, use SetPersistentClass. Note that only
  one persistent class can be used for any given type, but any number of types may use a given persistent
  class. Then, when a persistent object must be destroyed (such as when the real object is being deleted), 
  invalidate it using InvalidatePersistentObject with the class ID returned from registering, and the 
  value that identifies the reference. For example, you may have a LavishScript type definition for a
  C++ class called Person, and the 32-bit value used by this type is a Person*. In the Person destructor, 
  you would then call:
    InvalidatePersistentObject(MyPersistentClass,(unsigned int)this);
  This would invalidate any persistent references in the given persistent class pointing to that Person*.

Version 29d
- LavishVM (.NET 2.0)
	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 (mostly useful for exposing .NET 2.0 API)
	virtual void FrameLock()=0;
	virtual void FrameUnlock()=0;
	virtual bool FrameTryLock()=0;
	virtual void FrameWait(bool bLock)=0;

Version 29c
- More updates to LavishScript containers

Version 29b
- Updates to LavishScript containers, iteratables and iterators

Version 29a
- Misc fixes

Version 29
- LavishScript updates
- Added reserved functions to the Inner Space interfaces so that the API can be extended with
  minor ISXDK updates, rather than requiring a full version
- All instances of "unsigned long" have been changed to "unsigned int" for portability reasons.  
  Extensions will need to be updated accordingly
- New API includes
	virtual unsigned int SetPrintableBindsAllowed(bool bEnable)=0;
	virtual unsigned int GetPrintableBindsAllowedCount()=0;
	
	virtual unsigned int PreParseText(const char *Text, bool bDataSequence=false)=0;
	virtual bool RetrieveOriginalText(unsigned int ID, char *buf, unsigned int buflen)=0;
	virtual bool RetrieveProcessedText(unsigned int ID, char *buf, unsigned int buflen)=0;
	virtual bool RetrieveProcessedResult(unsigned int ID, LSOBJECT &Result)=0; // data sequence only
	virtual bool FreePreParsed(unsigned int ID)=0;
- Added ISXPreParse and ISXDataSequence helper classes for improving performance of parsing and
  data sequence reduction

Version 28a
- Misc fixes, new LavishScript helper classes, replacements for some of the old LavishScript
  helper classes

Version 28
- Navigation interface (ISNavigationInterface) replaced
- New API includes
	virtual unsigned long GetBuildNumber()=0;
	virtual bool DataParse(const char *Text, LSOBJECT &Object)=0;
- mkisx now adds a section to register the extension in InnerSpace.xml, and a version system.
  To add this to an existing extension, copy this function:
	void ISXFullTemplate::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 (ISXFullTemplate)
		// 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 long ExtensionSetGUID=pISInterface->GetExtensionSetGUID("ISXFullTemplate");
		if (!ExtensionSetGUID)
		{
			ExtensionSetGUID=pISInterface->CreateExtensionSet("ISXFullTemplate");
			if (!ExtensionSetGUID)
				return;
		}
		pISInterface->SetSetting(ExtensionSetGUID,"Filename",ModuleFileName);
		pISInterface->SetSetting(ExtensionSetGUID,"Path",ModulePath);
		pISInterface->SetSetting(ExtensionSetGUID,"Version",FullTemplate_Version);
	}
  Call the function at the top of your extension's Initialize function, after setting pISInterface.
- Extended utf8string functionality a little bit with += operator for concatenation, among other
  things
  
Version 27b
- Added fopen_utf8, which works the same as the libc fopen, but supports UTF-8 file/path names.
  You should switch all "fopen" usage in extensions to fopen_utf8

Version 27a
- Added "Modules" service (not to be confused with LavishScript modules, this simply refers to
  host program modules which may be dynamically loaded), which indicates when a DLL is loaded 
  or freed

Version 27
- LavishGUI API Version 8
- New API includes
	virtual unsigned long EnumAliases(fLSGenericEnumCallback Callback, void *pData)=0;
	virtual unsigned long EnumCommands(fLSGenericEnumCallback Callback, void *pData)=0;
	virtual unsigned long EnumLSTypeDefinitions(fLSGenericEnumCallback Callback, void *pData)=0;
	virtual unsigned long EnumTopLevelObjects(fLSGenericEnumCallback Callback, void *pData)=0;
	virtual unsigned long EnumScripts(fLSGenericEnumCallback Callback, void *pData)=0;

Version 26
- ISXDK distribution now uses sub-folders of "lib" to store libraries for different
  compilers.  lib/vs70 is for Visual Studio .net 2002 and 2003 (aka 7.0 and 7.1).
  lib/vs80 is for Visual Studio 2005 (aka 8.0).  lib/gcc is for GNU compiler collection.

Version 25
- LavishGUI API Version 7

Version 24
- LavishGUI API Version 6
- New API includes but is not limited to...
	virtual unsigned long GetExtensionSetGUID(const char *Extension)=0;
	virtual unsigned long GetScriptSetGUID(const char *Script)=0;
	virtual unsigned long CreateExtensionSet(const char *Extension)=0;
	virtual unsigned long CreateScriptSet(const char *Script)=0;
	virtual bool HighStealthEnabled()=0;
	virtual void EnableHighStealth()=0;
	virtual void DisableHighStealth()=0;
- "High Stealth" is for TEMPORARY additional stealth while an application performs scanning
  routines.  Proper usage would be as follows:
    bool Temp=pISInterface->HighStealthEnabled();
    if (!Temp)
		pISInterface->EnableHighStealth();
	PerformScanning();
	if (!Temp)
		pISInterface->DisableHighStealth();
    

Version 23
- LavishGUI API version 5
- New API includes but is not limited to...
	virtual unsigned long RegisterEvent(const char *Name)=0;
	virtual void UnregisterEvent(unsigned long EventID)=0;
	virtual bool ExecuteEvent(unsigned long EventID,int BeginInclusive=0, int EndExclusive=0, char *argv[]=0, PLSOBJECT pThisLSObject=0)=0;
	virtual bool AttachEventTarget(unsigned long EventID,unsigned long AtomID)=0;
	virtual bool AttachEventTarget(unsigned long EventID,fLSEventTarget fCallback)=0;
	virtual bool DetachEventTarget(unsigned long EventID,unsigned long AtomID)=0;
	virtual bool DetachEventTarget(unsigned long EventID,fLSEventTarget fCallback)=0;
	virtual bool ScriptEngineActive()=0;
	virtual void LavishScriptPulse()=0;
	virtual void Print(const char *Text)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, const char *Value)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, bool &bValue)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, int iValue)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, float &fValue)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, unsigned long &ulValue)=0;
	virtual bool AssertSetting(unsigned long &SetGUID, const char *Setting, __int64 &Value)=0;


Version 22:
- LavishGUI API version 4
- Replaced mkisx.exe, which now uses ISXFullTemplate from the "samples" directory to generate
  an extension.  The template is fairly up to date and is far more organized and useful than
  the files produced by the old mkisx

Version 21:
- LavishGUI API version 3
- API support for LavishScript atoms added
- API support added for 64-bit integer math

Version 20a:
- Software Cursor support added via service
- LavishGUI API version 2

Version 20:
- Added some stubs for navigation-related functionality so I dont have to do another major update 
  soon just to add those
- The deprecated DataParse is now gone, use the new one
- ISUI has been separated from Inner Space and is now LavishGUI, LGUI for short.  Search/replace
  any instances of ISUI with LGUI in your code and you'll be fine.  This does not affect XML,
  existing scripts, etc -- just extensions.
- Added optional parameters in argc, argv form for RunScriptFromBuffer

Version 19:
- Added the missing CreateSet function to replace the old deprecated one

Version 18b:
- LavishScript-related updates:
  * Several structures and classes (and their members) have been renamed.  For compatibility,
    the old names can still be used just fine and with no adverse effects.  The changes as well
    as brief explanations of what each thing is follows:
    * LSType is now LSTypeDefinition. LSTypeDefinition tells LavishScript all about how to
      use a data type, given an instance of that type (such as how to handle a string, given
      the char *).  This includes how to retrieve or set data, how to initialize a variable of 
      this type, and so on.  Some types are not safe to use as both a variable (which has methods)
      and a constant (which doesn't have methods), in which case the LSTypeDefinition can optionally
      supply a different LSTypeDefinition pointer for use when creating and accessing variables of 
      the type.
    * LSVARPTR is now LSOBJECTDATA. LSOBJECTDATA is whatever 32-bit value is stored by an object
      (for example, a pointer to object data, an integer, a pointer to a string, etc)
    * LSTYPEVAR is now LSOBJECT. LSOBJECT is the combination of LSOBJECTDATA and a pointer to an
      LSTypeDefinition.  When you are expected to provide LSOBJECT, you must fill in the type
      definition AND the data, or return false.  Only return true if the data is valid for the
      given type (e.g. 0 is not a valid char*, so dont tell LavishScript that you're giving it
      a valid string definition).  Do not modify the TYPE portion of LSOBJECT unless you are
      returning a valid object, but you may modify the data portion.
    * VarPtr is now ObjectData. ObjectData is LSOBJECTDATA as described above
    * LSType-related functions in ISInterface have been renamed to add the word "Definition".    

Version 18a:
- ISUI Version 5

Version 18:
- LavishScript-related updates:
  * FromData is removed from LSType. This does not affect existing extensions.
  * GetTempBuffer can be used to create temporary buffers for data sequence use
  * New class CTempObject can be used in conjunction with AddTempObject for temporary
    objects in data sequences that require cleanup
  * The old DataParse function is now deprecated.  The new one is:
      int DataParse(const char *ToParse, char *buf, int buflen)
    The return value is -1 if the buffer would have overflowed.  Otherwise, the length
    of the resulting string in buf (excluding null terminator).
  * Scripts can now be executed from a buffer with this new function:
      bool RunScriptFromBuffer(char *Name, char *Buffer, unsigned long buflen)
    You must name the buffer.  Only one script running with this buffer name can be
    running.  The name will be prepended with "Buffer:" in the script list for ending
    scripts and such, to differentiate from scripts running from file.

Version 17:
- Added a couple missing settings-related functions

Version 16a:
- Fixed IsHex implementation

Version 16:
- Some work on organization of ISInterface by splitting the interface into several
  sub-interfaces.  Multiple inheritance is used, so this does not require changes to
  existing extensions.
- Added functionality for LavishSettings. Most of the old settings functions have been
  marked deprecated, and as such, will produce compiler warnings.  These warnings CAN
  be ignored.  However, these functions will be removed in a future version of ISXDK,
  likely to be version 17.
- GetConsoleWidth is now GetTerminalWidth, as is standard for LavishScript interfaces.
  This probably doesnt directly affect any currently existing extensions.
- Due to the new font support, text display functions have been deprecated.

Version 15:
- Various updates for LavishScript handling

Version 14a:
- "Process Frame" service has been merged with the "Pulse" service
- PROCESSFRAME_FRAME is now PULSE_PREFRAME
- Removed pause and resume from the Scripts service.  These were only in the service
  so I wouldn't have to bump ISXDK to version 14, but I ended up having to anyway and
  the functions were put in the ISInterface.


Version 14:
- Added Scripts service, including the ability to pause and resume scripts.  This will
  help solve problems during game loading times, when scripts should not be running
- Added many functions to the Inner Space interface

Version 13c:
- Fixed problem where extensions providing ISUI elements could not be re-loaded after
  unloading

Version 13b:
- ISUI heap corruption fix

Version 13a:
- ISUI updates

Version 13:
- ISUI updates

Version 12h:
- ISUI updates
- Added Queue helper class

Version 12f:
- ISUI updates (noticing a pattern here?)
- Added ISGetTriggerLine macro

Version 12e:
- ISUI updates

Version 12d:
- ISUI updates
- Added distance functions that do not use the square root function, for distance comparisons

Version 12b:
- Texture support... mostly

Version 12a:
- UI fixes

Version 12:
- CNavPath now uses names in addition to the points
- Inner Space User Interface support (ISUI)

Version 11:
- Minor fixes

Version 10c:
- Fixed column renderer

Version 10b:
- Fixed a screwup that required 10a to recompile any v10 extensions

Version 10a:
- Files service

Version 10:
- Added some stuff

Version 9a:
- Triggers service

Version 9:
- Added some functions for determining if commands, TLOs, etc exist

Version 8a:
- Updated for LavishScript separation
  ISType=>LSType
  ISTYPEVAR=>LSTYPEVAR
  ISVARPTR=>LSVARPTR
  fISCommand=>fLSCommand
  fISTopLevelObject=>fLSTopLevelObject
- Added "bin" directory, which now contains mkisx.exe for generating a templated extension for editing,
  and Struct2LSType.exe, which will convert a C header with structs to a set of LSType classes for use
  with LavishScript (to avoid confusion: you directly use the structs in your extensions, LSTypes are
  for scripting ;) )

Version 8:
- Added RGBCOLOR, which is the color format given in the new GetPixel functions
- Added to ISInterface...
 	virtual bool GetDisplaySize(unsigned long &Height, unsigned long &Width)=0;
	virtual bool GetPixel(int X, int Y, RGBCOLOR &Color)=0;
	virtual bool GetPixels(int X, int Y, unsigned long nRows, unsigned long nColumns, RGBCOLOR **Rows)=0;
- Added POINT2I and associated GetDistance2D function

Version 7:
- Added RunCommandFile to ISInterface
- "Press" Parameter added to AddHotkey

Version 6b:
- Renamed "ISData" used in reference to Top Level Objects to "TopLevelObject" to reduce confusion. The old
  names are around until next version, so switch asap to avoid compile errors later ;)

Version 6a:
- Added 2D point structure and distance function
- Added function to determine the nearest distance from a point to a line segment in 2 dimensions (e.g.
  generic 2D collision prediction)

Version 6:
- Navigation system functions

Version 5a:
- Memory service will now take advantage of memory protection services, also added messages to check if the
  current client has detoured or modified a specific address
- Added FileList.h 

Version 5:
- Added XML Settings system, which is not currently documented in this file, sorry!

Version 4b:
- "HTTP" service added, providing access to HTTP requests (FTP too... actually everything CURLlib supports)

Version 4a:
- "Memory" service added, providing transparent access to "detours" and memory modification

Version 4:
- Slowly giving access to more parts.  Nobody is asking for specific things so I'm adding them in as I see fit.
  Because I'm working more on the core of IS than the development kit, they will trickle in unless there's requests
	virtual bool MouseTo(int X, int Y)=0;
	virtual bool GetMousePos(int &X, int &Y)=0;
	virtual bool AddElement(char *Name, char *Data, int X, int Y, unsigned long Color, unsigned long FilterMask=1)=0;
	virtual bool RemoveElement(char *Name)=0;

Version 3b:
- Included TypeMember macro in ISType.h

Version 3a:
- Fixed IsNumber function

Version 3:
- Added INIFileName variable to the ISXPreSetup macro, to be used if you wish to use an .ini file for configuration

Version 2:
- Added functions to manipulate settings used by the current session (though it should be noted that most of the
  settings are retrieved only at startup, so they will not take immediate effect)
  