---------------------------------------------------------------------------------------------------------------------------------------
-- RSL_CollisionOps2SelectDisplay
-- By Paul Truss
-- Senior Technical Artist
-- Rockstar Games London
-- 12/01/2011
--
-- Modified for Rockstar North by Neil Gregory
-- 07/2011
--
--
-- Structure containing functions and UI used by RSL_CollisionOps2 in select/display mode
---------------------------------------------------------------------------------------------------------------------------------------

-- struct used to store both rexBound and standard attribute data for attributes e.g. stairs
struct RSL_flag
(
	---------------------------------------------------------------------------------------------------------------------------------------
	-- Struct variables
	---------------------------------------------------------------------------------------------------------------------------------------
	name,
	attr,
	rex,
	value,
	
	---------------------------------------------------------------------------------------------------------------------------------------
	--
	-- FUNCTIONS
	--
	---------------------------------------------------------------------------------------------------------------------------------------
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- compare() Compares the parsed flag with the struct variables. Returns true if they are the same.
	-- name and value struct variables are ignored.
	---------------------------------------------------------------------------------------------------------------------------------------
	fn compare flag =
	(
		if flag.attr == attr and flag.rex == rex then
		(
			true
		)
		else
		(
			false
		)
	)
)

-- main struct
struct RSL_CollisionOps2SelectDisplay
(
	---------------------------------------------------------------------------------------------------------------------------------------
	-- Struct variables
	---------------------------------------------------------------------------------------------------------------------------------------
	INIfile = (RsConfigGetWildWestDir() + "etc/config/general/collisionOps2.ini"),
	
	hideClassArray = #(),
	hideFlagArray = #(),
	
	otherHelpersArray = #(),
	hiddenObjectArray = #(),
	selectObjectArray = #(),
	HiddenFlagArray = #(),
	selectFlagArray = #(),
	
	hiddenSurfaceArray = #(),
	unHiddenSurfaceArray = #(),
	
	objectsurfaceTypeArray = #(),
	
	hiddenIcon = (RsConfigGetWildWestDir() + "script\\max\\Rockstar_London\\images\\EyeClosed.png"),
	unHiddenIcon = (RsConfigGetWildWestDir() + "script\\max\\Rockstar_London\\images\\EyeOpen.png"),
	
	ignoreCheck = false,
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- UI variables
	---------------------------------------------------------------------------------------------------------------------------------------
	checkButtonType = (dotNetObject "CheckBox").getType(),
	
	selectDisplayTableLayout,
	colTypeTableLayout,
	
	meshHideCheckButton,meshSelectButton,boxHideCheckButton,boxSelectButton,capsuleHideCheckButton,capsuleSelectButton,
	cylinderHideCheckButton,cylinderSelectButton,planeHideCheckButton,planeSelectButton,sphereHideCheckButton,sphereSelectButton,
	
	colTypeAllButton,colTypeNoneButton,colTypeInvertButton,
	attributeHideButton,attributeSelectButton,
	surfaceTypeDataGrid,surfaceTypeAllButton,surfaceTypeNoneButton,surfaceTypeInvertButton,
	
	attributesTableLayout,
	cameraHideCheckButton,cameraSelectButton,physicsHideCheckButton,physicsSelectButton,
	hiDetailHideCheckButton,hiDetailSelectButton,locoHideCheckButton,locoSelectButton,
	
	stairsHideCheckButton,stairsSelectButton,noCoverHideCheckButton,noCoverSelectButton,
	noClimbHideCheckButton,noClimbSelectButton,noWalkHideCheckButton,noWalkSelectButton,
	seeHideCheckButton,seeSelectButton,noCamHideCheckButton,noCamSelectButton,
	shootHideCheckButton,shootSelectButton,
	
	attributeAllButton,attributeNoneButton,attributeInvertButton,
	
	---------------------------------------------------------------------------------------------------------------------------------------
	--
	-- FUNCTIONS
	--
	---------------------------------------------------------------------------------------------------------------------------------------
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hideByClass() Sets the isHidden state for each parsed object to the parsed state if it is the same class as the parsed class
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn hideByClass object class state =
	(
		-- make sure we only do this for collision objects
		if (getAttrClass object) == "Gta Collision" then
		(
			if (classOf object) == class then
			(
				object.isHidden = state
				
				if state then
				(
					appendIfUnique hiddenObjectArray object
				)
				else
				(
					local index = (findItem hiddenObjectArray object)
					
					if index > 0 then
					(
						deleteItem hiddenObjectArray index
					)
				)
			)
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- selectByClass() Selects each parsed object if it is the same class as the parsed class
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn selectByClass object class =
	(
		if (classOf object) == class then
		(
			selectMore object
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- isRexBound() Checks to see if the object contains any rexBound materials. Returns true if rexBound materials are found
	---------------------------------------------------------------------------------------------------------------------------------------
	fn isRexBound object =
	(
		local result = true
		
		if object.material != undefined then
		(
			case (classOf object.material) of
			(
				default:
				(
					result = false
				)
				RexBoundMtl:
				(
					result = true
				)
				Multimaterial:
				(
					for i = 1 to object.material.materialList.count do
					(
						local subMaterial = object.material.materialList[i]
						
						if (classOf subMaterial) == RexBoundMtl then
						(
							result = true
						)
					)
				)
			)
		)
		else
		(
			result = false
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getFlagRexBound() Checks to see if any of the rexBound materials assigned to the parsed object have the parsed flag set
	-- Returns true if the flag is found
	---------------------------------------------------------------------------------------------------------------------------------------
	fn getFlagRexBound object flag =
	(
		local result = false
		local material = object.material
		
		case (classOf material) of
		(
			RexBoundMtl:
			(
				local flags = RexGetCollisionFlags material
				
				if (bit.and flags (bit.shift 1 flag.rex) > 0) then
				(
					result = true
				)
			)
			Multimaterial:
			(
				for i = 1 to material.materialList.count do 
				(
					local subMaterial = material.materialList[i]
					
					if (classOf subMaterial) == RexBoundMtl then
					(
						local flags = RexGetCollisionFlags subMaterial
						
						if (bit.and flags (bit.shift 1 flag.rex) > 0) then
						(
							result = true
						)
					)
				)
			)
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getFlagAttribute() Checks to see if the parsed object has the parsed flag attribute set. Returns true if the flag is set
	---------------------------------------------------------------------------------------------------------------------------------------
	fn getFlagAttribute object flag =
	(
		try (getAttr object flag.attr) catch (false)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getFlagRexBound() Checks to see if any of the rexBound materials assigned to the parsed object have the parsed surfaceType
	-- Returns true if the surfaceType is found
	---------------------------------------------------------------------------------------------------------------------------------------
	fn hasSurfaceTypeRexBound object surfaceType =
	(
		local result = false
		local material = object.material
		
		case (classOf material) of
		(
			RexBoundMtl:
			(
				local sType = RexGetCollisionName material
				
				if (toUpper sType) == (toUpper surfaceType) then
				(
					result = true
				)
			)
			Multimaterial:
			(
				for i = 1 to material.materialList.count do 
				(
					local subMaterial = material.materialList[i]
					
					if (classOf subMaterial) == RexBoundMtl then
					(
						local sType = RexGetCollisionName subMaterial
						
						if (toUpper sType) == (toUpper surfaceType) then
						(
							result = true
						)
					)
				)
			)
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getFlagAttribute() Checks to see if the parsed object has the parsed surfaceType attribute set. Returns true if the flag is set
	---------------------------------------------------------------------------------------------------------------------------------------
	fn hasSurfaceTypeAttribute object surfaceType =
	(
		local sType = getAttr object (getAttrIndex "Gta Collision" "Coll Type")
		
		if (toUpper sType) == (toUpper surfaceType) then
		(
			true
		)
		else
		(
			false
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getSurfaceTypeRexBound() Gathers all the surface types set for the parsed object from the rexBound materials. Returns
	-- an array
	---------------------------------------------------------------------------------------------------------------------------------------
	fn getSurfaceTypeRexBound object =
	(
		local result = #()
		local material = object.material
		
		case (classOf material) of
		(
			RexBoundMtl:
			(
				append result (RexGetCollisionName material)
			)
			Multimaterial:
			(
				for i = 1 to material.materialList.count do 
				(
					local subMaterial = material.materialList[i]
					
					if (classOf subMaterial) == RexBoundMtl then
					(
						append result (RexGetCollisionName subMaterial)
					)
				)
			)
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getSurfaceTypeRexBound() Gets the surface type attribute set for the parsed object. Returns an array
	---------------------------------------------------------------------------------------------------------------------------------------
	fn getSurfaceTypeAttribute object =
	(
		#(getAttr object (getAttrIndex "Gta Collision" "Coll Type"))
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- recurseCheckAttributes() Checks to see if the parsed attribute control, if it's marked as visible (un-checked), is set on
	-- the parsed object. Returns false if found because this is used to set the isHidden state of the parsed object.
	---------------------------------------------------------------------------------------------------------------------------------------
	fn recurseCheckAttributes control object &hideState =
	(
		-- make sure the control is a check button and it's un-checked
		if control.getType() == checkButtonType and not control.checked then
		(
			local flag = control.tag.value
			local rexBound = isRexBound object
			local state
			
			if rexBound and flag.rex != undefined then
			(
				state = getFlagRexBound object flag
			)
			else
			(
				state = getFlagAttribute object flag
			)
			
			if state then hideState = false
		)
		
		-- run the function on any sub controls of the control because the controls are embedded
		for i = 0 to control.controls.count - 1 do 
		(
			local subControl = control.controls.item[i]
			
			recurseCheckAttributes subControl object &hideState
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hideByAttributes() Sets the isHidden state for each parsed object based on the attributes
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn hideByAttributes object =
	(
		-- make sure we only do this for collision objects
		if (getAttrClass object) == "Gta Collision" then
		(
			local hideState = true
			
			-- check the attribute check buttons to see if any visible controls are attributes the object has
			recurseCheckAttributes attributesTableLayout object &hideState
			
			object.isHidden = hideState
			
			if hideState then
			(
				appendIfUnique HiddenFlagArray object
			)
			else
			(
				local index = findItem HiddenFlagArray object
				
				if index > 0 then
				(
					deleteItem HiddenFlagArray index
				)
			)
		)
		else
		(
			
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- selectByAttribute() Selects each parsed object if it has the parsed flag attribute set
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn selectByAttribute object flag =
	(
		-- make sure we only do this for collision objects
		if (getAttrClass object) == "Gta Collision" then
		(
			local rexBound = isRexBound object
			local state
			
			-- get the state of the flag on the object using the correct function
			if rexBound and flag.rex != undefined then
			(
				state = getFlagRexBound object flag
			)
			else
			(
				state = getFlagAttribute object flag
			)
			
			if state then
			(
				selectMore object
			)
		)
		else
		(
			
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- gatherObjectSurfaceTypes() Populates the objectSurfaceTypeArray with a dataPair containing surface types set for
	-- each parsed object
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn gatherObjectSurfaceTypes object =
	(
		-- make sure we only do this for collision objects
		if (getAttrClass object) == "Gta Collision" then
		(
			local data = DataPair object:object surfaceTypeArray:#()
			
			local rexBound = isRexBound object
			local state
			
			if rexBound then
			(
				data.surfaceTypeArray = getSurfaceTypeRexBound object
			)
			else
			(
				data.surfaceTypeArray = getSurfaceTypeAttribute object
			)
			
			append objectSurfaceTypeArray data
		)
		else
		(
			
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hasSurfaceType() Searches the objectSurfaceTypeArray for the parsed object to see if it has the parsed type assigned.
	-- Returns true if found
	---------------------------------------------------------------------------------------------------------------------------------------
	fn hasSurfaceType object type =
	(
		local result = false
		
		for entry in objectSurfaceTypeArray do
		(
			if entry.object == object then
			(
				if (findItem entry.surfaceTypeArray type) > 0 then
				(
					result = true
				)
			)
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- checkSurfaceTypes() Checks to see if any of the surface type dataGrid items, if they're marked as visible, are assigned
	-- to the  parsed object. Returns false if any are found because this is used to set the isHidden state of the parsed object.
	---------------------------------------------------------------------------------------------------------------------------------------
	fn checkSurfaceTypes object =
	(
		local result = true
		
		for i = 0 to surfaceTypeDataGrid.Rows.count - 1 do 
		(
			local row = surfaceTypeDataGrid.Rows.Item[i]
			local hidden = row.cells.item[3].value
			
			if not hidden then
			(
				local surfaceType = row.Cells.Item[0].value
				local state = hasSurfaceType object surfaceType
				
				if state then result = false
			)
		)
		
		result
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hideBySurfaceType() Sets the isHidden state for each parsed object based on the surface type
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn hideBySurfaceType object =
	(
		if (getAttrClass object) == "Gta Collision" then
		(
			local hideState = checkSurfaceTypes object
			
			if hideState then
			(
				append hiddenSurfaceArray object
			)
			else
			(
				append unHiddenSurfaceArray object
			)
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hideBySurfaceType() Selects each parsed object if it has the parsed surfaceType set
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn selectBySurfaceType object surfaceType =
	(
		if (getAttrClass object) == "Gta Collision" then
		(
			local state = hasSurfaceType object surfaceType
			
			if state then
			(
				selectMore object
			)
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- exitSelectDisplay() Unhides any objects in the hiddenObjectArray and HiddenFlagArray variables.
	-- CURRENTLY NOT USED
	---------------------------------------------------------------------------------------------------------------------------------------
	fn exitSelectDisplay =
	(
		if colTypeHideButton != undefined and colTypeHideButton.checked then
		(
			unHide hiddenObjectArray
			unHide HiddenFlagArray
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- hideBySurfaceType() Recursive function that sets the check state property of the parsed control to the parsed state
	---------------------------------------------------------------------------------------------------------------------------------------
	fn recurseSetCheck control state =
	(
		-- make sure we only set this on check buttons
		if control.getType() == checkButtonType then
		(
			if state == #invert then
			(
				control.checked = not control.checked 
			)
			else
			(
				control.checked = state
			)
		)
		
		for i = 0 to control.controls.count - 1 do 
		(
			local subControl = control.controls.item[i]
			
			recurseSetCheck subControl state
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- setupDataColumns() Sets up the data columns for the surfaceTypeDataGrid
	---------------------------------------------------------------------------------------------------------------------------------------
	fn setupDataColumns =
	(
		local nameColumn = dotNetObject "System.Windows.Forms.DataGridViewTextBoxColumn"
		nameColumn.width = 200
		-- set the AutoSizeMode so that this column resizes to fit the available area when the form is resized
		nameColumn.AutoSizeMode = (dotNetClass "System.Windows.Forms.DataGridViewAutoSizeColumnMode").Fill
		nameColumn.fillWeight = 100
		nameColumn.ReadOnly = true
		
		local hideColumn = dotNetObject "System.Windows.Forms.DataGridViewImageColumn"
		hideColumn.width = 24
		
		local selectColumn = dotNetObject "System.Windows.Forms.DataGridViewButtonColumn"
		selectColumn.width = 24
		
		-- this column is hidden and only used internally
		local checkColumn = dotNetObject "System.Windows.Forms.DataGridViewCheckBoxColumn"
		checkColumn.width = 0
		
		surfaceTypeDataGrid.columns.AddRange #(nameColumn, hideColumn, selectColumn, checkColumn)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- addSurfaceTypeData() Creates a row for each parsed surfaceType and assigns it to the surfaceTypeDataGrid
	---------------------------------------------------------------------------------------------------------------------------------------
	mapped fn addSurfaceTypeData surfaceType =
	(
		surfaceTypeDataGrid.Rows.add #(surfaceType.type, (RS_dotNetObject.imageObject unHiddenIcon), "S")
		
		local row = surfaceTypeDataGrid.Rows.item[surfaceTypeDataGrid.Rows.count - 1]
		row.cells.item[0].ToolTipText = surfaceType.type
		row.cells.item[3].value = false
		row.cells.item[0].Style.backColor = RS_dotNetClass.colourClass.White
		
		-- check to see if there's a colour in the INI file for this surface type
		local colour = getINISetting INIFile "surfaceColours" surfaceType.type
		
		if colour != "" then
		(
			local colourValue = readExpr (colour as stringStream)
			row.cells.item[0].Style.backColor = RS_dotNetClass.colourClass.fromARGB colourValue.r colourValue.g colourValue.b
			
			-- make sure the fore colour is not to similar to the back colour
			local backColTotal = colourValue.r + colourValue.g + colourValue.b
			local foreColTotal = row.cells.item[0].Style.foreColor.r + row.cells.item[0].Style.foreColor.g + row.cells.item[0].Style.foreColor.b
			
			-- it is so we make the fore colour either black or white
			if (abs (backColTotal - foreColTotal)) < 128 then
			(
				if row.cells.item[0].Style.foreColor == RS_dotNetClass.colourClass.White then
				(
					row.cells.item[0].Style.foreColor = RS_dotNetClass.colourClass.Black
				)
				else
				(
					row.cells.item[0].Style.foreColor = RS_dotNetClass.colourClass.White
				)
			)
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- surfaceTypeSetCheck() Sets the visibility state of each surface type in the surfaceTypeDataGrid to the parsed state
	---------------------------------------------------------------------------------------------------------------------------------------
	fn surfaceTypeSetCheck state =
	(
		for i = 0 to surfaceTypeDataGrid.Rows.count - 1 do 
		(
			local icon = surfaceTypeDataGrid.Rows.Item[i].Cells.Item[1]
			local control = surfaceTypeDataGrid.Rows.Item[i].Cells.Item[3]
			
			if state == #invert then
			(
				control.value = not control.value
			)
			else
			(
				control.value = state
			)
			
			if control.value then
			(
				icon.value = RS_dotNetObject.imageObject hiddenIcon
			)
			else
			(
				icon.value = RS_dotNetObject.imageObject unHiddenIcon
			)
		)
		
		hiddenSurfaceArray = #()
		unHiddenSurfaceArray = #()
		
		hideBySurfaceType helpers
		
		hide hiddenSurfaceArray
		unHide unHiddenSurfaceArray
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	--
	-- UI FUNCTIONS
	--
	---------------------------------------------------------------------------------------------------------------------------------------
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchFlagSelectClick() Dispatches flagSelectClick() Called when the user checks any one of the attribute selection buttons
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchFlagSelectClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.flagSelectClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- flagSelectClick() Runs the selectByAttribute function
	---------------------------------------------------------------------------------------------------------------------------------------
	fn flagSelectClick s e =
	(
		-- check to see if the control button is not down and set the object selection to none
		local control = dotNetClass "system.windows.forms.control"
		
		if control.modifierKeys != control.modifierKeys.Control then
		(
			max select none
		)
		
		selectByAttribute helpers s.tag.value
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchFlagHideCheck() Dispatches flagHideCheck() Called when the user checks any one of the collision type attribute
	-- visibility buttons
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchFlagHideCheck s e =
	(
		::RSL_CollisionOps.selectDisplayUI.flagHideCheck s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- flagHideCheck() Sets the icon for the pressed check button, the check state for the tag and then runs hideByAttributes
	-- if ignoreCheck is false
	---------------------------------------------------------------------------------------------------------------------------------------
	fn flagHideCheck s e =
	(
		if s.checked then
		(
			s.BackgroundImage = RS_dotNetObject.imageObject hiddenIcon
		)
		else
		(
			s.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		)
		
		s.tag.value.value = s.checked
		
		if not ignoreCheck then
		(
			hideByAttributes helpers
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchAttributeCheckClick() Dispatches attributeCheckClick() Called when the user checks any one of the all, none and
	-- invert buttons for attributes
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchAttributeCheckClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.attributeCheckClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- attributeCheckClick() Sets the visibility state based on which button is pressed, then sets the check state for all attribute
	-- check buttons and then runs hideByAttributes
	---------------------------------------------------------------------------------------------------------------------------------------
	fn attributeCheckClick s e =
	(
		-- set ignoreCheck to true because we dont want it to hideByAttributes each time we set the check state for an
		-- attribute check button
		ignoreCheck = true
		
		local state = #invert
		
		case s.name of
		(
			"attributeAllButton":(state = true)
			"attributeNoneButton":(state = false)
		)
		
		recurseSetCheck attributesTableLayout state
		hideByAttributes helpers
		
		ignoreCheck = false
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- createAttributeControls() Creates the attribute controls. These are the basic attributes shared between rexBound and
	-- standard atributes
	---------------------------------------------------------------------------------------------------------------------------------------
	fn createAttributeControls =
	(
		-- we set the tag value on each control to an RSL_flag struct so that we can use a single function to check for the existence of
		-- the attribute or lack when we decide to hide or select the object e.g...	
		-- (RSL_flag name:"Does Not Provide Cover" attr:(getAttrIndex "Gta Collision" "Does Not Provide Cover") rex:4 value:false)
		-- This has all the info we need to check if an object has "Does Not Provide Cover" set or un-set in both standard attribute and
		-- rexBound data.
		/*
		cameraLabel = RS_dotNetUI.Label "cameraLabel" text:" Camera" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		cameraHideCheckButton = RS_dotNetUI.checkBox "cameraHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		cameraHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		cameraHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		cameraHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Camera" attr:(getAttrIndex "Gta Collision" "Camera") value:false)
		dotnet.addEventHandler cameraHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		cameraSelectButton = RS_dotNetUI.Button "cameraSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		cameraSelectButton.tag = dotNetMXSValue (RSL_flag name:"Camera" attr:(getAttrIndex "Gta Collision" "Camera") value:true)
		dotnet.addEventHandler cameraSelectButton "click" dispatchFlagSelectClick
		
		cameraTableLayout = RS_dotNetUI.tableLayout "cameraTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		cameraTableLayout.controls.add cameraLabel 0 0
		cameraTableLayout.controls.add cameraHideCheckButton 1 0
		cameraTableLayout.controls.add cameraSelectButton 2 0
		
		physicsLabel = RS_dotNetUI.Label "physicsLabel" text:" Physics" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		physicsHideCheckButton = RS_dotNetUI.checkBox "physicsHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		physicsHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		physicsHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		physicsHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Physics" attr:(getAttrIndex "Gta Collision" "Physics") value:false)
		dotnet.addEventHandler physicsHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		physicsSelectButton = RS_dotNetUI.Button "physicsSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		physicsSelectButton.tag = dotNetMXSValue (RSL_flag name:"Physics" attr:(getAttrIndex "Gta Collision" "Physics") value:true)
		dotnet.addEventHandler physicsSelectButton "click" dispatchFlagSelectClick
		
		physicsTableLayout = RS_dotNetUI.tableLayout "physicsTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		physicsTableLayout.controls.add physicsLabel 0 0
		physicsTableLayout.controls.add physicsHideCheckButton 1 0
		physicsTableLayout.controls.add physicsSelectButton 2 0
		
		hiDetailLabel = RS_dotNetUI.Label "hiDetailLabel" text:" Hi Detail" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		hiDetailHideCheckButton = RS_dotNetUI.checkBox "hiDetailHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		hiDetailHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		hiDetailHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		hiDetailHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Hi Detail" attr:(getAttrIndex "Gta Collision" "Hi Detail") value:false)
		dotnet.addEventHandler hiDetailHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		hiDetailSelectButton = RS_dotNetUI.Button "hiDetailSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		hiDetailSelectButton.tag = dotNetMXSValue (RSL_flag name:"Hi Detail" attr:(getAttrIndex "Gta Collision" "Hi Detail") value:true)
		dotnet.addEventHandler hiDetailSelectButton "click" dispatchFlagSelectClick
		
		hiDetailTableLayout = RS_dotNetUI.tableLayout "hiDetailTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		hiDetailTableLayout.controls.add hiDetailLabel 0 0
		hiDetailTableLayout.controls.add hiDetailHideCheckButton 1 0
		hiDetailTableLayout.controls.add hiDetailSelectButton 2 0
		
		locoLabel = RS_dotNetUI.Label "locoLabel" text:" Loco" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		locoHideCheckButton = RS_dotNetUI.checkBox "locoHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		locoHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		locoHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		locoHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Loco" attr:(getAttrIndex "Gta Collision" "Loco") value:false)
		dotnet.addEventHandler locoHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		locoSelectButton = RS_dotNetUI.Button "locoSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		locoSelectButton.tag = dotNetMXSValue (RSL_flag name:"Loco" attr:(getAttrIndex "Gta Collision" "Loco") value:true)
		dotnet.addEventHandler locoSelectButton "click" dispatchFlagSelectClick
		
		locoTableLayout = RS_dotNetUI.tableLayout "locoTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		locoTableLayout.controls.add locoLabel 0 0
		locoTableLayout.controls.add locoHideCheckButton 1 0
		locoTableLayout.controls.add locoSelectButton 2 0
		*/
		stairsLabel = RS_dotNetUI.Label "stairsLabel" text:" Stairs" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		stairsHideCheckButton = RS_dotNetUI.checkBox "stairsHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		stairsHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		stairsHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		stairsHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Stairs" attr:(getAttrIndex "Gta Collision" "Stairs") rex:0 value:false)
		dotnet.addEventHandler stairsHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		stairsSelectButton = RS_dotNetUI.Button "stairsSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		stairsSelectButton.tag = dotNetMXSValue (RSL_flag name:"Stairs" attr:(getAttrIndex "Gta Collision" "Stairs") rex:0 value:true)
		dotnet.addEventHandler stairsSelectButton "click" dispatchFlagSelectClick
		
		stairsTableLayout = RS_dotNetUI.tableLayout "stairsTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		stairsTableLayout.controls.add stairsLabel 0 0
		stairsTableLayout.controls.add stairsHideCheckButton 1 0
		stairsTableLayout.controls.add stairsSelectButton 2 0
		
		/*
		noCoverLabel = RS_dotNetUI.Label "noCoverLabel" text:" Doesn't Provide Cover" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		noCoverHideCheckButton = RS_dotNetUI.checkBox "noCoverHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		noCoverHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		noCoverHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		noCoverHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Does Not Provide Cover" attr:(getAttrIndex "Gta Collision" "Does Not Provide Cover") rex:4 value:false)
		dotnet.addEventHandler noCoverHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		noCoverSelectButton = RS_dotNetUI.Button "noCoverSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		noCoverSelectButton.tag = dotNetMXSValue (RSL_flag name:"Does Not Provide Cover" attr:(getAttrIndex "Gta Collision" "Does Not Provide Cover") rex:4 value:true)
		dotnet.addEventHandler noCoverSelectButton "click" dispatchFlagSelectClick
		
		noCoverTableLayout = RS_dotNetUI.tableLayout "noCoverTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		noCoverTableLayout.controls.add noCoverLabel 0 0
		noCoverTableLayout.controls.add noCoverHideCheckButton 1 0
		noCoverTableLayout.controls.add noCoverSelectButton 2 0
		*/
		
		noClimbLabel = RS_dotNetUI.Label "noClimbLabel" text:" Non Climable" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		noClimbHideCheckButton = RS_dotNetUI.checkBox "noClimbHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		noClimbHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		noClimbHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		noClimbHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Non Climable" attr:(getAttrIndex "Gta Collision" "Non Climable") rex:1 value:false)
		dotnet.addEventHandler noClimbHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		noClimbSelectButton = RS_dotNetUI.Button "noClimbSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		noClimbSelectButton.tag = dotNetMXSValue (RSL_flag name:"Non Climable" attr:(getAttrIndex "Gta Collision" "Non Climable") rex:1 value:true)
		dotnet.addEventHandler noClimbSelectButton "click" dispatchFlagSelectClick
		
		noClimbTableLayout = RS_dotNetUI.tableLayout "noClimbTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		noClimbTableLayout.controls.add noClimbLabel 0 0
		noClimbTableLayout.controls.add noClimbHideCheckButton 1 0
		noClimbTableLayout.controls.add noClimbSelectButton 2 0
		
		/*
		noWalkLabel = RS_dotNetUI.Label "noWalkLabel" text:" Non Walkable" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		noWalkHideCheckButton = RS_dotNetUI.checkBox "noWalkHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		noWalkHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		noWalkHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		noWalkHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Non Walkable" attr:(getAttrIndex "Gta Collision" "Non Walkable") rex:5 value:false)
		dotnet.addEventHandler noWalkHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		noWalkSelectButton = RS_dotNetUI.Button "noWalkSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		noWalkSelectButton.tag = dotNetMXSValue (RSL_flag name:"Non Walkable" attr:(getAttrIndex "Gta Collision" "Non Walkable") rex:5 value:true)
		dotnet.addEventHandler noWalkSelectButton "click" dispatchFlagSelectClick
		
		noWalkTableLayout = RS_dotNetUI.tableLayout "noWalkTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		noWalkTableLayout.controls.add noWalkLabel 0 0
		noWalkTableLayout.controls.add noWalkHideCheckButton 1 0
		noWalkTableLayout.controls.add noWalkSelectButton 2 0
		*/
		
		seeLabel = RS_dotNetUI.Label "seeLabel" text:" See Through" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		seeHideCheckButton = RS_dotNetUI.checkBox "seeHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		seeHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		seeHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		seeHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"See Through" attr:(getAttrIndex "Gta Collision" "See Through") rex:2 value:false)
		dotnet.addEventHandler seeHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		seeSelectButton = RS_dotNetUI.Button "seeSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		seeSelectButton.tag = dotNetMXSValue (RSL_flag name:"See Through" attr:(getAttrIndex "Gta Collision" "See Through") rex:2 value:true)
		dotnet.addEventHandler seeSelectButton "click" dispatchFlagSelectClick
		
		seeTableLayout = RS_dotNetUI.tableLayout "seeTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		seeTableLayout.controls.add seeLabel 0 0
		seeTableLayout.controls.add seeHideCheckButton 1 0
		seeTableLayout.controls.add seeSelectButton 2 0
		
		noCamLabel = RS_dotNetUI.Label "noCamLabel" text:" Non Camera Collidable" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		noCamHideCheckButton = RS_dotNetUI.checkBox "noCamHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		noCamHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		noCamHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		noCamHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Non Camera Collidable" attr:(getAttrIndex "Gta Collision" "Non Camera Collidable") rex:7 value:false)
		dotnet.addEventHandler noCamHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		noCamSelectButton = RS_dotNetUI.Button "noCamSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		noCamSelectButton.tag = dotNetMXSValue (RSL_flag name:"Non Camera Collidable" attr:(getAttrIndex "Gta Collision" "Non Camera Collidable") rex:7 value:true)
		dotnet.addEventHandler noCamSelectButton "click" dispatchFlagSelectClick
		
		noCamTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		noCamTableLayout.controls.add noCamLabel 0 0
		noCamTableLayout.controls.add noCamHideCheckButton 1 0
		noCamTableLayout.controls.add noCamSelectButton 2 0
		
		-------------------
		--Shoot Through
		-------------------
		shootLabel = RS_dotNetUI.Label "shootLabel" text:" Shoot Through" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		shootHideCheckButton = RS_dotNetUI.checkBox "shootHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		shootHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		shootHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		shootHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Shoot Through" attr:(getAttrIndex "Gta Collision" "Shoot Through") rex:3 value:false)
		dotnet.addEventHandler shootHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		shootSelectButton = RS_dotNetUI.Button "shootSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		shootSelectButton.tag = dotNetMXSValue (RSL_flag name:"Shoot Through" attr:(getAttrIndex "Gta Collision" "Shoot Through") rex:3 value:true)
		dotnet.addEventHandler shootSelectButton "click" dispatchFlagSelectClick
		
		shootTableLayout = RS_dotNetUI.tableLayout "shootTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		shootTableLayout.controls.add shootLabel 0 0
		shootTableLayout.controls.add shootHideCheckButton 1 0
		shootTableLayout.controls.add shootSelectButton 2 0
		
		-----------------------
		--Edited by leeds
		-----------------------
		/*
		leedsLabel = RS_dotNetUI.Label "leedsLabel" text:" Edited by Leeds" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		leedsHideCheckButton = RS_dotNetUI.checkBox "shootHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		leedsHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		leedsHideCheckButton.BackgroundImageLayout =q (dotNetClass "System.Windows.Forms.ImageLayout").Center
		leedsHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Edited by Leeds" attr:(getAttrIndex "Gta Collision" "Edited by Leeds") rex:6 value:false)
		dotnet.addEventHandler leedsHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		leedsSelectButton = RS_dotNetUI.Button "leedsSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		leedsSelectButton.tag = dotNetMXSValue (RSL_flag name:"Edited by Leeds" attr:(getAttrIndex "Gta Collision" "Edited by Leeds") rex:6 value:true)
		dotnet.addEventHandler leedsSelectButton "click" dispatchFlagSelectClick
		
		leedsTableLayout = RS_dotNetUI.tableLayout "leedsTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		leedsTableLayout.controls.add leedsLabel 0 0
		leedsTableLayout.controls.add leedsHideCheckButton 1 0
		leedsTableLayout.controls.add leedsSelectButton 2 0
		*/
		
		---------------------
		--BVH Bound
		---------------------
		BVHBoundLabel = RS_dotNetUI.Label "BVHBoundLabel" text:" BVH Bound" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		BVHBoundHideCheckButton = RS_dotNetUI.checkBox "BVHBoundHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		BVHBoundHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		BVHBoundHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		BVHBoundHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"BVH Bound" attr:(getAttrIndex "Gta Collision" "BVH Bound") rex:8 value:false)
		dotnet.addEventHandler BVHBoundHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		BVHBoundSelectButton = RS_dotNetUI.Button "BVHBoundSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		BVHBoundSelectButton.tag = dotNetMXSValue (RSL_flag name:"BVH Bound" attr:(getAttrIndex "Gta Collision" "BVH Bound") rex:8 value:true)
		
		BVHBoundTableLayout = RS_dotNetUI.tableLayout "BVHBoundTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		BVHBoundTableLayout.controls.add BVHBoundLabel 0 0
		BVHBoundTableLayout.controls.add BVHBoundHideCheckButton 1 0
		BVHBoundTableLayout.controls.add BVHBoundSelectButton 2 0
		
		-------------------------
		--Wet
		-------------------------
		WetLabel = RS_dotNetUI.Label "WetLabel" text:" Wet" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		WetHideCheckButton = RS_dotNetUI.checkBox "WetHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		WetHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		WetHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		WetHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Wet" attr:(getAttrIndex "Gta Collision" "Wet") rex:4 value:false)
		dotnet.addEventHandler WetHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		WetSelectButton = RS_dotNetUI.Button "WetSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		WetSelectButton.tag = dotNetMXSValue (RSL_flag name:"Wet" attr:(getAttrIndex "Gta Collision" "Wet") rex:4 value:true)
		
		WetTableLayout = RS_dotNetUI.tableLayout "WetTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		WetTableLayout.controls.add WetLabel 0 0
		WetTableLayout.controls.add WetHideCheckButton 1 0
		WetTableLayout.controls.add WetSelectButton 2 0
		
		-------------------------
		--Path
		-------------------------
		pathLabel = RS_dotNetUI.Label "pathLabel" text:" Path" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		pathHideCheckButton = RS_dotNetUI.checkBox "pathHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		pathHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		pathHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		pathHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Path" attr:(getAttrIndex "Gta Collision" "Path") rex:5 value:false)
		dotnet.addEventHandler pathHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		pathSelectButton = RS_dotNetUI.Button "pathSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		pathSelectButton.tag = dotNetMXSValue (RSL_flag name:"Path" attr:(getAttrIndex "Gta Collision" "Path") rex:5 value:true)
		
		pathTableLayout = RS_dotNetUI.tableLayout "pathTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		pathTableLayout.controls.add pathLabel 0 0
		pathTableLayout.controls.add pathHideCheckButton 1 0
		pathTableLayout.controls.add pathSelectButton 2 0
		
		-------------------------
		--Use Procedural Tint
		-------------------------
		procTintLabel = RS_dotNetUI.Label "procTintLabel" text:" Use Procedural Tint" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		procTintHideCheckButton = RS_dotNetUI.checkBox "procTintHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		procTintHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		procTintHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		procTintHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Use Procedural Tint" attr:(getAttrIndex "Gta Collision" "Use Procedural Tint") rex:9 value:false)
		dotnet.addEventHandler procTintHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		procTintSelectButton = RS_dotNetUI.Button "procTintSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		procTintSelectButton.tag = dotNetMXSValue (RSL_flag name:"Use Procedural Tint" attr:(getAttrIndex "Gta Collision" "Use Procedural Tint") rex:9 value:true)
		
		procTintTableLayout = RS_dotNetUI.tableLayout "procTintTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		procTintTableLayout.controls.add procTintLabel 0 0
		procTintTableLayout.controls.add procTintHideCheckButton 1 0
		procTintTableLayout.controls.add procTintSelectButton 2 0
		
		-------------------------
		--Is Cloth Collision
		-------------------------
		clothCollLabel = RS_dotNetUI.Label "clothCollLabel" text:" Is Cloth Collision" textAlign:RS_dotNetPreset.CA_MiddleLeft \
										borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		clothCollHideCheckButton = RS_dotNetUI.checkBox "clothCollHideCheckButton" text:"" dockStyle:RS_dotNetPreset.DS_Fill appearance:RS_dotNetPreset.AC_Button \
											margin:(RS_dotNetObject.paddingObject 0)
		clothCollHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		clothCollHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		clothCollHideCheckButton.tag = dotNetMXSValue (RSL_flag name:"Is Cloth Collision" attr:(getAttrIndex "Gta Collision" "Is Cloth Collision") rex:10 value:false)
		dotnet.addEventHandler clothCollHideCheckButton "CheckedChanged" dispatchFlagHideCheck
		
		clothCollSelectButton = RS_dotNetUI.Button "clothCollSelectButton" text:"S" dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		clothCollSelectButton.tag = dotNetMXSValue (RSL_flag name:"Is Cloth Collision" attr:(getAttrIndex "Gta Collision" "Is Cloth Collision") rex:10 value:true)
		
		clothCollTableLayout = RS_dotNetUI.tableLayout "clothCollTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		clothCollTableLayout.controls.add clothCollLabel 0 0
		clothCollTableLayout.controls.add clothCollHideCheckButton 1 0
		clothCollTableLayout.controls.add clothCollSelectButton 2 0
		
		-------------------------
		--Attribute buttons
		-------------------------
		attributeAllButton = RS_dotNetUI.Button "attributeAllButton" text:("All") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler attributeAllButton "click" dispatchAttributeCheckClick
		
		attributeNoneButton = RS_dotNetUI.Button "attributeNoneButton" text:("None") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler attributeNoneButton "click" dispatchAttributeCheckClick
		
		attributeInvertButton = RS_dotNetUI.Button "attributeInvertButton" text:("Invert") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler attributeInvertButton "click" dispatchAttributeCheckClick
		
		attributesTableLayout = RS_dotNetUI.tableLayout "attributesTableLayout" text:"attributesTableLayout" \
									collumns:#((dataPair type:"Percent" value:75),(dataPair type:"Percent" value:25)) \
									rows:#((dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)
											,(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									dockStyle:RS_dotNetPreset.DS_Fill
		
		attributesTableLayout.controls.add attributeAllButton 1 0
		attributesTableLayout.controls.add stairsTableLayout 0 0 --stairsCheckBox
		attributesTableLayout.controls.add noClimbTableLayout 0 1 --noClimbCheckBox
		--attributesTableLayout.controls.add cameraTableLayout 0 0 --cameraCheckBox
		attributesTableLayout.controls.add attributeNoneButton 1 1
		attributesTableLayout.controls.add seeTableLayout 0 2 --seeCheckBox
		--attributesTableLayout.controls.add physicsTableLayout 0 1 --physicsCheckBox
		attributesTableLayout.controls.add attributeInvertButton 1 2
		attributesTableLayout.controls.add noCamTableLayout 0 3 --noCameraCheckBox
		--attributesTableLayout.controls.add hiDetailTableLayout 0 2 --hiDetailCheckBox
		--attributesTableLayout.controls.add locoTableLayout 0 3 --locoCheckBox
		attributesTableLayout.controls.add shootTableLayout 0 4 --shootCheckBox
		
		attributesTableLayout.controls.add BVHBoundTableLayout 0 5 --BVHBoundCheckbox
		attributesTableLayout.controls.add WetTableLayout 0 6 --wetCheckbox
		attributesTableLayout.controls.add pathTableLayout 0 7 --PathCheckbox
		attributesTableLayout.controls.add procTintTableLayout 0 8 --procTintCheckbox
		attributesTableLayout.controls.add clothCollTableLayout 0 9 --clothCollCheckbox
		
		attributesTableLayout
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchColTypeCheckClick() Dispatches colTypeCheckClick() Called when the user checks any one of the all, none and
	-- invert buttons for collision object types
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchColTypeCheckClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.colTypeCheckClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- colTypeCheckClick() Set the state based on which button is pressed and then set the check state for all the collision object
	-- type check buttons based on the state
	---------------------------------------------------------------------------------------------------------------------------------------
	fn colTypeCheckClick s e =
	(
		local state = #invert
		
		case s.name of
		(
			"colTypeAllButton":(state = true)
			"colTypeNoneButton":(state = false)
		)
		
		recurseSetCheck colTypeTableLayout state
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchColTypeHideCheck() Dispatches colTypeHideCheck() Called when the user checks any one of the collision object type
	-- visibility check buttons
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchColTypeHideCheck s e =
	(
		::RSL_CollisionOps.selectDisplayUI.colTypeHideCheck s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- colTypeHideCheck() Set the icon for the pressed button and the runs the hideByClass function
	---------------------------------------------------------------------------------------------------------------------------------------
	fn colTypeHideCheck s e =
	(
		if s.checked then
		(
			s.BackgroundImage = RS_dotNetObject.imageObject hiddenIcon
		)
		else
		(
			s.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		)
		
		hideByClass helpers s.tag.value s.checked
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchColTypeSelectClick() Dispatches colTypeSelectClick() Called when the user checks any one of the collision object type
	-- selection check buttons
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchColTypeSelectClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.colTypeSelectClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- colTypeSelectClick() Runs the selectByClass function
	---------------------------------------------------------------------------------------------------------------------------------------
	fn colTypeSelectClick s e =
	(
		-- check to see if the control button is not down and set the object selection to none
		local control = dotNetClass "system.windows.forms.control"
		
		if control.modifierKeys != control.modifierKeys.Control then
		(
			max select none
		)
		
		selectByClass helpers s.tag.value
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchSurfaceTypeGridClick() Dispatches surfaceTypeGridClick(), called when the user clicks a cell in the surfaceTypeDataGrid 
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchSurfaceTypeGridClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.surfaceTypeGridClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- surfaceTypeGridClick() Either hides or selects based on which cell is clicked
	---------------------------------------------------------------------------------------------------------------------------------------
	fn surfaceTypeGridClick s e =
	(
		local row = surfaceTypeDataGrid.rows.item[e.RowIndex]
		
		case e.columnIndex of
		(
			default:()
			1:
			(
				-- A visibility cell has been clicked so we gather the surface types for each object, set the icon
				-- based on the check state of the hidden check button and then hideBySurfaceType
				objectSurfaceTypeArray = #()
				gatherObjectSurfaceTypes helpers
				
				if not row.cells.item[3].value then
				(
					row.cells.item[3].value = true
					row.cells.item[1].value = RS_dotNetObject.imageObject hiddenIcon
				)
				else
				(
					row.cells.item[3].value = false
					row.cells.item[1].value = RS_dotNetObject.imageObject unHiddenIcon
				)
				
				hiddenSurfaceArray = #()
				unHiddenSurfaceArray = #()
				
				hideBySurfaceType helpers
				
				hide hiddenSurfaceArray
				unHide unHiddenSurfaceArray
			)
			2:
			(
				-- A Selection cell button has been clicked so we gather the surface types for each object and
				-- selectBySurfaceType
				objectsurfaceTypeArray = #()
				gatherObjectSurfaceTypes helpers
				
				-- check to see if the control button is not down and set the object selection to none
				local control = dotNetClass "system.windows.forms.control"
				
				if control.modifierKeys != control.modifierKeys.Control then
				(
					max select none
				)
				
				selectBySurfaceType helpers row.cells.item[0].value
			)
		)
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- dispatchSurfaceTypeCheckClick() Dispatches surfaceTypeCheckClick(), called when the user clicks any of the all, none or
	-- invert buttons for the surface type group
	---------------------------------------------------------------------------------------------------------------------------------------
	fn dispatchSurfaceTypeCheckClick s e =
	(
		::RSL_CollisionOps.selectDisplayUI.surfaceTypeCheckClick s e
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- surfaceTypeCheckClick() Sets the visibility state for every surface type in the surfaceTypeDataGrid based on the pressed
	-- button
	---------------------------------------------------------------------------------------------------------------------------------------
	fn surfaceTypeCheckClick s e =
	(
		local state = #invert
		
		case s.name of
		(
			"surfaceTypeAllButton":(state = true)
			"surfaceTypeNoneButton":(state = false)
		)
		
		surfaceTypeSetCheck state
	),
	
	---------------------------------------------------------------------------------------------------------------------------------------
	-- getUI() Creates the UI for select/display mode
	---------------------------------------------------------------------------------------------------------------------------------------
	fn getUI =
	(
		hideClassArray = #()
		otherHelpersArray = #()
		hiddenObjectArray = #()
		selectObjectArray = #()
		
		selectDisplayTableLayout = RS_dotNetUI.tableLayout "selectDisplayTableLayout" text:"selectDisplayTableLayout" \
									collumns:#((dataPair type:"Percent" value:50)) \
									rows:#((dataPair type:"Absolute" value:170),(dataPair type:"Absolute" value:(316 - 27)),(dataPair type:"Absolute" value:(24 + 244)),(dataPair type:"Absolute" value:24)) \
									dockStyle:RS_dotNetPreset.DS_Fill
		
		meshLabel = RS_dotNetUI.Label "meshLabel" text:" Mesh" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		meshHideCheckButton = RS_dotNetUI.checkBox "meshHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		meshHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		meshHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		meshHideCheckButton.tag = dotNetMXSValue Col_Mesh
		dotnet.addEventHandler meshHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		meshSelectButton = RS_dotNetUI.Button "meshSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		meshSelectButton.tag = dotNetMXSValue Col_Mesh
		dotnet.addEventHandler meshSelectButton "click" dispatchColTypeSelectClick
		
		meshClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		meshClassTableLayout.controls.add meshLabel 0 0
		meshClassTableLayout.controls.add meshHideCheckButton 1 0
		meshClassTableLayout.controls.add meshSelectButton 2 0
		
		boxLabel = RS_dotNetUI.Label "boxLabel" text:" Box" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		boxHideCheckButton = RS_dotNetUI.checkBox "boxHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		boxHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		boxHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		boxHideCheckButton.tag = dotNetMXSValue Col_box
		dotnet.addEventHandler boxHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		boxSelectButton = RS_dotNetUI.Button "boxSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		boxSelectButton.tag = dotNetMXSValue Col_box
		dotnet.addEventHandler boxSelectButton "click" dispatchColTypeSelectClick
		
		boxClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		boxClassTableLayout.controls.add boxLabel 0 0
		boxClassTableLayout.controls.add boxHideCheckButton 1 0
		boxClassTableLayout.controls.add boxSelectButton 2 0
		
		capsuleLabel = RS_dotNetUI.Label "capsuleLabel" text:" capsule" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		capsuleHideCheckButton = RS_dotNetUI.checkBox "capsuleHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		capsuleHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		capsuleHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		capsuleHideCheckButton.tag = dotNetMXSValue Col_capsule
		dotnet.addEventHandler capsuleHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		capsuleSelectButton = RS_dotNetUI.Button "capsuleSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		capsuleSelectButton.tag = dotNetMXSValue Col_capsule
		dotnet.addEventHandler capsuleSelectButton "click" dispatchColTypeSelectClick
		
		capsuleClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		capsuleClassTableLayout.controls.add capsuleLabel 0 0
		capsuleClassTableLayout.controls.add capsuleHideCheckButton 1 0
		capsuleClassTableLayout.controls.add capsuleSelectButton 2 0
		
		cylinderLabel = RS_dotNetUI.Label "cylinderLabel" text:" cylinder" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		cylinderHideCheckButton = RS_dotNetUI.checkBox "cylinderHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		cylinderHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		cylinderHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		cylinderHideCheckButton.tag = dotNetMXSValue Col_cylinder
		dotnet.addEventHandler cylinderHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		cylinderSelectButton = RS_dotNetUI.Button "cylinderSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		cylinderSelectButton.tag = dotNetMXSValue Col_cylinder
		dotnet.addEventHandler cylinderSelectButton "click" dispatchColTypeSelectClick
		
		cylinderClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		cylinderClassTableLayout.controls.add cylinderLabel 0 0
		cylinderClassTableLayout.controls.add cylinderHideCheckButton 1 0
		cylinderClassTableLayout.controls.add cylinderSelectButton 2 0
		
		planeLabel = RS_dotNetUI.Label "planeLabel" text:" plane" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		planeHideCheckButton = RS_dotNetUI.checkBox "planeHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		planeHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		planeHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		planeHideCheckButton.tag = dotNetMXSValue Col_plane
		dotnet.addEventHandler planeHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		planeSelectButton = RS_dotNetUI.Button "planeSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		planeSelectButton.tag = dotNetMXSValue Col_plane
		dotnet.addEventHandler planeSelectButton "click" dispatchColTypeSelectClick
		
		planeClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		planeClassTableLayout.controls.add planeLabel 0 0
		planeClassTableLayout.controls.add planeHideCheckButton 1 0
		planeClassTableLayout.controls.add planeSelectButton 2 0
		
		sphereLabel = RS_dotNetUI.Label "sphereLabel" text:" sphere" textAlign:RS_dotNetPreset.CA_MiddleLeft \
												borderStyle:RS_dotNetPreset.BS_None dockStyle:RS_dotNetPreset.DS_Fill
		
		sphereHideCheckButton = RS_dotNetUI.checkBox "sphereHideCheckButton" text:"" appearance:RS_dotNetPreset.AC_Button textAlign:RS_dotNetPreset.CA_MiddleLeft \
										dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		sphereHideCheckButton.BackgroundImage = RS_dotNetObject.imageObject unHiddenIcon
		sphereHideCheckButton.BackgroundImageLayout = (dotNetClass "System.Windows.Forms.ImageLayout").Center
		sphereHideCheckButton.tag = dotNetMXSValue Col_sphere
		dotnet.addEventHandler sphereHideCheckButton "CheckedChanged" dispatchColTypeHideCheck
		
		sphereSelectButton = RS_dotNetUI.Button "sphereSelectButton" text:("S") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		sphereSelectButton.tag = dotNetMXSValue Col_sphere
		dotnet.addEventHandler sphereSelectButton "click" dispatchColTypeSelectClick
		
		sphereClassTableLayout = RS_dotNetUI.tableLayout "noCamTableLayout" \
									collumns:#((dataPair type:"Percent" value:50),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									rows:#((dataPair type:"Absolute" value:24)) dockStyle:RS_dotNetPreset.DS_Fill
		
		sphereClassTableLayout.controls.add sphereLabel 0 0
		sphereClassTableLayout.controls.add sphereHideCheckButton 1 0
		sphereClassTableLayout.controls.add sphereSelectButton 2 0
		
		colTypeAllButton = RS_dotNetUI.Button "colTypeAllButton" text:("All") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler colTypeAllButton "click" dispatchColTypeCheckClick
		
		colTypeNoneButton = RS_dotNetUI.Button "colTypeNoneButton" text:("None") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler colTypeNoneButton "click" dispatchColTypeCheckClick
		
		colTypeInvertButton = RS_dotNetUI.Button "colTypeInvertButton" text:("Invert") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler colTypeInvertButton "click" dispatchColTypeCheckClick
		
		colTypeTableLayout = RS_dotNetUI.tableLayout "colTypeTableLayout" text:"colTypeTableLayout" \
									collumns:#((dataPair type:"Percent" value:75),(dataPair type:"Percent" value:25)) \
									rows:#((dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)
												,(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24)) \
									dockStyle:RS_dotNetPreset.DS_Fill
		
		colTypeTableLayout.controls.add meshClassTableLayout 0 0 --meshCheckBox
		colTypeTableLayout.controls.add colTypeAllButton 1 0
		colTypeTableLayout.controls.add boxClassTableLayout 0 1 --boxCheckBox
		colTypeTableLayout.controls.add colTypeNoneButton 1 1
		colTypeTableLayout.controls.add capsuleClassTableLayout 0 2 --capsuleCheckBox
		colTypeTableLayout.controls.add colTypeInvertButton 1 2
		colTypeTableLayout.controls.add cylinderClassTableLayout 0 3 --cylinderCheckBox
		colTypeTableLayout.controls.add planeClassTableLayout 0 4 --planeCheckBox
		colTypeTableLayout.controls.add sphereClassTableLayout 0 5 --sphereCheckBox
		
		colTypeGroup = RS_dotNetUI.GroupBox "classGroup" Text:"Collision Object Type" dockStyle:RS_dotNetPreset.DS_Fill
		colTypeGroup.controls.add colTypeTableLayout
		
		attributePanel = (createAttributeControls())
		
		attributeTableLayout = RS_dotNetUI.tableLayout "attributeTableLayout" text:"attributeTableLayout" \
									collumns:#((dataPair type:"Percent" value:75),(dataPair type:"Percent" value:25)) \
									rows:#((dataPair type:"Absolute" value:240),(dataPair type:"Absolute" value:24)) \
									dockStyle:RS_dotNetPreset.DS_Fill --cellStyle:RS_dotNetPreset.CBS_Single
		
		attributeTableLayout.controls.add attributePanel 0 0
		
		attributeTableLayout.SetColumnSpan attributePanel 2
		
		attributeGroup = RS_dotNetUI.GroupBox "attributeGroup" Text:"Attribute" dockStyle:RS_dotNetPreset.DS_Fill
		attributeGroup.controls.add attributeTableLayout
		
		surfaceTypeDataGrid = RS_dotNetUI.dataGridView "surfaceTypeDataGrid" text:"Surface Types" dockStyle:RS_dotNetPreset.DS_Fill
		surfaceTypeDataGrid.ColumnHeadersVisible = false
		surfaceTypeDataGrid.SelectionMode = (dotNetClass "System.Windows.Forms.DataGridViewSelectionMode").FullRowSelect --CellSelect
		surfaceTypeDataGrid.RowHeadersWidthSizeMode = (dotNetClass "System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode").DisableResizing
		surfaceTypeDataGrid.backColor = RS_dotNetClass.colourClass.White
		dotnet.addEventHandler surfaceTypeDataGrid "CellClick" dispatchSurfaceTypeGridClick --CellContentClick
		
		setupDataColumns()
		addSurfaceTypeData ::RSL_CollisionOps.attribute.matDatSurfaceTypeArray
		
		surfaceTypeAllButton = RS_dotNetUI.Button "surfaceTypeAllButton" text:("All") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler surfaceTypeAllButton "click" dispatchSurfaceTypeCheckClick
		
		surfaceTypeNoneButton = RS_dotNetUI.Button "surfaceTypeNoneButton" text:("None") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler surfaceTypeNoneButton "click" dispatchSurfaceTypeCheckClick
		
		surfaceTypeInvertButton = RS_dotNetUI.Button "surfaceTypeInvertButton" text:("Invert") dockStyle:RS_dotNetPreset.DS_Fill margin:(RS_dotNetObject.paddingObject 0)
		dotnet.addEventHandler surfaceTypeInvertButton "click" dispatchSurfaceTypeCheckClick
		
		surfaceTypeTableLayout = RS_dotNetUI.tableLayout "surfaceTypeTableLayout" text:"surfaceTypeTableLayout" \
									collumns:#((dataPair type:"Percent" value:75),(dataPair type:"Percent" value:25)) \
									rows:#((dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:24),(dataPair type:"Absolute" value:168),(dataPair type:"Absolute" value:24)) \
									dockStyle:RS_dotNetPreset.DS_Fill --cellStyle:RS_dotNetPreset.CBS_Single
		
		surfaceTypeTableLayout.controls.add surfaceTypeDataGrid 0 0 --surfaceTypeSelectButton
		surfaceTypeTableLayout.controls.add surfaceTypeAllButton 1 0
		surfaceTypeTableLayout.controls.add surfaceTypeNoneButton 1 1
		surfaceTypeTableLayout.controls.add surfaceTypeInvertButton 1 2
		
		surfaceTypeTableLayout.setRowSpan surfaceTypeDataGrid 4
		
		surfaceTypeGroup = RS_dotNetUI.GroupBox "surfaceTypeGroup" Text:"Surface Type" dockStyle:RS_dotNetPreset.DS_Fill
		surfaceTypeGroup.controls.add surfaceTypeTableLayout
		
		selectDisplayTableLayout.controls.add colTypeGroup
		selectDisplayTableLayout.controls.add attributeGroup
		selectDisplayTableLayout.controls.add surfaceTypeGroup
		
		selectDisplayTableLayout
	)
)