---------------------------------------------
-- Base class for R2 components / features --
---------------------------------------------

-- NB : throughout the file 'this' is used instead of the lua 'self' to denote the fact
-- that method are not called on the class definition, but on the instances of this class

baseClass = -- not local here because of the implementation ...
{
	----------------------
	-- CLASS PROPERTIES --
	----------------------	

	BaseClass          = "",			-- Name of the base class
    Version = 0,
	Name			   = "BaseClass",	-- Name of the class			
	BuildPropertySheet = true,          -- True if objects of this class should be editable by using a generic property sheet
	                                    -- Setting to 'true' will cause the framework to create the property sheet ui at launch
	Menu="",							-- ui path of the contextual menu for this class
	--
	DisplayerUI = "",					-- name of the C++ class that displays this object in the ui
	DisplayerUIParams = "",             -- parameters passed to the ui displayer when it is created
	--
	DisplayerProperties		= "R2::CDisplayerLua",		   -- 'lua' type of displayer takes the name of a lua function that must return the class of the displayer
	DisplayerPropertiesParams = "propertySheetDisplayer",  -- name of the function that build the displayer that update the property sheet.
	--
	TreeIcon="",						-- icon to be displayed in the tree (or a method returning it)
	PermanentTreeIcon="",				-- icon to be displayed in the tree if in permanent content (or a method returning it)
	SelectBarType = "",					-- type in select bar
	-- rollout header for the generic property sheet (a string giving the xml code for the header)	
	PropertySheetHeader = nil,

	-------------------
	-- CLASS METHODS --
	-------------------
	ClassMethods = {},

	--------------------------
	-- INSTANCES PROPERTIES --
	--------------------------
	-- * Unlike class properties above, they are created in each instance of the class. They are directly accessible in the objects.
	-- * They are C++ objects exposed through the metatable mechanism
	-- * They are *READ-ONLY*. They should be modified by network commands like r2.requestSetNode and the like
	--                         To store client side transcient values, use the native property 'User' (detailed below) instead
	-- TODO complete doc (available types, widgets ...)
	Prop = 
	{
		{Name="InstanceId", Type="String", WidgetStyle="StaticText", Category="Advanced", Visible=false },
	},	


	-- 'VIRTUAL' PROPERTIES (NOT IMPLEMENTED)
	-- Not really properties of this class, but 'shortcuts' to other, real properties
	-- The virtual properties are use by the property sheet to display properties than are jnot directly in the object,
	-- but that can be found in another place. (son object for example, or object that require an indirection)
	-- each virtual prop should provide a 'getPath' function which takes the InstanceId of the instance in which it is contained as its parameter
	-- It should return a couple : realOwnerInstanceId, realPropName (arrays not supported yet)
	-- an observer is placed on the real property to take its changes in account in the property sheet
	-- IMPORTANT: the getPath function will be called each frame to see if observers should be removed
	-- and placed on another target

	-- Example : indirection to fictive string property 'Toto' in the Scenario
	--VirtualProp = 
	--{
	--	{Name="InstanceId", Type="String", WidgetStyle="StaticText", Category="Advanced", Visible=true,
	--   getPath = function()
	--		return r2.Scenario.InstanceId, "Toto"
	--	 end,
	--	},
	--},

	---------------------------------
	-- NATIVE / SPECIAL PROPERTIES --
	---------------------------------

	-- They are implemented in C++ (thanks to the lua metatables)
	-- Parent		  : (R/O) :  The direct parent of this object. If parent object is in a table, returns the table
	-- ParentInstance : (R/O) : Next parent of this object with an InstanceId. In object is contained in a property that
	--					is a table, the object containing the table will be returned, not the table
	-- IndexInParent  : (R/O) : If parent is a table, then return index into it, -1 otherwise
	-- User			  : Read/Write lua table attached to the object. The 'User' field itself is R/O This is the place to store client side
	--                  edition variables.
	-- Size			  : (R/O) : If object is a table, returns its size, nil otherwise
	-- DisplayerUI    : (R/O) : for instances : returns reference to the ui displayer. May be nil. 
	--                  In the case where the field 'DisplayerUI' of this class definition id 'R2::CDisplayerLua', it would return
    --                  the displayer object created by a call to the function defined in 'DisplayerUIParams' (in this class definition)
	-- DisplayerVisual     : (R/O) : Same as DisplayerUI but for 'in scene' displayer
	-- DisplayerProperties : (R/O) : Same as DisplayerUI but for the properties displayer
	-- Selectable          : (R/W) : default is true. When false, the  object can't be selected in the scene. This flag is local to the instance (ancestor state not inherited)
	-- SelectableFromRoot  : (R/O) : True if this object and also its ancestor are selectable

	------------
	-- EVENTS --
	------------
	-- Events that are sent to the displayers, are also sent to instances that hold those displayers :
	-- By default they are not handled
	-- To handle, one shouldd redefine :
	-- function baseClass.onCreate(this)
	-- function baseClass.onErase(this)	
	-- etc ...
	-- see r2_ui_displayers.lua for details	

}

---------------------
-- GENERAL METHODS --
---------------------

-- Methods are defined in the class definition and are nevertheless callable on instances as follow :
-- instance:methodName(params ...)
-- In the class, the method would be defined as follow:
-- methodName = function(this, param1, param2 ...)  ... some code ... end
-- 'this' will be filled at runtime by a reference on the instance on which the method is called.
-- Method calling is possible thanks to the metamethod mechanism (in this case it is implemented in C++)
-- Calling a method is in fact equivalent to doing the following :
-- r2:getClass(instance).methodName(instance, param1, param2 ..)


---------------------------------------
-- TYPE / CLASS / PROPERTIES METHODS --
---------------------------------------

---------------------------------------------------------------------------------------------------------
-- return a reference to the class of this object
function baseClass.getClass(this)	
	return r2:getClass(this)
end

---------------------------------------------------------------------------------------------------------
-- get description of a property (as found in the 'Prop' table of the class definition) from its name
function baseClass.getPropDesc(this, propName)
	return this:getClass().NameToProp[propName]
end

---------------------------------------------------------------------------------------------------------
-- return name of the parent class
function baseClass.getClassName(this)
	return this.Class
end

---------------------------------------------------------------------------------------------------------
-- test if object is of the given class (or derived from the class)
-- param 'class' should be a string identifying the class
function baseClass.isKindOf(this, className)

	assert( type(this) == "userdata")
	local currClass = this:getClass()
	while currClass do
		if currClass.Name == className then
			return true
		end
		currClass = r2.Classes[currClass.BaseClass]
	end
	return false
end


---------------------------------------------------------------------------------------------------------
-- return a 'this' of the base class
-- Use this to access a method defined in a base class from a derived class
--
-- example : this:delegate():doThis() -- Call the doThis function in the parent class
--
-- Expected behavior is the same than with C++ :
-- Call from a delegated pointer is static
-- any further call is the call chain is polymorphic
-- Calls to delegate can be chained
-- NB : this function shouldn't be redefined in derived classes (the delegation mechanism uses a pointer on this function)
--function baseClass.delegate(this)	
--	return __baseClassImpl.delegate(this) -- implementation defined in "r2_base_class_private.lua"	
--end

---------------------------------------------------------------------------------------------------------
-- Get actual C++ "this" for this object. Because of the delegation mechanism, this may be a raw C++ object
-- or a lua table that performs the delegation
-- OBSOLETE, TO REMOVE
function baseClass.getRawThis(this)
	-- return __baseClassImpl.getRawThis(this) -- implementation defined in "r2_base_class_private.lua"
	return this
end


---------------------------------------------------------------------------------------------------------
-- compare current "this", with another "this" pointer
-- This should be the standard way to compare instance in memory because 'this' may sometime be a userdata
-- (raw C++ pointer to internal C++ object), or a table (delegated 'this' pointer)
-- OBSOLETE, TO REMOVE
function baseClass.isSameObjectThan(this, other)	
	--if this:isKindOf("Act") then
	--	breakPoint()
	--end
	--return this:getRawThis() == other:getRawThis()
	return this == other
end




---------------------------------------------------------------------------------------------------------
-- Helper : Return world position (that is, absolute position). By default, object deriving from the base class have no position
function baseClass.getWorldPos()
	return { x = 0, y = 0, z = 0 }
end

---------------------------------------------------------------------------------------------------------
-- When adding content, pionneer have a limited budget. This method gives the 'cost' of this object (0 by default)
--function baseClass.getUsedQuota(this)
--	return 0
--end

-------------------
-- SCENARIO COST --
-------------------

---------------------------------------------------------------------------------------------------------
-- See wether this element has a cost in the scenario
function baseClass.hasScenarioCost(this)
	return false
end

---------------------------------------------------------------------------------------------------------
-- get local cost cached in object
function baseClass.getLocalCost(this)
	return defaulting(this.User.Cost, 0)
end

---------------------------------------------------------------------------------------------------------
-- set local cost in object
function baseClass.setLocalCost(this, cost)
	this.User.Cost = cost
end

---------------------------------------------------------------------------------------------------------
-- get local static cost cached in object
function baseClass.getLocalStaticCost(this)
	return defaulting(this.User.StaticCost, 0)
end

---------------------------------------------------------------------------------------------------------
-- set local static cost in object
function baseClass.setLocalStaticCost(this, cost)
	this.User.StaticCost = cost
end



function baseClass.getStaticObjectCost(this) 
	return 0
end

function baseClass.getAiCost(this) 
	return 0
end

----------------------
-- OBJECT HIERARCHY --
----------------------

---------------------------------------------------------------------------------------------------------
-- append all sub-content that is "kind of" 'kind' to 'destTable' 
-- NB : this is very SLOW!!! please use iterators instead (see r2:enumInstances)
function baseClass.appendInstancesByType(this, destTable, kind)	
	assert(type(kind) == "string")	
	if this.CompareClass and this.CompareClass == true then
		if this.Class == kind then
			if destTable == nil then
				dumpCallStack(1)
			end
			table.insert(destTable, this:getRawThis())	
		end
	elseif this:isKindOf(kind) then
		if destTable == nil then
			dumpCallStack(1)
		end
		table.insert(destTable, this:getRawThis())		
	end	
end

---------------------------------------------------------------------------------------------------------
-- Append all instances rooted at this object (including this one)	
 
function baseClass.getSons(this, destTable)
	r2:exploreInstanceTree(this, destTable)		
end

---------------------------------------------------------------------------------------------------------
-- Search first ancestor of the wanted kind (that is of class 'className' or a derived class)
function baseClass.getParentOfKind(this, className)
	local parent = this.ParentInstance
	while parent do
		assert(parent.isKindOf)
		if parent:isKindOf(className) then return parent end
		parent = parent.ParentInstance
	end
	return nil
end

---------------------------------------------------------------------------------------------------------
-- Search parent until an act is found
function baseClass.getParentAct(this)
	return this:getParentOfKind("Act")
end

---------------------------------------------------------------------------------------------------------
-- Search parent until a scenario is found
function baseClass.getParentScenario(this)
	return this:getParentOfKind("Scenario")	
end

---------------------------------------------------------------------------------------------------------
-- See if hits object is inserted in the default feature (that is : single npcs, bot objects, roads etc. with no enclosing group or feature)
function baseClass.isInDefaultFeature(this)	
	return this.ParentInstance:isKindOf('DefaultFeature')
end


--------------------------
-- UI METHODS / DISPLAY --
--------------------------

---------------------------------------------------------------------------------------------------------
-- Called by the contextual menu/toolbar when the 'delete' option is chosen by the user
-- on THIS client
-- This is the place to perform additionnal deletion tasks
-- Example : a vertex may want to delete its containing region when there are 2 vertices left only
-- default -> just call 'r2.requestEraseNode'
function baseClass.onDelete(this)
	if this.User.DeleteInProgress == true then return end
	this.User.DeleteInProgress = true
	this:setDeleteActionName()
	this:selectNext()
	r2.requestEraseNode(this.InstanceId, "", -1)
	r2.requestEndAction()	
end

-- helper : add "delete : name_of_the_thing_being_deleted"  in the action historic as the name of the delete action that is about 
-- to be done
function baseClass.setDeleteActionName(this)
	r2.requestNewAction(concatString(i18n.get("uiR2EDDeleteAction"), this:getDisplayName()))
end


---------------------------------------------------------------------------------------------------------
-- Test wether the user can delete this object
function baseClass.isDeletable(this)
	if this.Deletable and this.Deletable == 0 then  return false end
	return true
end

---------------------------------------------------------------------------------------------------------
-- called when the instance is selected (default is no op)
function baseClass.onSelect(this)
   
end

---------------------------------------------------------------------------------------------------------
-- Tell if object can be selected as next object if a predecessor object
-- has been selected in the parent list
function baseClass.isNextSelectable(this)
	return false
end

---------------------------------------------------------------------------------------------------------
-- get next selectable object (or nil else)
function baseClass.getNextSelectableObject(this)
	local startIndex = this.IndexInParent
	if type(startIndex) ~= "number" then return nil end
	local currIndex = startIndex
	while true do
		currIndex = currIndex + 1
		if currIndex == this.Parent.Size then
			currIndex = 0
		end
		local instance = this.Parent[currIndex]
		if currIndex == startIndex then break end 
		if instance ~= nil then
			local firstSon = instance:getFirstSelectableSon()
			if firstSon ~= nil and firstSon:isNextSelectable() then
				return firstSon
			elseif instance.Selectable and instance:isNextSelectable() then
				return instance
			end
		end
	end
	if this.ParentInstance:isKindOf("DefaultFeature") then
		return this.ParentInstance:getNextSelectableObject()
	end
	return nil
end

---------------------------------------------------------------------------------------------------------
-- select object next to this one, if there's one
function baseClass.selectNext(this)	
	local nextSelection = this
	while 1 do
		nextSelection = nextSelection:getNextSelectableObject()
		if not nextSelection or nextSelection == this then
			r2:setSelectedInstanceId("")
			return
		end	
		if nextSelection then
			-- should not be frozen or hiden
			if (not nextSelection.DisplayerVisual) or (nextSelection.DisplayerVisual.DisplayMode ~= 1 and nextSelection.DisplayerVisual.DisplayMode ~= 2) then							
				r2:setSelectedInstanceId(nextSelection.InstanceId)
				return
			end			
		end	
	end
end

---------------------------------------------------------------------------------------------------------
-- if an object is not selectable if may nevertheless contain selectable object, the first one is returned by this method
function baseClass.getFirstSelectableSon(this)
	return nil
end

---------------------------------------------------------------------------------------------------------
-- get select bar type
function baseClass.getSelectBarType(this)
	return r2:evalProp(this:getClass().SelectBarType, this, "")	
end

---------------------------------------------------------------------------------------------------------
-- get name of tree icon
function baseClass.getTreeIcon(this)
	return r2:evalProp(this:getClass().TreeIcon, this, "")	
end	

---------------------------------------------------------------------------------------------------------
-- get name of tree icon
function baseClass.getPermanentTreeIcon(this)
	return r2:evalProp(this:getClass().PermanentTreeIcon, this, "")	
end	

---------------------------------------------------------------------------------------------------------
-- get name of tree icon according to permanent or current act
function baseClass.getContextualTreeIcon(this)
	if this:getParentAct() and this:getParentAct():isBaseAct() then
		return this:getPermanentTreeIcon()
	else
		return this:getTreeIcon()
	end
end	

---------------------------------------------------------------------------------------------------------
-- get name of permanent statut icon 
function baseClass.getPermanentStatutIcon(this)
	return "" 
end	
---------------------------------------------------------------------------------------------------------
-- get name of icon to be displayed in the slect bar
function baseClass.getSelectBarIcon(this)
   return this:getContextualTreeIcon()
end

---------------------------------------------------------------------------------------------------------
-- Get the display name (in i18n format). This name will be displayed in the property sheet or inthe instance tree
function baseClass.getDisplayName(this)
	local displayName = ""
	if this.Name ~= nil and this.Name ~= "" then		
		displayName = this.Name
	else
		return i18n.get("uiR2EDNoName")
		-- local className = this.Class
		-- -- tmp patch
		-- if this:isKindOf("Npc") then			
		-- if this:isBotObject() then
		-- 	className = "Bot object"
		-- end
		-- end
		-- className = className .. " : " .. this.InstanceId
		-- displayName = className
	end
	return displayName
end

---------------------------------------------------------------------------------------------------------
-- Get the base name for instance name generation (should return a utf-8 string)
function baseClass.getBaseName(this)
	return ""
end


---------------------------------------------------------------------------------------------------------
-- return true if this instance can by displayed as a button in the select bar
function baseClass.displayInSelectBar(this)
	return true
end

---------------------------------------------------------------------------------------------------------
-- get first parent that is selectable in the select bar
function baseClass.getFirstSelectBarParent(this)
	local curr = this.ParentInstance
	while curr and not curr:displayInSelectBar() do
		curr = curr.ParentInstance
	end
	return curr
end

---------------------------------------------------------------------------------------------------------
-- search the first son that could be inserted in the select bar
-- default is to look recursively in the 'son select bar container'
function baseClass.getFirstSelectBarSon(this)
	local sons = this:getSelectBarSons()
	if not sons then return nil end
	for k, v in specPairs(sons) do
		if v:displayInSelectBar() then
			return v
		end
		local firstSelectBarSon = v:getFirstSelectBarSon()
		if firstSelectBarSon ~= nil then
			return firstSelectBarSon
		end
	end
end

---------------------------------------------------------------------------------------------------------
-- test if object can have sons than are displayable in the select bar
function baseClass.canHaveSelectBarSons(this)
	return false;
end

---------------------------------------------------------------------------------------------------------
-- return the default container that may contain object displayable in the select bar
function baseClass.getSelectBarSons()
	return nil
end

---------------------------------------------------------------------------------------------------------
-- called by the select bar when it displays its menu. Additionnal can be added there
function baseClass.completeSelectBarMenu(rootMenu)
	-- no-op
end

---------------------------------------------------------------------------------------------------------
-- The following method is called when the default ui displayer wants to know where to attach an object in the instance tree
-- Default behaviour is to return the tree node of the parent object when one is found
function baseClass.getParentTreeNode(this)	
	parent = this.ParentInstance
	while parent ~= nil do		
		if parent.User.TreeNodes ~= nil then
			return parent.User.TreeNodes
		end
		parent = parent.ParentInstance
	end	
	return nil
end

--------------------------------------------------------------------------------------------			
-- Helper function for features : return the feature parent tree node in their act
function baseClass.getFeatureParentTreeNode(this)	
	
	--return this:getParentAct():getContentTreeNodes("macro_components")
	return this:getParentAct():getContentTreeNodes()
end


--------------------------------------------------------------------------------------------
-- TODO: test if the object can be exported (true by default)
function baseClass.isExportable(this)
	return true
end

---------------------------------------------------------------------------------------------------------
-- This method is called by the C++ when the contextual menu is about to be displayed
function baseClass.onSetupMenu(this)
	local class = r2:getClass(this)	
	local menuName = class.Menu
	if menuName == nil then return end	
	local menu = getUI(menuName)	
	-- setup menu entries to select parents	
	--for i = 1,8 do		
	-- 	menu["selectParent" .. tostring(i)].active = false
	--end	
	-- local parent = this.ParentInstance
	-- for i = 1,9 do
	-- 	if parent == nil or parent.Parent == nil then break end		
	-- 	menu["selectParent" .. tostring(i)].active = true
	-- 	menu["selectParent" .. tostring(i)].text = i18n.get("uimR2EDSelectParent") + (parent.InstanceId .. "  (" .. parent.Class .. ")")
	-- 	--debugInfo(colorTag(0, 255, 255) .. tostring(i))
	-- 	parent = parent.ParentInstance
	-- end		
	-- -- setup cut & paste entries
	-- local cuttedSelection = r2:getCuttedSelection()
	-- if cuttedSelection and this.accept ~= nil then
	-- 	local canPaste = this:accept(cuttedSelection)
	-- 	debugInfo("canPaste = " .. tostring(canPaste))
	-- 	menu.paste.grayed = not canPaste
	-- else
	-- 	menu.paste.grayed = true
	-- end
   -- debug options   
   local extDebug = config.R2EDExtendedDebug == 1   
   menu.dump_lua_table.active   = extDebug
   menu.inspect_lua_table.active = extDebug
   menu.translateFeatures.active = extDebug
   menu.dump_dialogs_as_text.active = extDebug
   menu.update_dialogs_from_text.active =  extDebug

   menu.cut.active = extDebug
   menu.paste.active = extDebug

   

	r2.ContextualCommands:setupMenu(this, menu)

	

	-- delete entries for dynamic content
	-- local menuRoot = menu:getRootMenu()
	-- local startLine = menuRoot:getLineFromId("dynamic_content_start")
	-- local endLine = menuRoot:getLineFromId("dynamic_content_end")
	-- assert(startLine ~= -1 and endLine ~= -1)
	-- for lineToDel = endLine - 1, startLine + 1, -1 do
	--	menuRoot:removeLine(lineToDel)		
	-- end
	-- retrieve dynamic commands
	-- local commands = this:getAvailableCommands()
	-- local currentLine = startLine + 1
	-- local commandIndex = 1
	-- for commandIndex, command in commands do
	--	menuRoot:addLineAtIndex(currentLine, i18n.get(command.TextId), "lua", "", "dyn_command_" .. tostring(commandIndex))
		-- if there's a bitmap, build a group with the buitmap in it, and add to menu
		-- if command.ButtonBitmap and command.ButtonBitmap ~= "" then
		--	local menuButton = createGroupInstance("r2_menu_button", "", { bitmap = command.ButtonBitmap, })
		--	if menuButton then
		--		menuRoot:setUserGroupLeft(currentLine, menuButton)
		--	end
		-- end
		--currentLine = currentLine + 1		
	--end   
end
---------------------------------------------------------------------------------------------------------
-- Show the property window for this instance
-- (react to the event 'show properties' triggered in the ui, by contextual menu or toolbar)
function baseClass.onShowProperties(this)
	-- for now a global (see r2_ui_property_sheet.lua)
	r2:showProperties(this)
end

---------------------------------------------------------------------------------------------------------
-- Return list of currently available commands to launch on that instance.
-- such commands are displayed in the contextual toolbar or in the contextual menu.
-- Returned value should be an array (starting at index 1) with commands of the following format :
--
-- { DoCommand = function(instance) ...,  -- code to execute when the command is triggered (by menu or toolbar)
--                                        -- Because the function takes 'instance' as a parameter, it may be 
--                                        -- either a global function or a method of this class
--   Id = "",							  -- Id of the action. The action "r2ed_context_command" defined in actions.xml
--                                        -- will search for this id when a key is pressed to find the good action
--   TextId  = "...",                     -- Text id for entry menu & toolbar tooltip
--   ButtonBitmap = "filename.tga",       -- Name of the button to display in the toolbar, nil
--                                        -- or "" if the command should not appear in the contextual toolbar   
--   Separator = "true",                  -- optionnal, false by default : specify if there should be a separator 
--                                        -- between this button and previous buttons
--   ShowInMenu = false,                   -- false if the entry shouldn't be displayed in the menu
--   IsActivity = false					  -- true if event is an activity
-- }
--
-- 'getAvailableCommands' should be called by derived class, possibly adding their
--  own commands
--
-- See also : 'buildCommand'

function baseClass.getAvailableCommands(this, dest)	
	if this.ParentInstance:isKindOf("UserComponentHolder") then
		table.insert(dest, this:buildCommand(this.onRemoveFromUserComponent, "removeFromUserComponent", "uimR2EDRemoveFromUserComponent", ""))
	end
	if this:isDeletable() and this.User.DeleteInProgress ~= true then
		table.insert(dest, this:buildCommand(this.onDelete, "delete", "uimR2EDMenuDelete", "r2_toolbar_delete.tga"))
	end
	if this:getClass().BuildPropertySheet then
		table.insert(dest, this:buildCommand(this.onShowProperties, "properties", "uimR2EDMenuProperties",  "r2_toolbar_properties.tga", true))
	end

	if this:isKindOf("NpcCustom") then
		table.insert(dest, this:buildCommand(this.customizeLook, "customize_look", "uiR2EDCustomizeLook", "r2_toolbar_customize_look.tga", false))
	end

end

---------------------------------------------------------------------------------------------------------
-- Build a single command entry to be used by  'getAvailableCommands'
-- A command entry translates into a button in the contextual toolbar
function baseClass.buildCommand(this, command, id, textId, bitmap, separator, showInMenu)
	if showInMenu == nil then showInMenu = true end
	return 
	{	
		DoCommand    = command,
		TextId       = textId,
		Id			 = id,
		ButtonBitmap = bitmap,
		Separator    = separator,
		ShowInMenu   = showInMenu,
		IsActivity   = false
	}
end

---------------------------------------------------------------------------------------------------------
-- same as 'buildCommand', but for activities
function baseClass.buildActivityCommand(this, command, id, textId, bitmap, separator, showInMenu)
	local result = this:buildCommand(command, id, textId, bitmap, separator, showInMenu)
	result.IsActivity = true
   return result
end

---------------------------------------------------------------------------------------------------------
-- Special, class method (not instance method) for dev : returns a table containing all infos on which the xml generic property sheet depends 
-- When this table is modified, then the xml property sheet will be rebuild for this class (when 'resetEditor'
-- is called for example.
function baseClass.ClassMethods.getGenericPropertySheetCacheInfos(this)
	local infos = {}
	infos.Prop = this.Prop									-- if one of the properties change, then must rebuild the property sheet
	infos.PropertySheetHeader = this.PropertySheetHeader    -- if the xml header change, then must rebuild the sheet, too
	return infos
end


---------------------------------------------------------------------------------------------------------
-- get list of command for display in the mini toolbar
function baseClass.getAvailableMiniCommands(this, result)	
	-- OBSOLETE
	--	table.insert(result, this:buildCommand(this.editDialogs, "edit_dialogs", "uiR2EDEditDialogs",  "r2_icon_dialog_mini.tga"))
	--	table.insert(result, this:buildCommand(this.editActions, "edit_actions", "uiR2EDEditActions",  "r2_icon_action_mini.tga"))
	--	table.insert(result, this:buildCommand(this.editReactions, "edit_reactions", "uiR2EDEditReactions",  "r2_icon_reaction_mini.tga"))	
end

---------------------------------------------------------------------------------------------------------
-- Return true if sequences can be edited on that object
function baseClass.isSequencable(this)
	return false
end

---------------------------------------------------------------------------------------------------------
-- For sequencable object only (baseClass.isSequencable) : return the lookup string for a verb from an activity name
-- Indeed, an activity may have different name depending on who performs it
-- for example, the "Feed In Zone" activity will be name "work" for a worker kitin instead of "feed" for a carnivore
function baseClass.getActivityVerbLookupName(this, activityName)
	return activityName
end


---------------------------------------------------------------------------------------------------------
-- is the object global to the scenario ? The select bar will call this to force the good update
-- for global objects that are selectable (plot items ...)
function baseClass.isGlobalObject(this)
	return false
end



function baseClass.onRemoveFromUserComponent(this)
	r2_core.CurrentHolderId = this.ParentInstance.InstanceId
	r2_core:removeUserComponentElement(this.InstanceId)
end

-------------
-- REF IDS --
-------------

-- Set the value of a refId inside this object. (empty string to delete)
-- This will push a new action name & call r2.requestNode
function baseClass.setRefIdValue(this, refIdName, targetId)	
	local name = this:getDisplayName()
	local refIdUCName = r2:getPropertyTranslation(this:getClass().NameToProp[refIdName])
	if targetId == "" then
	r2.requestNewAction(concatString(i18n.get("uiR2EDRemovingTargetAction"), name,
								i18n.get("uiR2EDAddingReferenceSeparator"), refIdname))
	else
		local targetName = r2:getInstanceFromId(targetId):getDisplayName()
		r2.requestNewAction(concatString(i18n.get("uiR2EDAddingReferenceAction"), name,
									i18n.get("uiR2EDAddingReferenceSeparator"), refIdUCName,
									i18n.get("uiR2EDAddingReferenceToAction"), targetName))
	end
	r2.requestSetNode(this.InstanceId, refIdName, targetId)

end


---------------------------
-- COPY / PASTE HANDLING --
---------------------------

---------------------------------------------------------------------------------------------------------
-- see if this object support copy (false by default)
function baseClass.isCopyable(this)
	return false
end

---------------------------------------------------------------------------------------------------------
-- Create a canonical copy of this object, this copy can be used by subsequent calls to 'newCopy'
function baseClass.copy(this)	
	-- implementation in "r2_base_class_private.lua"
end


-- Create a new copy from a canonical copy
-- New instance ids are generated
-- Default behavior is to remove all external dependencies and to rename 
-- internal dependencies
-- The result can be used as input to 'paste' & 'ghostPaste'
function baseClass.newCopy(canonicalCopy)	
	-- implementation in "r2_base_class_private.lua"
end


---------------------------------------------------------------------------------------------------------
-- Paste the current clipboard
-- not really a method here, because 'src' id a lua table (should be the content of the clipboard ...) that can be used with 
-- a r2.request.. command.
-- - this function should copy the result in a suitable place (maybe into current selection, or at global scope)
--   NB : if newPlace is not true, then the result should be past at the coordinates found in src
-- - It should check that there is some room in the scenario before doing the copy
function baseClass.paste(src, newPlace, srcInstanceId)	
	if r2:getLeftQuota() <= 0 then
		r2:makeRoomMsg()
		return
	end
end

function baseClass.pasteGhost(src)	
		
	if r2:getLeftQuota() <= 0 then
		r2:makeRoomMsg()
		return
	end
end



-- TMP TMP : move events test

--
function baseClass.onTargetInstancePreHrcMove(this, targetAttr, targetIndexInArray)
	debugInfo(string.format("instance: pre hrc move : %s", targetAttr))
end
--
function baseClass.onTargetInstancePostHrcMove(this, targetAttr, targetIndexInArray)
	debugInfo(string.format("instance : post hrc move : %s", targetAttr))	
end



-- IMPLEMENTATION
r2.doFile("r2_base_class_private.lua")


r2.registerComponent(baseClass)

baseClass = nil




















