Added copy of original OpenFM window

src/main/scala/ocelot/desktop/entity/OpenFMRadio.scala

@@ -27,23 +27,17 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
   private val defaultScreenColor = IntColor(0x0AFF0A)
 
   var screenColor: IntColor = defaultScreenColor
-  var screenText: String = defaultScreenText
+  var url: Option[String] = None
+  var isListenRedstone: Boolean = false
 
   private var thread: Option[Thread] = None
-  private var _volume: Float = 1
-  private var _url: Option[String] = None
-
   private var soundSource: Option[SoundSource] = None
 
-  def url: Option[String] = _url
+  private var _screenText: String = defaultScreenText
+  private var _volume: Float = 1
 
-  def url_=(value: Option[String]): Unit = {
+  def screenText: String = _screenText
-    _url =
+  def screenText_=(value: String): Unit = _screenText = value.take(32)
-      if (value.isDefined)
-        Option(value.get.take(32))
-      else
-        value
-  }
 
   private def playSynchronously(): Unit = {
     try {
@@ -186,7 +180,7 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
   @Callback()
   def getScreenColor(context: Context, args: Arguments): Array[AnyRef] = result(screenColor.color)
 
-  private def callbackSetVol(value: Float): Array[AnyRef] = {
+  private def setVol(value: Float): Array[AnyRef] = {
     if (value > 0 && value <= 1) {
       volume = value
 
@@ -196,27 +190,27 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
     result(false)
   }
 
-  private def callbackVolUpOrDown(factor: Float): Array[AnyRef] = {
-    callbackSetVol(volume + factor)
-  }
-
   @Callback()
   def getVol(context: Context, args: Arguments): Array[AnyRef] = result(volume)
 
+  private def callbackVolUpOrDown(factor: Float): Array[AnyRef] = {
+    setVol(volume + factor)
+  }
+
   @Callback()
   def setVol(context: Context, args: Arguments): Array[AnyRef] = {
-    callbackSetVol(args.checkDouble(0).toFloat)
+    setVol(args.checkDouble(0).toFloat)
   }
 
-  @Callback()
+  def volUp(): Array[AnyRef] = callbackVolUpOrDown(0.1f)
-  def volUp(context: Context, args: Arguments): Array[AnyRef] = {
-    callbackVolUpOrDown(0.1f)
-  }
 
   @Callback()
-  def volDown(context: Context, args: Arguments): Array[AnyRef] = {
+  def volUp(context: Context, args: Arguments): Array[AnyRef] = volUp()
-    callbackVolUpOrDown(-0.1f)
+
-  }
+  def volDown(): Array[AnyRef] = callbackVolUpOrDown(-0.1f)
+
+  @Callback()
+  def volDown(context: Context, args: Arguments): Array[AnyRef] = volDown()
 
   @Callback()
   def start(context: Context, args: Arguments): Array[AnyRef] = {
@@ -237,11 +231,13 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
 
   @Callback()
   def getListenRedstone(context: Context, args: Arguments): Array[AnyRef] = {
-    result(true)
+    result(isListenRedstone)
   }
 
   @Callback()
   def setListenRedstone(context: Context, args: Arguments): Array[AnyRef] = {
+    isListenRedstone = args.checkBoolean(0)
+
     result(true)
   }
 
@@ -286,6 +282,8 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
       else
         1
 
+    isListenRedstone = nbt.hasKey("isListenRedstone") && nbt.getBoolean("isListenRedstone")
+
     // Playing again if previously saved value was true
     if (nbt.hasKey("isPlaying") && nbt.getBoolean("isPlaying"))
       play()
@@ -302,6 +300,7 @@ class OpenFMRadio extends Entity with Environment with DeviceInfo {
     nbt.setInteger("screenColor", screenColor.color)
     nbt.setString("screenText", screenText)
     nbt.setDouble("volume", volume)
+    nbt.setBoolean("isListenRedstone", isListenRedstone)
     nbt.setBoolean("isPlaying", isPlaying)
   }
 }

src/main/scala/ocelot/desktop/windows/OpenFMRadioWindow.scala

@@ -1,13 +1,13 @@
 package ocelot.desktop.windows
 
 import ocelot.desktop.audio.{SoundSource, SoundSources}
-import ocelot.desktop.color.Color
+import ocelot.desktop.color.{Color, IntColor}
 import ocelot.desktop.entity.OpenFMRadio
 import ocelot.desktop.geometry.{Padding2D, Size2D}
 import ocelot.desktop.graphics.Graphics
 import ocelot.desktop.node.nodes.{ComputerNode, OpenFMRadioNode}
 import ocelot.desktop.ui.event.MouseEvent
-import ocelot.desktop.ui.layout.{Layout, LinearLayout}
+import ocelot.desktop.ui.layout.{Alignment, Layout, LinearLayout}
 import ocelot.desktop.ui.widget._
 import ocelot.desktop.ui.widget.tooltip.Tooltip
 import ocelot.desktop.ui.widget.window.BasicWindow
@@ -18,44 +18,185 @@ import totoro.ocelot.brain.entity.Case
 import totoro.ocelot.brain.nbt.NBTTagCompound
 
 class OpenFMRadioWindow(radioNode: OpenFMRadioNode) extends BasicWindow {
+  private val scale = 2f
+
   private def radio: OpenFMRadio = radioNode.openFMRadio
 
-  children :+= new Widget {
+  override def minimumSize: Size2D = new Size2D(232 * scale, 105 * scale)
-    override protected val layout: Layout = new LinearLayout(this, orientation = Orientation.Vertical)
+  override protected val layout: Layout = new LinearLayout(this, Orientation.Vertical)
 
-    children :+= new PaddingBox(
+  // Volume controls
-      new Widget {
+  children :+= new PaddingBox(
-        children :+= new IconButton(
+    new Widget {
-          "buttons/PowerOff",
+      override protected val layout: Layout = new LinearLayout(
-          "buttons/PowerOn",
+        this,
-          isSwitch = true
+        Orientation.Horizontal,
+        0,
+        Alignment.Start
+      )
+
+      // Volume up/down buttons
+      private def addVolumeUpOrDownButton(isUp: Boolean, x: Float): Unit = {
+        children :+= new PaddingBox(
+          new IconButton(
+            s"buttons/OpenFMRadioVolume${if (isUp) "Up" else "Down"}Off",
+            s"buttons/OpenFMRadioVolume${if (isUp) "Up" else "Down"}On",
+            sizeMultiplier = scale
+          ) {
+            override def onPressed(): Unit = {
+              if (isUp)
+                radio.volUp()
+              else
+                radio.volDown()
+            }
+          },
+          Padding2D(0, 0, 0, x)
+        )
+      }
+
+      addVolumeUpOrDownButton(false, 0)
+
+      // Volume label
+      children :+= new PaddingBox(
+        new Label {
+          override def maximumSize: Size2D = Size2D(20, 20)
+          override def text: String = (radio.volume * 10).floor.toInt.toString
+          override def color: Color = Color.White
+        },
+        Padding2D(2, 0, 0, 20)
+      )
+
+      addVolumeUpOrDownButton(true, 8)
+
+      // Redstone button
+      children :+= new PaddingBox(
+        new IconButton(
+          "buttons/OpenFMRadioRedstoneOff",
+          "buttons/OpenFMRadioRedstoneOn",
+          isSwitch = true,
+          sizeMultiplier = scale
         ) {
-          override def isOn: Boolean = radio.isPlaying
+          override def isOn: Boolean = radio.isListenRedstone
+          override def onPressed(): Unit = radio.isListenRedstone = true
+          override def onReleased(): Unit = radio.isListenRedstone = false
+        },
+        Padding2D(0, 0, 0, 128)
+      )
 
-          override def onPressed(): Unit = {
+      // Close button
-            radio.play()
+      children :+= new PaddingBox(
+        new IconButton(
+          "buttons/OpenFMRadioCloseOff",
+          "buttons/OpenFMRadioCloseOn",
+          sizeMultiplier = scale
+        ) {
+          override def onPressed(): Unit = hide()
+        },
+        Padding2D(0, 0, 0, 10)
+      )
+    },
+    Padding2D(8, 0, 0, 188)
+  )
+
+  // Url text input
+  children :+= new PaddingBox(
+    new TextInput(radio.url.getOrElse("")) {
+      override def minimumSize: Size2D = Size2D(402, 20)
+      override def maximumSize: Size2D = Size2D(402, 20)
+      override def onConfirm(): Unit = radio.url = Option(text)
+    },
+    Padding2D(5, 0, 0, 32)
+  )
+
+  // Start/stop button
+  children :+= new PaddingBox(
+    new IconButton(
+      "buttons/OpenFMRadioStartOff",
+      "buttons/OpenFMRadioStopOn",
+      isSwitch = true,
+      sizeMultiplier = scale
+    ) {
+      override def isOn: Boolean = radio.isPlaying
+      override def onPressed(): Unit = radio.play()
+      override def onReleased(): Unit = radio.stop()
+    },
+    Padding2D(13, 0, 0, 208)
+  )
+
+  // Color / text titles
+  children :+= new PaddingBox(
+    new Widget {
+      override protected val layout: Layout = new LinearLayout(
+        this,
+        Orientation.Horizontal,
+        0,
+        Alignment.Start
+      )
+
+      // Color title
+      children :+= new Label {
+        override def text: String = "Screen color"
+        override def color: Color = Color.White
+      }
+
+      // Text title
+      children :+= new Label {
+        override def text: String = "Screen text"
+        override def color: Color = Color.White
+      }
+    },
+    Padding2D(10, 0, 0, 30)
+  )
+
+  // Color / text text inputs
+  children :+= new PaddingBox(
+    new Widget {
+      override protected val layout: Layout = new LinearLayout(
+        this,
+        Orientation.Horizontal,
+        46
+      )
+
+      // Color
+      children :+= new TextInput(radio.screenColor.color.toHexString.toUpperCase) {
+        override def minimumSize: Size2D = Size2D(118, 20)
+        override def maximumSize: Size2D = Size2D(118, 20)
+        override def onConfirm(): Unit = radio.screenColor = IntColor(Integer.parseInt(text, 16))
+
+        override def validator(text: String): Boolean = {
+          try {
+            Integer.parseInt(text, 16)
+            true
           }
-
+          catch {
-          override def onReleased(): Unit = {
+            case _: Throwable => false
-            radio.stop()
           }
-
-          protected override def clickSoundSource: SoundSource = SoundSources.MinecraftClick
         }
-      },
+      }
-      Padding2D(top = 44, left = 22)
-    )
-  }
 
-  override def update(): Unit = {
+      // Text
-    super.update()
+      children :+= new TextInput(radio.screenText) {
+        override def maximumSize: Size2D = Size2D(240, 20)
+        override def onConfirm(): Unit = radio.screenText = text
+      }
+    },
+    Padding2D(1, 0, 0, 30)
+  )
 
-
+  // OpenFM logo
-  }
+  children :+= new PaddingBox(
+    new Label {
+      override def text: String = "OpenFM"
+      override def color: Color = Color.White
+    },
+    Padding2D(22, 0, 0, 210)
+  )
 
   override def draw(g: Graphics): Unit = {
     beginDraw(g)
-    DrawUtils.windowWithShadow(g, position.x, position.y, size.width, size.height, 1f, 0.5f)
+
+    g.sprite("window/OpenFMRadio", position.x, position.y, size.width, size.height)
+
     drawChildren(g)
     endDraw(g)
   }