Lost and found

src/main/scala/ocelot/desktop/OcelotDesktop.scala

@@ -3,7 +3,7 @@ package ocelot.desktop
 import java.io.{PrintWriter, StringWriter}
 
 import ocelot.desktop.ui.UiHandler
-import ocelot.desktop.ui.widget.ScreenWidget
+import ocelot.desktop.ui.widget.{RootWidget, ScreenView}
 import ocelot.desktop.util.{Audio, ResourceManager}
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.scala.Logging
@@ -17,7 +17,7 @@ import totoro.ocelot.brain.util.Tier
 
 
 object OcelotDesktop extends Logging {
-  var screenWidget: ScreenWidget = _
+  var root: RootWidget = _
   var ui: UiHandler = _
 
   def mainInner(): Unit = {
@@ -27,8 +27,8 @@ object OcelotDesktop extends Logging {
     Ocelot.initialize(LogManager.getLogger(Ocelot))
     createWorkspace()
 
-    screenWidget = new ScreenWidget(screen)
+    root = new RootWidget(screen)
-    ui = new UiHandler(screenWidget)
+    ui = new UiHandler(root)
 
     setupEventHandlers()
     computer.turnOn()
@@ -110,27 +110,27 @@ object OcelotDesktop extends Logging {
     })
 
     EventBus.listenTo(classOf[TextBufferSetEvent], { case event: TextBufferSetEvent =>
-      screenWidget.set(event.x, event.y, event.value, event.vertical)
+      root.screenView.set(event.x, event.y, event.value, event.vertical)
     })
 
     EventBus.listenTo(classOf[TextBufferFillEvent], { case event: TextBufferFillEvent =>
-      screenWidget.fill(event.x, event.y, event.width, event.height, event.value)
+      root.screenView.fill(event.x, event.y, event.width, event.height, event.value)
     })
 
     EventBus.listenTo(classOf[TextBufferCopyEvent], { case event: TextBufferCopyEvent =>
-      screenWidget.copy(event.x, event.y, event.width, event.height, event.horizontalTranslation, event.verticalTranslation)
+      root.screenView.copy(event.x, event.y, event.width, event.height, event.horizontalTranslation, event.verticalTranslation)
     })
 
     EventBus.listenTo(classOf[TextBufferSetForegroundColorEvent], { case event: TextBufferSetForegroundColorEvent =>
-      screenWidget.foreground = event.color
+      root.screenView.foreground = event.color
     })
 
     EventBus.listenTo(classOf[TextBufferSetBackgroundColorEvent], { case event: TextBufferSetBackgroundColorEvent =>
-      screenWidget.background = event.color
+      root.screenView.background = event.color
     })
 
     EventBus.listenTo(classOf[TextBufferSetResolutionEvent], { case event: TextBufferSetResolutionEvent =>
-      screenWidget.setResolution(event.width, event.height)
+      root.screenView.setResolution(event.width, event.height)
     })
   }
 }

src/main/scala/ocelot/desktop/graphics/Graphics.scala

@@ -8,6 +8,8 @@ import ocelot.desktop.util.{FontLoader, Spritesheet}
 import org.apache.logging.log4j.scala.Logging
 import org.lwjgl.opengl.GL11
 
+import scala.collection.mutable.ArrayBuffer
+
 class Graphics extends Logging {
   private var projection = Transform2D.viewport(800, 600)
   private var z = 0f
@@ -28,6 +30,8 @@ class Graphics extends Logging {
   private var spriteRect = Spritesheet.sprites(_sprite)
   private val emptySpriteTrans = Transform2D.translate(spriteRect.x, spriteRect.y) >> Transform2D.scale(spriteRect.w, spriteRect.h)
 
+  private val transformStack = new ArrayBuffer[Transform2D]()
+
   GL11.glEnable(GL11.GL_DEPTH_TEST)
   GL11.glDepthFunc(GL11.GL_LEQUAL)
   GL11.glEnable(GL11.GL_BLEND)
@@ -78,6 +82,24 @@ class Graphics extends Logging {
     _fontSize = value
   }
 
+  def transform: Transform2D = transformStack.lastOption.getOrElse(Transform2D.identity)
+
+  def pushTransform(): Unit = {
+    transformStack += transform
+  }
+
+  def popTransform(): Unit = {
+    transformStack.remove(transformStack.length - 1)
+  }
+
+  def transform(t: Transform2D): Unit = {
+    transformStack(transformStack.length - 1) = transform >> t
+  }
+
+  def translate(x: Float, y: Float): Unit = {
+    transform(Transform2D.translate(x, y))
+  }
+
   def sprite: String = _sprite
 
   def sprite_=(value: String): Unit = {
@@ -116,8 +138,10 @@ class Graphics extends Logging {
       // ^ dirty hack to avoid edge bleeding, somehow works
     )
 
-    rectRenderer.schedule(MeshInstance(_background, z, Transform2D.translate(x, y) >> Transform2D.scale(width, height), emptySpriteTrans))
+    val transform = this.transform >> Transform2D.translate(x, y) >> Transform2D.scale(width, height)
-    textRenderer.schedule(MeshInstance(_foreground, z + 1, Transform2D.translate(x, y) >> Transform2D.scale(width, height), uvTransform))
+
+    rectRenderer.schedule(MeshInstance(_background, z, transform, emptySpriteTrans))
+    textRenderer.schedule(MeshInstance(_foreground, z + 1, transform, uvTransform))
 
     z += 2
   }
@@ -130,8 +154,9 @@ class Graphics extends Logging {
   }
 
   def rect(x: Float, y: Float, width: Float, height: Float): Unit = {
+    val transform = this.transform >> Transform2D.translate(x, y) >> Transform2D.scale(width, height)
     val uvTransform = Transform2D.translate(spriteRect.x, spriteRect.y) >> Transform2D.scale(spriteRect.w, spriteRect.h)
-    rectRenderer.schedule(MeshInstance(_background, z, Transform2D.translate(x, y) >> Transform2D.scale(width, height), uvTransform))
+    rectRenderer.schedule(MeshInstance(_background, z, transform, uvTransform))
     z += 1
   }
 

src/main/scala/ocelot/desktop/ui/UiHandler.scala

@@ -4,7 +4,7 @@ import java.nio.{ByteBuffer, IntBuffer}
 
 import ocelot.desktop.geometry.{Size2D, Vector2D}
 import ocelot.desktop.graphics.Graphics
-import ocelot.desktop.ui.widget.RootWidget
+import ocelot.desktop.ui.widget.{RootWidget, Widget}
 import ocelot.desktop.util.{Audio, FPSCalculator, FontLoader, Spritesheet}
 import org.apache.logging.log4j.scala.Logging
 import org.lwjgl.glfw.{GLFW, GLFWErrorCallback}
@@ -13,8 +13,6 @@ import org.lwjgl.opengl.{GL, GL11}
 import org.lwjgl.system.MemoryUtil.NULL
 
 class UiHandler(val root: RootWidget) extends Logging {
-  root.uiHandler = this
-
   private var graphics: Graphics = _
   private var window: Long = _
   private var fullRedraw = true
@@ -23,11 +21,11 @@ class UiHandler(val root: RootWidget) extends Logging {
   private var soundContext: Long = _
 
   private val fpsCalculator = new FPSCalculator
-  private var windowTitle = root.windowTitle
+  private var windowTitle = "hello there"
 
-  private var windowSize: Size2D = Size2D(0, 0)
+  private var windowSize: Size2D = Size2D(800, 600)
   private var sizeLimits = SizeLimits(root.minimumSize, root.maximumSize)
-  root.size = Size2D.Zero
+  root.size = windowSize
 
   def fps: Float = fpsCalculator.fps
 
@@ -126,6 +124,8 @@ class UiHandler(val root: RootWidget) extends Logging {
   }
 
   private def update(): Unit = {
+    updateWidget(root)
+
     val newSizeLimits = SizeLimits(root.minimumSize, root.maximumSize)
     if (sizeLimits != newSizeLimits) {
       sizeLimits = newSizeLimits
@@ -145,13 +145,27 @@ class UiHandler(val root: RootWidget) extends Logging {
 
     for (event <- KeyHandler.events.iterator ++ MouseHandler.events.iterator ++ ScrollHandler.events.iterator)
       root.handleEvent(event)
+  }
 
-    root.update()
+  private def updateWidget(widget: Widget): Unit = {
+    widget.uiHandler = this
+    widget.update()
+
+    for (child <- widget.children)
+      updateWidget(child)
+  }
+
+  private def drawWidget(widget: Widget, forceRedraw: Boolean = false): Unit = {
+    val redrawParent = forceRedraw || widget.shouldRedraw
+    if (redrawParent) widget.draw(graphics)
+
+    for (child <- widget.children)
+      drawWidget(child, forceRedraw = redrawParent)
   }
 
   private def draw(): Unit = {
     graphics.clear()
-    root.draw(graphics)
+    drawWidget(root, forceRedraw = fullRedraw)
     graphics.commit()
   }
 

src/main/scala/ocelot/desktop/ui/widget/RootWidget.scala

@@ -1,12 +1,11 @@
 package ocelot.desktop.ui.widget
 
-import ocelot.desktop.ui.UiHandler
+import totoro.ocelot.brain.entity.Screen
 
-abstract class RootWidget extends Widget {
+class RootWidget(screen: Screen) extends WrapperWidget {
-  // TODO: Remove
+  val screenView = new ScreenView(screen)
-  var uiHandler: UiHandler = _
 
-  def windowTitle: String
+  override protected val inner = new ScrollView(screenView)
 
-  def update(): Unit = {}
+  def windowTitle: String = f"Ocelot Desktop [FPS: ${uiHandler.fps}%2.3f]"
 }

src/main/scala/ocelot/desktop/ui/widget/ScreenView.scala

@@ -11,11 +11,11 @@ import totoro.ocelot.brain.user.User
 
 import scala.collection.mutable
 
-class ScreenWidget(screen: Screen) extends RootWidget with Logging {
+class ScreenView(screen: Screen) extends Widget with Logging {
   private val fontSize = 16f
 
-  var width = screen.getWidth
+  private var width = screen.getWidth
-  var height = screen.getHeight
+  private var height = screen.getHeight
 
   var background: Int = 0x000000
   var foreground: Int = 0xFFFFFF
@@ -76,13 +76,14 @@ class ScreenWidget(screen: Screen) extends RootWidget with Logging {
     }
   }
 
-  override def windowTitle: String = f"Ocelot Desktop [FPS: ${uiHandler.fps}%2.3f]"
-
   override def draw(g: Graphics): Unit = {
+    g.pushTransform()
+    g.translate(position.x, position.y)
+
     val w = math.round(fontSize * width / 2f) + 32
     val h = math.round(fontSize * height) + 32
 
-    g.clear(0, 0, w, h)
+    g.clear(position.x.toInt, position.y.toInt, w, h)
     g.background = IntColor(0x333333)
     g.sprite = "Empty"
     g.rect(0, 0, w, h)
@@ -108,6 +109,8 @@ class ScreenWidget(screen: Screen) extends RootWidget with Logging {
     g.sprite("BorderH", 16, h - 16, w - 32, 16)
     g.sprite("BorderV", 0, 16, 16, h - 32)
     g.sprite("BorderV", w - 16, 16, 16, h - 32)
+
+    g.popTransform()
   }
 
   def set(x: Int, y: Int, text: String, vertical: Boolean): Unit = {

src/main/scala/ocelot/desktop/ui/widget/ScrollView.scala

@@ -0,0 +1,20 @@
+package ocelot.desktop.ui.widget
+import ocelot.desktop.geometry.Size2D
+
+class ScrollView(contents: Widget) extends Widget {
+  override def minimumSize: Option[Size2D] = Some(Size2D(10, 10))
+
+  override def maximumSize: Option[Size2D] = None
+
+  override def children: Seq[Widget] = {
+    Array(contents)
+  }
+
+  class ScrollBar(orientation: Orientation.Value) extends Widget {
+
+  }
+
+  object Orientation extends Enumeration {
+    val Vertical, Horizontal = Value
+  }
+}

src/main/scala/ocelot/desktop/ui/widget/Widget.scala

@@ -1,12 +1,17 @@
 package ocelot.desktop.ui.widget
 
-import ocelot.desktop.geometry.Size2D
+import ocelot.desktop.geometry.{Size2D, Vector2D}
 import ocelot.desktop.graphics.Graphics
-import ocelot.desktop.ui.EventHandlers
+import ocelot.desktop.ui.{EventHandlers, UiHandler}
 import ocelot.desktop.ui.event.Event
 
-class Widget {
+abstract class Widget {
+  private var _position: Vector2D = Vector2D(0, 0)
   private var _size: Size2D = Size2D(0, 0)
+  private var _parent: Option[Widget] = None
+
+  // TODO: Remove
+  var uiHandler: UiHandler = _
 
   val eventHandlers = new EventHandlers
 
@@ -19,11 +24,31 @@ class Widget {
     )
   }
 
+  def position: Vector2D = _position
+
+  def position_=(value: Vector2D): Unit = {
+    _position = value
+  }
+
   def minimumSize: Option[Size2D] = None
 
   def maximumSize: Option[Size2D] = None
 
-  def draw(g: Graphics): Unit = {}
+  def children: Seq[Widget] = Array[Widget]()
+
+  def parent: Option[Widget] = _parent
+
+  def parent_=(value: Option[Widget]): Unit = {
+    _parent = value
+  }
 
   def handleEvent(event: Event): Unit = eventHandlers(event)
+
+  def draw(g: Graphics): Unit = {}
+
+  def shouldRedraw: Boolean = true
+
+  def update(): Unit = {}
+
+  def relayout(): Unit = {}
 }

src/main/scala/ocelot/desktop/ui/widget/WrapperWidget.scala

@@ -0,0 +1,13 @@
+package ocelot.desktop.ui.widget
+
+import ocelot.desktop.geometry.Size2D
+
+abstract class WrapperWidget extends Widget {
+  protected val inner: Widget
+
+  override def minimumSize: Option[Size2D] = inner.minimumSize
+
+  override def maximumSize: Option[Size2D] = inner.maximumSize
+
+  override def children: Seq[Widget] = Array(inner)
+}