AutoHotkey Community

data[index*5]

data[index*5+1]

;"uri field"

;in Java (0-based index)
data[index*5]

;in AHK (1-based index)
Array_get(data, index*5+1)

;"localName field"

;in Java (0-based index)
data[index*5+1]

;in AHK (1-based index)
Array_get(data, index*5+2)

;"localName field"

;in Java (0-based index)
data[index*5+1] = "Some name"

;in AHK (1-based index)
Array_set(data, index*5+2, String_new("Some name"))

;0-based index
index = 0

;0-based field ("uri" is the first field)
field = 0

;+1 converts from 0-based to 1-based index
value := Vector_get(data, index*5+field+1)

;0-based index
index = 0

;0-based field ("uri" is the second field)
field = 1

;+1 converts from 0-based to 1-based index
value := Vector_get(data, index*5+field+1)

/*
ImplementationFactory Interface

This interface provides methods and fields for any class acting as a factory class, allowing object registration and retrieval, either temporarily or consistently between sessions.

The "new" method of the ImplementationFactory should never be called by the end user. It is called only within the "singleton" method as needed. All static methods should use the "singleton" method to retrieve the current factoryObject.

A class must be registered with the factory (which should then persist permanently unless unregistered).
Registration can happen one of the following ways:
 - Calling the "register" method (which should persist permanently between sessions [unless unregistered or not found])
 - Calling the "add" method (which only persists until the factory object is destroyed)
 - Modifying the defaultImplementations list, though how that is implemented is not defined here

 Factories should generally store registered implementations in an implementationsFile. How this is implemented is not defined in this interface, however.

 Note:
 Many times, factories will need to locate an implementation based on what "features" the it offers. How this is handled is out of scope for this interface, but a recommentation is to expand the "create" method into a "create[ImplementationName] method which includes one or more parameters for defining the features to check for.
*/

/*
   Static Methods
*/

/*   Method: singleton
   Description: returns the current factoryObject, and optionally re-creates it

   This function is called within every other static function to always get the current factoryObject.

   This function handles the one and only factory object that should exist during any session. The factoryObject should be a static variable within this function. It is created upon the first call to this method, and destroyed and re-created if the reset parameter is true.

   The function ALWAYS returns a valid factory object. If one already exists, and reset is not true, it simply returns the existing factory.
*/
ImplementationFactoryI_singleton(reset) {
   return Class_sCall(A_ThisFunc, implementation)
}

/*   Method: create
   Description: Locates and creates a new instance of an object from a registered implementation

   This allows a single point of object creation no matter which class implements the object.

   Some ImplementationFactories may create several types of objects, and may have different createImplementation-style static functions to accomodate creating different types of things. In those cases, this function may return either one of the other creation functions, or nothing.
*/
ImplementationFactoryI_create() {
   return Class_sCall(A_ThisFunc)
}

/*   Method: register
   Description: Register an implementation with the factory (permanently until unregistered)

   The factory should save the implementation permanently. No matter how this is implemented (usually by saving the list of implementations to file), it should not allow duplicates in the list.

   This method should also add the new implementation to the current factoryObject, unless it has already been added manually with the "add" method (duplicates should not be allowed in that list either).

   An ImplementationFactory is required to verify that a registered implementation actually exists before it is used. If it doesn't exist, or it's new function doesn't return a valid object, the next registered implementation is tried.

   An implementation may be unregistered automatically by the factory if it is not found, but it is not required by this interface.
*/
ImplementationFactoryI_register(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

/*   Method: unregister
   Description: Unregister an implementation with the factory

   The factory should remove the implementation permanently (unless it is again registered). It should also remove it from the current factoryObject, though it may also be removed manually before it is unregistered, so this method should not require the removal to succeed.
*/
ImplementationFactoryI_unregister(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

/*   Method: add
   Description: adds an implementation to the current implementationObject

   This does not persist between sessions, or register the implementation permanently. It should be used during this session as if it were registered, however.

*/
ImplementationFactoryI_add(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

/*   Method: remove
   Description: removes an implementation from the current implementationObject

   This does not persist if the implementation is registered, but only removes it from the current session's factoryObject. It does not unregister the implementation.
*/
ImplementationFactoryI_remove(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

/*
   Fields
*/
; Returns a list or object of registered (or known) implementations (can be called to get a list of all known implementations, though its format or return type is undefined here)
ImplementationFactoryI_getImplementations(ImplementationFactoryObject) {
   return Class_Call(ImplementationFactoryObject, A_ThisFunc)
}
; Sets the current list of implementations (usually not called by end-users)
ImplementationFactoryI_setImplementations(ImplementationFactoryObject, implementations) {
   return Class_Call(ImplementationFactoryObject, A_ThisFunc, implementations)
}

ImplementationFactoryI_singleton(reset) {
   return Class_sCall(A_ThisFunc, implementation)
}

ImplementationFactoryI_create() {
   return Class_sCall(A_ThisFunc)
}

ImplementationFactoryI_register(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

ImplementationFactoryI_unregister(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

ImplementationFactoryI_add(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

ImplementationFactoryI_remove(implementation) {
   return Class_sCall(A_ThisFunc, implementation)
}

ImplementationFactoryI_singleton(reset) {
   return Class_sCall(A_ThisFunc, implementation)
}

windowTest(0)

windowTest(offset) {

   window := new("Window", "/x:" . 200+offset . " /y:" . 50+offset)

   okButton := new("Button", "/text:Click me"
      . " /window:" . window
      . " /offset:" . offset
      . " /x:5 /y:5 /w:100")
   addCallback(okButton, "onClick", "clicked")

   quitButton := new("Button", "/text:Quit"
      . " /window:" . window
      . " /x:5 /y:45 /w:100")
   addCallback(quitButton, "onClick", "quit")

   call(window, "show")
}

clicked(this, args) {
   offset := getProperty(this, "offset")
   windowTest(25+offset)
}

quit(this, args) {
   ExitApp
}

#include ../../..
#include src/core/Package.ahk
#include src/gui/Package.ahk

Main := Main_new()
Main_setRun(Main, "lol")
return

#include Class.ahk

Main_getTR_Selection(MainObject)
{
    return Class_getValue(MainObject, "b1", "uint")
}
Main_setTR_Selection(MainObject, Object)
{
    return Class_setValue(MainObject, "b1", Object, "obj")
}

Main_getRun(thisObject)
{
    return Class_getString(thisObject, "b2")
}
Main_setRun(thisObject, list = "lol")
{
  NumberOfT := 0
  NumberOfP := 0
  Loop, c:\* , 2, 0
  {
    PName := A_LoopFileName
    NumberOfP := a_index
      loop, %PName%\* , 2 , 0
      {
          NumberOfT += 1
          if (NumberOfT = 1)
            TR_TemplatesString := A_LoopFileName . "|" . PName
          else
            TR_TemplatesString := TR_TemplatesString . "$" . A_LoopFileName . "|" . PName
      }
      loop, %PName%\* , 2 , 0
      {
          NumberOfT += 1
          if (NumberOfT = 1)
            TR_TemplatesString := A_LoopFileName . "|" . PName
          else
            TR_TemplatesString := TR_TemplatesString . "$" . A_LoopFileName . "|" . PName
      }
  }
  return Class_setString(thisObject, "b2", TR_TemplatesString)
}

;if called, this function MUST be called only once,
;   and before creating any objects of this class.
;sets the size of the user-defined values (can change script to script)
Main_setUserDefinedSize(Size = "")
{
    static UserDefinedSize = 0

    if (Size != "")
        UserDefinedSize := Size

    return UserDefinedSize
}


;destroys the specified Main object and frees any memory that it occupies.
Main_destroy(ByRef MainObject)
{
  if (result := Class_destroy(MainObject))
    MainObject := ""
  return result
}

Main_equals(MainObject, ClassObject)
{
    return Class_equals(MainObject, ClassObject)
}

;stores a single copy of the class name
Main_initClass()
{
    ;specify Class options in paretheses
    static ClassName := "Main(Cloneable)"

    return &ClassName
}


/*
allocates memory for a new Main object and returns it's address

eases creation of multiple constructors
    see the new() function for use)
*/
Main_new()
{
    ;size of built-in values
    static BuiltInSize = 0
    ;remove if Class allows user-defined values
    static UserDefinedSize = 0
       
    ;Allocate Main info structure
    if MainObject := Class_Alloc(4 * UserDefinedSize + BuiltInSize)
    {
        ;Store "Class values" (must be present in ALL classes)
        Class_setClass(MainObject, Main_initClass())
        Class_setBuiltInSize(MainObject, BuiltInSize)
        Class_setUserDefinedSize(MainObject, UserDefinedSize)
   
        ;Set Built-in values (done in constructors)
       
    }
   
    return MainObject
}

;stores a single copy of the structure for the built-in values
;(note: this is NOT stored with the class object)
Main_getBuiltInValues(variableName = "")
{
    static BuiltInValues

    if (BuiltInValues = "")
    {
        ;only done once

        BuiltInValues =
        (LTrim Comments Join,
            ;list the built-in values here
            obj   
            string
            ;obj
            ;obj 
            ;list the TYPES (used by the SETTERS) for your Class values
            ;the order MUST mimic the setter order
            ;   first value ("b1") first, etc.
        )
    }

    return BuiltInValues
}

;returns a clone of the Main object
Main_clone(MainObject, DeepCopy = true)
{

    TheClone := Class_clone(MainObject, DeepCopy)
   
    if (DeepCopy = -1)
    {

    }

    ;%CallFunction%(TheClone, MainObject, DeepCopy)

    return TheClone
}