Updated with a new Version of indirectReference.ahk

And fixed a bug with getSize()

Author: nnnik

classGDIp.ahk

@@ -101,8 +101,8 @@ class GDIp
 
 		getSize()
 		{
-			DllCall( "gdiplus\GdipGetImageWidth",  "Ptr", pBitmap, "UInt*", w )
-			DllCall( "gdiplus\GdipGetImageHeight", "Ptr", pBitmap, "UInt*", h )
+			DllCall( "gdiplus\GdipGetImageWidth",  "Ptr", This.ptr, "UInt*", w )
+			DllCall( "gdiplus\GdipGetImageHeight", "Ptr", This.ptr, "UInt*", h )
 			return [ w, h ]
 		}
 

indirectReference.ahk

@@ -1,7 +1,4 @@
-class indirectReference
-{
-	
-	/*
+	/*
 		CLASS indirectReference
 		author:			nnnik
 		
@@ -14,35 +11,79 @@
 		newIndirectReference:	The indirect reference towards the objects passed to the constructor
 		
 		object:				The object you want to refer to indirectly
-	*/
+		
+		modeOrModeStr:			Controls how the indirectReference is connected to the object directly
+							e.g. with a __Call mode all method calls towards the indirectReference will end up calling the same method with the same parameters in the object
+*/
+
+class indirectReference
+{
+	
+	static relationStorage    := {}
+	static performanceStorage := {}
+	static accessStorage      := {}
+	static modeStorage        := {}
+	static baseModes          := { __Call:indirectReference.Call, __Set:indirectReference.Set, __Get:indirectReference.Get, __New:indirectReference.New, __Delete:indirectReference.Delete, _NewEnum:"" }
 
-	__New( Object, modes = "" )
+	__New( obj, modeOrModeStr := "__Call" )
 	{
-		if !( modes )
+		if !isObject( obj )
+			return
+		if isObject( modeOrModeStr )
 		{
-			if !indirectReference.storage.hasKey( &Object )
+			str := ""
+			For modeName, val in modeOrModeStr
+				str .= modeName . "|"
+			modeOrModeStr := subStr( str, 1, -1 )
+		}
+		if !indirectReference.performanceStorage.hasKey( &obj )
+		{
+			indirectReference.performanceStorage[ &obj ] := []
+			indirectReference.accessStorage[ &obj ] := []
+			obj.base := { __Delete: indirectReference.DeleteObject, base: obj.base }
+		}
+		if ( !indirectReference.performanceStorage[ &obj ].hasKey( modeOrModeStr ) | deleteMode := inStr( modeOrModeStr, "__Delete" ) )
+		{
+			if !indirectReference.modeStorage.hasKey( modeOrModeStr )
 			{
-				This.base                            := { __Call:indirectReference.connectBase.__Call, __Delete:indirectReference.removeFromStorage , base:{ __Delete: indirectReference.__Delete } }
-				indirectReference.storage[ &Object ] :=	This
-				indirectReference.storage2[ &This ]  := &Object
-				directReference.enter( This, Object )
+				newMode := {}
+				for each, mode in strSplit( modeOrModeStr, "|" )
+				{
+					newMode[ mode ] := indirectReference.baseModes[ mode ]
+					indirectReference.baseModes[ mode ]
+				}
+				indirectReference.modeStorage[ modeOrModeStr ] := newMode
 			}
-			return indirectReference.storage[ &Object ]
+			newReference := { base: indirectReference.modeStorage[ modeOrModeStr ] }
+			indirectReference.accessStorage[ &obj ].Push( &newReference )
+			indirectReference.relationStorage[ &newReference ] := &obj
+			if !deleteMode
+				indirectReference.performanceStorage[ &obj, modeOrModeStr ] := newReference
+			else
+				return newReference
 		}
-		for each, value in modes
-			modes[ each ] := indirectReference.connectBase[ each ]
-		modes.base := { __Delete:indirectReference.__Delete }
-		This.base  := modes
-		directReference.enter( This, Object )
+		return indirectReference.performanceStorage[ &obj, modeOrModeStr ]
 	}
 
-	static storage 	:= {}
-	static storage2	:= {}
-	static connectBase	:= { __Call:indirectReference.Call, __Set:indirectReference.Set, __Get:indirectReference.Get, __New:indirectReference.New, __Delete:indirectReference.Delete, _NewEnum:"" }
+	DeleteObject()
+	{
+		for each, reference in indirectReference.accessStorage[ &This ]
+		{
+			indirectReference.relationStorage.delete( reference )
+			Object( reference ).base := ""
+		}
+		indirectReference.accessStorage.Delete( &This )
+		indirectReference.performanceStorage.Delete( &This )
+		if ( isFunc( This.base.base.__Delete ) && This.base.base.__Delete.name != indirectReference.DeleteObject.name )
+		{
+			This.base := This.base.base
+			This.__Delete()
+		}
+	}
 
 	Call( functionName = "", parameters* )
 	{
-		if !indirectReference.connectBase.hasKey( functionName )
+		if !( indirectReference.baseModes.hasKey( functionName ) && !This.base.hasKey( functionName ) )
 			return ( new directReference( This ) )[ functionName ]( parameters* )
 	}
 
@@ -61,102 +102,32 @@
 	{
 		newIndirectReference := This.base
 		This.base := ""
-		return new ( new directReference( newIndirectReference ) )( parameter* )
+		__class := new directReference( newIndirectReference )
+		return new __class( parameters* )
 	}
 
 	Delete()
 	{
-		ret := ( new directReference( This ) ).__Delete()
-		continueChain( This, "__Delete", A_ThisFunc )
-		return ret
-	}
-	
-	__Delete()
-	{
-		This.base := ""
-	}
-	
-	removeFromStorage()
-	{
-		pObj := indirectReference.storage2[ &This ]
-		indirectReference.storage2.Delete( &This )
-		indirectReference.storage.Delete( pObj )
-		continueChain( This, "__Delete", A_ThisFunc )
+		return ( new directReference( This ) ).__Delete()
 	}
 
 }
 
-class directReference
-{
-	
-	
-	/*
-		CLASS directReference
-		description:		creates direct References from indirect ones.
-		
-		usage:			object := new directReference( newIndirectReference )
-		
-		object:			The inderect Reference you want to resolve
-	*/
-	
-	static storage  := {}
-	static storage2 := {}
+/*
+	CLASS directReference
+	description:			creates direct References from indirect ones.
 	
-	__New( newIndirectReference )
-	{
-		if directReference.storage.hasKey( &newIndirectReference )
-			return Object( directReference.storage[ &newIndirectReference ] )
-		indirectReference.saveRemoveFromStorage.Call( newIndirectReference )
-	}
+	usage:				object := new directReference( newIndirectReference )
 	
-	enter( newIndirectReference, Object )
-	{
-		if !This.storage.hasKey( &newIndirectReference )
-			newIndirectReference.base		   := { __Delete:This.leaveIndirectReference, base:newIndirectReference.base }
-		if !This.storage2.hasKey( &Object )
-			Object.base					   := { __Delete:This.leaveObject, base:Object.base }
-		This.storage[ &newIndirectReference ] := &Object
-		This.storage2[ &Object, &newIndirectReference ] := &newIndirectReference
-	}
+	newIndirectReference:	A indirectReference created by calling new indirectReference( object )  
 	
-	leaveObject()
-	{
-		ret := continueChain( This, "__Delete", A_ThisFunc )
-		storage := directReference.storage2[ &This ]
-		loop
-		{
-			each := ""
-			for each,val in storage
-			{
-				Object( val ).__Delete()
-				if storage.hasKey( each )
-					storage.Delete( each )
-			}
-		}Until !each
-		return ret
-	}
-	
-	leaveIndirectReference()
-	{
-		ret := continueChain( This, "__Delete", A_ThisFunc )
-		pObj := directReference.storage[ &This ]
-		directReference.storage.Delete( &This )
-		directReference.storage2[ pObj ].Delete( &This )
-		if !directReference.storage2[ pObj ]._newEnum()._Next( each, val )
-			directReference.storage2.Delete( pObj )
-		return ret
-	}
-	
-}
+	object:				The object that is refered to by the indirectReference
+*/
 
-continueChain( object, methodName, functionName, parameters* )
+class directReference
 {
-	obj := object
-	While ( isObject( obj ) && !( obj.hasKey( methodName ) && obj[ methodName ].name = functionName ) )
-		obj := obj.base
-	obj := obj.base
-	While ( isObject( obj ) && !( obj.hasKey( methodName ) && isFunc( obj[ methodName ] ) ) )
-		obj := obj.base
-	if isFunc( obj[ methodName ] )
-		return obj[ methodName ].Call( object, parameters* )
+	__New( reference )
+	{
+		return Object( indirectReference.relationStorage[ &reference ] )
+	}
 }