manager.lua

dgsLogLuaMemory()
local loadstring = loadstring
-------------------------------------------------Parent/Layer Manager
--Speed Up
local tableInsert = table.insert
local tableRemove = table.remove
local tableFind = table.find
local isElement = isElement
local assert = assert
local tostring = tostring
local tonumber = tonumber
local type = type
local mathMin = math.min
local mathMax = math.max
local mathClamp = math.clamp
local getElementType = getElementType
-------------------------------------------------------Table Defines
--Animations
animQueue = {}
--Render Info
dgsRenderInfo = {
	frames = 0,
	RTRestoreNeed = false,
	renderingResource = {},
}
--Render Settings
dgsRenderSetting = {
	postGUI = false,
	renderPriority = "normal",
}
--Render Functions
dgsPreRenderer = {}
dgsRenderer = {}
dgsChildRenderer = {}
dgs3DRenderer = {}
dgsCustomTexture = {}
dgsBackEndRenderer = {
	register = function(self,dgsType,theFunction)
		self[dgsType] = theFunction
	end,
}
--On Click Action
dgsOnMouseClickAction = {}
dgsOnMouseScrollAction = {}
--Collider
dgsCollider = {
	default = function(source,mx,my,x,y,w,h)
		if mx >= x and mx <= x+w and my >= y and my <= y+h then
			return source
		end
	end,
}
--Visibility
dgsOnVisibilityChange = {}
--Plugin System
dgsPluginTable = {}
--Parent System
BackEndTable = {}			--Store Back-end Render Element (If it has back-end renderer)
BottomRootTable = {}		--Store Bottom Root Element
CenterRootTable = {}		--Store Center Root Element (Default)
TopRootTable = {}			--Store Top Root Element
dgsWorld3DTable = {}
dgsScreen3DTable = {}
LayerCastTable = {center=CenterRootTable,top=TopRootTable,bottom=BottomRootTable}
--
--Element Data System
dgsElementData = {[resourceRoot] = {}}		----The Global BuiltIn DGS Element Data Table
--Property List
dgsElementPropertyList = {}					----The Registered exported property list
--
--Element Type
dgsElementType = {}
--
--TranslationUpdater
dgsOnTranslationUpdate = {
	default = function(dgsEle,key,value)
		local text = dgsElementData[dgsEle]._translation_text
		local translationListener = dgsElementData[dgsEle].translationListener
		if text then
			if key then
				text[key] = value
			elseif translationListener then
				for propertyName in pairs(translationListener) do
					text[propertyName] = dgsElementData[dgsEle][propertyName] or ""
				end
			end
			dgsSetData(dgsEle,"text",text)
		end
		local font = dgsElementData[dgsEle]._translation_font
		if font then
			dgsSetData(dgsEle,"font",font)
		end
	end,
}
--
--Plugin Creation Manager
addEventHandler("onDgsPluginCreate",resourceRoot,function(theResource)
	insertResource(theResource,source)
	local typ = dgsElementData[source].asPlugin
	dgsPluginTable[typ] = dgsPluginTable[typ] or {}
	table.insert(dgsPluginTable[typ],source)
	addEventHandler("onDgsDestroy",source,function()
		local id = table.find(dgsPluginTable[typ],source)
		if id then
			table.remove(dgsPluginTable[typ],id)
		end
	end,false)
end)

--------------------------------------------------------Layer System
function dgsSetLayer(dgsEle,layer,forceDetatch)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsSetLayer",1,"dgs-dxelement")) end
	if dgsElementType[dgsEle] == "dgs-dxtab" then return false end
	if not(layerBuiltIn[layer]) then error(dgsGenAsrt(layer,"dgsSetLayer",2,"string","top/center/bottom")) end
	local parent = dgsElementData[dgsEle].parent
	local hasParent = isElement(parent)
	if hasParent and not forceDetatch then return false end
	if hasParent then
		local id = tableFind(dgsElementData[parent].children,dgsEle)
		if id then
			tableRemove(dgsElementData[parent].children,id)
		end
		dgsElementData[dgsEle].parent = nil
	end
	local oldLayer = dgsElementData[dgsEle].alwaysOn or "center"
	if oldLayer == layer then return false end
	local id = tableFind(LayerCastTable[oldLayer],dgsEle)
	if id then
		tableRemove(LayerCastTable[oldLayer],id)
	end
	dgsSetData(dgsEle,"alwaysOn",layer == "center" and false or layer)
	tableInsert(LayerCastTable[layer],dgsEle)
	return true
end

function dgsGetLayer(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetLayer",1,"dgs-dxelement")) end
	return dgsElementData[dgsEle].alwaysOn or "center"
end

function dgsSetCurrentLayerIndex(dgsEle,index)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsSetCurrentLayerIndex",1,"dgs-dxelement")) end
	if not(type(index) == "number") then error(dgsGenAsrt(index,"dgsSetCurrentLayerIndex",2,"number")) end
	local layer = dgsElementData[dgsEle].alwaysOn or "center"
	local parent = dgsElementData[dgsEle].parent
	local theTable = isElement(parent) and dgsElementData[parent].children or LayerCastTable[layer]
	index = mathClamp(index,1,#theTable+1)
	local id = tableFind(theTable,dgsEle)
	if id then
		tableRemove(theTable,id)
	end
	tableInsert(theTable,index,dgsEle)
	return true
end

function dgsGetCurrentLayerIndex(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetCurrentLayerIndex",1,"dgs-dxelement")) end
	local layer = dgsElementData[dgsEle].alwaysOn or "center"
	local parent = dgsElementData[dgsEle].parent
	local theTable = isElement(parent) and dgsElementData[parent].children or LayerCastTable[layer]
	return tableFind(theTable,dgsEle) or false
end

function dgsGetLayerElements(layer)
	if not(layerBuiltIn[layer]) then error(dgsGenAsrt(layer,"dgsGetLayerElements",1,"string","top/center/bottom")) end
	return #LayerCastTable[layer] or false
end

function dgsGetElementsInLayer(layer)
	if layer == true or layer:lower() == "bottom" then
		return BottomRootTable
	elseif layer:lower() == "top" then
		return TopRootTable
	else
		return CenterRootTable
	end
end

function dgsGetElementsFromResource(res)
	res = res or sourceResource
	if res == "all" then
		local serialized,cnt = {},0
		for r,storeTable in pairs(boundResource) do
			for k,v in pairs(boundResource[r] or {}) do
				cnt = cnt+1
				serialized[cnt] = k
			end
		end
		return serialized
	else
		local serialized,cnt = {},0
		for k,v in pairs(boundResource[res] or {}) do
			cnt = cnt+1
			serialized[cnt] = k
		end
		return serialized
	end
end

function dgsGetChild(dgsEle,id)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetChild",1,"dgs-dxelement")) end
	if not(type(id) == "number") then error(dgsGenAsrt(id,"dgsGetChild",2,"number")) end
	if dgsElementData[dgsEle].children then
		return dgsElementData[dgsEle].children[id] or false
	end
	return false
end

function dgsGetChildren(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetChildren",1,"dgs-dxelement")) end
	return dgsElementData[dgsEle].children or {}
end

function dgsGetParent(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetParent",1,"dgs-dxelement")) end
	return dgsElementData[dgsEle] and dgsElementData[dgsEle].parent or false
end

function dgsSetParent(child,newParent,nocheckRoot,noUpdatePosSize)
	if newParent == resourceRoot then newParent = nil end
	if not(dgsIsType(child)) then error(dgsGenAsrt(child,"dgsSetParent",1,"dgs-dxelement")) end
	if not(not dgsElementData[child] or not dgsElementData[child].attachTo) then error(dgsGenAsrt(child,"dgsSetParent",1,_,_,_,"attached dgs element can not have a parent")) end
	if not dgsElementData[child] then dgsElementData[child] = {} end
	local oldParent = dgsElementData[child].parent
	local parentTable = isElement(oldParent) and dgsElementData[oldParent].children or CenterRootTable
	if isElement(newParent) then
		if not dgsIsType(newParent) then return end
		if not nocheckRoot then
			local id = tableFind(parentTable,child)
			if id then
				tableRemove(parentTable,id)
			end
		end
		dgsElementData[child].parent = newParent
		if not dgsElementData[newParent].children then dgsElementData[newParent].children = {} end
		tableInsert(dgsElementData[newParent].children,child)
		setElementParent(child,newParent)
	else
		local id = tableFind(parentTable,child)
		if id then
			tableRemove(parentTable,id)
		end
		dgsElementData[child].parent = nil
		tableInsert(CenterRootTable,child)
		setElementParent(child,resourceRoot)
	end
	---Update Position and Size
	if not noUpdatePosSize then
		local rlt = dgsElementData[child].relative
		local pos = rlt[1] and dgsElementData[child].rltPos or dgsElementData[child].absPos
		local size = rlt[2] and dgsElementData[child].rltSize or dgsElementData[child].absSize
		calculateGuiPositionSize(child,pos[1],pos[2],rlt[1] and true or false,size[1],size[2],rlt[2] and true or false)
	end
	if dgsElementType[child] == "dgs-dxscrollpane" then
		local scrollbars = (dgsElementData[child] or {}).scrollbars
		if scrollbars then
			dgsSetParent(scrollbars[1],newParent)
			dgsSetParent(scrollbars[2],newParent)
			configScrollPane(child)
		end
	end
	return true
end

function dgsBringToFront(dgsEle,mouse,dontMoveParent,dontFocus)
	local eleType = dgsIsType(dgsEle)
	if not(eleType) then error(dgsGenAsrt(dgsEle,"dgsBringToFront",1,"dgs-dxelement")) end
	if mouse then
		local mouseButtons = dgsElementData[dgsEle].mouseButtons
		if mouseButtons then
			if (mouse == "left" and not mouseButtons[1])
			or (mouse == "right" and not mouseButtons[2])
			or (mouse == "middle" and not mouseButtons[3]) then
				return
			end
		end
	end
	local parent = dgsElementData[dgsEle].parent	--Get Parent
	if not dontFocus then dgsFocus(dgsEle) end
	if dgsElementData[dgsEle].changeOrder then
		if not isElement(parent) then
			if dgsTypeScreen3D[eleType] then
				local id = tableFind(dgsScreen3DTable,dgsEle)
				if id then
					tableRemove(dgsScreen3DTable,id)
					tableInsert(dgsScreen3DTable,dgsEle)
				end
			elseif dgsTypeWorld3D[eleType] then
				local id = tableFind(dgsWorld3DTable,dgsEle)
				if id then
					tableRemove(dgsWorld3DTable,id)
					tableInsert(dgsWorld3DTable,dgsEle)
				end
			else
				local layer = dgsElementData[dgsEle].alwaysOn or "center"
				local layerTable = LayerCastTable[layer]
				local id = tableFind(layerTable,dgsEle)
				if id then
					tableRemove(layerTable,id)
					tableInsert(layerTable,dgsEle)
				end
			end
		else
			local parents = dgsEle
			while true do
				local uparents = dgsElementData[parents].parent	--Get Parent
				eleType = dgsIsType(uparents)
				if isElement(uparents) then
					local children = dgsElementData[uparents].children
					local id = tableFind(children,parents)
					if id then
						tableRemove(children,id)
						tableInsert(children,parents)
						if dgsElementType[parents] == "dgs-dxscrollpane" then
							local scrollbar = dgsElementData[parents].scrollbars
							local clickedButton = "left"
							local mouseButtons = dgsElementData[parents].mouseButtons
							if mouseButtons and not mouseButtons[1] then
								clickedButton = (mouseButtons[2] and "right") or (mouseButtons[3] and "middle") or "left"
							end
							dgsBringToFront(scrollbar[1],clickedButton,_,true,false)
							dgsBringToFront(scrollbar[2],clickedButton,_,true,false)
						end
					end
					parents = uparents
				else
					if dgsTypeScreen3D[eleType] then
						local id = tableFind(dgsScreen3DTable,parents)
						if id then
							tableRemove(dgsScreen3DTable,id)
							tableInsert(dgsScreen3DTable,parents)
						end
						break
					elseif dgsTypeWorld3D[eleType] then
						local id = tableFind(dgsWorld3DTable,parents)
						if id then
							tableRemove(dgsWorld3DTable,id)
							tableInsert(dgsWorld3DTable,parents)
						end
						break
					else
						local layer = dgsElementData[parents].alwaysOn or "center"
						local layerTable = LayerCastTable[layer]
						local id = tableFind(layerTable,parents)
						if id then
							tableRemove(layerTable,id)
							tableInsert(layerTable,parents)
							if dgsElementType[parents] == "dgs-dxscrollpane" then
								local scrollbar = dgsElementData[parents].scrollbars
								local clickedButton = "left"
								local mouseButtons = dgsElementData[parents].mouseButtons
								if mouseButtons and not mouseButtons[1] then
									clickedButton = (mouseButtons[2] and "right") or (mouseButtons[3] and "middle") or "left"
								end
								dgsBringToFront(scrollbar[1],clickedButton,_,true,false)
								dgsBringToFront(scrollbar[2],clickedButton,_,true,false)
							end
						end
						break
					end
				end
				if dontMoveParent then
					break
				end
			end
		end
	end
	if mouse == "left" then
		MouseData.click.left = dgsEle
		if not MouseData.hitData2D[0] and MouseData.hitData3D[0] and MouseData.hitData3D[5] then
			MouseData.lock3DInterface = MouseData.hitData3D[5]
		end
		MouseData.clickData = nil
	elseif mouse == "right" then
		MouseData.click.right = dgsEle
	elseif mouse == "middle" then
		MouseData.click.middle = dgsEle
	end
	return true
end

function dgsMoveToBack(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsMoveToBack",1,"dgs-dxelement")) end
	if dgsElementData[dgsEle].changeOrder then
		local parent = dgsElementData[dgsEle].parent	--Get Parent
		if isElement(parent) then
			local children = dgsElementData[parent].children
			local id = tableFind(children,dgsEle)
			if id then
				tableRemove(children,id)
				tableInsert(children,1,dgsEle)
				return true
			end
			return false
		else
			local layer = dgsElementData[dgsEle].alwaysOn or "center"
			local layerTable = LayerCastTable[layer]
			local id = tableFind(layerTable,dgsEle)
			if id then
				tableRemove(layerTable,id)
				tableInsert(layerTable,1,dgsEle)
				return true
			end
			return false
		end
	end
end

------------------------------------------------Type Manager
dgsType,dgsPluginType = {},{}

---Userdata Type
MTAUserDataType = {
	["resource-data"] = true,
	["xml-node"] = true,
	["lua-timer"] = true,
	["vector2"] = true,
	["vector3"] = true,
	["vector4"] = true,
	["matrix"] = true,
}

function dgsRegisterType(typeName,...)
	for i=1,select("#",...) do
		local tag = select(i,...)
		if not _G[tag] then _G[tag] = {} end
		_G[tag][typeName] = typeName
	end
	dgsType[typeName] = typeName
	return true
end

function dgsRegisterPluginType(typeName)
	dgsPluginType[typeName] = typeName
end

function dgsGetType(dgsEle,dgsTypeOnly)
	if dgsTypeOnly then
		if isElement(dgsEle) then return dgsElementType[dgsEle],dgsType[dgsElementType[dgsEle] or ""] end
	else
		if isElement(dgsEle) then return tostring(dgsElementType[dgsEle] or getElementType(dgsEle)) end
		local theType = type(dgsEle)
		if theType == "userdata" then
			local userdataType = getUserdataType(dgsEle)
			if MTAUserDataType[userdataType] then
				return userdataType
			else
				return "destroyed element"
			end
		end
		return theType
	end
	return false
end

function dgsIsType(dgsEle,isType)
	if isType then
		if isElement(dgsEle) then
			local eleData = dgsElementData[dgsEle]
			if isType == (eleData and eleData.asPlugin) then return true end
			if isType == dgsElementType[dgsEle] then return true end
			if _G[isType] and _G[isType][dgsElementType[dgsEle]] then return true end
			return getElementType(dgsEle) == isType
		else
			return type(dgsEle) == isType
		end
	else
		if not isElement(dgsEle) then return false end
		local eleData = dgsElementData[dgsEle]
		if eleData and eleData.asPlugin then
			return dgsPluginType[eleData.asPlugin]
		end
		return dgsType[dgsElementType[dgsEle] or getElementType(dgsEle)]
	end
end

function dgsGetPluginType(dgsEle) return dgsEle and (dgsElementData[dgsEle] and dgsElementData[dgsEle].asPlugin or false) or dgsGetType(dgsEle) end

function dgsSetType(dgsEle,myType)
	if isElement(dgsEle) and type(myType) == "string" then
		dgsElementType[dgsEle] = myType
		return true
	end
	return false
end

function dgsRegisterDeprecatedFunction(fncNameOld,fncNameNew)
	_G[fncNameOld] = function(...)
		if not getElementData(resourceRoot,"DGS-enableCompatibilityCheck") then
			if not getElementData(localPlayer,"DGS-DEBUG-C") then
				outputDebugString("Deprecated function @'"..fncNameOld.."', replace with '"..fncNameNew.."'. See information below, or run again with command /debugdgs c",2)
				if getElementData(localPlayer,"DGS-DEBUG") == 3 then
					dgsTriggerEvent("DGSI_onDebug",sourceResourceRoot or resourceRoot,"FunctionCompatibility",fncNameOld,fncNameNew)
				end
			else
				if getElementData(localPlayer,"DGS-DEBUG") == 3 then
					dgsTriggerEvent("DGSI_onDebug",sourceResourceRoot or resourceRoot,"FunctionCompatibility",fncNameOld,fncNameNew)
				end
				error("Found deprecated function @'"..fncNameOld.."', replace with '"..fncNameNew.."'")
			end
		end
		return _G[fncNameNew](...)
	end
end

------------------------------------------------Property Manager
dgsOnPropertyChange = {
	["default"] = {
		text = function(dgsEle,key,value,oldValue)
			if type(value) == "table" then
				dgsElementData[dgsEle]._translation_text = value
				value = dgsTranslate(dgsEle,value,sourceResource)
			else
				dgsElementData[dgsEle]._translation_text = nil
			end
			dgsElementData[dgsEle].text = tostring(value)
			dgsTriggerEvent("onDgsTextChange",dgsEle)
		end,
		font = function(dgsEle,key,value,oldValue)
			--Multilingual
			if type(value) == "table" then
				dgsElementData[dgsEle]._translation_font = value
				value = dgsGetTranslationFont(dgsEle,value,sourceResource)
			else
				dgsElementData[dgsEle]._translation_font = nil
			end
			dgsElementData[dgsEle].font = value
		end,
		caption = function(dgsEle,key,value,oldValue)
			if type(value) == "table" then
				dgsElementData[dgsEle]._translation_text = value
				value = dgsTranslate(dgsEle,value,sourceResource)
			else
				dgsElementData[dgsEle]._translation_text = nil
			end
			dgsElementData[dgsEle].caption = tostring(value)
		end,
		ignoreParentTitle = function(dgsEle,key,value,oldValue)
			configPosSize(dgsEle,false,true)
		end,
		ignoreTitle = function(dgsEle,key,value,oldValue)
			local children = dgsGetChildren(dgsEle)
			for i=1,#children do
				if not dgsElementData[children[i]].ignoreParentTitle then
					configPosSize(children[i],false,true)
					if dgsElementType[children[i]] == "dgs-dxscrollpane" then
						configScrollPane(children[i])
					end
				end
			end
		end,
		asPlugin = function(dgsEle,key,value,oldValue)
			dgsRegisterPluginType(value)
		end,
		visible = function(dgsEle,key,value,oldValue)
			dgsApplyVisibleInherited(dgsEle,value and dgsElementData[dgsEle].visibleInherited)
		end
	},
}

--[[
{}: table with item checked
1:nil
2:number
4:bool
8.string
16.table without item checked
32.font
64.material
128.color
]]
PArg = {
	"Nil",
	"Number",
	"Bool",
	"String",
	"Table",
	"Font",
	"Material",
	"Color",
	"Text",
}
for i=1,#PArg do
	PArg[ PArg[i] ] = 2^(i-1)
end

function dgsRegisterProperty(eleType,propertyName,propertyArgTemplate)
	if not(type(eleType) == "string") then error(dgsGenAsrt(eleType,"dgsRegisterProperty",1,"string")) end
	if not(type(propertyName) == "string") then error(dgsGenAsrt(propertyName,"dgsRegisterProperty",2,"string")) end
	if not(type(propertyArgTemplate) == "table") then error(dgsGenAsrt(propertyArgTemplate,"dgsRegisterProperty",3,"table")) end
	if _G[eleType] then
		for eleType2 in pairs(_G[eleType]) do
			dgsRegisterProperty(eleType2,propertyName,propertyArgTemplate)
		end
	else
		if not dgsElementPropertyList[eleType] then dgsElementPropertyList[eleType] = {} end
		dgsElementPropertyList[eleType][propertyName] = propertyArgTemplate
	end
	return true
end

function dgsRegisterProperties(eleType,propertyList)
	if not(type(eleType) == "string") then error(dgsGenAsrt(eleType,"dgsRegisterProperties",1,"string")) end
	if not(type(propertyList) == "table") then error(dgsGenAsrt(propertyList,"dgsRegisterProperties",2,"table")) end
	if _G[eleType] then
		for eleType2 in pairs(_G[eleType]) do
			dgsRegisterProperties(eleType2,propertyList)
		end
	else
		if not dgsElementPropertyList[eleType] then dgsElementPropertyList[eleType] = {} end
		for propertyName,propertyArgTemplate in pairs(propertyList) do
			dgsElementPropertyList[eleType][propertyName] = propertyArgTemplate
		end
	end
	return true
end

function dgsListPropertyTypes(propertyTemplateValue)
	if type(propertyTemplateValue) ~= "number" then return type(propertyTemplateValue) end
	local pTypeList = {}
	local index = 0
	while(propertyTemplateValue ~= 0) do
		index = index+1
		local pType = propertyTemplateValue%2
		propertyTemplateValue = math.floor(propertyTemplateValue/2)
		if pType == 1 then
			pTypeList[#pTypeList+1] = PArg[index]
		end
	end
	return pTypeList
end

function dgsCheckPropertyByTemplate(propertyTemplate,propretyValue)
	-- todo
end

function dgsCheckProperty(dgsElement,propertyName,propertyValue)
	local eleType = dgsElementType[dgsElement]
	local propertyCheck = dgsElementPropertyList[eleType]
	if not propertyCheck then return true end
	if propertyCheck[propertyName] then
		return dgsCheckPropertyByTemplate(propertyCheck[propertyName],propertyValue)
	else
		local specialProperties = propertyCheck.__Special
		if not propertyCheck.__Special then return true end
		for i=1,#specialProperties do
			local specialProperty = specialProperties[i]
			local basis = specialProperty.__Basis
			if basis then
				local basisData = dgsElementData[eleType][basis]
				if basisData then
					if specialProperty[basisData] then
						return dgsCheckPropertyByTemplate(specialProperty[basisData][propertyName],propertyValue)
					end
				end
			end
		end
	end
	return true
end

function dgsGetRegisteredProperties(eleType,withArgTemplate)
	if not(type(eleType) == "string") then error(dgsGenAsrt(eleType,"dgsGetRegisteredProperties",1,"string")) end
	if not dgsElementPropertyList[eleType] then return false end
	if withArgTemplate then
		return dgsElementPropertyList[eleType]
	else
		local propertyList = {}
		for propType in pairs(dgsElementPropertyList[eleType]) do
			propertyList[#propertyList+1] = propType
		end
		return propertyList
	end
end

function dgsGetData(dgsEle,key)
	return dgsElementData[dgsEle] and dgsElementData[dgsEle][key] or false
end

function dgsSetData(dgsEle,key,value,nocheck)
	local dgsType = dgsGetType(dgsEle)
	if not (isElement(dgsEle) and dgsType and key) then return false end
	if not dgsElementData[dgsEle] then dgsElementData[dgsEle] = {} end
	local eleData = dgsElementData[dgsEle]
	local oldValue = eleData[key]
	if oldValue == value then return true end
	eleData[key] = value
	if nocheck then return true end
	local dataHandlerList = dgsOnPropertyChange[dgsType] or dgsOnPropertyChange.default
	local dataHandler = dataHandlerList[key] or dgsOnPropertyChange.default[key]
	local translationListener = eleData.translationListener
	if translationListener and translationListener[key] then
		if dgsOnTranslationUpdate[dgsEle] then dgsOnTranslationUpdate[dgsType](dgsEle,key,value,translationListener[key]) else dgsOnTranslationUpdate.default(dgsEle,key,value,translationListener[key]) end
	end
	if dataHandler then dataHandler(dgsEle,key,value,oldValue) end
	if eleData.propertyListener and eleData.propertyListener[key] then dgsTriggerEvent("onDgsPropertyChange",dgsEle,key,value,oldValue) end
	return true
end

function dgsAddPropertyListener(dgsEle,propertyNames)
	local isTable = type(dgsEle) == "table"
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsAddPropertyListener",1,"dgs-dxelement/table")) end
	if isTable then
		for index,dgsEleItem in pairs(dgsEle) do
			dgsAddPropertyListener(dgsEleItem,propertyNames)
		end
		return true
	else
		local eleData = dgsElementData[dgsEle]
		eleData.propertyListener = eleData.propertyListener or {}
		if type(propertyNames) == "table" then
			for i=1,#propertyNames do
				eleData.propertyListener[propertyNames[i]] = true
			end
		else
			eleData.propertyListener[propertyNames] = true
		end
	end
end

function dgsRemovePropertyListener(dgsEle,propertyNames)
	local isTable = type(dgsEle) == "table"
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsRemovePropertyListener",1,"dgs-dxelement/table")) end
	if isTable then
		for index,dgsEleItem in pairs(dgsEle) do
			dgsRemovePropertyListener(dgsEleItem,propertyNames)
		end
		return true
	else
		local eleData = dgsElementData[dgsEle]
		eleData.propertyListener = eleData.propertyListener or {}
		if type(propertyNames) == "table" then
			for i=1,#propertyNames do
				eleData.propertyListener[propertyNames[i]] = false
			end
		else
			eleData.propertyListener[propertyNames] = false
		end
	end
end

function dgsGetListenedProperties(dgsEle)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetListenedProperties",1,"dgs-dxelement")) end
	local eleData = dgsElementData[dgsEle]
	eleData.propertyListener = eleData.propertyListener or {}
	local listening = {}
	for k,v in pairs(eleData.propertyListener) do
		listening[#listening+1] = k
	end
	return listening
end

local compatibility = {
	["dgs-dxscrollbar"] = {
		length = "cursorLength"
	}
}
function checkCompatibility(dgsEle,key,sResRoot)
	local eleTyp = dgsGetType(dgsEle)
	if getElementData(resourceRoot,"DGS-enableCompatibilityCheck") then return (compatibility[eleTyp] and compatibility[eleTyp][key]) or compatibility[key] or key end
	if compatibility[eleTyp] and compatibility[eleTyp][key] then
		if not getElementData(localPlayer,"DGS-DEBUG-C") then
			outputDebugString("[DGS]Deprecated property '"..key.."' @dgsSetProperty with "..eleTyp..", replace with '"..compatibility[eleTyp][key].."'. See information below, or run again with command /debugdgs c",4,254,128,0)
			if getElementData(localPlayer,"DGS-DEBUG") == 3 then
				dgsTriggerEvent("DGSI_onDebug",sResRoot,"PropertyCompatibility",key,compatibility[eleTyp][key])
			end
			return compatibility[eleTyp][key]
		else
			if getElementData(localPlayer,"DGS-DEBUG") == 3 then
				dgsTriggerEvent("DGSI_onDebug",sResRoot,"PropertyCompatibility",key,compatibility[eleTyp][key])
			end
			outputDebugString("Found deprecated '"..key.."' @dgsSetProperty with "..eleTyp..", replace with "..compatibility[eleTyp][key],2)
			return false
		end
	end
	if compatibility[key] then
		if not getElementData(localPlayer,"DGS-DEBUG-C") then
			outputDebugString("[DGS]Deprecated property '"..key.."' @dgsSetProperty with all dgs elements, replace with '"..compatibility[key].."'. See information below, or run again with command /debugdgs c",4,254,128,0)
			if getElementData(localPlayer,"DGS-DEBUG") == 3 then
				dgsTriggerEvent("DGSI_onDebug",sResRoot,"PropertyCompatibility",key,compatibility[key])
			end
			return compatibility[key]
		else
			if getElementData(localPlayer,"DGS-DEBUG") == 3 then
				dgsTriggerEvent("DGSI_onDebug",sResRoot,"PropertyCompatibility",key,compatibility[key])
			end
			outputDebugString("Found deprecated property '"..key.."' @dgsSetProperty with all dgs elements, replace with "..compatibility[key],2)
			return false
		end
	end
	return key
end

local _dgsSetData = dgsSetData
function dgsSetProperty(dgsEle,key,value,...)
	local isTable = type(dgsEle) == "table"
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsSetProperty",1,"dgs-dxelement/table")) end
	if isTable then
		for index,dgsEleItem in pairs(dgsEle) do
			dgsSetProperty(dgsEleItem,key,value,...)
		end
		return true
	else
		if #compatibility ~= 0 then
			local newKey = checkCompatibility(dgsEle,key,sourceResourceRoot or resourceRoot)
			if newKey == false then
				error("DGS Compatibility Check")
			end
			key = newKey
		end
		if key == "functions" then
			if value then
				local fnc,err
				if type(value) == "function" then
					fnc = value
				else
					fnc,err = loadstring(value)
					dgsElementData[dgsEle].functions_string = {value,{...}}
				end
				if not fnc then error("Bad argument @dgsSetProperty at argument 2, failed to load function ("..err..")") end
				value = {fnc,{...}}
			end
		elseif key == "absPos" then
			dgsSetPosition(dgsEle,value[1],value[2],false)
		elseif key == "rltPos" then
			dgsSetPosition(dgsEle,value[1],value[2],true)
		elseif key == "absSize" then
			dgsSetSize(dgsEle,value[1],value[2],false)
		elseif key == "rltSize" then
			dgsSetSize(dgsEle,value[1],value[2],true)
		end
		return _dgsSetData(dgsEle,key,value)
	end
end

function dgsGetProperty(dgsEle,key)
	if not(dgsIsType(dgsEle)) then error(dgsGenAsrt(dgsEle,"dgsGetProperty",1,"dgs-dxelement")) end
	return (dgsElementData[dgsEle] or {})[key] or false
end

function dgsSetProperties(dgsEle,theTable)
	local isTable = type(dgsEle) == "table"
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsSetProperties",1,"dgs-dxelement/table")) end
	if not(type(theTable) == "table") then error(dgsGenAsrt(theTable,"dgsSetProperties",2,"table")) end
	local dxElements = isTable and dgsEle or {dgsEle}
	for i=1,#dxElements do
		dgsEle = dxElements[i]
		for key,value in pairs(theTable) do
			dgsSetProperty(dgsEle,key,value)
		end
	end
	return true
end

function dgsGetProperties(dgsEle,properties)
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsGetProperties",1,"dgs-dxelement/table")) end
	if not(not properties or type(properties) == "table") then error(dgsGenAsrt(properties,"dgsGetProperties",2,"table/none")) end
	local eleData = dgsElementData[dgsEle]
	if not eleData then return false end
	if not properties then return eleData end
	local data = {}
	for k,key in ipairs(properties) do
		data[key] = eleData[key]
	end
	return data
end

function dgsSetPropertyInherit(dgsEle,key,value,...)
	local isTable = type(dgsEle) == "table"
	if not(dgsIsType(dgsEle) or isTable) then error(dgsGenAsrt(dgsEle,"dgsSetPropertyInherit",1,"dgs-dxelement/table")) end
	local dxElements = isTable and dgsEle or {dgsEle}
	for i=1,#dxElements do
		dgsEle = dxElements[i]
		dgsSetProperty(dgsEle,key,value)
		for index,child in ipairs(dgsGetChildren(dgsEle)) do
			dgsSetPropertyInherit(child,key,value,...)
		end
	end
	return true
end
------------------------Custom Easing Function
resourceTranslation = {}
LanguageTranslation = {}
LanguageTranslationAttach = {}
boundResource = {}
dgsEasingFunction = {}
dgsEasingFunctionOrg = {}
SEInterface = [[
local progress,setting,self = ...
local propertyTable = dgsElementData[self]
]]
function dgsAddEasingFunction(name,str,isOverWrite)
	if not(type(name) == "string") then error(dgsGenAsrt(name,"dgsAddEasingFunction",1,"string")) end
	if not(type(str) == "string") then error(dgsGenAsrt(str,"dgsAddEasingFunction",2,"string")) end
	if easingBuiltIn[name] then error(dgsGenAsrt(name,"dgsAddEasingFunction",1,_,_,"duplicated name with built-in easing function ("..name..")")) end
	if not isOverWrite and dgsEasingFunction[name] then error(dgsGenAsrt(name,"dgsAddEasingFunction",1,_,_,"this name has been used ("..name..")")) end
	str = SEInterface..str
	local fnc,err = loadstring(str)
	if not fnc then error(dgsGenAsrt(fnc,"dgsAddEasingFunction",2,_,_,_,"Failed to load function:"..err)) end
	dgsEasingFunction[name] = fnc
	dgsEasingFunctionOrg[name] = str
	return true
end

function dgsRemoveEasingFunction(name)
	if not(type(name) == "string") then error(dgsGenAsrt(name,"dgsRemoveEasingFunction",1,"string")) end
	if dgsEasingFunction[name] then
		dgsEasingFunction[name] = nil
		dgsEasingFunctionOrg[name] = nil
		return true
	end
	return false
end

function dgsEasingFunctionExists(name)
	if not(type(name) == "string") then error(dgsGenAsrt(name,"dgsEasingFunctionExists",1,"string")) end
	return easingBuiltIn[name] or (dgsEasingFunction[name] and true)
end

addEventHandler("onClientResourceStop",resourceRoot,function()
	if isElement(GlobalEdit) then
		removeEventHandler("onClientElementDestroy",GlobalEdit,dgsGlobalEditDestroyDetector)	--shutdown global edit destroy detector
	end
	if isElement(GlobalMemo) then
		removeEventHandler("onClientElementDestroy",GlobalMemo,dgsGlobalMemoDestroyDetector)	--shutdown global memo destroy detector
	end
end,false)


addEventHandler("onClientResourceStop",root,function(res)
	if boundResource[res] then
		dgsClear(nil,res)
		resourceTranslation[res] = nil
		boundResource[res] = nil
	end
	if res == resource and CursorData.enabled then --Recover Cursor Alpha
		setCursorAlpha(255)
	end
	if G2DHookerEvents[res] then -- G2D Hooker
		G2DHookerEvents[res] = nil
		if table.count(G2DHookerEvents) == 0 then
			removeEventHandler("onDgsEditAccepted",root,handleHookerEvents)
			removeEventHandler("onDgsTextChange",root,handleHookerEvents)
			removeEventHandler("onDgsComboBoxSelect",root,handleHookerEvents)
			removeEventHandler("onDgsTabSelect",root,handleHookerEvents)
		end
	end
end)