mirror of
https://gitlab.com/2009scape/rt4-client.git
synced 2025-12-11 17:10:24 -07:00
777 lines
30 KiB
Kotlin
777 lines
30 KiB
Kotlin
package KondoKit
|
|
|
|
import KondoKit.Helpers.formatHtmlLabelText
|
|
import KondoKit.Helpers.formatNumber
|
|
import KondoKit.Helpers.getSpriteId
|
|
import KondoKit.Helpers.showAlert
|
|
import KondoKit.views.HiscoresView
|
|
import KondoKit.views.LootTrackerView
|
|
import KondoKit.views.ReflectiveEditorView
|
|
import KondoKit.SpriteToBufferedImage.getBufferedImageFromSprite
|
|
import KondoKit.Themes.Theme
|
|
import KondoKit.Themes.ThemeType
|
|
import KondoKit.Themes.getTheme
|
|
import KondoKit.components.ProgressBar
|
|
import KondoKit.components.ScrollablePanel
|
|
import KondoKit.components.ToggleSwitch
|
|
import KondoKit.components.*
|
|
import KondoKit.views.XPTrackerView
|
|
import KondoKit.plugin.StateManager.focusedView
|
|
import KondoKit.views.Constants.COMBAT_LVL_SPRITE
|
|
import KondoKit.views.HiscoresView.createHiscoreSearchView
|
|
import KondoKit.views.HiscoresView.hiScoreView
|
|
import KondoKit.views.LootTrackerView.BAG_ICON
|
|
import KondoKit.views.LootTrackerView.createLootTrackerView
|
|
import KondoKit.views.LootTrackerView.lootTrackerView
|
|
import KondoKit.views.LootTrackerView.npcDeathSnapshots
|
|
import KondoKit.views.LootTrackerView.onPostClientTick
|
|
import KondoKit.views.LootTrackerView.takeGroundSnapshot
|
|
import KondoKit.views.ReflectiveEditorView.addPlugins
|
|
import KondoKit.views.ReflectiveEditorView.createReflectiveEditorView
|
|
import KondoKit.views.ReflectiveEditorView.reflectiveEditorView
|
|
import KondoKit.views.XPTrackerView.createXPTrackerView
|
|
import KondoKit.views.XPTrackerView.createXPWidget
|
|
import KondoKit.views.XPTrackerView.initialXP
|
|
import KondoKit.views.XPTrackerView.resetXPTracker
|
|
import KondoKit.views.XPTrackerView.totalXPWidget
|
|
import KondoKit.views.XPTrackerView.updateWidget
|
|
import KondoKit.views.XPTrackerView.wrappedWidget
|
|
import KondoKit.views.XPTrackerView.xpTrackerView
|
|
import KondoKit.views.XPTrackerView.xpWidgets
|
|
import plugin.Plugin
|
|
import plugin.api.*
|
|
import plugin.api.API.*
|
|
import plugin.api.FontColor.fromColor
|
|
import rt4.*
|
|
import rt4.DisplayMode
|
|
import rt4.GameShell.canvas
|
|
import rt4.GameShell.frame
|
|
import rt4.client.js5Archive8
|
|
import rt4.client.mainLoadState
|
|
import java.awt.*
|
|
import java.awt.Font
|
|
import java.awt.event.ActionListener
|
|
import java.awt.event.MouseAdapter
|
|
import java.awt.event.MouseEvent
|
|
import javax.swing.*
|
|
|
|
|
|
@Target(AnnotationTarget.FIELD)
|
|
@Retention(AnnotationRetention.RUNTIME)
|
|
annotation class Exposed(val description: String = "")
|
|
|
|
class plugin : Plugin() {
|
|
companion object {
|
|
val WIDGET_SIZE = Dimension(220, 50)
|
|
val TOTAL_XP_WIDGET_SIZE = Dimension(220, 30)
|
|
val IMAGE_SIZE = Dimension(25, 23)
|
|
|
|
// Default Theme Colors
|
|
var WIDGET_COLOR = Color(30, 30, 30)
|
|
var TITLE_BAR_COLOR = Color(21, 21, 21)
|
|
var VIEW_BACKGROUND_COLOR = Color(40, 40, 40)
|
|
var primaryColor = Color(165, 165, 165) // Color for "XP Gained:"
|
|
var secondaryColor = Color(255, 255, 255) // Color for "0"
|
|
var POPUP_BACKGROUND = Color(45, 45, 45)
|
|
var POPUP_FOREGROUND = Color(220, 220, 220)
|
|
var TOOLTIP_BACKGROUND = Color(50,50,50)
|
|
var SCROLL_BAR_COLOR = Color(64, 64, 64)
|
|
var PROGRESS_BAR_FILL = Color(61, 56, 49)
|
|
var NAV_TINT: Color? = null
|
|
var NAV_GREYSCALE = false
|
|
var BOOST = 1f
|
|
|
|
var appliedTheme = ThemeType.RUNELITE
|
|
|
|
@Exposed("Theme colors for KondoKit, requires a relaunch to apply.")
|
|
var theme = ThemeType.RUNELITE
|
|
|
|
@Exposed("Default: true, Use Local JSON or the prices from the Live/Stable server API")
|
|
var useLiveGEPrices = true
|
|
|
|
@Exposed("Used to calculate Combat Actions until next level.")
|
|
var playerXPMultiplier = 5
|
|
|
|
@Exposed("Start minimized/collapsed by default")
|
|
var launchMinimized = false
|
|
|
|
@Exposed("Default 16 on Windows, 0 Linux/macOS. If Kondo is not " +
|
|
"perfectly snapped to the edge of the game due to window chrome you can update this to fix it")
|
|
var uiOffset = 0
|
|
|
|
@Exposed("Stretched/Scaled Fixed Mode Support")
|
|
var useScaledFixed = false
|
|
|
|
const val FIXED_WIDTH = 765
|
|
const val FIXED_HEIGHT = 503
|
|
private const val NAVBAR_WIDTH = 30
|
|
private const val MAIN_CONTENT_WIDTH = 242
|
|
private const val WRENCH_ICON = 907
|
|
private const val LOOT_ICON = 777
|
|
private const val MAG_SPRITE = 1423
|
|
const val LVL_ICON = 898
|
|
private lateinit var cardLayout: CardLayout
|
|
private lateinit var mainContentPanel: JPanel
|
|
private var rightPanelWrapper: JScrollPane? = null
|
|
private var accumulatedTime = 0L
|
|
private var reloadInterfaces = false
|
|
private const val TICK_INTERVAL = 600L
|
|
private var pluginsReloaded = false
|
|
private var loginScreen = 160
|
|
private var lastLogin = ""
|
|
private var initialized = false
|
|
private var lastClickTime = 0L
|
|
private var lastUIOffset = 0
|
|
private var themeName = "RUNELITE"
|
|
private const val HIDDEN_VIEW = "HIDDEN"
|
|
private var altCanvas: AltCanvas? = null
|
|
private val drawActions = mutableListOf<() -> Unit>()
|
|
|
|
fun registerDrawAction(action: () -> Unit) {
|
|
synchronized(drawActions) {
|
|
drawActions.add(action)
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun Init() {
|
|
// Disable Font AA
|
|
System.setProperty("sun.java2d.opengl", "false")
|
|
System.setProperty("awt.useSystemAAFontSettings", "off")
|
|
System.setProperty("swing.aatext", "false")
|
|
}
|
|
|
|
override fun OnLogin() {
|
|
if (lastLogin != "" && lastLogin != Player.usernameInput.toString()) {
|
|
// if we logged in with a new character
|
|
// we need to reset the trackers
|
|
xpTrackerView?.let { resetXPTracker(it) }
|
|
}
|
|
lastLogin = Player.usernameInput.toString()
|
|
}
|
|
|
|
override fun OnMiniMenuCreate(currentEntries: Array<out MiniMenuEntry>?) {
|
|
if (currentEntries != null) {
|
|
for ((index, entry) in currentEntries.withIndex()) {
|
|
if (entry.type == MiniMenuType.PLAYER && index == currentEntries.size - 1) {
|
|
val input = entry.subject
|
|
// Trim spaces, clean up tags, and remove the level info
|
|
val cleanedInput = input
|
|
.trim() // Remove any leading/trailing spaces
|
|
.replace(Regex("<col=[0-9a-fA-F]{6}>"), "") // Remove color tags
|
|
.replace(Regex("<img=\\d+>"), "") // Remove image tags
|
|
.replace(Regex("\\(level: \\d+\\)"), "") // Remove level text e.g. (level: 44)
|
|
.trim() // Trim again to remove extra spaces after removing level text
|
|
|
|
// Proceed with the full cleaned username
|
|
InsertMiniMenuEntry("Lookup", entry.subject, searchHiscore(cleanedInput))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun OnPluginsReloaded(): Boolean {
|
|
if (!initialized) return true
|
|
// Ensure Swing updates happen on the EDT to avoid flicker
|
|
SwingUtilities.invokeLater {
|
|
updateDisplaySettings()
|
|
frame.remove(rightPanelWrapper)
|
|
frame.layout = BorderLayout()
|
|
rightPanelWrapper?.let { frame.add(it, BorderLayout.EAST) }
|
|
frame.revalidate()
|
|
frame.repaint()
|
|
}
|
|
pluginsReloaded = true
|
|
reloadInterfaces = true
|
|
return true
|
|
}
|
|
|
|
override fun OnXPUpdate(skillId: Int, xp: Int) {
|
|
if (!initialXP.containsKey(skillId)) {
|
|
initialXP[skillId] = xp
|
|
return
|
|
}
|
|
val previousXpSnapshot = initialXP[skillId] ?: xp
|
|
if (xp == initialXP[skillId]) return
|
|
|
|
val ensureOnEdt = Runnable {
|
|
var xpWidget = xpWidgets[skillId]
|
|
if (xpWidget != null) {
|
|
updateWidget(xpWidget, xp)
|
|
} else {
|
|
xpWidget = createXPWidget(skillId, previousXpSnapshot)
|
|
xpWidgets[skillId] = xpWidget
|
|
|
|
val wrapped = wrappedWidget(xpWidget.container)
|
|
// Attach per-widget remove menu
|
|
val popupMenu = XPTrackerView.removeXPWidgetMenu(wrapped, skillId)
|
|
val rightClickListener = object : MouseAdapter() {
|
|
override fun mousePressed(e: MouseEvent) {
|
|
if (e.isPopupTrigger) popupMenu.show(e.component, e.x, e.y)
|
|
}
|
|
override fun mouseReleased(e: MouseEvent) {
|
|
if (e.isPopupTrigger) popupMenu.show(e.component, e.x, e.y)
|
|
}
|
|
}
|
|
Helpers.addMouseListenerToAll(wrapped, rightClickListener)
|
|
wrapped.addMouseListener(rightClickListener)
|
|
|
|
xpTrackerView?.add(wrapped)
|
|
xpTrackerView?.add(Box.createVerticalStrut(5))
|
|
|
|
if(focusedView == XPTrackerView.VIEW_NAME) {
|
|
xpTrackerView?.revalidate()
|
|
xpTrackerView?.repaint()
|
|
}
|
|
|
|
updateWidget(xpWidget, xp)
|
|
}
|
|
}
|
|
|
|
if (SwingUtilities.isEventDispatchThread()) {
|
|
ensureOnEdt.run()
|
|
} else {
|
|
SwingUtilities.invokeLater(ensureOnEdt)
|
|
}
|
|
}
|
|
|
|
override fun Draw(timeDelta: Long) {
|
|
if (GlRenderer.enabled && GlRenderer.canvasWidth != GameShell.canvasWidth) {
|
|
GlRenderer.canvasWidth = GameShell.canvasWidth
|
|
GlRenderer.setViewportBounds(0, 0, GameShell.canvasWidth, GameShell.canvasHeight)
|
|
}
|
|
|
|
if (pluginsReloaded) {
|
|
// Rebuild the reflective editor UI on the EDT and in one batch
|
|
SwingUtilities.invokeLater {
|
|
reflectiveEditorView?.let { addPlugins(it) }
|
|
}
|
|
pluginsReloaded = false
|
|
}
|
|
|
|
if (reloadInterfaces){
|
|
InterfaceList.method3712(true) // Gets the resize working correctly
|
|
reloadInterfaces = false
|
|
}
|
|
|
|
accumulatedTime += timeDelta
|
|
if (accumulatedTime >= TICK_INTERVAL) {
|
|
lootTrackerView?.let { onPostClientTick(it) }
|
|
accumulatedTime = 0L
|
|
}
|
|
|
|
// Draw synced actions (that require to be done between glBegin and glEnd)
|
|
if (drawActions.isNotEmpty()) {
|
|
synchronized(drawActions) {
|
|
val actionsCopy = drawActions.toList()
|
|
drawActions.clear()
|
|
for (action in actionsCopy) {
|
|
action()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Init in the draw call so we know we are between glBegin and glEnd for HD
|
|
if(!initialized && mainLoadState >= loginScreen) {
|
|
initKondoUI()
|
|
}
|
|
}
|
|
|
|
override fun LateDraw(timeDelta: Long) {
|
|
if (!initialized) return
|
|
if(GameShell.fullScreenFrame != null) {
|
|
DisplayMode.setWindowMode(true, 0, FIXED_WIDTH, FIXED_HEIGHT)
|
|
showAlert("Fullscreen is not supported by KondoKit. Disable the plugin first.",
|
|
"Error",
|
|
JOptionPane.INFORMATION_MESSAGE
|
|
)
|
|
return
|
|
}
|
|
if(!useScaledFixed) return
|
|
if(GetWindowMode() == WindowMode.FIXED){
|
|
moveAltCanvasToFront()
|
|
} else {
|
|
moveCanvasToFront()
|
|
}
|
|
altCanvas?.updateGameImage() // Update the game image as needed
|
|
}
|
|
|
|
override fun Update() {
|
|
|
|
val widgets = xpWidgets.values
|
|
val totalXP = totalXPWidget
|
|
|
|
widgets.forEach { xpWidget ->
|
|
val elapsedTime = (System.currentTimeMillis() - xpWidget.startTime) / 1000.0 / 60.0 / 60.0
|
|
val xpPerHour = if (elapsedTime > 0) (xpWidget.totalXpGained / elapsedTime).toInt() else 0
|
|
val formattedXpPerHour = formatNumber(xpPerHour)
|
|
xpWidget.xpPerHourLabel.text =
|
|
formatHtmlLabelText("XP /hr: ", primaryColor, formattedXpPerHour, secondaryColor)
|
|
xpWidget.container.repaint()
|
|
}
|
|
|
|
totalXP?.let { totalXPWidget ->
|
|
val elapsedTime = (System.currentTimeMillis() - totalXPWidget.startTime) / 1000.0 / 60.0 / 60.0
|
|
val totalXPPerHour = if (elapsedTime > 0) (totalXPWidget.totalXpGained / elapsedTime).toInt() else 0
|
|
val formattedTotalXpPerHour = formatNumber(totalXPPerHour)
|
|
totalXPWidget.xpPerHourLabel.text =
|
|
formatHtmlLabelText("XP /hr: ", primaryColor, formattedTotalXpPerHour, secondaryColor)
|
|
totalXPWidget.container.repaint()
|
|
}
|
|
}
|
|
|
|
override fun OnKillingBlowNPC(npcID: Int, x: Int, z: Int) {
|
|
val preDeathSnapshot = takeGroundSnapshot(Pair(x,z))
|
|
npcDeathSnapshots[npcID] = LootTrackerView.GroundSnapshot(preDeathSnapshot, Pair(x, z), 0)
|
|
}
|
|
|
|
private fun allSpritesLoaded() : Boolean {
|
|
// Check all skill sprites
|
|
try{
|
|
for (i in 0 until 24) {
|
|
if(!js5Archive8.isFileReady(getSpriteId(i))){
|
|
return false
|
|
}
|
|
}
|
|
val otherIcons = arrayOf(LVL_ICON, MAG_SPRITE, LOOT_ICON, WRENCH_ICON, COMBAT_LVL_SPRITE, BAG_ICON)
|
|
for (icon in otherIcons) {
|
|
if(!js5Archive8.isFileReady(icon)){
|
|
return false
|
|
}
|
|
}
|
|
} catch (e : Exception){
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
private fun updateDisplaySettings() {
|
|
val mode = GetWindowMode()
|
|
val currentScrollPaneWidth = if (mainContentPanel.isVisible) NAVBAR_WIDTH + MAIN_CONTENT_WIDTH else NAVBAR_WIDTH
|
|
lastUIOffset = uiOffset
|
|
|
|
if(mode != WindowMode.FIXED) {
|
|
destroyAltCanvas()
|
|
} else if (useScaledFixed && altCanvas == null) {
|
|
initAltCanvas()
|
|
}
|
|
|
|
when (mode) {
|
|
WindowMode.FIXED -> {
|
|
if (frame.width < FIXED_WIDTH + currentScrollPaneWidth + uiOffset) {
|
|
frame.setSize(FIXED_WIDTH + currentScrollPaneWidth + uiOffset, frame.height)
|
|
}
|
|
|
|
val difference = frame.width - (uiOffset + currentScrollPaneWidth)
|
|
|
|
if (useScaledFixed) {
|
|
GameShell.leftMargin = 0
|
|
val canvasWidth = difference + uiOffset / 2
|
|
val canvasHeight = frame.height - canvas.y // Restricting height to frame height
|
|
|
|
altCanvas?.size = Dimension(canvasWidth, canvasHeight)
|
|
altCanvas?.setLocation(0, canvas.y)
|
|
canvas.setLocation(0, canvas.y)
|
|
} else {
|
|
val difference = frame.width - (FIXED_WIDTH + uiOffset + currentScrollPaneWidth)
|
|
GameShell.leftMargin = difference / 2
|
|
}
|
|
}
|
|
|
|
WindowMode.RESIZABLE -> {
|
|
GameShell.canvasWidth = frame.width - (currentScrollPaneWidth + uiOffset)
|
|
}
|
|
}
|
|
|
|
rightPanelWrapper?.preferredSize = Dimension(currentScrollPaneWidth, frame.height)
|
|
rightPanelWrapper?.isDoubleBuffered = true
|
|
rightPanelWrapper?.revalidate()
|
|
rightPanelWrapper?.repaint()
|
|
}
|
|
|
|
fun OnKondoValueUpdated(){
|
|
StoreData("kondoUseRemoteGE", useLiveGEPrices)
|
|
StoreData("kondoTheme", theme.toString())
|
|
if(appliedTheme != theme) {
|
|
showAlert(
|
|
"KondoKit Theme changes require a relaunch.",
|
|
"KondoKit",
|
|
JOptionPane.INFORMATION_MESSAGE
|
|
)
|
|
}
|
|
StoreData("kondoPlayerXPMultiplier", playerXPMultiplier)
|
|
LootTrackerView.gePriceMap = LootTrackerView.loadGEPrices()
|
|
StoreData("kondoLaunchMinimized", launchMinimized)
|
|
StoreData("kondoUIOffset", uiOffset)
|
|
StoreData("kondoScaledFixed", useScaledFixed)
|
|
if(lastUIOffset != uiOffset){
|
|
reloadInterfaces = true
|
|
}
|
|
updateDisplaySettings()
|
|
}
|
|
|
|
private fun initAltCanvas(){
|
|
if(GetWindowMode() != WindowMode.FIXED || altCanvas != null) return
|
|
if (frame != null) {
|
|
altCanvas = AltCanvas().apply {
|
|
preferredSize = Dimension(FIXED_WIDTH, FIXED_HEIGHT)
|
|
}
|
|
altCanvas?.let { frame.add(it) }
|
|
moveAltCanvasToFront()
|
|
frame.setComponentZOrder(rightPanelWrapper, 2)
|
|
}
|
|
}
|
|
|
|
private fun destroyAltCanvas(){
|
|
if (altCanvas == null) return
|
|
moveCanvasToFront()
|
|
frame.remove(altCanvas)
|
|
altCanvas = null
|
|
}
|
|
|
|
private fun moveAltCanvasToFront(){
|
|
if (altCanvas == null) return
|
|
frame.setComponentZOrder(canvas, 2)
|
|
frame.setComponentZOrder(altCanvas, 1)
|
|
frame.setComponentZOrder(rightPanelWrapper, 0)
|
|
}
|
|
|
|
private fun moveCanvasToFront(){
|
|
if (altCanvas == null) return
|
|
frame.setComponentZOrder(altCanvas, 2)
|
|
frame.setComponentZOrder(canvas, 1)
|
|
frame.setComponentZOrder(rightPanelWrapper, 0)
|
|
}
|
|
|
|
private fun searchHiscore(username: String): Runnable {
|
|
return Runnable {
|
|
setActiveView(HiscoresView.VIEW_NAME)
|
|
val customSearchField = hiScoreView?.let { HiscoresView.CustomSearchField(it) }
|
|
|
|
customSearchField?.searchPlayer(username) ?: run {
|
|
println("searchView is null or CustomSearchField creation failed.")
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun restoreSettings(){
|
|
themeName = (GetData("kondoTheme") as? String) ?: "RUNELITE"
|
|
useLiveGEPrices = (GetData("kondoUseRemoteGE") as? Boolean) ?: true
|
|
playerXPMultiplier = (GetData("kondoPlayerXPMultiplier") as? Int) ?: 5
|
|
val osName = System.getProperty("os.name").toLowerCase()
|
|
uiOffset = (GetData("kondoUIOffset") as? Int) ?: if (osName.contains("win")) 16 else 0
|
|
launchMinimized = (GetData("kondoLaunchMinimized") as? Boolean) ?: false
|
|
useScaledFixed = (GetData("kondoScaledFixed") as? Boolean) ?: false
|
|
}
|
|
|
|
private fun initKondoUI(){
|
|
DrawText(FontType.LARGE, fromColor(Color(16777215)), TextModifier.CENTER, "KondoKit Loading Sprites...", GameShell.canvasWidth/2, GameShell.canvasHeight/2)
|
|
if(!allSpritesLoaded()) return
|
|
val frame: Frame? = GameShell.frame
|
|
if (frame != null) {
|
|
restoreSettings()
|
|
theme = ThemeType.valueOf(themeName)
|
|
applyTheme(getTheme(theme))
|
|
appliedTheme = theme
|
|
configureLookAndFeel()
|
|
|
|
cardLayout = CardLayout()
|
|
mainContentPanel = JPanel(cardLayout).apply {
|
|
border = BorderFactory.createEmptyBorder(0, 0, 0, 0) // Removes any default border or padding
|
|
background = VIEW_BACKGROUND_COLOR
|
|
preferredSize = Dimension(MAIN_CONTENT_WIDTH, frame.height)
|
|
isOpaque = true
|
|
}
|
|
|
|
// Register Views
|
|
createXPTrackerView()
|
|
createHiscoreSearchView()
|
|
createLootTrackerView()
|
|
createReflectiveEditorView()
|
|
|
|
mainContentPanel.add(ScrollablePanel(xpTrackerView!!), XPTrackerView.VIEW_NAME)
|
|
mainContentPanel.add(ScrollablePanel(hiScoreView!!), HiscoresView.VIEW_NAME)
|
|
mainContentPanel.add(ScrollablePanel(lootTrackerView!!), LootTrackerView.VIEW_NAME)
|
|
mainContentPanel.add(ScrollablePanel(reflectiveEditorView!!), ReflectiveEditorView.VIEW_NAME)
|
|
|
|
val navPanel = Panel().apply {
|
|
layout = BoxLayout(this, BoxLayout.Y_AXIS)
|
|
background = WIDGET_COLOR
|
|
preferredSize = Dimension(NAVBAR_WIDTH, frame.height)
|
|
}
|
|
|
|
navPanel.add(createNavButton(LVL_ICON, XPTrackerView.VIEW_NAME))
|
|
navPanel.add(createNavButton(MAG_SPRITE, HiscoresView.VIEW_NAME))
|
|
navPanel.add(createNavButton(LOOT_ICON, LootTrackerView.VIEW_NAME))
|
|
navPanel.add(createNavButton(WRENCH_ICON, ReflectiveEditorView.VIEW_NAME))
|
|
|
|
val rightPanel = Panel(BorderLayout()).apply {
|
|
add(mainContentPanel, BorderLayout.CENTER)
|
|
add(navPanel, BorderLayout.EAST)
|
|
}
|
|
|
|
rightPanelWrapper = JScrollPane(rightPanel).apply {
|
|
preferredSize = Dimension(NAVBAR_WIDTH + MAIN_CONTENT_WIDTH, frame.height)
|
|
background = VIEW_BACKGROUND_COLOR
|
|
border = BorderFactory.createEmptyBorder()
|
|
horizontalScrollBarPolicy = JScrollPane.HORIZONTAL_SCROLLBAR_NEVER
|
|
verticalScrollBarPolicy = JScrollPane.VERTICAL_SCROLLBAR_NEVER
|
|
}
|
|
|
|
val desiredView = if (launchMinimized) HIDDEN_VIEW else XPTrackerView.VIEW_NAME
|
|
// Commit layout synchronously on the EDT to avoid initial misplacement
|
|
val commit = Runnable {
|
|
frame.layout = BorderLayout()
|
|
rightPanelWrapper?.let { frame.add(it, BorderLayout.EAST) }
|
|
setActiveView(desiredView)
|
|
frame.validate()
|
|
frame.repaint()
|
|
}
|
|
if (SwingUtilities.isEventDispatchThread()) {
|
|
commit.run()
|
|
} else {
|
|
try {
|
|
javax.swing.SwingUtilities.invokeAndWait(commit)
|
|
} catch (e: Exception) {
|
|
// Fallback to async if invokeAndWait fails for any reason
|
|
SwingUtilities.invokeLater(commit)
|
|
}
|
|
}
|
|
initialized = true
|
|
pluginsReloaded = true
|
|
}
|
|
}
|
|
|
|
private fun setActiveView(viewName: String) {
|
|
val runUpdate: () -> Unit = {
|
|
// Track visibility change to decide if we need to resize/reload interfaces
|
|
val wasVisible = mainContentPanel.isVisible
|
|
|
|
// Handle the visibility of the main content panel and card switch
|
|
if (viewName == HIDDEN_VIEW) {
|
|
mainContentPanel.isVisible = false
|
|
} else {
|
|
if (!mainContentPanel.isVisible) {
|
|
mainContentPanel.isVisible = true
|
|
}
|
|
cardLayout.show(mainContentPanel, viewName)
|
|
}
|
|
|
|
val visibilityChanged = wasVisible != mainContentPanel.isVisible
|
|
|
|
// Batch painting to avoid intermediate repaints
|
|
rightPanelWrapper?.ignoreRepaint = true
|
|
try {
|
|
if (visibilityChanged) {
|
|
// Only touch layout and client interfaces if width actually changes
|
|
updateDisplaySettings()
|
|
reloadInterfaces = true
|
|
rightPanelWrapper?.revalidate()
|
|
frame?.validate()
|
|
} else {
|
|
// Just a card switch; avoid full frame revalidate
|
|
mainContentPanel.revalidate()
|
|
}
|
|
} finally {
|
|
rightPanelWrapper?.ignoreRepaint = false
|
|
}
|
|
|
|
// Targeted repaint for snappy feedback
|
|
if (visibilityChanged) {
|
|
rightPanelWrapper?.repaint()
|
|
frame?.repaint()
|
|
} else {
|
|
mainContentPanel.repaint()
|
|
}
|
|
|
|
focusedView = viewName
|
|
}
|
|
|
|
if (SwingUtilities.isEventDispatchThread()) {
|
|
runUpdate()
|
|
} else {
|
|
SwingUtilities.invokeLater { runUpdate() }
|
|
}
|
|
}
|
|
|
|
private fun createNavButton(spriteId: Int, viewName: String): JPanel {
|
|
val bufferedImageSprite = getBufferedImageFromSprite(GetSprite(spriteId), NAV_TINT, NAV_GREYSCALE, BOOST)
|
|
val buttonSize = Dimension(NAVBAR_WIDTH, 32)
|
|
val imageSize = Dimension((bufferedImageSprite.width / 1.2f).toInt(), (bufferedImageSprite.height / 1.2f).toInt())
|
|
val cooldownDuration = 100L
|
|
|
|
val actionListener = ActionListener {
|
|
val currentTime = System.currentTimeMillis()
|
|
if (currentTime - lastClickTime < cooldownDuration) {
|
|
return@ActionListener
|
|
}
|
|
lastClickTime = currentTime
|
|
|
|
if (focusedView == viewName) {
|
|
setActiveView("HIDDEN")
|
|
} else {
|
|
setActiveView(viewName)
|
|
}
|
|
}
|
|
|
|
// ImageCanvas with forced size
|
|
val imageCanvas = ImageCanvas(bufferedImageSprite).apply {
|
|
background = WIDGET_COLOR
|
|
preferredSize = imageSize
|
|
maximumSize = imageSize
|
|
minimumSize = imageSize
|
|
}
|
|
|
|
// Wrapping the ImageCanvas in another JPanel to prevent stretching
|
|
val imageCanvasWrapper = JPanel().apply {
|
|
layout = GridBagLayout() // Keeps the layout of the wrapped panel minimal
|
|
preferredSize = imageSize
|
|
maximumSize = imageSize
|
|
minimumSize = imageSize
|
|
isOpaque = false // No background for the wrapper
|
|
add(imageCanvas) // Adding ImageCanvas directly, layout won't stretch it
|
|
}
|
|
|
|
val panelButton = JPanel().apply {
|
|
layout = GridBagLayout()
|
|
preferredSize = buttonSize
|
|
maximumSize = buttonSize
|
|
minimumSize = buttonSize
|
|
background = WIDGET_COLOR
|
|
isOpaque = true
|
|
|
|
val gbc = GridBagConstraints().apply {
|
|
anchor = GridBagConstraints.CENTER
|
|
fill = GridBagConstraints.NONE // Prevents stretching
|
|
}
|
|
|
|
add(imageCanvasWrapper, gbc)
|
|
|
|
// Hover and click behavior
|
|
val hoverListener = object : MouseAdapter() {
|
|
override fun mouseEntered(e: MouseEvent?) {
|
|
background = WIDGET_COLOR.darker()
|
|
imageCanvas.fillColor = WIDGET_COLOR.darker()
|
|
imageCanvas.repaint()
|
|
repaint()
|
|
}
|
|
|
|
override fun mouseExited(e: MouseEvent?) {
|
|
background = WIDGET_COLOR
|
|
imageCanvas.fillColor = WIDGET_COLOR
|
|
imageCanvas.repaint()
|
|
repaint()
|
|
}
|
|
|
|
override fun mouseClicked(e: MouseEvent?) {
|
|
actionListener.actionPerformed(null)
|
|
}
|
|
}
|
|
|
|
addMouseListener(hoverListener)
|
|
imageCanvas.addMouseListener(hoverListener)
|
|
}
|
|
|
|
return panelButton
|
|
}
|
|
|
|
private fun configureLookAndFeel(){
|
|
loadFont()
|
|
try {
|
|
UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel")
|
|
|
|
// Modify the UI properties to match theme
|
|
UIManager.put("control", VIEW_BACKGROUND_COLOR)
|
|
UIManager.put("info", VIEW_BACKGROUND_COLOR)
|
|
UIManager.put("nimbusBase", WIDGET_COLOR)
|
|
UIManager.put("nimbusBlueGrey", TITLE_BAR_COLOR)
|
|
|
|
UIManager.put("nimbusDisabledText", primaryColor)
|
|
UIManager.put("nimbusSelectedText", secondaryColor)
|
|
UIManager.put("text", secondaryColor)
|
|
|
|
UIManager.put("nimbusFocus", TITLE_BAR_COLOR)
|
|
UIManager.put("nimbusInfoBlue", POPUP_BACKGROUND)
|
|
UIManager.put("nimbusLightBackground", WIDGET_COLOR)
|
|
UIManager.put("nimbusSelectionBackground", PROGRESS_BAR_FILL)
|
|
|
|
UIManager.put("Button.background", WIDGET_COLOR)
|
|
UIManager.put("Button.foreground", secondaryColor)
|
|
|
|
UIManager.put("CheckBox.background", VIEW_BACKGROUND_COLOR)
|
|
UIManager.put("CheckBox.foreground", secondaryColor)
|
|
UIManager.put("CheckBox.icon", UIManager.getIcon("CheckBox.icon"))
|
|
|
|
UIManager.put("ComboBox.background", WIDGET_COLOR)
|
|
UIManager.put("ComboBox.foreground", secondaryColor)
|
|
UIManager.put("ComboBox.selectionBackground", PROGRESS_BAR_FILL)
|
|
UIManager.put("ComboBox.selectionForeground", primaryColor)
|
|
UIManager.put("ComboBox.buttonBackground", WIDGET_COLOR)
|
|
|
|
UIManager.put("Spinner.background", WIDGET_COLOR)
|
|
UIManager.put("Spinner.foreground", secondaryColor)
|
|
UIManager.put("Spinner.border", BorderFactory.createLineBorder(TITLE_BAR_COLOR))
|
|
|
|
UIManager.put("TextField.background", WIDGET_COLOR)
|
|
UIManager.put("TextField.foreground", secondaryColor)
|
|
UIManager.put("TextField.caretForeground", secondaryColor)
|
|
UIManager.put("TextField.border", BorderFactory.createLineBorder(TITLE_BAR_COLOR))
|
|
|
|
UIManager.put("ScrollBar.thumb", WIDGET_COLOR)
|
|
UIManager.put("ScrollBar.track", VIEW_BACKGROUND_COLOR)
|
|
UIManager.put("ScrollBar.thumbHighlight", TITLE_BAR_COLOR)
|
|
|
|
UIManager.put("ProgressBar.foreground", PROGRESS_BAR_FILL)
|
|
UIManager.put("ProgressBar.background", WIDGET_COLOR)
|
|
UIManager.put("ProgressBar.border", BorderFactory.createLineBorder(TITLE_BAR_COLOR))
|
|
|
|
UIManager.put("ToolTip.background", VIEW_BACKGROUND_COLOR)
|
|
UIManager.put("ToolTip.foreground", secondaryColor)
|
|
UIManager.put("ToolTip.border", BorderFactory.createLineBorder(TITLE_BAR_COLOR))
|
|
|
|
// Update component tree UI to apply the new theme
|
|
SwingUtilities.updateComponentTreeUI(frame)
|
|
frame.background = Color.BLACK
|
|
} catch (e : Exception) {
|
|
e.printStackTrace()
|
|
}
|
|
}
|
|
|
|
private fun loadFont(): Font? {
|
|
val fontStream = Helpers.openResource("res/runescape_small.ttf")
|
|
return if (fontStream != null) {
|
|
try {
|
|
val font = Font.createFont(Font.TRUETYPE_FONT, fontStream)
|
|
val ge = GraphicsEnvironment.getLocalGraphicsEnvironment()
|
|
ge.registerFont(font) // Register the font in the graphics environment
|
|
font
|
|
} catch (e: Exception) {
|
|
e.printStackTrace()
|
|
null
|
|
}
|
|
} else {
|
|
println("Font not found!")
|
|
null
|
|
}
|
|
}
|
|
|
|
object StateManager {
|
|
var focusedView: String = ""
|
|
}
|
|
|
|
private fun applyTheme(theme: Theme) {
|
|
WIDGET_COLOR = theme.widgetColor
|
|
TITLE_BAR_COLOR = theme.titleBarColor
|
|
VIEW_BACKGROUND_COLOR = theme.viewBackgroundColor
|
|
primaryColor = theme.primaryColor
|
|
secondaryColor = theme.secondaryColor
|
|
POPUP_BACKGROUND = theme.popupBackground
|
|
POPUP_FOREGROUND = theme.popupForeground
|
|
TOOLTIP_BACKGROUND = theme.tooltipBackground
|
|
SCROLL_BAR_COLOR = theme.scrollBarColor
|
|
PROGRESS_BAR_FILL = theme.progressBarFill
|
|
NAV_TINT = theme.navTint
|
|
NAV_GREYSCALE = theme.navGreyScale
|
|
BOOST = theme.boost
|
|
}
|
|
}
|