From 96f09851009ee3e56b809ca81a89858eacc2c4c0 Mon Sep 17 00:00:00 2001 From: JoePfeiffer Date: Fri, 12 Jul 2024 05:53:43 -0600 Subject: [PATCH 1/7] Remove longitudinalAcceleration field from DataStore. This was initialized to NaN, but never set to anything else. It (along with the atmospheric conditions) was passed to calculateThrust for possible more accurate thrust calculation in the future, but not used there at present The entire DataStore is now passed to calculateAcceleration() to use whatever fields are useful to it -- none at present. --- .../core/simulation/AbstractSimulationStepper.java | 10 +++------- .../core/simulation/RK4SimulationStepper.java | 2 +- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java index dcd152768..94810fb8e 100644 --- a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java @@ -163,14 +163,12 @@ public abstract class AbstractSimulationStepper implements SimulationStepper { * * @param status the current simulation status. * @param timestep the time step of the current iteration. - * @param acceleration the current (approximate) acceleration - * @param atmosphericConditions the current atmospheric conditions + * @param store the simulation calculation DataStore (contains acceleration, atmosphere) * @param stepMotors whether to step the motors forward or work on a clone object * @return the average thrust during the time step. */ - protected double calculateThrust(SimulationStatus status, - double acceleration, AtmosphericConditions atmosphericConditions, - boolean stepMotors) throws SimulationException { + protected double calculateThrust(SimulationStatus status, DataStore store, + boolean stepMotors) throws SimulationException { double thrust; // Pre-listeners @@ -240,8 +238,6 @@ public abstract class AbstractSimulationStepper implements SimulationStepper { public FlightConditions flightConditions; - public double longitudinalAcceleration = Double.NaN; - public RigidBody rocketMass; public RigidBody motorMass; diff --git a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java index 91b76d28d..f235da572 100644 --- a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java @@ -325,7 +325,7 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { double fN = store.forces.getCN() * dynP * refArea; double fSide = store.forces.getCside() * dynP * refArea; - store.thrustForce = calculateThrust(status, store.longitudinalAcceleration, store.flightConditions.getAtmosphericConditions(), false); + store.thrustForce = calculateThrust(status, store, false); double forceZ = store.thrustForce - store.dragForce; store.linearAcceleration = new Coordinate(-fN / store.rocketMass.getMass(), From e07eaf7297bf3609013bed64c4ad9b78042e7c9f Mon Sep 17 00:00:00 2001 From: JoePfeiffer Date: Fri, 12 Jul 2024 09:25:05 -0600 Subject: [PATCH 2/7] Don't use store.linearAcceleration and store.angularAcceleration in RK4SimulationStepper. Use local variables in calculateAcceleration, and pull values out of store.accelerationData, instead --- .../core/simulation/RK4SimulationStepper.java | 36 ++++++++++--------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java index f235da572..ac8496d42 100644 --- a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java @@ -273,8 +273,8 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { // Call post-listeners store.accelerationData = SimulationListenerHelper.firePostAccelerationCalculation(status, store.accelerationData); - params.a = dataStore.linearAcceleration; - params.ra = dataStore.angularAcceleration; + params.a = dataStore.accelerationData.getLinearAccelerationWC(); + params.ra = dataStore.accelerationData.getRotationalAccelerationWC(); params.v = status.getRocketVelocity(); params.rv = status.getRocketRotationVelocity(); @@ -298,7 +298,9 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { * @throws SimulationException */ private AccelerationData calculateAcceleration(SimulationStatus status, DataStore store) throws SimulationException { - + Coordinate linearAcceleration; + Coordinate angularAcceleration; + // Compute the forces affecting the rocket calculateForces(status, store); @@ -328,30 +330,30 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { store.thrustForce = calculateThrust(status, store, false); double forceZ = store.thrustForce - store.dragForce; - store.linearAcceleration = new Coordinate(-fN / store.rocketMass.getMass(), + linearAcceleration = new Coordinate(-fN / store.rocketMass.getMass(), -fSide / store.rocketMass.getMass(), forceZ / store.rocketMass.getMass()); - store.linearAcceleration = store.thetaRotation.rotateZ(store.linearAcceleration); + linearAcceleration = store.thetaRotation.rotateZ(linearAcceleration); // Convert into rocket world coordinates - store.linearAcceleration = status.getRocketOrientationQuaternion().rotate(store.linearAcceleration); + linearAcceleration = status.getRocketOrientationQuaternion().rotate(linearAcceleration); // add effect of gravity store.gravity = modelGravity(status); - store.linearAcceleration = store.linearAcceleration.sub(0, 0, store.gravity); + linearAcceleration = linearAcceleration.sub(0, 0, store.gravity); // add effect of Coriolis acceleration store.coriolisAcceleration = status.getSimulationConditions().getGeodeticComputation() .getCoriolisAcceleration(status.getRocketWorldPosition(), status.getRocketVelocity()); - store.linearAcceleration = store.linearAcceleration.add(store.coriolisAcceleration); + linearAcceleration = linearAcceleration.add(store.coriolisAcceleration); // If still on the launch rod, project acceleration onto launch rod direction and // set angular acceleration to zero. if (!status.isLaunchRodCleared()) { - store.linearAcceleration = store.launchRodDirection.multiply(store.linearAcceleration.dot(store.launchRodDirection)); - store.angularAcceleration = Coordinate.NUL; + linearAcceleration = store.launchRodDirection.multiply(linearAcceleration.dot(store.launchRodDirection)); + angularAcceleration = Coordinate.NUL; store.rollAcceleration = 0; store.lateralPitchAcceleration = 0; @@ -367,23 +369,23 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { double momZ = store.forces.getCroll() * dynP * refArea * refLength; // Compute acceleration in rocket coordinates - store.angularAcceleration = new Coordinate(momX / store.rocketMass.getLongitudinalInertia(), + angularAcceleration = new Coordinate(momX / store.rocketMass.getLongitudinalInertia(), momY / store.rocketMass.getLongitudinalInertia(), momZ / store.rocketMass.getRotationalInertia()); - store.rollAcceleration = store.angularAcceleration.z; + store.rollAcceleration = angularAcceleration.z; // TODO: LOW: This should be hypot, but does it matter? - store.lateralPitchAcceleration = MathUtil.max(Math.abs(store.angularAcceleration.x), - Math.abs(store.angularAcceleration.y)); + store.lateralPitchAcceleration = MathUtil.max(Math.abs(angularAcceleration.x), + Math.abs(angularAcceleration.y)); - store.angularAcceleration = store.thetaRotation.rotateZ(store.angularAcceleration); + angularAcceleration = store.thetaRotation.rotateZ(angularAcceleration); // Convert to world coordinates - store.angularAcceleration = status.getRocketOrientationQuaternion().rotate(store.angularAcceleration); + angularAcceleration = status.getRocketOrientationQuaternion().rotate(angularAcceleration); } - return new AccelerationData(null, null, store.linearAcceleration, store.angularAcceleration, status.getRocketOrientationQuaternion()); + return new AccelerationData(null, null, linearAcceleration, angularAcceleration, status.getRocketOrientationQuaternion()); } From 46ed6942b214efea0f214fc2da9c8735a40f37b6 Mon Sep 17 00:00:00 2001 From: JoePfeiffer Date: Sun, 14 Jul 2024 15:19:01 -0600 Subject: [PATCH 3/7] Modify AbstractEulerStepper to use local linearAcceleration variable instead of store.linearAcceleration. Save acceleration data (after computation) in DataStore, not SimulationStatus --- .../core/simulation/AbstractEulerStepper.java | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/core/src/main/java/info/openrocket/core/simulation/AbstractEulerStepper.java b/core/src/main/java/info/openrocket/core/simulation/AbstractEulerStepper.java index 1dcb406fb..d1042183e 100644 --- a/core/src/main/java/info/openrocket/core/simulation/AbstractEulerStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/AbstractEulerStepper.java @@ -70,22 +70,24 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { } // Compute drag acceleration - store.linearAcceleration = airSpeed.normalize().multiply(-store.dragForce / store.rocketMass.getMass()); + Coordinate linearAcceleration = airSpeed.normalize().multiply(-store.dragForce / store.rocketMass.getMass()); // Add effect of gravity store.gravity = modelGravity(status); - store.linearAcceleration = store.linearAcceleration.sub(0, 0, store.gravity); + linearAcceleration = linearAcceleration.sub(0, 0, store.gravity); // Add coriolis acceleration store.coriolisAcceleration = status.getSimulationConditions().getGeodeticComputation().getCoriolisAcceleration( status.getRocketWorldPosition(), status.getRocketVelocity()); - store.linearAcceleration = store.linearAcceleration.add(store.coriolisAcceleration); + linearAcceleration = linearAcceleration.add(store.coriolisAcceleration); + + store.accelerationData = new AccelerationData(null, null, linearAcceleration, Coordinate.NUL, status.getRocketOrientationQuaternion()); // Select tentative time step store.timeStep = RECOVERY_TIME_STEP; // adjust based on acceleration - final double absAccel = store.linearAcceleration.length(); + final double absAccel = linearAcceleration.length(); if (absAccel > MathUtil.EPSILON) { store.timeStep = Math.min(store.timeStep, 1.0/absAccel); } @@ -105,7 +107,7 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { log.trace("timeStep is " + store.timeStep); // Perform Euler integration - EulerValues newVals = eulerIntegrate(status.getRocketPosition(), status.getRocketVelocity(), store.linearAcceleration, store.timeStep); + EulerValues newVals = eulerIntegrate(status.getRocketPosition(), status.getRocketVelocity(), linearAcceleration, store.timeStep); // Check to see if z or either of its first two derivatives have changed sign and recalculate // time step to point of change if so @@ -115,7 +117,7 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { // Note that it's virtually impossible for apogee to occur on the same // step as either ground hit or descent rate inflection, and if we get a ground hit // any descent rate inflection won't matter - final double a = store.linearAcceleration.z; + final double a = linearAcceleration.z; final double v = status.getRocketVelocity().z; final double z = status.getRocketPosition().z; double t = store.timeStep; @@ -136,11 +138,11 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { // dA/dT = dA/dV * dV/dT final double dFdV = CdA * store.atmosphericConditions.getDensity() * airSpeed.length(); final Coordinate dAdV = airSpeed.normalize().multiply(dFdV / store.rocketMass.getMass()); - final Coordinate jerk = store.linearAcceleration.multiply(dAdV); - final Coordinate newAcceleration = store.linearAcceleration.add(jerk.multiply(store.timeStep)); + final Coordinate jerk = linearAcceleration.multiply(dAdV); + final Coordinate newAcceleration = linearAcceleration.add(jerk.multiply(store.timeStep)); // Only do this one if acceleration is appreciably different from 0 - if (newAcceleration.z * store.linearAcceleration.z < -MathUtil.EPSILON) { + if (newAcceleration.z * linearAcceleration.z < -MathUtil.EPSILON) { // If acceleration oscillation is building up, the new timestep is the solution of // a + j*t = 0 t = Math.abs(a / jerk.z); @@ -159,7 +161,7 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { store.timeStep = maxTimeStep; } - newVals = eulerIntegrate(status.getRocketPosition(), status.getRocketVelocity(), store.linearAcceleration, store.timeStep); + newVals = eulerIntegrate(status.getRocketPosition(), status.getRocketVelocity(), linearAcceleration, store.timeStep); // If we just landed chop off rounding error if (Math.abs(newVals.pos.z) < MathUtil.EPSILON) { @@ -171,7 +173,6 @@ public abstract class AbstractEulerStepper extends AbstractSimulationStepper { status.setRocketPosition(newVals.pos); status.setRocketVelocity(newVals.vel); - status.setRocketAcceleration(store.linearAcceleration); // Update the world coordinate WorldCoordinate w = status.getSimulationConditions().getLaunchSite(); From e346969c24392d97a22374c7931810388919b120 Mon Sep 17 00:00:00 2001 From: JoePfeiffer Date: Mon, 15 Jul 2024 09:45:35 -0600 Subject: [PATCH 4/7] Get rid of linearAcceleration and angularAcceleration from DataStore; that data is in AccelerationData --- .../core/simulation/AbstractSimulationStepper.java | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java index ec2bb586b..7ef9de44d 100644 --- a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java @@ -243,9 +243,6 @@ public abstract class AbstractSimulationStepper implements SimulationStepper { public RigidBody motorMass; public Coordinate coriolisAcceleration; - - public Coordinate linearAcceleration; - public Coordinate angularAcceleration; public Coordinate launchRodDirection = null; @@ -282,12 +279,12 @@ public abstract class AbstractSimulationStepper implements SimulationStepper { dataBranch.setValue(FlightDataType.TYPE_CORIOLIS_ACCELERATION, coriolisAcceleration.length()); } - if (null != linearAcceleration) { + if (null != accelerationData) { dataBranch.setValue(FlightDataType.TYPE_ACCELERATION_XY, - MathUtil.hypot(linearAcceleration.x, linearAcceleration.y)); + MathUtil.hypot(accelerationData.getLinearAccelerationWC().x, accelerationData.getLinearAccelerationWC().y)); - dataBranch.setValue(FlightDataType.TYPE_ACCELERATION_TOTAL, linearAcceleration.length()); - dataBranch.setValue(FlightDataType.TYPE_ACCELERATION_Z, linearAcceleration.z); + dataBranch.setValue(FlightDataType.TYPE_ACCELERATION_TOTAL, accelerationData.getLinearAccelerationWC().length()); + dataBranch.setValue(FlightDataType.TYPE_ACCELERATION_Z, accelerationData.getLinearAccelerationWC().z); } if (null != rocketMass) { From 7252ae66e03371c8ab6fe0bc0a05ea5e6403a60f Mon Sep 17 00:00:00 2001 From: SiboVG Date: Thu, 18 Jul 2024 01:56:50 +0200 Subject: [PATCH 5/7] [#2093] Allow 2D views to be rotated by click-dragging --- .../swing/gui/scalefigure/RocketPanel.java | 39 +++++++++++++++++-- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/swing/src/main/java/info/openrocket/swing/gui/scalefigure/RocketPanel.java b/swing/src/main/java/info/openrocket/swing/gui/scalefigure/RocketPanel.java index 070c85bbb..5437348c2 100644 --- a/swing/src/main/java/info/openrocket/swing/gui/scalefigure/RocketPanel.java +++ b/swing/src/main/java/info/openrocket/swing/gui/scalefigure/RocketPanel.java @@ -217,12 +217,27 @@ public class RocketPanel extends JPanel implements TreeSelectionListener, Change scrollPane = new ScaleScrollPane(figure) { private static final long serialVersionUID = 1L; final CustomClickCountListener clickCountListener = new CustomClickCountListener(); + private Point mousePressedLoc = null; + private double originalFigureRotation = 0; @Override public void mouseClicked(MouseEvent event) { clickCountListener.click(); handleMouseClick(event, clickCountListener.getClickCount()); } + + public void mousePressed(MouseEvent e) { + if (is3d) { + return; + } + mousePressedLoc = e.getPoint(); + originalFigureRotation = figure.getRotation(); + } + + @Override + public void mouseDragged(MouseEvent e) { + handleMouseDragged(e, mousePressedLoc, originalFigureRotation); + } }; scrollPane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE); scrollPane.setFitting(true); @@ -413,6 +428,7 @@ public class RocketPanel extends JPanel implements TreeSelectionListener, Change // Create slider and scroll pane rotationModel = new DoubleModel(figure, "Rotation", UnitGroup.UNITS_ANGLE, 0, 2 * Math.PI); + figure.addChangeListener(rotationModel); UnitSelector us = new UnitSelector(rotationModel, true); us.setHorizontalAlignment(JLabel.CENTER); add(us, "alignx 50%, growx"); @@ -422,12 +438,13 @@ public class RocketPanel extends JPanel implements TreeSelectionListener, Change add(figureHolder, "grow, spany 2, wmin 300lp, hmin 100lp, wrap"); // Add rotation slider - // Dummy label to find the minimum size to fit "360deg" - JLabel l = new JLabel("360" + Chars.DEGREE); + // Dummy label to find the minimum size to fit "360.0deg" + JLabel l = new JLabel("360.0" + Chars.DEGREE); Dimension d = l.getPreferredSize(); - add(rotationSlider = new BasicSlider(rotationModel.getSliderModel(0, 2 * Math.PI), JSlider.VERTICAL, true), - "ax 50%, wrap, width " + (d.width + 6) + "px:null:null, growy"); + us.setMinimumSize(new Dimension(d.width, us.getPreferredSize().height)); + rotationSlider = new BasicSlider(rotationModel.getSliderModel(0, 2 * Math.PI), JSlider.VERTICAL, true); + add(rotationSlider, "ax 50%, wrap, width " + (d.width + 6) + "px:null:null, growy"); rotationSlider.addChangeListener(new ChangeListener() { @Override public void stateChanged(ChangeEvent e) { @@ -737,6 +754,20 @@ public class RocketPanel extends JPanel implements TreeSelectionListener, Change } } + private void handleMouseDragged(MouseEvent event, Point originalDragLocation, double originalRotation) { + if (originalDragLocation == null || is3d) { + return; + } + + int dy = event.getY() - originalDragLocation.y; + + double rotationOffset = ((double) dy / scrollPane.getHeight()) * Math.PI; + double newRotation = originalRotation - rotationOffset; + // Ensure the rotation is within the range [0, 2*PI] + newRotation = (newRotation + 2 * Math.PI) % (2 * Math.PI); + figure.setRotation(newRotation); + } + /** * Updates the extra data included in the figure. Currently this includes * the CP and CG carets. Also start the background simulator. From e0ebef261c3aaa86965e990a7f9a6cb65214ede8 Mon Sep 17 00:00:00 2001 From: JoePfeiffer Date: Wed, 17 Jul 2024 18:07:14 -0600 Subject: [PATCH 6/7] Remove store.rollAcceleration and store.lateralPitchAcceleration. That data is in store.AccelerationData --- .../simulation/AbstractSimulationStepper.java | 3 --- .../core/simulation/RK4SimulationStepper.java | 18 ++++++------------ 2 files changed, 6 insertions(+), 15 deletions(-) diff --git a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java index 7ef9de44d..474d6c474 100644 --- a/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/AbstractSimulationStepper.java @@ -257,9 +257,6 @@ public abstract class AbstractSimulationStepper implements SimulationStepper { public double dragForce = Double.NaN; public double lateralPitchRate = Double.NaN; - public double rollAcceleration = Double.NaN; - public double lateralPitchAcceleration = Double.NaN; - public Rotation2D thetaRotation; void storeData(SimulationStatus status) { diff --git a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java index ac8496d42..889e74d17 100644 --- a/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java +++ b/core/src/main/java/info/openrocket/core/simulation/RK4SimulationStepper.java @@ -57,7 +57,7 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { // private static final double MAX_ROLL_STEP_ANGLE = 8.32 * Math.PI/180; private static final double MAX_ROLL_RATE_CHANGE = 2 * Math.PI / 180; - private static final double MAX_PITCH_CHANGE = 4 * Math.PI / 180; + private static final double MAX_PITCH_YAW_CHANGE = 4 * Math.PI / 180; private Random random; DataStore store = new DataStore(); @@ -133,8 +133,10 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { dt[1] = maxTimeStep; dt[2] = status.getSimulationConditions().getMaximumAngleStep() / store.lateralPitchRate; dt[3] = Math.abs(MAX_ROLL_STEP_ANGLE / store.flightConditions.getRollRate()); - dt[4] = Math.abs(MAX_ROLL_RATE_CHANGE / store.rollAcceleration); - dt[5] = Math.abs(MAX_PITCH_CHANGE / store.lateralPitchAcceleration); + dt[4] = Math.abs(MAX_ROLL_RATE_CHANGE / store.accelerationData.getRotationalAccelerationRC().z); + dt[5] = Math.abs(MAX_PITCH_YAW_CHANGE / + MathUtil.max(Math.abs(store.accelerationData.getRotationalAccelerationRC().x), + Math.abs(store.accelerationData.getRotationalAccelerationRC().y))); if (!status.isLaunchRodCleared()) { dt[0] /= 5.0; dt[6] = status.getSimulationConditions().getLaunchRodLength() / k1.v.length() / 10; @@ -354,8 +356,6 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { linearAcceleration = store.launchRodDirection.multiply(linearAcceleration.dot(store.launchRodDirection)); angularAcceleration = Coordinate.NUL; - store.rollAcceleration = 0; - store.lateralPitchAcceleration = 0; } else { @@ -368,21 +368,15 @@ public class RK4SimulationStepper extends AbstractSimulationStepper { double momY = Cm * dynP * refArea * refLength; double momZ = store.forces.getCroll() * dynP * refArea * refLength; - // Compute acceleration in rocket coordinates + // Compute angular acceleration in rocket coordinates angularAcceleration = new Coordinate(momX / store.rocketMass.getLongitudinalInertia(), momY / store.rocketMass.getLongitudinalInertia(), momZ / store.rocketMass.getRotationalInertia()); - store.rollAcceleration = angularAcceleration.z; - // TODO: LOW: This should be hypot, but does it matter? - store.lateralPitchAcceleration = MathUtil.max(Math.abs(angularAcceleration.x), - Math.abs(angularAcceleration.y)); - angularAcceleration = store.thetaRotation.rotateZ(angularAcceleration); // Convert to world coordinates angularAcceleration = status.getRocketOrientationQuaternion().rotate(angularAcceleration); - } return new AccelerationData(null, null, linearAcceleration, angularAcceleration, status.getRocketOrientationQuaternion()); From 51a99a331ad675821cac143e2d8ace7158dfdff7 Mon Sep 17 00:00:00 2001 From: SiboVG Date: Thu, 18 Jul 2024 20:56:26 +0200 Subject: [PATCH 7/7] Bump flatlaf --- swing/build.gradle | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/swing/build.gradle b/swing/build.gradle index 1d0736c53..6a0b167c2 100644 --- a/swing/build.gradle +++ b/swing/build.gradle @@ -80,9 +80,9 @@ dependencies { implementation group: 'io.github.g00fy2', name: 'versioncompare', version: '1.5.0' implementation 'com.github.Dansoftowner:jSystemThemeDetector:3.8' - implementation group: 'com.formdev', name: 'flatlaf', version: '3.4.1' - implementation group: 'com.formdev', name: 'flatlaf-extras', version: '3.4.1' - implementation group: 'com.formdev', name: 'flatlaf-intellij-themes', version: '3.4.1' + implementation group: 'com.formdev', name: 'flatlaf', version: '3.5' + implementation group: 'com.formdev', name: 'flatlaf-extras', version: '3.5' + implementation group: 'com.formdev', name: 'flatlaf-intellij-themes', version: '3.5' implementation group: 'ch.qos.logback', name: 'logback-core', version: '1.5.0' implementation group: 'ch.qos.logback', name: 'logback-classic', version: '1.5.0'