Add display item for group and order them in create order

src/main/kotlin/xyz/alexcrea/cuanvil/group/AbstractMaterialGroup.kt

@@ -5,7 +5,6 @@ import java.util.*
 
 abstract class AbstractMaterialGroup(private val name: String) {
     protected val includedMaterial by lazy {createDefaultSet()}
-    protected var groupChangeNotified = false
 
     /**
      * Get the group default set
@@ -15,7 +14,7 @@ abstract class AbstractMaterialGroup(private val name: String) {
     /**
      * Get if a material is allowed following the group policy
      */
-    fun contain(mat : Material): Boolean {
+    open fun contain(mat : Material): Boolean {
         return mat in includedMaterial
     }
 
@@ -35,14 +34,28 @@ abstract class AbstractMaterialGroup(private val name: String) {
     abstract fun addToPolicy(other : AbstractMaterialGroup)
 
     /**
-     * Get the group as a set
+     * Get the group contained material as a set
      */
-    abstract fun getMaterials(): MutableSet<Material>
+    abstract fun getMaterials(): EnumSet<Material>
+
+    /**
+     * Get the group non-inherited material as a set
+     */
+    open fun getNonGroupInheritedMaterials(): EnumSet<Material> {
+        return includedMaterial
+    }
+    /**
+     * Get the group non-inherited material as a set
+     */
+    open fun setNonGroupInheritedMaterials(materials: EnumSet<Material>) {
+        this.includedMaterial.clear()
+        this.includedMaterial.addAll(materials)
+    }
 
     /**
      * Get the group name in case something is wrong
      */
-    fun getName(): String {
+    open fun getName(): String {
         return name
     }
 
@@ -56,4 +69,22 @@ abstract class AbstractMaterialGroup(private val name: String) {
      */
     abstract fun getGroups(): MutableSet<AbstractMaterialGroup>
 
+    open fun getRepresentativeMaterial() : Material {
+        // Test inner material
+        val matIterator = includedMaterial.iterator()
+        while(matIterator.hasNext()){
+            val material = matIterator.next();
+            if(material.isAir) continue
+            return material;
+        }
+        // Test included group representative material
+        val groupIterator = getGroups().iterator()
+        while (groupIterator.hasNext()){
+            val groupMat = groupIterator.next().getRepresentativeMaterial()
+            if(groupMat.isAir) continue
+            return groupMat;
+        }
+        return Material.PAPER;
+    }
+
 }

src/main/kotlin/xyz/alexcrea/cuanvil/group/ExcludeGroup.kt

@@ -9,7 +9,7 @@ class ExcludeGroup(name: String): AbstractMaterialGroup(name) {
     }
 
     private var includedGroup: MutableSet<AbstractMaterialGroup> = HashSet()
-    private val groupItems: MutableSet<Material> by lazy {createDefaultSet()}
+    private val groupItems by lazy {createDefaultSet()}
 
     override fun isReferencing(other: AbstractMaterialGroup): Boolean {
         for (materialGroup in includedGroup.iterator()) {
@@ -27,28 +27,28 @@ class ExcludeGroup(name: String): AbstractMaterialGroup(name) {
 
     override fun addToPolicy(other: AbstractMaterialGroup) {
         includedGroup.add(other)
-        groupItems.removeAll(other.getMaterials());
+        groupItems.removeAll(other.getMaterials())
     }
 
     override fun setGroups(groups: MutableSet<AbstractMaterialGroup>) {
         groupItems.clear()
         groupItems.addAll(includedMaterial)
 
-        includedGroup.clear();
+        includedGroup.clear()
         groups.forEach { group ->
             if(!group.isReferencing(this)) {
-                includedGroup.add(group);
+                includedGroup.add(group)
                 groupItems.removeAll(group.getMaterials())
             }
         }
     }
 
     override fun getGroups(): MutableSet<AbstractMaterialGroup> {
-        return includedGroup;
+        return includedGroup
     }
 
-    override fun getMaterials(): MutableSet<Material> {
-        return groupItems;
+    override fun getMaterials(): EnumSet<Material> {
+        return groupItems
     }
 
 

src/main/kotlin/xyz/alexcrea/cuanvil/group/IncludeGroup.kt

@@ -9,7 +9,7 @@ class IncludeGroup(name: String): AbstractMaterialGroup(name) {
     }
 
     private var includedGroup: MutableSet<AbstractMaterialGroup> = HashSet()
-    private val groupItems: MutableSet<Material> by lazy {createDefaultSet()}
+    private val groupItems by lazy {createDefaultSet()}
 
     override fun isReferencing(other: AbstractMaterialGroup): Boolean {
         for (materialGroup in includedGroup.iterator()) {
@@ -27,27 +27,38 @@ class IncludeGroup(name: String): AbstractMaterialGroup(name) {
 
     override fun addToPolicy(other: AbstractMaterialGroup) {
         includedGroup.add(other)
-        groupItems.addAll(other.getMaterials());
+        groupItems.addAll(other.getMaterials())
     }
 
     override fun setGroups(groups: MutableSet<AbstractMaterialGroup>) {
-        groupItems.clear();
+        groupItems.clear()
         groupItems.addAll(includedMaterial)
 
-        includedGroup.clear();
+        includedGroup.clear()
         groups.forEach { group ->
             if(!group.isReferencing(this)){
-                includedGroup.add(group);
+                includedGroup.add(group)
                 groupItems.addAll(group.getMaterials())
             }
         }
     }
 
+    override fun setNonGroupInheritedMaterials(materials: EnumSet<Material>) {
+        super.setNonGroupInheritedMaterials(materials)
+        // Update group items
+        groupItems.clear()
+        groupItems.addAll(includedMaterial)
+
+        includedGroup.forEach { group ->
+            groupItems.addAll(group.getMaterials())
+        }
+    }
+
     override fun getGroups(): MutableSet<AbstractMaterialGroup> {
         return includedGroup
     }
 
-    override fun getMaterials(): MutableSet<Material> {
+    override fun getMaterials(): EnumSet<Material> {
         return groupItems
     }
 

src/main/kotlin/xyz/alexcrea/cuanvil/group/ItemGroupManager.kt

@@ -4,6 +4,7 @@ import io.delilaheve.CustomAnvil
 import org.bukkit.Material
 import org.bukkit.configuration.ConfigurationSection
 import java.util.*
+import kotlin.collections.LinkedHashMap
 
 class ItemGroupManager {
 
@@ -18,11 +19,11 @@ class ItemGroupManager {
         private val FUTURE_MATERIAL = setOf("PIGLIN_HEAD","BRUSH")
     }
 
-    lateinit var groupMap : HashMap<String, AbstractMaterialGroup>
+    lateinit var groupMap : LinkedHashMap<String, AbstractMaterialGroup>
 
     // Read and create material groups
     fun prepareGroups(config: ConfigurationSection){
-        groupMap = HashMap()
+        groupMap = LinkedHashMap()
 
         val keys = config.getKeys(false)
         for (key in keys) {