Behavior element behavior adding a renderable Desktop widget.

This behavior is useful for models with a complex dynamic texture where the content of the texture is provided by a Desktop widget. Multiple other behaviors can add their content Window to the Desktop separating logic for reuse. Using ECBehaviorRenderableDesktop instead of ECBehaviorRenderableCanvas allows to use the full power of the GUI ToolKit including using Gui Themes to create complex content easily.

The default layout for the Desktop is StackLayout]. The default gui theme is “/shareddata/guithemes/modern/modern.guitheme.xml”. The default Desktop designer selector is “RenderableDesktop”.

To use this behavior add an ECBehaviorDynamicSkin to the element class before adding this behavior. Create ECBehaviorRenderableDesktop behavior and set the dynamic skin and designer selector and GuiTheme for the Desktop. Now you can add other behaviors targeting the ECBehaviorRenderableDesktop to add Widget resources to.

The Desktop is created with a default size of 1024×1024 . You can change the size using the element property to fit the texture requirements.

Multiple instances of ECBehaviorRenderableDesktop can be added to affect individual dynamic skin textures. The example below uses one component with one dynamic skin to two individual renderables named “content1” and “content2” each allowing to be individiaully filled with content by different behaviors.

class MyElement extends BehaviorElementClass
   public func new()
      ECBehaviorComponent.new(this)
      ECBehaviorDynamicSkin.new(this)
      
      ECBehaviorCanvas.new(this)
      ECBehaviorCanvas.new(this, "canvas2")
      
      var ECBehaviorRenderableDesktop behavior = ECBehaviorRenderableDesktop.new(this)
      behavior.getRenderable().setValue("content1")
      behavior.getGuiTheme().setPath("/content/renderable.guitheme.xml")
      behavior.getDesignerSelector().setValue("Desktop.MyElement")
      
      behavior = ECBehaviorRenderableDesktop.new(this, "renderableDesktop2")
      behavior.setBackgroundColor(Color.blue)
      behavior.getRenderable().setValue("intensity2")
      behavior.getGuiTheme().setPath("/content/renderable.guitheme.xml")
      behavior.getDesignerSelector().setValue("Desktop.MyElement")
   end
end

Element class properties have the prefix renderableDesktop. or renderableDesktop(id). if id is not empty.

Name of the renderable in the component skin to modify.

• Full name: “renderableDesktop.renderable” or “renderableDesktop(id).renderable”
• Type: string
• Default Value: “” (empty string)
• Example (*.deeclass):

  <string name='renderableDesktop.renderable'>monitor content</string>

Size of desktop in pixels.

• Full name: “renderableDesktop.size” or “renderableDesktop(id).size”
• Type: Point
• Default value: (1024, 1024)
• Example (*.deeclass):

  <point name='renderableDesktop.size' x='1024' y='512'/>

Path to gui theme (*.guitheme.xml) to load. If the same gui theme is used in multiple elements it is loaded only once and shared.

• Full name: “renderableDesktop.guiTheme” or “renderableDesktop(id).guiTheme”
• Type: Path (*.guitheme.xml)
• Default value: “/shareddata/guithemes/modern/modern.guitheme.xml”
• Example (*.deeclass):

  <string name='renderableDesktop.guiTheme'>/content/ui/ingame.guitheme.xml</string>

Name of designer selector to use from gui theme specified in guiTheme property for desktop widget. Allows to define multiple desktops in one gui theme potentially sharing definitions.

• Full name: “renderableDesktop.designerSelector” or “renderableDesktop(id).designerSelector”
• Type: string
• Default Value: “RenderableDesktop”
• Example (*.deeclass):

  <string name='renderableDesktop.designerSelector'>RenderableDesktop.CockpitMonitor.Center</string>

• ECBehaviorDynamicSkin

This behavior does not support optional behaviors.

This behavior does not use persistency.

ECBehaviorRenderableDesktop.

Since DragonScript Module Version 1.3

• Create displays and monitors showing dynamic content like a digital wall clock or a train station time table. The element has one renderable used (typically emissivity to show the content. For each dynamic content to show add behavior providing the content.
• Generate textures with randomized content during game loading. Same as previous use case but content typically is static.
• Create dynamic skin content which is difficult to create using skin properties only. This can be individual moving and changing content like advertize board or shop signs.

class ExampleElementClass extends BehaviorElementClass
   public var ECBehaviorComponent component
   public var ECBehaviorCollider collider
   public var ECBehaviorDynamicSkin dynamicSkin
   public var ECBehaviorRenderableDesktop renderableDesktop
   
   public func new() super("ExampleElement")
     // add required behaviors component and collider
     component = ECBehaviorComponent.new(this)
     collider = ECBehaviorCollider.new(this, component)
     
     // add dynamic skin to modify component
     dynamicSkin = ECBehaviorDynamicSkin.new(this, component)
     
     // create renderable desktop. the skin has to use a renderable named "board".
     // the panel has a size of 1024x1024 and uses gui theme loaded from "adboard.guitheme.xml".
     // the desktop uses by default a stack layout hence all widgets added fill the
     // entire desktop space and are layered ontop of each other. any behavior can
     // change the layout used for the desktop if required
     renderableDesktop = ECBehaviorRenderableDesktop.new(this, dynamicSkin)
     renderableDesktop.getRenderable().setValue("board")
     renderableDesktop.getSize().setPoint(Point.new(512, 256))
     renderableDesktop.getGuiTheme().setPath("/content/ui/adboard.guitheme.xml")

     // here you could now add behaviors adding content to the renderable.
     // the simply have to create (during their init(StubElement) call) one or more widgets
     // adding them to the renderable. using behavior makes this a reusable process
     //
     // MyContentBehavior.new(this, renderableDesktop)
   end
   
   // another way is adding widgets yourself. this can be useful for prototyping
   // and situations where you have a simple gui widget
   protected func Element createElement()
     var BehaviorElement element = super.createElement()
     var Desktop desktop = renderableDesktop.instance(element).getDesktop()
     
     // add some content to it. this example adds two labels against the top
     // and bottom edge with an image stretched between them. each can be
     // designed using a respective designer selector like adding borders,
     // changing background, changing padding, font and color
     var Window window = Window.new(Point.new(20, 50), Point.new(600, 500))
     
     window.setLayout(BorderLayout.new(5))
     window.addWidget(Label.new("Top-Side", "Label.TopSide"), BorderLayout.Area.top)
     window.addWidget(DisplayImage.new("/content/adEatMorePears.png", RepeatMode.stretch, "Image.AdEatMorePears"), BorderLayout.Area.content)
     window.addWidget(Label.new("Bottom-Side", "Label.BottomSide"), BorderLayout.Area.bottom)
     
     desktop.addWindow(window)
     
     // later on in the game you could use a WidgetInputProcessor to direct
     // player input to the desktop widget to allow the player to interact
     // with the content as if it is the regular UI
     return element
   end
end